mocks.go RawHistoryFolder

1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8	"github.com/bnema/dumber/internal/domain/entity"
9	"github.com/bnema/dumber/internal/ui/layout"
10	"github.com/jwijenbergh/puregotk/v4/gtk"
11	mock "github.com/stretchr/testify/mock"
12)
13
14// 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.
15// The first argument is typically a *testing.T value.
16func NewMockPaneViewFactory(t interface {
17	mock.TestingT
18	Cleanup(func())
19}) *MockPaneViewFactory {
20	mock := &MockPaneViewFactory{}
21	mock.Mock.Test(t)
22
23	t.Cleanup(func() { mock.AssertExpectations(t) })
24
25	return mock
26}
27
28// MockPaneViewFactory is an autogenerated mock type for the PaneViewFactory type
29type MockPaneViewFactory struct {
30	mock.Mock
31}
32
33type MockPaneViewFactory_Expecter struct {
34	mock *mock.Mock
35}
36
37func (_m *MockPaneViewFactory) EXPECT() *MockPaneViewFactory_Expecter {
38	return &MockPaneViewFactory_Expecter{mock: &_m.Mock}
39}
40
41// CreatePaneView provides a mock function for the type MockPaneViewFactory
42func (_mock *MockPaneViewFactory) CreatePaneView(node *entity.PaneNode) layout.Widget {
43	ret := _mock.Called(node)
44
45	if len(ret) == 0 {
46		panic("no return value specified for CreatePaneView")
47	}
48
49	var r0 layout.Widget
50	if returnFunc, ok := ret.Get(0).(func(*entity.PaneNode) layout.Widget); ok {
51		r0 = returnFunc(node)
52	} else {
53		if ret.Get(0) != nil {
54			r0 = ret.Get(0).(layout.Widget)
55		}
56	}
57	return r0
58}
59
60// MockPaneViewFactory_CreatePaneView_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePaneView'
61type MockPaneViewFactory_CreatePaneView_Call struct {
62	*mock.Call
63}
64
65// CreatePaneView is a helper method to define mock.On call
66//   - node *entity.PaneNode
67func (_e *MockPaneViewFactory_Expecter) CreatePaneView(node interface{}) *MockPaneViewFactory_CreatePaneView_Call {
68	return &MockPaneViewFactory_CreatePaneView_Call{Call: _e.mock.On("CreatePaneView", node)}
69}
70
71func (_c *MockPaneViewFactory_CreatePaneView_Call) Run(run func(node *entity.PaneNode)) *MockPaneViewFactory_CreatePaneView_Call {
72	_c.Call.Run(func(args mock.Arguments) {
73		var arg0 *entity.PaneNode
74		if args[0] != nil {
75			arg0 = args[0].(*entity.PaneNode)
76		}
77		run(
78			arg0,
79		)
80	})
81	return _c
82}
83
84func (_c *MockPaneViewFactory_CreatePaneView_Call) Return(widget layout.Widget) *MockPaneViewFactory_CreatePaneView_Call {
85	_c.Call.Return(widget)
86	return _c
87}
88
89func (_c *MockPaneViewFactory_CreatePaneView_Call) RunAndReturn(run func(node *entity.PaneNode) layout.Widget) *MockPaneViewFactory_CreatePaneView_Call {
90	_c.Call.Return(run)
91	return _c
92}
93
94// 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.
95// The first argument is typically a *testing.T value.
96func NewMockWidget(t interface {
97	mock.TestingT
98	Cleanup(func())
99}) *MockWidget {
100	mock := &MockWidget{}
101	mock.Mock.Test(t)
102
103	t.Cleanup(func() { mock.AssertExpectations(t) })
104
105	return mock
106}
107
108// MockWidget is an autogenerated mock type for the Widget type
109type MockWidget struct {
110	mock.Mock
111}
112
113type MockWidget_Expecter struct {
114	mock *mock.Mock
115}
116
117func (_m *MockWidget) EXPECT() *MockWidget_Expecter {
118	return &MockWidget_Expecter{mock: &_m.Mock}
119}
120
121// AddController provides a mock function for the type MockWidget
122func (_mock *MockWidget) AddController(controller *gtk.EventController) {
123	_mock.Called(controller)
124	return
125}
126
127// MockWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
128type MockWidget_AddController_Call struct {
129	*mock.Call
130}
131
132// AddController is a helper method to define mock.On call
133//   - controller *gtk.EventController
134func (_e *MockWidget_Expecter) AddController(controller interface{}) *MockWidget_AddController_Call {
135	return &MockWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
136}
137
138func (_c *MockWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockWidget_AddController_Call {
139	_c.Call.Run(func(args mock.Arguments) {
140		var arg0 *gtk.EventController
141		if args[0] != nil {
142			arg0 = args[0].(*gtk.EventController)
143		}
144		run(
145			arg0,
146		)
147	})
148	return _c
149}
150
151func (_c *MockWidget_AddController_Call) Return() *MockWidget_AddController_Call {
152	_c.Call.Return()
153	return _c
154}
155
156func (_c *MockWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockWidget_AddController_Call {
157	_c.Run(run)
158	return _c
159}
160
161// AddCssClass provides a mock function for the type MockWidget
162func (_mock *MockWidget) AddCssClass(cssClass string) {
163	_mock.Called(cssClass)
164	return
165}
166
167// MockWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
168type MockWidget_AddCssClass_Call struct {
169	*mock.Call
170}
171
172// AddCssClass is a helper method to define mock.On call
173//   - cssClass string
174func (_e *MockWidget_Expecter) AddCssClass(cssClass interface{}) *MockWidget_AddCssClass_Call {
175	return &MockWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
176}
177
178func (_c *MockWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockWidget_AddCssClass_Call {
179	_c.Call.Run(func(args mock.Arguments) {
180		var arg0 string
181		if args[0] != nil {
182			arg0 = args[0].(string)
183		}
184		run(
185			arg0,
186		)
187	})
188	return _c
189}
190
191func (_c *MockWidget_AddCssClass_Call) Return() *MockWidget_AddCssClass_Call {
192	_c.Call.Return()
193	return _c
194}
195
196func (_c *MockWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockWidget_AddCssClass_Call {
197	_c.Run(run)
198	return _c
199}
200
201// ComputePoint provides a mock function for the type MockWidget
202func (_mock *MockWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
203	ret := _mock.Called(target)
204
205	if len(ret) == 0 {
206		panic("no return value specified for ComputePoint")
207	}
208
209	var r0 float64
210	var r1 float64
211	var r2 bool
212	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
213		return returnFunc(target)
214	}
215	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
216		r0 = returnFunc(target)
217	} else {
218		r0 = ret.Get(0).(float64)
219	}
220	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
221		r1 = returnFunc(target)
222	} else {
223		r1 = ret.Get(1).(float64)
224	}
225	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
226		r2 = returnFunc(target)
227	} else {
228		r2 = ret.Get(2).(bool)
229	}
230	return r0, r1, r2
231}
232
233// MockWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
234type MockWidget_ComputePoint_Call struct {
235	*mock.Call
236}
237
238// ComputePoint is a helper method to define mock.On call
239//   - target layout.Widget
240func (_e *MockWidget_Expecter) ComputePoint(target interface{}) *MockWidget_ComputePoint_Call {
241	return &MockWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
242}
243
244func (_c *MockWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockWidget_ComputePoint_Call {
245	_c.Call.Run(func(args mock.Arguments) {
246		var arg0 layout.Widget
247		if args[0] != nil {
248			arg0 = args[0].(layout.Widget)
249		}
250		run(
251			arg0,
252		)
253	})
254	return _c
255}
256
257func (_c *MockWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockWidget_ComputePoint_Call {
258	_c.Call.Return(x, y, ok)
259	return _c
260}
261
262func (_c *MockWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockWidget_ComputePoint_Call {
263	_c.Call.Return(run)
264	return _c
265}
266
267// GetAllocatedHeight provides a mock function for the type MockWidget
268func (_mock *MockWidget) GetAllocatedHeight() int {
269	ret := _mock.Called()
270
271	if len(ret) == 0 {
272		panic("no return value specified for GetAllocatedHeight")
273	}
274
275	var r0 int
276	if returnFunc, ok := ret.Get(0).(func() int); ok {
277		r0 = returnFunc()
278	} else {
279		r0 = ret.Get(0).(int)
280	}
281	return r0
282}
283
284// MockWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
285type MockWidget_GetAllocatedHeight_Call struct {
286	*mock.Call
287}
288
289// GetAllocatedHeight is a helper method to define mock.On call
290func (_e *MockWidget_Expecter) GetAllocatedHeight() *MockWidget_GetAllocatedHeight_Call {
291	return &MockWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
292}
293
294func (_c *MockWidget_GetAllocatedHeight_Call) Run(run func()) *MockWidget_GetAllocatedHeight_Call {
295	_c.Call.Run(func(args mock.Arguments) {
296		run()
297	})
298	return _c
299}
300
301func (_c *MockWidget_GetAllocatedHeight_Call) Return(n int) *MockWidget_GetAllocatedHeight_Call {
302	_c.Call.Return(n)
303	return _c
304}
305
306func (_c *MockWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockWidget_GetAllocatedHeight_Call {
307	_c.Call.Return(run)
308	return _c
309}
310
311// GetAllocatedWidth provides a mock function for the type MockWidget
312func (_mock *MockWidget) GetAllocatedWidth() int {
313	ret := _mock.Called()
314
315	if len(ret) == 0 {
316		panic("no return value specified for GetAllocatedWidth")
317	}
318
319	var r0 int
320	if returnFunc, ok := ret.Get(0).(func() int); ok {
321		r0 = returnFunc()
322	} else {
323		r0 = ret.Get(0).(int)
324	}
325	return r0
326}
327
328// MockWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
329type MockWidget_GetAllocatedWidth_Call struct {
330	*mock.Call
331}
332
333// GetAllocatedWidth is a helper method to define mock.On call
334func (_e *MockWidget_Expecter) GetAllocatedWidth() *MockWidget_GetAllocatedWidth_Call {
335	return &MockWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
336}
337
338func (_c *MockWidget_GetAllocatedWidth_Call) Run(run func()) *MockWidget_GetAllocatedWidth_Call {
339	_c.Call.Run(func(args mock.Arguments) {
340		run()
341	})
342	return _c
343}
344
345func (_c *MockWidget_GetAllocatedWidth_Call) Return(n int) *MockWidget_GetAllocatedWidth_Call {
346	_c.Call.Return(n)
347	return _c
348}
349
350func (_c *MockWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockWidget_GetAllocatedWidth_Call {
351	_c.Call.Return(run)
352	return _c
353}
354
355// GetHexpand provides a mock function for the type MockWidget
356func (_mock *MockWidget) GetHexpand() bool {
357	ret := _mock.Called()
358
359	if len(ret) == 0 {
360		panic("no return value specified for GetHexpand")
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_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
373type MockWidget_GetHexpand_Call struct {
374	*mock.Call
375}
376
377// GetHexpand is a helper method to define mock.On call
378func (_e *MockWidget_Expecter) GetHexpand() *MockWidget_GetHexpand_Call {
379	return &MockWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
380}
381
382func (_c *MockWidget_GetHexpand_Call) Run(run func()) *MockWidget_GetHexpand_Call {
383	_c.Call.Run(func(args mock.Arguments) {
384		run()
385	})
386	return _c
387}
388
389func (_c *MockWidget_GetHexpand_Call) Return(b bool) *MockWidget_GetHexpand_Call {
390	_c.Call.Return(b)
391	return _c
392}
393
394func (_c *MockWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockWidget_GetHexpand_Call {
395	_c.Call.Return(run)
396	return _c
397}
398
399// GetParent provides a mock function for the type MockWidget
400func (_mock *MockWidget) GetParent() layout.Widget {
401	ret := _mock.Called()
402
403	if len(ret) == 0 {
404		panic("no return value specified for GetParent")
405	}
406
407	var r0 layout.Widget
408	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
409		r0 = returnFunc()
410	} else {
411		if ret.Get(0) != nil {
412			r0 = ret.Get(0).(layout.Widget)
413		}
414	}
415	return r0
416}
417
418// MockWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
419type MockWidget_GetParent_Call struct {
420	*mock.Call
421}
422
423// GetParent is a helper method to define mock.On call
424func (_e *MockWidget_Expecter) GetParent() *MockWidget_GetParent_Call {
425	return &MockWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
426}
427
428func (_c *MockWidget_GetParent_Call) Run(run func()) *MockWidget_GetParent_Call {
429	_c.Call.Run(func(args mock.Arguments) {
430		run()
431	})
432	return _c
433}
434
435func (_c *MockWidget_GetParent_Call) Return(widget layout.Widget) *MockWidget_GetParent_Call {
436	_c.Call.Return(widget)
437	return _c
438}
439
440func (_c *MockWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockWidget_GetParent_Call {
441	_c.Call.Return(run)
442	return _c
443}
444
445// GetVexpand provides a mock function for the type MockWidget
446func (_mock *MockWidget) GetVexpand() bool {
447	ret := _mock.Called()
448
449	if len(ret) == 0 {
450		panic("no return value specified for GetVexpand")
451	}
452
453	var r0 bool
454	if returnFunc, ok := ret.Get(0).(func() bool); ok {
455		r0 = returnFunc()
456	} else {
457		r0 = ret.Get(0).(bool)
458	}
459	return r0
460}
461
462// MockWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
463type MockWidget_GetVexpand_Call struct {
464	*mock.Call
465}
466
467// GetVexpand is a helper method to define mock.On call
468func (_e *MockWidget_Expecter) GetVexpand() *MockWidget_GetVexpand_Call {
469	return &MockWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
470}
471
472func (_c *MockWidget_GetVexpand_Call) Run(run func()) *MockWidget_GetVexpand_Call {
473	_c.Call.Run(func(args mock.Arguments) {
474		run()
475	})
476	return _c
477}
478
479func (_c *MockWidget_GetVexpand_Call) Return(b bool) *MockWidget_GetVexpand_Call {
480	_c.Call.Return(b)
481	return _c
482}
483
484func (_c *MockWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockWidget_GetVexpand_Call {
485	_c.Call.Return(run)
486	return _c
487}
488
489// GrabFocus provides a mock function for the type MockWidget
490func (_mock *MockWidget) GrabFocus() bool {
491	ret := _mock.Called()
492
493	if len(ret) == 0 {
494		panic("no return value specified for GrabFocus")
495	}
496
497	var r0 bool
498	if returnFunc, ok := ret.Get(0).(func() bool); ok {
499		r0 = returnFunc()
500	} else {
501		r0 = ret.Get(0).(bool)
502	}
503	return r0
504}
505
506// MockWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
507type MockWidget_GrabFocus_Call struct {
508	*mock.Call
509}
510
511// GrabFocus is a helper method to define mock.On call
512func (_e *MockWidget_Expecter) GrabFocus() *MockWidget_GrabFocus_Call {
513	return &MockWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
514}
515
516func (_c *MockWidget_GrabFocus_Call) Run(run func()) *MockWidget_GrabFocus_Call {
517	_c.Call.Run(func(args mock.Arguments) {
518		run()
519	})
520	return _c
521}
522
523func (_c *MockWidget_GrabFocus_Call) Return(b bool) *MockWidget_GrabFocus_Call {
524	_c.Call.Return(b)
525	return _c
526}
527
528func (_c *MockWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockWidget_GrabFocus_Call {
529	_c.Call.Return(run)
530	return _c
531}
532
533// GtkWidget provides a mock function for the type MockWidget
534func (_mock *MockWidget) GtkWidget() *gtk.Widget {
535	ret := _mock.Called()
536
537	if len(ret) == 0 {
538		panic("no return value specified for GtkWidget")
539	}
540
541	var r0 *gtk.Widget
542	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
543		r0 = returnFunc()
544	} else {
545		if ret.Get(0) != nil {
546			r0 = ret.Get(0).(*gtk.Widget)
547		}
548	}
549	return r0
550}
551
552// MockWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
553type MockWidget_GtkWidget_Call struct {
554	*mock.Call
555}
556
557// GtkWidget is a helper method to define mock.On call
558func (_e *MockWidget_Expecter) GtkWidget() *MockWidget_GtkWidget_Call {
559	return &MockWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
560}
561
562func (_c *MockWidget_GtkWidget_Call) Run(run func()) *MockWidget_GtkWidget_Call {
563	_c.Call.Run(func(args mock.Arguments) {
564		run()
565	})
566	return _c
567}
568
569func (_c *MockWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockWidget_GtkWidget_Call {
570	_c.Call.Return(widget)
571	return _c
572}
573
574func (_c *MockWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockWidget_GtkWidget_Call {
575	_c.Call.Return(run)
576	return _c
577}
578
579// HasCssClass provides a mock function for the type MockWidget
580func (_mock *MockWidget) HasCssClass(cssClass string) bool {
581	ret := _mock.Called(cssClass)
582
583	if len(ret) == 0 {
584		panic("no return value specified for HasCssClass")
585	}
586
587	var r0 bool
588	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
589		r0 = returnFunc(cssClass)
590	} else {
591		r0 = ret.Get(0).(bool)
592	}
593	return r0
594}
595
596// MockWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
597type MockWidget_HasCssClass_Call struct {
598	*mock.Call
599}
600
601// HasCssClass is a helper method to define mock.On call
602//   - cssClass string
603func (_e *MockWidget_Expecter) HasCssClass(cssClass interface{}) *MockWidget_HasCssClass_Call {
604	return &MockWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
605}
606
607func (_c *MockWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockWidget_HasCssClass_Call {
608	_c.Call.Run(func(args mock.Arguments) {
609		var arg0 string
610		if args[0] != nil {
611			arg0 = args[0].(string)
612		}
613		run(
614			arg0,
615		)
616	})
617	return _c
618}
619
620func (_c *MockWidget_HasCssClass_Call) Return(b bool) *MockWidget_HasCssClass_Call {
621	_c.Call.Return(b)
622	return _c
623}
624
625func (_c *MockWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockWidget_HasCssClass_Call {
626	_c.Call.Return(run)
627	return _c
628}
629
630// HasFocus provides a mock function for the type MockWidget
631func (_mock *MockWidget) HasFocus() bool {
632	ret := _mock.Called()
633
634	if len(ret) == 0 {
635		panic("no return value specified for HasFocus")
636	}
637
638	var r0 bool
639	if returnFunc, ok := ret.Get(0).(func() bool); ok {
640		r0 = returnFunc()
641	} else {
642		r0 = ret.Get(0).(bool)
643	}
644	return r0
645}
646
647// MockWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
648type MockWidget_HasFocus_Call struct {
649	*mock.Call
650}
651
652// HasFocus is a helper method to define mock.On call
653func (_e *MockWidget_Expecter) HasFocus() *MockWidget_HasFocus_Call {
654	return &MockWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
655}
656
657func (_c *MockWidget_HasFocus_Call) Run(run func()) *MockWidget_HasFocus_Call {
658	_c.Call.Run(func(args mock.Arguments) {
659		run()
660	})
661	return _c
662}
663
664func (_c *MockWidget_HasFocus_Call) Return(b bool) *MockWidget_HasFocus_Call {
665	_c.Call.Return(b)
666	return _c
667}
668
669func (_c *MockWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockWidget_HasFocus_Call {
670	_c.Call.Return(run)
671	return _c
672}
673
674// Hide provides a mock function for the type MockWidget
675func (_mock *MockWidget) Hide() {
676	_mock.Called()
677	return
678}
679
680// MockWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
681type MockWidget_Hide_Call struct {
682	*mock.Call
683}
684
685// Hide is a helper method to define mock.On call
686func (_e *MockWidget_Expecter) Hide() *MockWidget_Hide_Call {
687	return &MockWidget_Hide_Call{Call: _e.mock.On("Hide")}
688}
689
690func (_c *MockWidget_Hide_Call) Run(run func()) *MockWidget_Hide_Call {
691	_c.Call.Run(func(args mock.Arguments) {
692		run()
693	})
694	return _c
695}
696
697func (_c *MockWidget_Hide_Call) Return() *MockWidget_Hide_Call {
698	_c.Call.Return()
699	return _c
700}
701
702func (_c *MockWidget_Hide_Call) RunAndReturn(run func()) *MockWidget_Hide_Call {
703	_c.Run(run)
704	return _c
705}
706
707// IsVisible provides a mock function for the type MockWidget
708func (_mock *MockWidget) IsVisible() bool {
709	ret := _mock.Called()
710
711	if len(ret) == 0 {
712		panic("no return value specified for IsVisible")
713	}
714
715	var r0 bool
716	if returnFunc, ok := ret.Get(0).(func() bool); ok {
717		r0 = returnFunc()
718	} else {
719		r0 = ret.Get(0).(bool)
720	}
721	return r0
722}
723
724// MockWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
725type MockWidget_IsVisible_Call struct {
726	*mock.Call
727}
728
729// IsVisible is a helper method to define mock.On call
730func (_e *MockWidget_Expecter) IsVisible() *MockWidget_IsVisible_Call {
731	return &MockWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
732}
733
734func (_c *MockWidget_IsVisible_Call) Run(run func()) *MockWidget_IsVisible_Call {
735	_c.Call.Run(func(args mock.Arguments) {
736		run()
737	})
738	return _c
739}
740
741func (_c *MockWidget_IsVisible_Call) Return(b bool) *MockWidget_IsVisible_Call {
742	_c.Call.Return(b)
743	return _c
744}
745
746func (_c *MockWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockWidget_IsVisible_Call {
747	_c.Call.Return(run)
748	return _c
749}
750
751// RemoveCssClass provides a mock function for the type MockWidget
752func (_mock *MockWidget) RemoveCssClass(cssClass string) {
753	_mock.Called(cssClass)
754	return
755}
756
757// MockWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
758type MockWidget_RemoveCssClass_Call struct {
759	*mock.Call
760}
761
762// RemoveCssClass is a helper method to define mock.On call
763//   - cssClass string
764func (_e *MockWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockWidget_RemoveCssClass_Call {
765	return &MockWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
766}
767
768func (_c *MockWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockWidget_RemoveCssClass_Call {
769	_c.Call.Run(func(args mock.Arguments) {
770		var arg0 string
771		if args[0] != nil {
772			arg0 = args[0].(string)
773		}
774		run(
775			arg0,
776		)
777	})
778	return _c
779}
780
781func (_c *MockWidget_RemoveCssClass_Call) Return() *MockWidget_RemoveCssClass_Call {
782	_c.Call.Return()
783	return _c
784}
785
786func (_c *MockWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockWidget_RemoveCssClass_Call {
787	_c.Run(run)
788	return _c
789}
790
791// SetCanFocus provides a mock function for the type MockWidget
792func (_mock *MockWidget) SetCanFocus(canFocus bool) {
793	_mock.Called(canFocus)
794	return
795}
796
797// MockWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
798type MockWidget_SetCanFocus_Call struct {
799	*mock.Call
800}
801
802// SetCanFocus is a helper method to define mock.On call
803//   - canFocus bool
804func (_e *MockWidget_Expecter) SetCanFocus(canFocus interface{}) *MockWidget_SetCanFocus_Call {
805	return &MockWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
806}
807
808func (_c *MockWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockWidget_SetCanFocus_Call {
809	_c.Call.Run(func(args mock.Arguments) {
810		var arg0 bool
811		if args[0] != nil {
812			arg0 = args[0].(bool)
813		}
814		run(
815			arg0,
816		)
817	})
818	return _c
819}
820
821func (_c *MockWidget_SetCanFocus_Call) Return() *MockWidget_SetCanFocus_Call {
822	_c.Call.Return()
823	return _c
824}
825
826func (_c *MockWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockWidget_SetCanFocus_Call {
827	_c.Run(run)
828	return _c
829}
830
831// SetCanTarget provides a mock function for the type MockWidget
832func (_mock *MockWidget) SetCanTarget(canTarget bool) {
833	_mock.Called(canTarget)
834	return
835}
836
837// MockWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
838type MockWidget_SetCanTarget_Call struct {
839	*mock.Call
840}
841
842// SetCanTarget is a helper method to define mock.On call
843//   - canTarget bool
844func (_e *MockWidget_Expecter) SetCanTarget(canTarget interface{}) *MockWidget_SetCanTarget_Call {
845	return &MockWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
846}
847
848func (_c *MockWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockWidget_SetCanTarget_Call {
849	_c.Call.Run(func(args mock.Arguments) {
850		var arg0 bool
851		if args[0] != nil {
852			arg0 = args[0].(bool)
853		}
854		run(
855			arg0,
856		)
857	})
858	return _c
859}
860
861func (_c *MockWidget_SetCanTarget_Call) Return() *MockWidget_SetCanTarget_Call {
862	_c.Call.Return()
863	return _c
864}
865
866func (_c *MockWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockWidget_SetCanTarget_Call {
867	_c.Run(run)
868	return _c
869}
870
871// SetFocusOnClick provides a mock function for the type MockWidget
872func (_mock *MockWidget) SetFocusOnClick(focusOnClick bool) {
873	_mock.Called(focusOnClick)
874	return
875}
876
877// MockWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
878type MockWidget_SetFocusOnClick_Call struct {
879	*mock.Call
880}
881
882// SetFocusOnClick is a helper method to define mock.On call
883//   - focusOnClick bool
884func (_e *MockWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockWidget_SetFocusOnClick_Call {
885	return &MockWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
886}
887
888func (_c *MockWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockWidget_SetFocusOnClick_Call {
889	_c.Call.Run(func(args mock.Arguments) {
890		var arg0 bool
891		if args[0] != nil {
892			arg0 = args[0].(bool)
893		}
894		run(
895			arg0,
896		)
897	})
898	return _c
899}
900
901func (_c *MockWidget_SetFocusOnClick_Call) Return() *MockWidget_SetFocusOnClick_Call {
902	_c.Call.Return()
903	return _c
904}
905
906func (_c *MockWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockWidget_SetFocusOnClick_Call {
907	_c.Run(run)
908	return _c
909}
910
911// SetHalign provides a mock function for the type MockWidget
912func (_mock *MockWidget) SetHalign(align gtk.Align) {
913	_mock.Called(align)
914	return
915}
916
917// MockWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
918type MockWidget_SetHalign_Call struct {
919	*mock.Call
920}
921
922// SetHalign is a helper method to define mock.On call
923//   - align gtk.Align
924func (_e *MockWidget_Expecter) SetHalign(align interface{}) *MockWidget_SetHalign_Call {
925	return &MockWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
926}
927
928func (_c *MockWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockWidget_SetHalign_Call {
929	_c.Call.Run(func(args mock.Arguments) {
930		var arg0 gtk.Align
931		if args[0] != nil {
932			arg0 = args[0].(gtk.Align)
933		}
934		run(
935			arg0,
936		)
937	})
938	return _c
939}
940
941func (_c *MockWidget_SetHalign_Call) Return() *MockWidget_SetHalign_Call {
942	_c.Call.Return()
943	return _c
944}
945
946func (_c *MockWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockWidget_SetHalign_Call {
947	_c.Run(run)
948	return _c
949}
950
951// SetHexpand provides a mock function for the type MockWidget
952func (_mock *MockWidget) SetHexpand(expand bool) {
953	_mock.Called(expand)
954	return
955}
956
957// MockWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
958type MockWidget_SetHexpand_Call struct {
959	*mock.Call
960}
961
962// SetHexpand is a helper method to define mock.On call
963//   - expand bool
964func (_e *MockWidget_Expecter) SetHexpand(expand interface{}) *MockWidget_SetHexpand_Call {
965	return &MockWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
966}
967
968func (_c *MockWidget_SetHexpand_Call) Run(run func(expand bool)) *MockWidget_SetHexpand_Call {
969	_c.Call.Run(func(args mock.Arguments) {
970		var arg0 bool
971		if args[0] != nil {
972			arg0 = args[0].(bool)
973		}
974		run(
975			arg0,
976		)
977	})
978	return _c
979}
980
981func (_c *MockWidget_SetHexpand_Call) Return() *MockWidget_SetHexpand_Call {
982	_c.Call.Return()
983	return _c
984}
985
986func (_c *MockWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockWidget_SetHexpand_Call {
987	_c.Run(run)
988	return _c
989}
990
991// SetSizeRequest provides a mock function for the type MockWidget
992func (_mock *MockWidget) SetSizeRequest(width int, height int) {
993	_mock.Called(width, height)
994	return
995}
996
997// MockWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
998type MockWidget_SetSizeRequest_Call struct {
999	*mock.Call
1000}
1001
1002// SetSizeRequest is a helper method to define mock.On call
1003//   - width int
1004//   - height int
1005func (_e *MockWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockWidget_SetSizeRequest_Call {
1006	return &MockWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
1007}
1008
1009func (_c *MockWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockWidget_SetSizeRequest_Call {
1010	_c.Call.Run(func(args mock.Arguments) {
1011		var arg0 int
1012		if args[0] != nil {
1013			arg0 = args[0].(int)
1014		}
1015		var arg1 int
1016		if args[1] != nil {
1017			arg1 = args[1].(int)
1018		}
1019		run(
1020			arg0,
1021			arg1,
1022		)
1023	})
1024	return _c
1025}
1026
1027func (_c *MockWidget_SetSizeRequest_Call) Return() *MockWidget_SetSizeRequest_Call {
1028	_c.Call.Return()
1029	return _c
1030}
1031
1032func (_c *MockWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockWidget_SetSizeRequest_Call {
1033	_c.Run(run)
1034	return _c
1035}
1036
1037// SetValign provides a mock function for the type MockWidget
1038func (_mock *MockWidget) SetValign(align gtk.Align) {
1039	_mock.Called(align)
1040	return
1041}
1042
1043// MockWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
1044type MockWidget_SetValign_Call struct {
1045	*mock.Call
1046}
1047
1048// SetValign is a helper method to define mock.On call
1049//   - align gtk.Align
1050func (_e *MockWidget_Expecter) SetValign(align interface{}) *MockWidget_SetValign_Call {
1051	return &MockWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
1052}
1053
1054func (_c *MockWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockWidget_SetValign_Call {
1055	_c.Call.Run(func(args mock.Arguments) {
1056		var arg0 gtk.Align
1057		if args[0] != nil {
1058			arg0 = args[0].(gtk.Align)
1059		}
1060		run(
1061			arg0,
1062		)
1063	})
1064	return _c
1065}
1066
1067func (_c *MockWidget_SetValign_Call) Return() *MockWidget_SetValign_Call {
1068	_c.Call.Return()
1069	return _c
1070}
1071
1072func (_c *MockWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockWidget_SetValign_Call {
1073	_c.Run(run)
1074	return _c
1075}
1076
1077// SetVexpand provides a mock function for the type MockWidget
1078func (_mock *MockWidget) SetVexpand(expand bool) {
1079	_mock.Called(expand)
1080	return
1081}
1082
1083// MockWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
1084type MockWidget_SetVexpand_Call struct {
1085	*mock.Call
1086}
1087
1088// SetVexpand is a helper method to define mock.On call
1089//   - expand bool
1090func (_e *MockWidget_Expecter) SetVexpand(expand interface{}) *MockWidget_SetVexpand_Call {
1091	return &MockWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
1092}
1093
1094func (_c *MockWidget_SetVexpand_Call) Run(run func(expand bool)) *MockWidget_SetVexpand_Call {
1095	_c.Call.Run(func(args mock.Arguments) {
1096		var arg0 bool
1097		if args[0] != nil {
1098			arg0 = args[0].(bool)
1099		}
1100		run(
1101			arg0,
1102		)
1103	})
1104	return _c
1105}
1106
1107func (_c *MockWidget_SetVexpand_Call) Return() *MockWidget_SetVexpand_Call {
1108	_c.Call.Return()
1109	return _c
1110}
1111
1112func (_c *MockWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockWidget_SetVexpand_Call {
1113	_c.Run(run)
1114	return _c
1115}
1116
1117// SetVisible provides a mock function for the type MockWidget
1118func (_mock *MockWidget) SetVisible(visible bool) {
1119	_mock.Called(visible)
1120	return
1121}
1122
1123// MockWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
1124type MockWidget_SetVisible_Call struct {
1125	*mock.Call
1126}
1127
1128// SetVisible is a helper method to define mock.On call
1129//   - visible bool
1130func (_e *MockWidget_Expecter) SetVisible(visible interface{}) *MockWidget_SetVisible_Call {
1131	return &MockWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
1132}
1133
1134func (_c *MockWidget_SetVisible_Call) Run(run func(visible bool)) *MockWidget_SetVisible_Call {
1135	_c.Call.Run(func(args mock.Arguments) {
1136		var arg0 bool
1137		if args[0] != nil {
1138			arg0 = args[0].(bool)
1139		}
1140		run(
1141			arg0,
1142		)
1143	})
1144	return _c
1145}
1146
1147func (_c *MockWidget_SetVisible_Call) Return() *MockWidget_SetVisible_Call {
1148	_c.Call.Return()
1149	return _c
1150}
1151
1152func (_c *MockWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockWidget_SetVisible_Call {
1153	_c.Run(run)
1154	return _c
1155}
1156
1157// Show provides a mock function for the type MockWidget
1158func (_mock *MockWidget) Show() {
1159	_mock.Called()
1160	return
1161}
1162
1163// MockWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
1164type MockWidget_Show_Call struct {
1165	*mock.Call
1166}
1167
1168// Show is a helper method to define mock.On call
1169func (_e *MockWidget_Expecter) Show() *MockWidget_Show_Call {
1170	return &MockWidget_Show_Call{Call: _e.mock.On("Show")}
1171}
1172
1173func (_c *MockWidget_Show_Call) Run(run func()) *MockWidget_Show_Call {
1174	_c.Call.Run(func(args mock.Arguments) {
1175		run()
1176	})
1177	return _c
1178}
1179
1180func (_c *MockWidget_Show_Call) Return() *MockWidget_Show_Call {
1181	_c.Call.Return()
1182	return _c
1183}
1184
1185func (_c *MockWidget_Show_Call) RunAndReturn(run func()) *MockWidget_Show_Call {
1186	_c.Run(run)
1187	return _c
1188}
1189
1190// Unparent provides a mock function for the type MockWidget
1191func (_mock *MockWidget) Unparent() {
1192	_mock.Called()
1193	return
1194}
1195
1196// MockWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
1197type MockWidget_Unparent_Call struct {
1198	*mock.Call
1199}
1200
1201// Unparent is a helper method to define mock.On call
1202func (_e *MockWidget_Expecter) Unparent() *MockWidget_Unparent_Call {
1203	return &MockWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
1204}
1205
1206func (_c *MockWidget_Unparent_Call) Run(run func()) *MockWidget_Unparent_Call {
1207	_c.Call.Run(func(args mock.Arguments) {
1208		run()
1209	})
1210	return _c
1211}
1212
1213func (_c *MockWidget_Unparent_Call) Return() *MockWidget_Unparent_Call {
1214	_c.Call.Return()
1215	return _c
1216}
1217
1218func (_c *MockWidget_Unparent_Call) RunAndReturn(run func()) *MockWidget_Unparent_Call {
1219	_c.Run(run)
1220	return _c
1221}
1222
1223// 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.
1224// The first argument is typically a *testing.T value.
1225func NewMockPanedWidget(t interface {
1226	mock.TestingT
1227	Cleanup(func())
1228}) *MockPanedWidget {
1229	mock := &MockPanedWidget{}
1230	mock.Mock.Test(t)
1231
1232	t.Cleanup(func() { mock.AssertExpectations(t) })
1233
1234	return mock
1235}
1236
1237// MockPanedWidget is an autogenerated mock type for the PanedWidget type
1238type MockPanedWidget struct {
1239	mock.Mock
1240}
1241
1242type MockPanedWidget_Expecter struct {
1243	mock *mock.Mock
1244}
1245
1246func (_m *MockPanedWidget) EXPECT() *MockPanedWidget_Expecter {
1247	return &MockPanedWidget_Expecter{mock: &_m.Mock}
1248}
1249
1250// AddController provides a mock function for the type MockPanedWidget
1251func (_mock *MockPanedWidget) AddController(controller *gtk.EventController) {
1252	_mock.Called(controller)
1253	return
1254}
1255
1256// MockPanedWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
1257type MockPanedWidget_AddController_Call struct {
1258	*mock.Call
1259}
1260
1261// AddController is a helper method to define mock.On call
1262//   - controller *gtk.EventController
1263func (_e *MockPanedWidget_Expecter) AddController(controller interface{}) *MockPanedWidget_AddController_Call {
1264	return &MockPanedWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
1265}
1266
1267func (_c *MockPanedWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockPanedWidget_AddController_Call {
1268	_c.Call.Run(func(args mock.Arguments) {
1269		var arg0 *gtk.EventController
1270		if args[0] != nil {
1271			arg0 = args[0].(*gtk.EventController)
1272		}
1273		run(
1274			arg0,
1275		)
1276	})
1277	return _c
1278}
1279
1280func (_c *MockPanedWidget_AddController_Call) Return() *MockPanedWidget_AddController_Call {
1281	_c.Call.Return()
1282	return _c
1283}
1284
1285func (_c *MockPanedWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockPanedWidget_AddController_Call {
1286	_c.Run(run)
1287	return _c
1288}
1289
1290// AddCssClass provides a mock function for the type MockPanedWidget
1291func (_mock *MockPanedWidget) AddCssClass(cssClass string) {
1292	_mock.Called(cssClass)
1293	return
1294}
1295
1296// MockPanedWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
1297type MockPanedWidget_AddCssClass_Call struct {
1298	*mock.Call
1299}
1300
1301// AddCssClass is a helper method to define mock.On call
1302//   - cssClass string
1303func (_e *MockPanedWidget_Expecter) AddCssClass(cssClass interface{}) *MockPanedWidget_AddCssClass_Call {
1304	return &MockPanedWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
1305}
1306
1307func (_c *MockPanedWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_AddCssClass_Call {
1308	_c.Call.Run(func(args mock.Arguments) {
1309		var arg0 string
1310		if args[0] != nil {
1311			arg0 = args[0].(string)
1312		}
1313		run(
1314			arg0,
1315		)
1316	})
1317	return _c
1318}
1319
1320func (_c *MockPanedWidget_AddCssClass_Call) Return() *MockPanedWidget_AddCssClass_Call {
1321	_c.Call.Return()
1322	return _c
1323}
1324
1325func (_c *MockPanedWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockPanedWidget_AddCssClass_Call {
1326	_c.Run(run)
1327	return _c
1328}
1329
1330// AddTickCallback provides a mock function for the type MockPanedWidget
1331func (_mock *MockPanedWidget) AddTickCallback(callback func() bool) uint {
1332	ret := _mock.Called(callback)
1333
1334	if len(ret) == 0 {
1335		panic("no return value specified for AddTickCallback")
1336	}
1337
1338	var r0 uint
1339	if returnFunc, ok := ret.Get(0).(func(func() bool) uint); ok {
1340		r0 = returnFunc(callback)
1341	} else {
1342		r0 = ret.Get(0).(uint)
1343	}
1344	return r0
1345}
1346
1347// MockPanedWidget_AddTickCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTickCallback'
1348type MockPanedWidget_AddTickCallback_Call struct {
1349	*mock.Call
1350}
1351
1352// AddTickCallback is a helper method to define mock.On call
1353//   - callback func() bool
1354func (_e *MockPanedWidget_Expecter) AddTickCallback(callback interface{}) *MockPanedWidget_AddTickCallback_Call {
1355	return &MockPanedWidget_AddTickCallback_Call{Call: _e.mock.On("AddTickCallback", callback)}
1356}
1357
1358func (_c *MockPanedWidget_AddTickCallback_Call) Run(run func(callback func() bool)) *MockPanedWidget_AddTickCallback_Call {
1359	_c.Call.Run(func(args mock.Arguments) {
1360		var arg0 func() bool
1361		if args[0] != nil {
1362			arg0 = args[0].(func() bool)
1363		}
1364		run(
1365			arg0,
1366		)
1367	})
1368	return _c
1369}
1370
1371func (_c *MockPanedWidget_AddTickCallback_Call) Return(v uint) *MockPanedWidget_AddTickCallback_Call {
1372	_c.Call.Return(v)
1373	return _c
1374}
1375
1376func (_c *MockPanedWidget_AddTickCallback_Call) RunAndReturn(run func(callback func() bool) uint) *MockPanedWidget_AddTickCallback_Call {
1377	_c.Call.Return(run)
1378	return _c
1379}
1380
1381// ComputePoint provides a mock function for the type MockPanedWidget
1382func (_mock *MockPanedWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
1383	ret := _mock.Called(target)
1384
1385	if len(ret) == 0 {
1386		panic("no return value specified for ComputePoint")
1387	}
1388
1389	var r0 float64
1390	var r1 float64
1391	var r2 bool
1392	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
1393		return returnFunc(target)
1394	}
1395	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
1396		r0 = returnFunc(target)
1397	} else {
1398		r0 = ret.Get(0).(float64)
1399	}
1400	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
1401		r1 = returnFunc(target)
1402	} else {
1403		r1 = ret.Get(1).(float64)
1404	}
1405	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
1406		r2 = returnFunc(target)
1407	} else {
1408		r2 = ret.Get(2).(bool)
1409	}
1410	return r0, r1, r2
1411}
1412
1413// MockPanedWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
1414type MockPanedWidget_ComputePoint_Call struct {
1415	*mock.Call
1416}
1417
1418// ComputePoint is a helper method to define mock.On call
1419//   - target layout.Widget
1420func (_e *MockPanedWidget_Expecter) ComputePoint(target interface{}) *MockPanedWidget_ComputePoint_Call {
1421	return &MockPanedWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
1422}
1423
1424func (_c *MockPanedWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockPanedWidget_ComputePoint_Call {
1425	_c.Call.Run(func(args mock.Arguments) {
1426		var arg0 layout.Widget
1427		if args[0] != nil {
1428			arg0 = args[0].(layout.Widget)
1429		}
1430		run(
1431			arg0,
1432		)
1433	})
1434	return _c
1435}
1436
1437func (_c *MockPanedWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockPanedWidget_ComputePoint_Call {
1438	_c.Call.Return(x, y, ok)
1439	return _c
1440}
1441
1442func (_c *MockPanedWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockPanedWidget_ComputePoint_Call {
1443	_c.Call.Return(run)
1444	return _c
1445}
1446
1447// ConnectMap provides a mock function for the type MockPanedWidget
1448func (_mock *MockPanedWidget) ConnectMap(callback func()) uint32 {
1449	ret := _mock.Called(callback)
1450
1451	if len(ret) == 0 {
1452		panic("no return value specified for ConnectMap")
1453	}
1454
1455	var r0 uint32
1456	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
1457		r0 = returnFunc(callback)
1458	} else {
1459		r0 = ret.Get(0).(uint32)
1460	}
1461	return r0
1462}
1463
1464// MockPanedWidget_ConnectMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectMap'
1465type MockPanedWidget_ConnectMap_Call struct {
1466	*mock.Call
1467}
1468
1469// ConnectMap is a helper method to define mock.On call
1470//   - callback func()
1471func (_e *MockPanedWidget_Expecter) ConnectMap(callback interface{}) *MockPanedWidget_ConnectMap_Call {
1472	return &MockPanedWidget_ConnectMap_Call{Call: _e.mock.On("ConnectMap", callback)}
1473}
1474
1475func (_c *MockPanedWidget_ConnectMap_Call) Run(run func(callback func())) *MockPanedWidget_ConnectMap_Call {
1476	_c.Call.Run(func(args mock.Arguments) {
1477		var arg0 func()
1478		if args[0] != nil {
1479			arg0 = args[0].(func())
1480		}
1481		run(
1482			arg0,
1483		)
1484	})
1485	return _c
1486}
1487
1488func (_c *MockPanedWidget_ConnectMap_Call) Return(v uint32) *MockPanedWidget_ConnectMap_Call {
1489	_c.Call.Return(v)
1490	return _c
1491}
1492
1493func (_c *MockPanedWidget_ConnectMap_Call) RunAndReturn(run func(callback func()) uint32) *MockPanedWidget_ConnectMap_Call {
1494	_c.Call.Return(run)
1495	return _c
1496}
1497
1498// ConnectNotifyPosition provides a mock function for the type MockPanedWidget
1499func (_mock *MockPanedWidget) ConnectNotifyPosition(callback func()) uint32 {
1500	ret := _mock.Called(callback)
1501
1502	if len(ret) == 0 {
1503		panic("no return value specified for ConnectNotifyPosition")
1504	}
1505
1506	var r0 uint32
1507	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
1508		r0 = returnFunc(callback)
1509	} else {
1510		r0 = ret.Get(0).(uint32)
1511	}
1512	return r0
1513}
1514
1515// MockPanedWidget_ConnectNotifyPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectNotifyPosition'
1516type MockPanedWidget_ConnectNotifyPosition_Call struct {
1517	*mock.Call
1518}
1519
1520// ConnectNotifyPosition is a helper method to define mock.On call
1521//   - callback func()
1522func (_e *MockPanedWidget_Expecter) ConnectNotifyPosition(callback interface{}) *MockPanedWidget_ConnectNotifyPosition_Call {
1523	return &MockPanedWidget_ConnectNotifyPosition_Call{Call: _e.mock.On("ConnectNotifyPosition", callback)}
1524}
1525
1526func (_c *MockPanedWidget_ConnectNotifyPosition_Call) Run(run func(callback func())) *MockPanedWidget_ConnectNotifyPosition_Call {
1527	_c.Call.Run(func(args mock.Arguments) {
1528		var arg0 func()
1529		if args[0] != nil {
1530			arg0 = args[0].(func())
1531		}
1532		run(
1533			arg0,
1534		)
1535	})
1536	return _c
1537}
1538
1539func (_c *MockPanedWidget_ConnectNotifyPosition_Call) Return(v uint32) *MockPanedWidget_ConnectNotifyPosition_Call {
1540	_c.Call.Return(v)
1541	return _c
1542}
1543
1544func (_c *MockPanedWidget_ConnectNotifyPosition_Call) RunAndReturn(run func(callback func()) uint32) *MockPanedWidget_ConnectNotifyPosition_Call {
1545	_c.Call.Return(run)
1546	return _c
1547}
1548
1549// GetAllocatedHeight provides a mock function for the type MockPanedWidget
1550func (_mock *MockPanedWidget) GetAllocatedHeight() int {
1551	ret := _mock.Called()
1552
1553	if len(ret) == 0 {
1554		panic("no return value specified for GetAllocatedHeight")
1555	}
1556
1557	var r0 int
1558	if returnFunc, ok := ret.Get(0).(func() int); ok {
1559		r0 = returnFunc()
1560	} else {
1561		r0 = ret.Get(0).(int)
1562	}
1563	return r0
1564}
1565
1566// MockPanedWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
1567type MockPanedWidget_GetAllocatedHeight_Call struct {
1568	*mock.Call
1569}
1570
1571// GetAllocatedHeight is a helper method to define mock.On call
1572func (_e *MockPanedWidget_Expecter) GetAllocatedHeight() *MockPanedWidget_GetAllocatedHeight_Call {
1573	return &MockPanedWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
1574}
1575
1576func (_c *MockPanedWidget_GetAllocatedHeight_Call) Run(run func()) *MockPanedWidget_GetAllocatedHeight_Call {
1577	_c.Call.Run(func(args mock.Arguments) {
1578		run()
1579	})
1580	return _c
1581}
1582
1583func (_c *MockPanedWidget_GetAllocatedHeight_Call) Return(n int) *MockPanedWidget_GetAllocatedHeight_Call {
1584	_c.Call.Return(n)
1585	return _c
1586}
1587
1588func (_c *MockPanedWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockPanedWidget_GetAllocatedHeight_Call {
1589	_c.Call.Return(run)
1590	return _c
1591}
1592
1593// GetAllocatedWidth provides a mock function for the type MockPanedWidget
1594func (_mock *MockPanedWidget) GetAllocatedWidth() int {
1595	ret := _mock.Called()
1596
1597	if len(ret) == 0 {
1598		panic("no return value specified for GetAllocatedWidth")
1599	}
1600
1601	var r0 int
1602	if returnFunc, ok := ret.Get(0).(func() int); ok {
1603		r0 = returnFunc()
1604	} else {
1605		r0 = ret.Get(0).(int)
1606	}
1607	return r0
1608}
1609
1610// MockPanedWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
1611type MockPanedWidget_GetAllocatedWidth_Call struct {
1612	*mock.Call
1613}
1614
1615// GetAllocatedWidth is a helper method to define mock.On call
1616func (_e *MockPanedWidget_Expecter) GetAllocatedWidth() *MockPanedWidget_GetAllocatedWidth_Call {
1617	return &MockPanedWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
1618}
1619
1620func (_c *MockPanedWidget_GetAllocatedWidth_Call) Run(run func()) *MockPanedWidget_GetAllocatedWidth_Call {
1621	_c.Call.Run(func(args mock.Arguments) {
1622		run()
1623	})
1624	return _c
1625}
1626
1627func (_c *MockPanedWidget_GetAllocatedWidth_Call) Return(n int) *MockPanedWidget_GetAllocatedWidth_Call {
1628	_c.Call.Return(n)
1629	return _c
1630}
1631
1632func (_c *MockPanedWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockPanedWidget_GetAllocatedWidth_Call {
1633	_c.Call.Return(run)
1634	return _c
1635}
1636
1637// GetEndChild provides a mock function for the type MockPanedWidget
1638func (_mock *MockPanedWidget) GetEndChild() layout.Widget {
1639	ret := _mock.Called()
1640
1641	if len(ret) == 0 {
1642		panic("no return value specified for GetEndChild")
1643	}
1644
1645	var r0 layout.Widget
1646	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
1647		r0 = returnFunc()
1648	} else {
1649		if ret.Get(0) != nil {
1650			r0 = ret.Get(0).(layout.Widget)
1651		}
1652	}
1653	return r0
1654}
1655
1656// MockPanedWidget_GetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEndChild'
1657type MockPanedWidget_GetEndChild_Call struct {
1658	*mock.Call
1659}
1660
1661// GetEndChild is a helper method to define mock.On call
1662func (_e *MockPanedWidget_Expecter) GetEndChild() *MockPanedWidget_GetEndChild_Call {
1663	return &MockPanedWidget_GetEndChild_Call{Call: _e.mock.On("GetEndChild")}
1664}
1665
1666func (_c *MockPanedWidget_GetEndChild_Call) Run(run func()) *MockPanedWidget_GetEndChild_Call {
1667	_c.Call.Run(func(args mock.Arguments) {
1668		run()
1669	})
1670	return _c
1671}
1672
1673func (_c *MockPanedWidget_GetEndChild_Call) Return(widget layout.Widget) *MockPanedWidget_GetEndChild_Call {
1674	_c.Call.Return(widget)
1675	return _c
1676}
1677
1678func (_c *MockPanedWidget_GetEndChild_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetEndChild_Call {
1679	_c.Call.Return(run)
1680	return _c
1681}
1682
1683// GetHexpand provides a mock function for the type MockPanedWidget
1684func (_mock *MockPanedWidget) GetHexpand() bool {
1685	ret := _mock.Called()
1686
1687	if len(ret) == 0 {
1688		panic("no return value specified for GetHexpand")
1689	}
1690
1691	var r0 bool
1692	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1693		r0 = returnFunc()
1694	} else {
1695		r0 = ret.Get(0).(bool)
1696	}
1697	return r0
1698}
1699
1700// MockPanedWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
1701type MockPanedWidget_GetHexpand_Call struct {
1702	*mock.Call
1703}
1704
1705// GetHexpand is a helper method to define mock.On call
1706func (_e *MockPanedWidget_Expecter) GetHexpand() *MockPanedWidget_GetHexpand_Call {
1707	return &MockPanedWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
1708}
1709
1710func (_c *MockPanedWidget_GetHexpand_Call) Run(run func()) *MockPanedWidget_GetHexpand_Call {
1711	_c.Call.Run(func(args mock.Arguments) {
1712		run()
1713	})
1714	return _c
1715}
1716
1717func (_c *MockPanedWidget_GetHexpand_Call) Return(b bool) *MockPanedWidget_GetHexpand_Call {
1718	_c.Call.Return(b)
1719	return _c
1720}
1721
1722func (_c *MockPanedWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetHexpand_Call {
1723	_c.Call.Return(run)
1724	return _c
1725}
1726
1727// GetParent provides a mock function for the type MockPanedWidget
1728func (_mock *MockPanedWidget) GetParent() layout.Widget {
1729	ret := _mock.Called()
1730
1731	if len(ret) == 0 {
1732		panic("no return value specified for GetParent")
1733	}
1734
1735	var r0 layout.Widget
1736	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
1737		r0 = returnFunc()
1738	} else {
1739		if ret.Get(0) != nil {
1740			r0 = ret.Get(0).(layout.Widget)
1741		}
1742	}
1743	return r0
1744}
1745
1746// MockPanedWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
1747type MockPanedWidget_GetParent_Call struct {
1748	*mock.Call
1749}
1750
1751// GetParent is a helper method to define mock.On call
1752func (_e *MockPanedWidget_Expecter) GetParent() *MockPanedWidget_GetParent_Call {
1753	return &MockPanedWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
1754}
1755
1756func (_c *MockPanedWidget_GetParent_Call) Run(run func()) *MockPanedWidget_GetParent_Call {
1757	_c.Call.Run(func(args mock.Arguments) {
1758		run()
1759	})
1760	return _c
1761}
1762
1763func (_c *MockPanedWidget_GetParent_Call) Return(widget layout.Widget) *MockPanedWidget_GetParent_Call {
1764	_c.Call.Return(widget)
1765	return _c
1766}
1767
1768func (_c *MockPanedWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetParent_Call {
1769	_c.Call.Return(run)
1770	return _c
1771}
1772
1773// GetPosition provides a mock function for the type MockPanedWidget
1774func (_mock *MockPanedWidget) GetPosition() int {
1775	ret := _mock.Called()
1776
1777	if len(ret) == 0 {
1778		panic("no return value specified for GetPosition")
1779	}
1780
1781	var r0 int
1782	if returnFunc, ok := ret.Get(0).(func() int); ok {
1783		r0 = returnFunc()
1784	} else {
1785		r0 = ret.Get(0).(int)
1786	}
1787	return r0
1788}
1789
1790// MockPanedWidget_GetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPosition'
1791type MockPanedWidget_GetPosition_Call struct {
1792	*mock.Call
1793}
1794
1795// GetPosition is a helper method to define mock.On call
1796func (_e *MockPanedWidget_Expecter) GetPosition() *MockPanedWidget_GetPosition_Call {
1797	return &MockPanedWidget_GetPosition_Call{Call: _e.mock.On("GetPosition")}
1798}
1799
1800func (_c *MockPanedWidget_GetPosition_Call) Run(run func()) *MockPanedWidget_GetPosition_Call {
1801	_c.Call.Run(func(args mock.Arguments) {
1802		run()
1803	})
1804	return _c
1805}
1806
1807func (_c *MockPanedWidget_GetPosition_Call) Return(n int) *MockPanedWidget_GetPosition_Call {
1808	_c.Call.Return(n)
1809	return _c
1810}
1811
1812func (_c *MockPanedWidget_GetPosition_Call) RunAndReturn(run func() int) *MockPanedWidget_GetPosition_Call {
1813	_c.Call.Return(run)
1814	return _c
1815}
1816
1817// GetResizeEndChild provides a mock function for the type MockPanedWidget
1818func (_mock *MockPanedWidget) GetResizeEndChild() bool {
1819	ret := _mock.Called()
1820
1821	if len(ret) == 0 {
1822		panic("no return value specified for GetResizeEndChild")
1823	}
1824
1825	var r0 bool
1826	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1827		r0 = returnFunc()
1828	} else {
1829		r0 = ret.Get(0).(bool)
1830	}
1831	return r0
1832}
1833
1834// MockPanedWidget_GetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeEndChild'
1835type MockPanedWidget_GetResizeEndChild_Call struct {
1836	*mock.Call
1837}
1838
1839// GetResizeEndChild is a helper method to define mock.On call
1840func (_e *MockPanedWidget_Expecter) GetResizeEndChild() *MockPanedWidget_GetResizeEndChild_Call {
1841	return &MockPanedWidget_GetResizeEndChild_Call{Call: _e.mock.On("GetResizeEndChild")}
1842}
1843
1844func (_c *MockPanedWidget_GetResizeEndChild_Call) Run(run func()) *MockPanedWidget_GetResizeEndChild_Call {
1845	_c.Call.Run(func(args mock.Arguments) {
1846		run()
1847	})
1848	return _c
1849}
1850
1851func (_c *MockPanedWidget_GetResizeEndChild_Call) Return(b bool) *MockPanedWidget_GetResizeEndChild_Call {
1852	_c.Call.Return(b)
1853	return _c
1854}
1855
1856func (_c *MockPanedWidget_GetResizeEndChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetResizeEndChild_Call {
1857	_c.Call.Return(run)
1858	return _c
1859}
1860
1861// GetResizeStartChild provides a mock function for the type MockPanedWidget
1862func (_mock *MockPanedWidget) GetResizeStartChild() bool {
1863	ret := _mock.Called()
1864
1865	if len(ret) == 0 {
1866		panic("no return value specified for GetResizeStartChild")
1867	}
1868
1869	var r0 bool
1870	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1871		r0 = returnFunc()
1872	} else {
1873		r0 = ret.Get(0).(bool)
1874	}
1875	return r0
1876}
1877
1878// MockPanedWidget_GetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeStartChild'
1879type MockPanedWidget_GetResizeStartChild_Call struct {
1880	*mock.Call
1881}
1882
1883// GetResizeStartChild is a helper method to define mock.On call
1884func (_e *MockPanedWidget_Expecter) GetResizeStartChild() *MockPanedWidget_GetResizeStartChild_Call {
1885	return &MockPanedWidget_GetResizeStartChild_Call{Call: _e.mock.On("GetResizeStartChild")}
1886}
1887
1888func (_c *MockPanedWidget_GetResizeStartChild_Call) Run(run func()) *MockPanedWidget_GetResizeStartChild_Call {
1889	_c.Call.Run(func(args mock.Arguments) {
1890		run()
1891	})
1892	return _c
1893}
1894
1895func (_c *MockPanedWidget_GetResizeStartChild_Call) Return(b bool) *MockPanedWidget_GetResizeStartChild_Call {
1896	_c.Call.Return(b)
1897	return _c
1898}
1899
1900func (_c *MockPanedWidget_GetResizeStartChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetResizeStartChild_Call {
1901	_c.Call.Return(run)
1902	return _c
1903}
1904
1905// GetShrinkEndChild provides a mock function for the type MockPanedWidget
1906func (_mock *MockPanedWidget) GetShrinkEndChild() bool {
1907	ret := _mock.Called()
1908
1909	if len(ret) == 0 {
1910		panic("no return value specified for GetShrinkEndChild")
1911	}
1912
1913	var r0 bool
1914	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1915		r0 = returnFunc()
1916	} else {
1917		r0 = ret.Get(0).(bool)
1918	}
1919	return r0
1920}
1921
1922// MockPanedWidget_GetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkEndChild'
1923type MockPanedWidget_GetShrinkEndChild_Call struct {
1924	*mock.Call
1925}
1926
1927// GetShrinkEndChild is a helper method to define mock.On call
1928func (_e *MockPanedWidget_Expecter) GetShrinkEndChild() *MockPanedWidget_GetShrinkEndChild_Call {
1929	return &MockPanedWidget_GetShrinkEndChild_Call{Call: _e.mock.On("GetShrinkEndChild")}
1930}
1931
1932func (_c *MockPanedWidget_GetShrinkEndChild_Call) Run(run func()) *MockPanedWidget_GetShrinkEndChild_Call {
1933	_c.Call.Run(func(args mock.Arguments) {
1934		run()
1935	})
1936	return _c
1937}
1938
1939func (_c *MockPanedWidget_GetShrinkEndChild_Call) Return(b bool) *MockPanedWidget_GetShrinkEndChild_Call {
1940	_c.Call.Return(b)
1941	return _c
1942}
1943
1944func (_c *MockPanedWidget_GetShrinkEndChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetShrinkEndChild_Call {
1945	_c.Call.Return(run)
1946	return _c
1947}
1948
1949// GetShrinkStartChild provides a mock function for the type MockPanedWidget
1950func (_mock *MockPanedWidget) GetShrinkStartChild() bool {
1951	ret := _mock.Called()
1952
1953	if len(ret) == 0 {
1954		panic("no return value specified for GetShrinkStartChild")
1955	}
1956
1957	var r0 bool
1958	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1959		r0 = returnFunc()
1960	} else {
1961		r0 = ret.Get(0).(bool)
1962	}
1963	return r0
1964}
1965
1966// MockPanedWidget_GetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkStartChild'
1967type MockPanedWidget_GetShrinkStartChild_Call struct {
1968	*mock.Call
1969}
1970
1971// GetShrinkStartChild is a helper method to define mock.On call
1972func (_e *MockPanedWidget_Expecter) GetShrinkStartChild() *MockPanedWidget_GetShrinkStartChild_Call {
1973	return &MockPanedWidget_GetShrinkStartChild_Call{Call: _e.mock.On("GetShrinkStartChild")}
1974}
1975
1976func (_c *MockPanedWidget_GetShrinkStartChild_Call) Run(run func()) *MockPanedWidget_GetShrinkStartChild_Call {
1977	_c.Call.Run(func(args mock.Arguments) {
1978		run()
1979	})
1980	return _c
1981}
1982
1983func (_c *MockPanedWidget_GetShrinkStartChild_Call) Return(b bool) *MockPanedWidget_GetShrinkStartChild_Call {
1984	_c.Call.Return(b)
1985	return _c
1986}
1987
1988func (_c *MockPanedWidget_GetShrinkStartChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetShrinkStartChild_Call {
1989	_c.Call.Return(run)
1990	return _c
1991}
1992
1993// GetStartChild provides a mock function for the type MockPanedWidget
1994func (_mock *MockPanedWidget) GetStartChild() layout.Widget {
1995	ret := _mock.Called()
1996
1997	if len(ret) == 0 {
1998		panic("no return value specified for GetStartChild")
1999	}
2000
2001	var r0 layout.Widget
2002	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
2003		r0 = returnFunc()
2004	} else {
2005		if ret.Get(0) != nil {
2006			r0 = ret.Get(0).(layout.Widget)
2007		}
2008	}
2009	return r0
2010}
2011
2012// MockPanedWidget_GetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStartChild'
2013type MockPanedWidget_GetStartChild_Call struct {
2014	*mock.Call
2015}
2016
2017// GetStartChild is a helper method to define mock.On call
2018func (_e *MockPanedWidget_Expecter) GetStartChild() *MockPanedWidget_GetStartChild_Call {
2019	return &MockPanedWidget_GetStartChild_Call{Call: _e.mock.On("GetStartChild")}
2020}
2021
2022func (_c *MockPanedWidget_GetStartChild_Call) Run(run func()) *MockPanedWidget_GetStartChild_Call {
2023	_c.Call.Run(func(args mock.Arguments) {
2024		run()
2025	})
2026	return _c
2027}
2028
2029func (_c *MockPanedWidget_GetStartChild_Call) Return(widget layout.Widget) *MockPanedWidget_GetStartChild_Call {
2030	_c.Call.Return(widget)
2031	return _c
2032}
2033
2034func (_c *MockPanedWidget_GetStartChild_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetStartChild_Call {
2035	_c.Call.Return(run)
2036	return _c
2037}
2038
2039// GetVexpand provides a mock function for the type MockPanedWidget
2040func (_mock *MockPanedWidget) GetVexpand() bool {
2041	ret := _mock.Called()
2042
2043	if len(ret) == 0 {
2044		panic("no return value specified for GetVexpand")
2045	}
2046
2047	var r0 bool
2048	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2049		r0 = returnFunc()
2050	} else {
2051		r0 = ret.Get(0).(bool)
2052	}
2053	return r0
2054}
2055
2056// MockPanedWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
2057type MockPanedWidget_GetVexpand_Call struct {
2058	*mock.Call
2059}
2060
2061// GetVexpand is a helper method to define mock.On call
2062func (_e *MockPanedWidget_Expecter) GetVexpand() *MockPanedWidget_GetVexpand_Call {
2063	return &MockPanedWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
2064}
2065
2066func (_c *MockPanedWidget_GetVexpand_Call) Run(run func()) *MockPanedWidget_GetVexpand_Call {
2067	_c.Call.Run(func(args mock.Arguments) {
2068		run()
2069	})
2070	return _c
2071}
2072
2073func (_c *MockPanedWidget_GetVexpand_Call) Return(b bool) *MockPanedWidget_GetVexpand_Call {
2074	_c.Call.Return(b)
2075	return _c
2076}
2077
2078func (_c *MockPanedWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetVexpand_Call {
2079	_c.Call.Return(run)
2080	return _c
2081}
2082
2083// GetWideHandle provides a mock function for the type MockPanedWidget
2084func (_mock *MockPanedWidget) GetWideHandle() bool {
2085	ret := _mock.Called()
2086
2087	if len(ret) == 0 {
2088		panic("no return value specified for GetWideHandle")
2089	}
2090
2091	var r0 bool
2092	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2093		r0 = returnFunc()
2094	} else {
2095		r0 = ret.Get(0).(bool)
2096	}
2097	return r0
2098}
2099
2100// MockPanedWidget_GetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWideHandle'
2101type MockPanedWidget_GetWideHandle_Call struct {
2102	*mock.Call
2103}
2104
2105// GetWideHandle is a helper method to define mock.On call
2106func (_e *MockPanedWidget_Expecter) GetWideHandle() *MockPanedWidget_GetWideHandle_Call {
2107	return &MockPanedWidget_GetWideHandle_Call{Call: _e.mock.On("GetWideHandle")}
2108}
2109
2110func (_c *MockPanedWidget_GetWideHandle_Call) Run(run func()) *MockPanedWidget_GetWideHandle_Call {
2111	_c.Call.Run(func(args mock.Arguments) {
2112		run()
2113	})
2114	return _c
2115}
2116
2117func (_c *MockPanedWidget_GetWideHandle_Call) Return(b bool) *MockPanedWidget_GetWideHandle_Call {
2118	_c.Call.Return(b)
2119	return _c
2120}
2121
2122func (_c *MockPanedWidget_GetWideHandle_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetWideHandle_Call {
2123	_c.Call.Return(run)
2124	return _c
2125}
2126
2127// GrabFocus provides a mock function for the type MockPanedWidget
2128func (_mock *MockPanedWidget) GrabFocus() bool {
2129	ret := _mock.Called()
2130
2131	if len(ret) == 0 {
2132		panic("no return value specified for GrabFocus")
2133	}
2134
2135	var r0 bool
2136	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2137		r0 = returnFunc()
2138	} else {
2139		r0 = ret.Get(0).(bool)
2140	}
2141	return r0
2142}
2143
2144// MockPanedWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
2145type MockPanedWidget_GrabFocus_Call struct {
2146	*mock.Call
2147}
2148
2149// GrabFocus is a helper method to define mock.On call
2150func (_e *MockPanedWidget_Expecter) GrabFocus() *MockPanedWidget_GrabFocus_Call {
2151	return &MockPanedWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
2152}
2153
2154func (_c *MockPanedWidget_GrabFocus_Call) Run(run func()) *MockPanedWidget_GrabFocus_Call {
2155	_c.Call.Run(func(args mock.Arguments) {
2156		run()
2157	})
2158	return _c
2159}
2160
2161func (_c *MockPanedWidget_GrabFocus_Call) Return(b bool) *MockPanedWidget_GrabFocus_Call {
2162	_c.Call.Return(b)
2163	return _c
2164}
2165
2166func (_c *MockPanedWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockPanedWidget_GrabFocus_Call {
2167	_c.Call.Return(run)
2168	return _c
2169}
2170
2171// GtkWidget provides a mock function for the type MockPanedWidget
2172func (_mock *MockPanedWidget) GtkWidget() *gtk.Widget {
2173	ret := _mock.Called()
2174
2175	if len(ret) == 0 {
2176		panic("no return value specified for GtkWidget")
2177	}
2178
2179	var r0 *gtk.Widget
2180	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
2181		r0 = returnFunc()
2182	} else {
2183		if ret.Get(0) != nil {
2184			r0 = ret.Get(0).(*gtk.Widget)
2185		}
2186	}
2187	return r0
2188}
2189
2190// MockPanedWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
2191type MockPanedWidget_GtkWidget_Call struct {
2192	*mock.Call
2193}
2194
2195// GtkWidget is a helper method to define mock.On call
2196func (_e *MockPanedWidget_Expecter) GtkWidget() *MockPanedWidget_GtkWidget_Call {
2197	return &MockPanedWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
2198}
2199
2200func (_c *MockPanedWidget_GtkWidget_Call) Run(run func()) *MockPanedWidget_GtkWidget_Call {
2201	_c.Call.Run(func(args mock.Arguments) {
2202		run()
2203	})
2204	return _c
2205}
2206
2207func (_c *MockPanedWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockPanedWidget_GtkWidget_Call {
2208	_c.Call.Return(widget)
2209	return _c
2210}
2211
2212func (_c *MockPanedWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockPanedWidget_GtkWidget_Call {
2213	_c.Call.Return(run)
2214	return _c
2215}
2216
2217// HasCssClass provides a mock function for the type MockPanedWidget
2218func (_mock *MockPanedWidget) HasCssClass(cssClass string) bool {
2219	ret := _mock.Called(cssClass)
2220
2221	if len(ret) == 0 {
2222		panic("no return value specified for HasCssClass")
2223	}
2224
2225	var r0 bool
2226	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
2227		r0 = returnFunc(cssClass)
2228	} else {
2229		r0 = ret.Get(0).(bool)
2230	}
2231	return r0
2232}
2233
2234// MockPanedWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
2235type MockPanedWidget_HasCssClass_Call struct {
2236	*mock.Call
2237}
2238
2239// HasCssClass is a helper method to define mock.On call
2240//   - cssClass string
2241func (_e *MockPanedWidget_Expecter) HasCssClass(cssClass interface{}) *MockPanedWidget_HasCssClass_Call {
2242	return &MockPanedWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
2243}
2244
2245func (_c *MockPanedWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_HasCssClass_Call {
2246	_c.Call.Run(func(args mock.Arguments) {
2247		var arg0 string
2248		if args[0] != nil {
2249			arg0 = args[0].(string)
2250		}
2251		run(
2252			arg0,
2253		)
2254	})
2255	return _c
2256}
2257
2258func (_c *MockPanedWidget_HasCssClass_Call) Return(b bool) *MockPanedWidget_HasCssClass_Call {
2259	_c.Call.Return(b)
2260	return _c
2261}
2262
2263func (_c *MockPanedWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockPanedWidget_HasCssClass_Call {
2264	_c.Call.Return(run)
2265	return _c
2266}
2267
2268// HasFocus provides a mock function for the type MockPanedWidget
2269func (_mock *MockPanedWidget) HasFocus() bool {
2270	ret := _mock.Called()
2271
2272	if len(ret) == 0 {
2273		panic("no return value specified for HasFocus")
2274	}
2275
2276	var r0 bool
2277	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2278		r0 = returnFunc()
2279	} else {
2280		r0 = ret.Get(0).(bool)
2281	}
2282	return r0
2283}
2284
2285// MockPanedWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
2286type MockPanedWidget_HasFocus_Call struct {
2287	*mock.Call
2288}
2289
2290// HasFocus is a helper method to define mock.On call
2291func (_e *MockPanedWidget_Expecter) HasFocus() *MockPanedWidget_HasFocus_Call {
2292	return &MockPanedWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
2293}
2294
2295func (_c *MockPanedWidget_HasFocus_Call) Run(run func()) *MockPanedWidget_HasFocus_Call {
2296	_c.Call.Run(func(args mock.Arguments) {
2297		run()
2298	})
2299	return _c
2300}
2301
2302func (_c *MockPanedWidget_HasFocus_Call) Return(b bool) *MockPanedWidget_HasFocus_Call {
2303	_c.Call.Return(b)
2304	return _c
2305}
2306
2307func (_c *MockPanedWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockPanedWidget_HasFocus_Call {
2308	_c.Call.Return(run)
2309	return _c
2310}
2311
2312// Hide provides a mock function for the type MockPanedWidget
2313func (_mock *MockPanedWidget) Hide() {
2314	_mock.Called()
2315	return
2316}
2317
2318// MockPanedWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
2319type MockPanedWidget_Hide_Call struct {
2320	*mock.Call
2321}
2322
2323// Hide is a helper method to define mock.On call
2324func (_e *MockPanedWidget_Expecter) Hide() *MockPanedWidget_Hide_Call {
2325	return &MockPanedWidget_Hide_Call{Call: _e.mock.On("Hide")}
2326}
2327
2328func (_c *MockPanedWidget_Hide_Call) Run(run func()) *MockPanedWidget_Hide_Call {
2329	_c.Call.Run(func(args mock.Arguments) {
2330		run()
2331	})
2332	return _c
2333}
2334
2335func (_c *MockPanedWidget_Hide_Call) Return() *MockPanedWidget_Hide_Call {
2336	_c.Call.Return()
2337	return _c
2338}
2339
2340func (_c *MockPanedWidget_Hide_Call) RunAndReturn(run func()) *MockPanedWidget_Hide_Call {
2341	_c.Run(run)
2342	return _c
2343}
2344
2345// IsVisible provides a mock function for the type MockPanedWidget
2346func (_mock *MockPanedWidget) IsVisible() bool {
2347	ret := _mock.Called()
2348
2349	if len(ret) == 0 {
2350		panic("no return value specified for IsVisible")
2351	}
2352
2353	var r0 bool
2354	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2355		r0 = returnFunc()
2356	} else {
2357		r0 = ret.Get(0).(bool)
2358	}
2359	return r0
2360}
2361
2362// MockPanedWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
2363type MockPanedWidget_IsVisible_Call struct {
2364	*mock.Call
2365}
2366
2367// IsVisible is a helper method to define mock.On call
2368func (_e *MockPanedWidget_Expecter) IsVisible() *MockPanedWidget_IsVisible_Call {
2369	return &MockPanedWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
2370}
2371
2372func (_c *MockPanedWidget_IsVisible_Call) Run(run func()) *MockPanedWidget_IsVisible_Call {
2373	_c.Call.Run(func(args mock.Arguments) {
2374		run()
2375	})
2376	return _c
2377}
2378
2379func (_c *MockPanedWidget_IsVisible_Call) Return(b bool) *MockPanedWidget_IsVisible_Call {
2380	_c.Call.Return(b)
2381	return _c
2382}
2383
2384func (_c *MockPanedWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockPanedWidget_IsVisible_Call {
2385	_c.Call.Return(run)
2386	return _c
2387}
2388
2389// RemoveCssClass provides a mock function for the type MockPanedWidget
2390func (_mock *MockPanedWidget) RemoveCssClass(cssClass string) {
2391	_mock.Called(cssClass)
2392	return
2393}
2394
2395// MockPanedWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
2396type MockPanedWidget_RemoveCssClass_Call struct {
2397	*mock.Call
2398}
2399
2400// RemoveCssClass is a helper method to define mock.On call
2401//   - cssClass string
2402func (_e *MockPanedWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockPanedWidget_RemoveCssClass_Call {
2403	return &MockPanedWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
2404}
2405
2406func (_c *MockPanedWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_RemoveCssClass_Call {
2407	_c.Call.Run(func(args mock.Arguments) {
2408		var arg0 string
2409		if args[0] != nil {
2410			arg0 = args[0].(string)
2411		}
2412		run(
2413			arg0,
2414		)
2415	})
2416	return _c
2417}
2418
2419func (_c *MockPanedWidget_RemoveCssClass_Call) Return() *MockPanedWidget_RemoveCssClass_Call {
2420	_c.Call.Return()
2421	return _c
2422}
2423
2424func (_c *MockPanedWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockPanedWidget_RemoveCssClass_Call {
2425	_c.Run(run)
2426	return _c
2427}
2428
2429// SetCanFocus provides a mock function for the type MockPanedWidget
2430func (_mock *MockPanedWidget) SetCanFocus(canFocus bool) {
2431	_mock.Called(canFocus)
2432	return
2433}
2434
2435// MockPanedWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
2436type MockPanedWidget_SetCanFocus_Call struct {
2437	*mock.Call
2438}
2439
2440// SetCanFocus is a helper method to define mock.On call
2441//   - canFocus bool
2442func (_e *MockPanedWidget_Expecter) SetCanFocus(canFocus interface{}) *MockPanedWidget_SetCanFocus_Call {
2443	return &MockPanedWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
2444}
2445
2446func (_c *MockPanedWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockPanedWidget_SetCanFocus_Call {
2447	_c.Call.Run(func(args mock.Arguments) {
2448		var arg0 bool
2449		if args[0] != nil {
2450			arg0 = args[0].(bool)
2451		}
2452		run(
2453			arg0,
2454		)
2455	})
2456	return _c
2457}
2458
2459func (_c *MockPanedWidget_SetCanFocus_Call) Return() *MockPanedWidget_SetCanFocus_Call {
2460	_c.Call.Return()
2461	return _c
2462}
2463
2464func (_c *MockPanedWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockPanedWidget_SetCanFocus_Call {
2465	_c.Run(run)
2466	return _c
2467}
2468
2469// SetCanTarget provides a mock function for the type MockPanedWidget
2470func (_mock *MockPanedWidget) SetCanTarget(canTarget bool) {
2471	_mock.Called(canTarget)
2472	return
2473}
2474
2475// MockPanedWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
2476type MockPanedWidget_SetCanTarget_Call struct {
2477	*mock.Call
2478}
2479
2480// SetCanTarget is a helper method to define mock.On call
2481//   - canTarget bool
2482func (_e *MockPanedWidget_Expecter) SetCanTarget(canTarget interface{}) *MockPanedWidget_SetCanTarget_Call {
2483	return &MockPanedWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
2484}
2485
2486func (_c *MockPanedWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockPanedWidget_SetCanTarget_Call {
2487	_c.Call.Run(func(args mock.Arguments) {
2488		var arg0 bool
2489		if args[0] != nil {
2490			arg0 = args[0].(bool)
2491		}
2492		run(
2493			arg0,
2494		)
2495	})
2496	return _c
2497}
2498
2499func (_c *MockPanedWidget_SetCanTarget_Call) Return() *MockPanedWidget_SetCanTarget_Call {
2500	_c.Call.Return()
2501	return _c
2502}
2503
2504func (_c *MockPanedWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockPanedWidget_SetCanTarget_Call {
2505	_c.Run(run)
2506	return _c
2507}
2508
2509// SetEndChild provides a mock function for the type MockPanedWidget
2510func (_mock *MockPanedWidget) SetEndChild(child layout.Widget) {
2511	_mock.Called(child)
2512	return
2513}
2514
2515// MockPanedWidget_SetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEndChild'
2516type MockPanedWidget_SetEndChild_Call struct {
2517	*mock.Call
2518}
2519
2520// SetEndChild is a helper method to define mock.On call
2521//   - child layout.Widget
2522func (_e *MockPanedWidget_Expecter) SetEndChild(child interface{}) *MockPanedWidget_SetEndChild_Call {
2523	return &MockPanedWidget_SetEndChild_Call{Call: _e.mock.On("SetEndChild", child)}
2524}
2525
2526func (_c *MockPanedWidget_SetEndChild_Call) Run(run func(child layout.Widget)) *MockPanedWidget_SetEndChild_Call {
2527	_c.Call.Run(func(args mock.Arguments) {
2528		var arg0 layout.Widget
2529		if args[0] != nil {
2530			arg0 = args[0].(layout.Widget)
2531		}
2532		run(
2533			arg0,
2534		)
2535	})
2536	return _c
2537}
2538
2539func (_c *MockPanedWidget_SetEndChild_Call) Return() *MockPanedWidget_SetEndChild_Call {
2540	_c.Call.Return()
2541	return _c
2542}
2543
2544func (_c *MockPanedWidget_SetEndChild_Call) RunAndReturn(run func(child layout.Widget)) *MockPanedWidget_SetEndChild_Call {
2545	_c.Run(run)
2546	return _c
2547}
2548
2549// SetFocusOnClick provides a mock function for the type MockPanedWidget
2550func (_mock *MockPanedWidget) SetFocusOnClick(focusOnClick bool) {
2551	_mock.Called(focusOnClick)
2552	return
2553}
2554
2555// MockPanedWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
2556type MockPanedWidget_SetFocusOnClick_Call struct {
2557	*mock.Call
2558}
2559
2560// SetFocusOnClick is a helper method to define mock.On call
2561//   - focusOnClick bool
2562func (_e *MockPanedWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockPanedWidget_SetFocusOnClick_Call {
2563	return &MockPanedWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
2564}
2565
2566func (_c *MockPanedWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockPanedWidget_SetFocusOnClick_Call {
2567	_c.Call.Run(func(args mock.Arguments) {
2568		var arg0 bool
2569		if args[0] != nil {
2570			arg0 = args[0].(bool)
2571		}
2572		run(
2573			arg0,
2574		)
2575	})
2576	return _c
2577}
2578
2579func (_c *MockPanedWidget_SetFocusOnClick_Call) Return() *MockPanedWidget_SetFocusOnClick_Call {
2580	_c.Call.Return()
2581	return _c
2582}
2583
2584func (_c *MockPanedWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockPanedWidget_SetFocusOnClick_Call {
2585	_c.Run(run)
2586	return _c
2587}
2588
2589// SetHalign provides a mock function for the type MockPanedWidget
2590func (_mock *MockPanedWidget) SetHalign(align gtk.Align) {
2591	_mock.Called(align)
2592	return
2593}
2594
2595// MockPanedWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
2596type MockPanedWidget_SetHalign_Call struct {
2597	*mock.Call
2598}
2599
2600// SetHalign is a helper method to define mock.On call
2601//   - align gtk.Align
2602func (_e *MockPanedWidget_Expecter) SetHalign(align interface{}) *MockPanedWidget_SetHalign_Call {
2603	return &MockPanedWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
2604}
2605
2606func (_c *MockPanedWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockPanedWidget_SetHalign_Call {
2607	_c.Call.Run(func(args mock.Arguments) {
2608		var arg0 gtk.Align
2609		if args[0] != nil {
2610			arg0 = args[0].(gtk.Align)
2611		}
2612		run(
2613			arg0,
2614		)
2615	})
2616	return _c
2617}
2618
2619func (_c *MockPanedWidget_SetHalign_Call) Return() *MockPanedWidget_SetHalign_Call {
2620	_c.Call.Return()
2621	return _c
2622}
2623
2624func (_c *MockPanedWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockPanedWidget_SetHalign_Call {
2625	_c.Run(run)
2626	return _c
2627}
2628
2629// SetHexpand provides a mock function for the type MockPanedWidget
2630func (_mock *MockPanedWidget) SetHexpand(expand bool) {
2631	_mock.Called(expand)
2632	return
2633}
2634
2635// MockPanedWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
2636type MockPanedWidget_SetHexpand_Call struct {
2637	*mock.Call
2638}
2639
2640// SetHexpand is a helper method to define mock.On call
2641//   - expand bool
2642func (_e *MockPanedWidget_Expecter) SetHexpand(expand interface{}) *MockPanedWidget_SetHexpand_Call {
2643	return &MockPanedWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
2644}
2645
2646func (_c *MockPanedWidget_SetHexpand_Call) Run(run func(expand bool)) *MockPanedWidget_SetHexpand_Call {
2647	_c.Call.Run(func(args mock.Arguments) {
2648		var arg0 bool
2649		if args[0] != nil {
2650			arg0 = args[0].(bool)
2651		}
2652		run(
2653			arg0,
2654		)
2655	})
2656	return _c
2657}
2658
2659func (_c *MockPanedWidget_SetHexpand_Call) Return() *MockPanedWidget_SetHexpand_Call {
2660	_c.Call.Return()
2661	return _c
2662}
2663
2664func (_c *MockPanedWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockPanedWidget_SetHexpand_Call {
2665	_c.Run(run)
2666	return _c
2667}
2668
2669// SetPosition provides a mock function for the type MockPanedWidget
2670func (_mock *MockPanedWidget) SetPosition(position int) {
2671	_mock.Called(position)
2672	return
2673}
2674
2675// MockPanedWidget_SetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPosition'
2676type MockPanedWidget_SetPosition_Call struct {
2677	*mock.Call
2678}
2679
2680// SetPosition is a helper method to define mock.On call
2681//   - position int
2682func (_e *MockPanedWidget_Expecter) SetPosition(position interface{}) *MockPanedWidget_SetPosition_Call {
2683	return &MockPanedWidget_SetPosition_Call{Call: _e.mock.On("SetPosition", position)}
2684}
2685
2686func (_c *MockPanedWidget_SetPosition_Call) Run(run func(position int)) *MockPanedWidget_SetPosition_Call {
2687	_c.Call.Run(func(args mock.Arguments) {
2688		var arg0 int
2689		if args[0] != nil {
2690			arg0 = args[0].(int)
2691		}
2692		run(
2693			arg0,
2694		)
2695	})
2696	return _c
2697}
2698
2699func (_c *MockPanedWidget_SetPosition_Call) Return() *MockPanedWidget_SetPosition_Call {
2700	_c.Call.Return()
2701	return _c
2702}
2703
2704func (_c *MockPanedWidget_SetPosition_Call) RunAndReturn(run func(position int)) *MockPanedWidget_SetPosition_Call {
2705	_c.Run(run)
2706	return _c
2707}
2708
2709// SetResizeEndChild provides a mock function for the type MockPanedWidget
2710func (_mock *MockPanedWidget) SetResizeEndChild(resize bool) {
2711	_mock.Called(resize)
2712	return
2713}
2714
2715// MockPanedWidget_SetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeEndChild'
2716type MockPanedWidget_SetResizeEndChild_Call struct {
2717	*mock.Call
2718}
2719
2720// SetResizeEndChild is a helper method to define mock.On call
2721//   - resize bool
2722func (_e *MockPanedWidget_Expecter) SetResizeEndChild(resize interface{}) *MockPanedWidget_SetResizeEndChild_Call {
2723	return &MockPanedWidget_SetResizeEndChild_Call{Call: _e.mock.On("SetResizeEndChild", resize)}
2724}
2725
2726func (_c *MockPanedWidget_SetResizeEndChild_Call) Run(run func(resize bool)) *MockPanedWidget_SetResizeEndChild_Call {
2727	_c.Call.Run(func(args mock.Arguments) {
2728		var arg0 bool
2729		if args[0] != nil {
2730			arg0 = args[0].(bool)
2731		}
2732		run(
2733			arg0,
2734		)
2735	})
2736	return _c
2737}
2738
2739func (_c *MockPanedWidget_SetResizeEndChild_Call) Return() *MockPanedWidget_SetResizeEndChild_Call {
2740	_c.Call.Return()
2741	return _c
2742}
2743
2744func (_c *MockPanedWidget_SetResizeEndChild_Call) RunAndReturn(run func(resize bool)) *MockPanedWidget_SetResizeEndChild_Call {
2745	_c.Run(run)
2746	return _c
2747}
2748
2749// SetResizeStartChild provides a mock function for the type MockPanedWidget
2750func (_mock *MockPanedWidget) SetResizeStartChild(resize bool) {
2751	_mock.Called(resize)
2752	return
2753}
2754
2755// MockPanedWidget_SetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeStartChild'
2756type MockPanedWidget_SetResizeStartChild_Call struct {
2757	*mock.Call
2758}
2759
2760// SetResizeStartChild is a helper method to define mock.On call
2761//   - resize bool
2762func (_e *MockPanedWidget_Expecter) SetResizeStartChild(resize interface{}) *MockPanedWidget_SetResizeStartChild_Call {
2763	return &MockPanedWidget_SetResizeStartChild_Call{Call: _e.mock.On("SetResizeStartChild", resize)}
2764}
2765
2766func (_c *MockPanedWidget_SetResizeStartChild_Call) Run(run func(resize bool)) *MockPanedWidget_SetResizeStartChild_Call {
2767	_c.Call.Run(func(args mock.Arguments) {
2768		var arg0 bool
2769		if args[0] != nil {
2770			arg0 = args[0].(bool)
2771		}
2772		run(
2773			arg0,
2774		)
2775	})
2776	return _c
2777}
2778
2779func (_c *MockPanedWidget_SetResizeStartChild_Call) Return() *MockPanedWidget_SetResizeStartChild_Call {
2780	_c.Call.Return()
2781	return _c
2782}
2783
2784func (_c *MockPanedWidget_SetResizeStartChild_Call) RunAndReturn(run func(resize bool)) *MockPanedWidget_SetResizeStartChild_Call {
2785	_c.Run(run)
2786	return _c
2787}
2788
2789// SetShrinkEndChild provides a mock function for the type MockPanedWidget
2790func (_mock *MockPanedWidget) SetShrinkEndChild(shrink bool) {
2791	_mock.Called(shrink)
2792	return
2793}
2794
2795// MockPanedWidget_SetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkEndChild'
2796type MockPanedWidget_SetShrinkEndChild_Call struct {
2797	*mock.Call
2798}
2799
2800// SetShrinkEndChild is a helper method to define mock.On call
2801//   - shrink bool
2802func (_e *MockPanedWidget_Expecter) SetShrinkEndChild(shrink interface{}) *MockPanedWidget_SetShrinkEndChild_Call {
2803	return &MockPanedWidget_SetShrinkEndChild_Call{Call: _e.mock.On("SetShrinkEndChild", shrink)}
2804}
2805
2806func (_c *MockPanedWidget_SetShrinkEndChild_Call) Run(run func(shrink bool)) *MockPanedWidget_SetShrinkEndChild_Call {
2807	_c.Call.Run(func(args mock.Arguments) {
2808		var arg0 bool
2809		if args[0] != nil {
2810			arg0 = args[0].(bool)
2811		}
2812		run(
2813			arg0,
2814		)
2815	})
2816	return _c
2817}
2818
2819func (_c *MockPanedWidget_SetShrinkEndChild_Call) Return() *MockPanedWidget_SetShrinkEndChild_Call {
2820	_c.Call.Return()
2821	return _c
2822}
2823
2824func (_c *MockPanedWidget_SetShrinkEndChild_Call) RunAndReturn(run func(shrink bool)) *MockPanedWidget_SetShrinkEndChild_Call {
2825	_c.Run(run)
2826	return _c
2827}
2828
2829// SetShrinkStartChild provides a mock function for the type MockPanedWidget
2830func (_mock *MockPanedWidget) SetShrinkStartChild(shrink bool) {
2831	_mock.Called(shrink)
2832	return
2833}
2834
2835// MockPanedWidget_SetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkStartChild'
2836type MockPanedWidget_SetShrinkStartChild_Call struct {
2837	*mock.Call
2838}
2839
2840// SetShrinkStartChild is a helper method to define mock.On call
2841//   - shrink bool
2842func (_e *MockPanedWidget_Expecter) SetShrinkStartChild(shrink interface{}) *MockPanedWidget_SetShrinkStartChild_Call {
2843	return &MockPanedWidget_SetShrinkStartChild_Call{Call: _e.mock.On("SetShrinkStartChild", shrink)}
2844}
2845
2846func (_c *MockPanedWidget_SetShrinkStartChild_Call) Run(run func(shrink bool)) *MockPanedWidget_SetShrinkStartChild_Call {
2847	_c.Call.Run(func(args mock.Arguments) {
2848		var arg0 bool
2849		if args[0] != nil {
2850			arg0 = args[0].(bool)
2851		}
2852		run(
2853			arg0,
2854		)
2855	})
2856	return _c
2857}
2858
2859func (_c *MockPanedWidget_SetShrinkStartChild_Call) Return() *MockPanedWidget_SetShrinkStartChild_Call {
2860	_c.Call.Return()
2861	return _c
2862}
2863
2864func (_c *MockPanedWidget_SetShrinkStartChild_Call) RunAndReturn(run func(shrink bool)) *MockPanedWidget_SetShrinkStartChild_Call {
2865	_c.Run(run)
2866	return _c
2867}
2868
2869// SetSizeRequest provides a mock function for the type MockPanedWidget
2870func (_mock *MockPanedWidget) SetSizeRequest(width int, height int) {
2871	_mock.Called(width, height)
2872	return
2873}
2874
2875// MockPanedWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
2876type MockPanedWidget_SetSizeRequest_Call struct {
2877	*mock.Call
2878}
2879
2880// SetSizeRequest is a helper method to define mock.On call
2881//   - width int
2882//   - height int
2883func (_e *MockPanedWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockPanedWidget_SetSizeRequest_Call {
2884	return &MockPanedWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
2885}
2886
2887func (_c *MockPanedWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockPanedWidget_SetSizeRequest_Call {
2888	_c.Call.Run(func(args mock.Arguments) {
2889		var arg0 int
2890		if args[0] != nil {
2891			arg0 = args[0].(int)
2892		}
2893		var arg1 int
2894		if args[1] != nil {
2895			arg1 = args[1].(int)
2896		}
2897		run(
2898			arg0,
2899			arg1,
2900		)
2901	})
2902	return _c
2903}
2904
2905func (_c *MockPanedWidget_SetSizeRequest_Call) Return() *MockPanedWidget_SetSizeRequest_Call {
2906	_c.Call.Return()
2907	return _c
2908}
2909
2910func (_c *MockPanedWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockPanedWidget_SetSizeRequest_Call {
2911	_c.Run(run)
2912	return _c
2913}
2914
2915// SetStartChild provides a mock function for the type MockPanedWidget
2916func (_mock *MockPanedWidget) SetStartChild(child layout.Widget) {
2917	_mock.Called(child)
2918	return
2919}
2920
2921// MockPanedWidget_SetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStartChild'
2922type MockPanedWidget_SetStartChild_Call struct {
2923	*mock.Call
2924}
2925
2926// SetStartChild is a helper method to define mock.On call
2927//   - child layout.Widget
2928func (_e *MockPanedWidget_Expecter) SetStartChild(child interface{}) *MockPanedWidget_SetStartChild_Call {
2929	return &MockPanedWidget_SetStartChild_Call{Call: _e.mock.On("SetStartChild", child)}
2930}
2931
2932func (_c *MockPanedWidget_SetStartChild_Call) Run(run func(child layout.Widget)) *MockPanedWidget_SetStartChild_Call {
2933	_c.Call.Run(func(args mock.Arguments) {
2934		var arg0 layout.Widget
2935		if args[0] != nil {
2936			arg0 = args[0].(layout.Widget)
2937		}
2938		run(
2939			arg0,
2940		)
2941	})
2942	return _c
2943}
2944
2945func (_c *MockPanedWidget_SetStartChild_Call) Return() *MockPanedWidget_SetStartChild_Call {
2946	_c.Call.Return()
2947	return _c
2948}
2949
2950func (_c *MockPanedWidget_SetStartChild_Call) RunAndReturn(run func(child layout.Widget)) *MockPanedWidget_SetStartChild_Call {
2951	_c.Run(run)
2952	return _c
2953}
2954
2955// SetValign provides a mock function for the type MockPanedWidget
2956func (_mock *MockPanedWidget) SetValign(align gtk.Align) {
2957	_mock.Called(align)
2958	return
2959}
2960
2961// MockPanedWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
2962type MockPanedWidget_SetValign_Call struct {
2963	*mock.Call
2964}
2965
2966// SetValign is a helper method to define mock.On call
2967//   - align gtk.Align
2968func (_e *MockPanedWidget_Expecter) SetValign(align interface{}) *MockPanedWidget_SetValign_Call {
2969	return &MockPanedWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
2970}
2971
2972func (_c *MockPanedWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockPanedWidget_SetValign_Call {
2973	_c.Call.Run(func(args mock.Arguments) {
2974		var arg0 gtk.Align
2975		if args[0] != nil {
2976			arg0 = args[0].(gtk.Align)
2977		}
2978		run(
2979			arg0,
2980		)
2981	})
2982	return _c
2983}
2984
2985func (_c *MockPanedWidget_SetValign_Call) Return() *MockPanedWidget_SetValign_Call {
2986	_c.Call.Return()
2987	return _c
2988}
2989
2990func (_c *MockPanedWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockPanedWidget_SetValign_Call {
2991	_c.Run(run)
2992	return _c
2993}
2994
2995// SetVexpand provides a mock function for the type MockPanedWidget
2996func (_mock *MockPanedWidget) SetVexpand(expand bool) {
2997	_mock.Called(expand)
2998	return
2999}
3000
3001// MockPanedWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
3002type MockPanedWidget_SetVexpand_Call struct {
3003	*mock.Call
3004}
3005
3006// SetVexpand is a helper method to define mock.On call
3007//   - expand bool
3008func (_e *MockPanedWidget_Expecter) SetVexpand(expand interface{}) *MockPanedWidget_SetVexpand_Call {
3009	return &MockPanedWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
3010}
3011
3012func (_c *MockPanedWidget_SetVexpand_Call) Run(run func(expand bool)) *MockPanedWidget_SetVexpand_Call {
3013	_c.Call.Run(func(args mock.Arguments) {
3014		var arg0 bool
3015		if args[0] != nil {
3016			arg0 = args[0].(bool)
3017		}
3018		run(
3019			arg0,
3020		)
3021	})
3022	return _c
3023}
3024
3025func (_c *MockPanedWidget_SetVexpand_Call) Return() *MockPanedWidget_SetVexpand_Call {
3026	_c.Call.Return()
3027	return _c
3028}
3029
3030func (_c *MockPanedWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockPanedWidget_SetVexpand_Call {
3031	_c.Run(run)
3032	return _c
3033}
3034
3035// SetVisible provides a mock function for the type MockPanedWidget
3036func (_mock *MockPanedWidget) SetVisible(visible bool) {
3037	_mock.Called(visible)
3038	return
3039}
3040
3041// MockPanedWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
3042type MockPanedWidget_SetVisible_Call struct {
3043	*mock.Call
3044}
3045
3046// SetVisible is a helper method to define mock.On call
3047//   - visible bool
3048func (_e *MockPanedWidget_Expecter) SetVisible(visible interface{}) *MockPanedWidget_SetVisible_Call {
3049	return &MockPanedWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
3050}
3051
3052func (_c *MockPanedWidget_SetVisible_Call) Run(run func(visible bool)) *MockPanedWidget_SetVisible_Call {
3053	_c.Call.Run(func(args mock.Arguments) {
3054		var arg0 bool
3055		if args[0] != nil {
3056			arg0 = args[0].(bool)
3057		}
3058		run(
3059			arg0,
3060		)
3061	})
3062	return _c
3063}
3064
3065func (_c *MockPanedWidget_SetVisible_Call) Return() *MockPanedWidget_SetVisible_Call {
3066	_c.Call.Return()
3067	return _c
3068}
3069
3070func (_c *MockPanedWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockPanedWidget_SetVisible_Call {
3071	_c.Run(run)
3072	return _c
3073}
3074
3075// SetWideHandle provides a mock function for the type MockPanedWidget
3076func (_mock *MockPanedWidget) SetWideHandle(wide bool) {
3077	_mock.Called(wide)
3078	return
3079}
3080
3081// MockPanedWidget_SetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWideHandle'
3082type MockPanedWidget_SetWideHandle_Call struct {
3083	*mock.Call
3084}
3085
3086// SetWideHandle is a helper method to define mock.On call
3087//   - wide bool
3088func (_e *MockPanedWidget_Expecter) SetWideHandle(wide interface{}) *MockPanedWidget_SetWideHandle_Call {
3089	return &MockPanedWidget_SetWideHandle_Call{Call: _e.mock.On("SetWideHandle", wide)}
3090}
3091
3092func (_c *MockPanedWidget_SetWideHandle_Call) Run(run func(wide bool)) *MockPanedWidget_SetWideHandle_Call {
3093	_c.Call.Run(func(args mock.Arguments) {
3094		var arg0 bool
3095		if args[0] != nil {
3096			arg0 = args[0].(bool)
3097		}
3098		run(
3099			arg0,
3100		)
3101	})
3102	return _c
3103}
3104
3105func (_c *MockPanedWidget_SetWideHandle_Call) Return() *MockPanedWidget_SetWideHandle_Call {
3106	_c.Call.Return()
3107	return _c
3108}
3109
3110func (_c *MockPanedWidget_SetWideHandle_Call) RunAndReturn(run func(wide bool)) *MockPanedWidget_SetWideHandle_Call {
3111	_c.Run(run)
3112	return _c
3113}
3114
3115// Show provides a mock function for the type MockPanedWidget
3116func (_mock *MockPanedWidget) Show() {
3117	_mock.Called()
3118	return
3119}
3120
3121// MockPanedWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
3122type MockPanedWidget_Show_Call struct {
3123	*mock.Call
3124}
3125
3126// Show is a helper method to define mock.On call
3127func (_e *MockPanedWidget_Expecter) Show() *MockPanedWidget_Show_Call {
3128	return &MockPanedWidget_Show_Call{Call: _e.mock.On("Show")}
3129}
3130
3131func (_c *MockPanedWidget_Show_Call) Run(run func()) *MockPanedWidget_Show_Call {
3132	_c.Call.Run(func(args mock.Arguments) {
3133		run()
3134	})
3135	return _c
3136}
3137
3138func (_c *MockPanedWidget_Show_Call) Return() *MockPanedWidget_Show_Call {
3139	_c.Call.Return()
3140	return _c
3141}
3142
3143func (_c *MockPanedWidget_Show_Call) RunAndReturn(run func()) *MockPanedWidget_Show_Call {
3144	_c.Run(run)
3145	return _c
3146}
3147
3148// Unparent provides a mock function for the type MockPanedWidget
3149func (_mock *MockPanedWidget) Unparent() {
3150	_mock.Called()
3151	return
3152}
3153
3154// MockPanedWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
3155type MockPanedWidget_Unparent_Call struct {
3156	*mock.Call
3157}
3158
3159// Unparent is a helper method to define mock.On call
3160func (_e *MockPanedWidget_Expecter) Unparent() *MockPanedWidget_Unparent_Call {
3161	return &MockPanedWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
3162}
3163
3164func (_c *MockPanedWidget_Unparent_Call) Run(run func()) *MockPanedWidget_Unparent_Call {
3165	_c.Call.Run(func(args mock.Arguments) {
3166		run()
3167	})
3168	return _c
3169}
3170
3171func (_c *MockPanedWidget_Unparent_Call) Return() *MockPanedWidget_Unparent_Call {
3172	_c.Call.Return()
3173	return _c
3174}
3175
3176func (_c *MockPanedWidget_Unparent_Call) RunAndReturn(run func()) *MockPanedWidget_Unparent_Call {
3177	_c.Run(run)
3178	return _c
3179}
3180
3181// 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.
3182// The first argument is typically a *testing.T value.
3183func NewMockBoxWidget(t interface {
3184	mock.TestingT
3185	Cleanup(func())
3186}) *MockBoxWidget {
3187	mock := &MockBoxWidget{}
3188	mock.Mock.Test(t)
3189
3190	t.Cleanup(func() { mock.AssertExpectations(t) })
3191
3192	return mock
3193}
3194
3195// MockBoxWidget is an autogenerated mock type for the BoxWidget type
3196type MockBoxWidget struct {
3197	mock.Mock
3198}
3199
3200type MockBoxWidget_Expecter struct {
3201	mock *mock.Mock
3202}
3203
3204func (_m *MockBoxWidget) EXPECT() *MockBoxWidget_Expecter {
3205	return &MockBoxWidget_Expecter{mock: &_m.Mock}
3206}
3207
3208// AddController provides a mock function for the type MockBoxWidget
3209func (_mock *MockBoxWidget) AddController(controller *gtk.EventController) {
3210	_mock.Called(controller)
3211	return
3212}
3213
3214// MockBoxWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
3215type MockBoxWidget_AddController_Call struct {
3216	*mock.Call
3217}
3218
3219// AddController is a helper method to define mock.On call
3220//   - controller *gtk.EventController
3221func (_e *MockBoxWidget_Expecter) AddController(controller interface{}) *MockBoxWidget_AddController_Call {
3222	return &MockBoxWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
3223}
3224
3225func (_c *MockBoxWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockBoxWidget_AddController_Call {
3226	_c.Call.Run(func(args mock.Arguments) {
3227		var arg0 *gtk.EventController
3228		if args[0] != nil {
3229			arg0 = args[0].(*gtk.EventController)
3230		}
3231		run(
3232			arg0,
3233		)
3234	})
3235	return _c
3236}
3237
3238func (_c *MockBoxWidget_AddController_Call) Return() *MockBoxWidget_AddController_Call {
3239	_c.Call.Return()
3240	return _c
3241}
3242
3243func (_c *MockBoxWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockBoxWidget_AddController_Call {
3244	_c.Run(run)
3245	return _c
3246}
3247
3248// AddCssClass provides a mock function for the type MockBoxWidget
3249func (_mock *MockBoxWidget) AddCssClass(cssClass string) {
3250	_mock.Called(cssClass)
3251	return
3252}
3253
3254// MockBoxWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
3255type MockBoxWidget_AddCssClass_Call struct {
3256	*mock.Call
3257}
3258
3259// AddCssClass is a helper method to define mock.On call
3260//   - cssClass string
3261func (_e *MockBoxWidget_Expecter) AddCssClass(cssClass interface{}) *MockBoxWidget_AddCssClass_Call {
3262	return &MockBoxWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
3263}
3264
3265func (_c *MockBoxWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_AddCssClass_Call {
3266	_c.Call.Run(func(args mock.Arguments) {
3267		var arg0 string
3268		if args[0] != nil {
3269			arg0 = args[0].(string)
3270		}
3271		run(
3272			arg0,
3273		)
3274	})
3275	return _c
3276}
3277
3278func (_c *MockBoxWidget_AddCssClass_Call) Return() *MockBoxWidget_AddCssClass_Call {
3279	_c.Call.Return()
3280	return _c
3281}
3282
3283func (_c *MockBoxWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockBoxWidget_AddCssClass_Call {
3284	_c.Run(run)
3285	return _c
3286}
3287
3288// Append provides a mock function for the type MockBoxWidget
3289func (_mock *MockBoxWidget) Append(child layout.Widget) {
3290	_mock.Called(child)
3291	return
3292}
3293
3294// MockBoxWidget_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append'
3295type MockBoxWidget_Append_Call struct {
3296	*mock.Call
3297}
3298
3299// Append is a helper method to define mock.On call
3300//   - child layout.Widget
3301func (_e *MockBoxWidget_Expecter) Append(child interface{}) *MockBoxWidget_Append_Call {
3302	return &MockBoxWidget_Append_Call{Call: _e.mock.On("Append", child)}
3303}
3304
3305func (_c *MockBoxWidget_Append_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Append_Call {
3306	_c.Call.Run(func(args mock.Arguments) {
3307		var arg0 layout.Widget
3308		if args[0] != nil {
3309			arg0 = args[0].(layout.Widget)
3310		}
3311		run(
3312			arg0,
3313		)
3314	})
3315	return _c
3316}
3317
3318func (_c *MockBoxWidget_Append_Call) Return() *MockBoxWidget_Append_Call {
3319	_c.Call.Return()
3320	return _c
3321}
3322
3323func (_c *MockBoxWidget_Append_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Append_Call {
3324	_c.Run(run)
3325	return _c
3326}
3327
3328// ComputePoint provides a mock function for the type MockBoxWidget
3329func (_mock *MockBoxWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
3330	ret := _mock.Called(target)
3331
3332	if len(ret) == 0 {
3333		panic("no return value specified for ComputePoint")
3334	}
3335
3336	var r0 float64
3337	var r1 float64
3338	var r2 bool
3339	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
3340		return returnFunc(target)
3341	}
3342	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
3343		r0 = returnFunc(target)
3344	} else {
3345		r0 = ret.Get(0).(float64)
3346	}
3347	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
3348		r1 = returnFunc(target)
3349	} else {
3350		r1 = ret.Get(1).(float64)
3351	}
3352	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
3353		r2 = returnFunc(target)
3354	} else {
3355		r2 = ret.Get(2).(bool)
3356	}
3357	return r0, r1, r2
3358}
3359
3360// MockBoxWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
3361type MockBoxWidget_ComputePoint_Call struct {
3362	*mock.Call
3363}
3364
3365// ComputePoint is a helper method to define mock.On call
3366//   - target layout.Widget
3367func (_e *MockBoxWidget_Expecter) ComputePoint(target interface{}) *MockBoxWidget_ComputePoint_Call {
3368	return &MockBoxWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
3369}
3370
3371func (_c *MockBoxWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockBoxWidget_ComputePoint_Call {
3372	_c.Call.Run(func(args mock.Arguments) {
3373		var arg0 layout.Widget
3374		if args[0] != nil {
3375			arg0 = args[0].(layout.Widget)
3376		}
3377		run(
3378			arg0,
3379		)
3380	})
3381	return _c
3382}
3383
3384func (_c *MockBoxWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockBoxWidget_ComputePoint_Call {
3385	_c.Call.Return(x, y, ok)
3386	return _c
3387}
3388
3389func (_c *MockBoxWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockBoxWidget_ComputePoint_Call {
3390	_c.Call.Return(run)
3391	return _c
3392}
3393
3394// GetAllocatedHeight provides a mock function for the type MockBoxWidget
3395func (_mock *MockBoxWidget) GetAllocatedHeight() int {
3396	ret := _mock.Called()
3397
3398	if len(ret) == 0 {
3399		panic("no return value specified for GetAllocatedHeight")
3400	}
3401
3402	var r0 int
3403	if returnFunc, ok := ret.Get(0).(func() int); ok {
3404		r0 = returnFunc()
3405	} else {
3406		r0 = ret.Get(0).(int)
3407	}
3408	return r0
3409}
3410
3411// MockBoxWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
3412type MockBoxWidget_GetAllocatedHeight_Call struct {
3413	*mock.Call
3414}
3415
3416// GetAllocatedHeight is a helper method to define mock.On call
3417func (_e *MockBoxWidget_Expecter) GetAllocatedHeight() *MockBoxWidget_GetAllocatedHeight_Call {
3418	return &MockBoxWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
3419}
3420
3421func (_c *MockBoxWidget_GetAllocatedHeight_Call) Run(run func()) *MockBoxWidget_GetAllocatedHeight_Call {
3422	_c.Call.Run(func(args mock.Arguments) {
3423		run()
3424	})
3425	return _c
3426}
3427
3428func (_c *MockBoxWidget_GetAllocatedHeight_Call) Return(n int) *MockBoxWidget_GetAllocatedHeight_Call {
3429	_c.Call.Return(n)
3430	return _c
3431}
3432
3433func (_c *MockBoxWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockBoxWidget_GetAllocatedHeight_Call {
3434	_c.Call.Return(run)
3435	return _c
3436}
3437
3438// GetAllocatedWidth provides a mock function for the type MockBoxWidget
3439func (_mock *MockBoxWidget) GetAllocatedWidth() int {
3440	ret := _mock.Called()
3441
3442	if len(ret) == 0 {
3443		panic("no return value specified for GetAllocatedWidth")
3444	}
3445
3446	var r0 int
3447	if returnFunc, ok := ret.Get(0).(func() int); ok {
3448		r0 = returnFunc()
3449	} else {
3450		r0 = ret.Get(0).(int)
3451	}
3452	return r0
3453}
3454
3455// MockBoxWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
3456type MockBoxWidget_GetAllocatedWidth_Call struct {
3457	*mock.Call
3458}
3459
3460// GetAllocatedWidth is a helper method to define mock.On call
3461func (_e *MockBoxWidget_Expecter) GetAllocatedWidth() *MockBoxWidget_GetAllocatedWidth_Call {
3462	return &MockBoxWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
3463}
3464
3465func (_c *MockBoxWidget_GetAllocatedWidth_Call) Run(run func()) *MockBoxWidget_GetAllocatedWidth_Call {
3466	_c.Call.Run(func(args mock.Arguments) {
3467		run()
3468	})
3469	return _c
3470}
3471
3472func (_c *MockBoxWidget_GetAllocatedWidth_Call) Return(n int) *MockBoxWidget_GetAllocatedWidth_Call {
3473	_c.Call.Return(n)
3474	return _c
3475}
3476
3477func (_c *MockBoxWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockBoxWidget_GetAllocatedWidth_Call {
3478	_c.Call.Return(run)
3479	return _c
3480}
3481
3482// GetHexpand provides a mock function for the type MockBoxWidget
3483func (_mock *MockBoxWidget) GetHexpand() bool {
3484	ret := _mock.Called()
3485
3486	if len(ret) == 0 {
3487		panic("no return value specified for GetHexpand")
3488	}
3489
3490	var r0 bool
3491	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3492		r0 = returnFunc()
3493	} else {
3494		r0 = ret.Get(0).(bool)
3495	}
3496	return r0
3497}
3498
3499// MockBoxWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
3500type MockBoxWidget_GetHexpand_Call struct {
3501	*mock.Call
3502}
3503
3504// GetHexpand is a helper method to define mock.On call
3505func (_e *MockBoxWidget_Expecter) GetHexpand() *MockBoxWidget_GetHexpand_Call {
3506	return &MockBoxWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
3507}
3508
3509func (_c *MockBoxWidget_GetHexpand_Call) Run(run func()) *MockBoxWidget_GetHexpand_Call {
3510	_c.Call.Run(func(args mock.Arguments) {
3511		run()
3512	})
3513	return _c
3514}
3515
3516func (_c *MockBoxWidget_GetHexpand_Call) Return(b bool) *MockBoxWidget_GetHexpand_Call {
3517	_c.Call.Return(b)
3518	return _c
3519}
3520
3521func (_c *MockBoxWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetHexpand_Call {
3522	_c.Call.Return(run)
3523	return _c
3524}
3525
3526// GetHomogeneous provides a mock function for the type MockBoxWidget
3527func (_mock *MockBoxWidget) GetHomogeneous() bool {
3528	ret := _mock.Called()
3529
3530	if len(ret) == 0 {
3531		panic("no return value specified for GetHomogeneous")
3532	}
3533
3534	var r0 bool
3535	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3536		r0 = returnFunc()
3537	} else {
3538		r0 = ret.Get(0).(bool)
3539	}
3540	return r0
3541}
3542
3543// MockBoxWidget_GetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomogeneous'
3544type MockBoxWidget_GetHomogeneous_Call struct {
3545	*mock.Call
3546}
3547
3548// GetHomogeneous is a helper method to define mock.On call
3549func (_e *MockBoxWidget_Expecter) GetHomogeneous() *MockBoxWidget_GetHomogeneous_Call {
3550	return &MockBoxWidget_GetHomogeneous_Call{Call: _e.mock.On("GetHomogeneous")}
3551}
3552
3553func (_c *MockBoxWidget_GetHomogeneous_Call) Run(run func()) *MockBoxWidget_GetHomogeneous_Call {
3554	_c.Call.Run(func(args mock.Arguments) {
3555		run()
3556	})
3557	return _c
3558}
3559
3560func (_c *MockBoxWidget_GetHomogeneous_Call) Return(b bool) *MockBoxWidget_GetHomogeneous_Call {
3561	_c.Call.Return(b)
3562	return _c
3563}
3564
3565func (_c *MockBoxWidget_GetHomogeneous_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetHomogeneous_Call {
3566	_c.Call.Return(run)
3567	return _c
3568}
3569
3570// GetOrientation provides a mock function for the type MockBoxWidget
3571func (_mock *MockBoxWidget) GetOrientation() layout.Orientation {
3572	ret := _mock.Called()
3573
3574	if len(ret) == 0 {
3575		panic("no return value specified for GetOrientation")
3576	}
3577
3578	var r0 layout.Orientation
3579	if returnFunc, ok := ret.Get(0).(func() layout.Orientation); ok {
3580		r0 = returnFunc()
3581	} else {
3582		r0 = ret.Get(0).(layout.Orientation)
3583	}
3584	return r0
3585}
3586
3587// MockBoxWidget_GetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrientation'
3588type MockBoxWidget_GetOrientation_Call struct {
3589	*mock.Call
3590}
3591
3592// GetOrientation is a helper method to define mock.On call
3593func (_e *MockBoxWidget_Expecter) GetOrientation() *MockBoxWidget_GetOrientation_Call {
3594	return &MockBoxWidget_GetOrientation_Call{Call: _e.mock.On("GetOrientation")}
3595}
3596
3597func (_c *MockBoxWidget_GetOrientation_Call) Run(run func()) *MockBoxWidget_GetOrientation_Call {
3598	_c.Call.Run(func(args mock.Arguments) {
3599		run()
3600	})
3601	return _c
3602}
3603
3604func (_c *MockBoxWidget_GetOrientation_Call) Return(v layout.Orientation) *MockBoxWidget_GetOrientation_Call {
3605	_c.Call.Return(v)
3606	return _c
3607}
3608
3609func (_c *MockBoxWidget_GetOrientation_Call) RunAndReturn(run func() layout.Orientation) *MockBoxWidget_GetOrientation_Call {
3610	_c.Call.Return(run)
3611	return _c
3612}
3613
3614// GetParent provides a mock function for the type MockBoxWidget
3615func (_mock *MockBoxWidget) GetParent() layout.Widget {
3616	ret := _mock.Called()
3617
3618	if len(ret) == 0 {
3619		panic("no return value specified for GetParent")
3620	}
3621
3622	var r0 layout.Widget
3623	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
3624		r0 = returnFunc()
3625	} else {
3626		if ret.Get(0) != nil {
3627			r0 = ret.Get(0).(layout.Widget)
3628		}
3629	}
3630	return r0
3631}
3632
3633// MockBoxWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
3634type MockBoxWidget_GetParent_Call struct {
3635	*mock.Call
3636}
3637
3638// GetParent is a helper method to define mock.On call
3639func (_e *MockBoxWidget_Expecter) GetParent() *MockBoxWidget_GetParent_Call {
3640	return &MockBoxWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
3641}
3642
3643func (_c *MockBoxWidget_GetParent_Call) Run(run func()) *MockBoxWidget_GetParent_Call {
3644	_c.Call.Run(func(args mock.Arguments) {
3645		run()
3646	})
3647	return _c
3648}
3649
3650func (_c *MockBoxWidget_GetParent_Call) Return(widget layout.Widget) *MockBoxWidget_GetParent_Call {
3651	_c.Call.Return(widget)
3652	return _c
3653}
3654
3655func (_c *MockBoxWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockBoxWidget_GetParent_Call {
3656	_c.Call.Return(run)
3657	return _c
3658}
3659
3660// GetSpacing provides a mock function for the type MockBoxWidget
3661func (_mock *MockBoxWidget) GetSpacing() int {
3662	ret := _mock.Called()
3663
3664	if len(ret) == 0 {
3665		panic("no return value specified for GetSpacing")
3666	}
3667
3668	var r0 int
3669	if returnFunc, ok := ret.Get(0).(func() int); ok {
3670		r0 = returnFunc()
3671	} else {
3672		r0 = ret.Get(0).(int)
3673	}
3674	return r0
3675}
3676
3677// MockBoxWidget_GetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpacing'
3678type MockBoxWidget_GetSpacing_Call struct {
3679	*mock.Call
3680}
3681
3682// GetSpacing is a helper method to define mock.On call
3683func (_e *MockBoxWidget_Expecter) GetSpacing() *MockBoxWidget_GetSpacing_Call {
3684	return &MockBoxWidget_GetSpacing_Call{Call: _e.mock.On("GetSpacing")}
3685}
3686
3687func (_c *MockBoxWidget_GetSpacing_Call) Run(run func()) *MockBoxWidget_GetSpacing_Call {
3688	_c.Call.Run(func(args mock.Arguments) {
3689		run()
3690	})
3691	return _c
3692}
3693
3694func (_c *MockBoxWidget_GetSpacing_Call) Return(n int) *MockBoxWidget_GetSpacing_Call {
3695	_c.Call.Return(n)
3696	return _c
3697}
3698
3699func (_c *MockBoxWidget_GetSpacing_Call) RunAndReturn(run func() int) *MockBoxWidget_GetSpacing_Call {
3700	_c.Call.Return(run)
3701	return _c
3702}
3703
3704// GetVexpand provides a mock function for the type MockBoxWidget
3705func (_mock *MockBoxWidget) GetVexpand() bool {
3706	ret := _mock.Called()
3707
3708	if len(ret) == 0 {
3709		panic("no return value specified for GetVexpand")
3710	}
3711
3712	var r0 bool
3713	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3714		r0 = returnFunc()
3715	} else {
3716		r0 = ret.Get(0).(bool)
3717	}
3718	return r0
3719}
3720
3721// MockBoxWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
3722type MockBoxWidget_GetVexpand_Call struct {
3723	*mock.Call
3724}
3725
3726// GetVexpand is a helper method to define mock.On call
3727func (_e *MockBoxWidget_Expecter) GetVexpand() *MockBoxWidget_GetVexpand_Call {
3728	return &MockBoxWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
3729}
3730
3731func (_c *MockBoxWidget_GetVexpand_Call) Run(run func()) *MockBoxWidget_GetVexpand_Call {
3732	_c.Call.Run(func(args mock.Arguments) {
3733		run()
3734	})
3735	return _c
3736}
3737
3738func (_c *MockBoxWidget_GetVexpand_Call) Return(b bool) *MockBoxWidget_GetVexpand_Call {
3739	_c.Call.Return(b)
3740	return _c
3741}
3742
3743func (_c *MockBoxWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetVexpand_Call {
3744	_c.Call.Return(run)
3745	return _c
3746}
3747
3748// GrabFocus provides a mock function for the type MockBoxWidget
3749func (_mock *MockBoxWidget) GrabFocus() bool {
3750	ret := _mock.Called()
3751
3752	if len(ret) == 0 {
3753		panic("no return value specified for GrabFocus")
3754	}
3755
3756	var r0 bool
3757	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3758		r0 = returnFunc()
3759	} else {
3760		r0 = ret.Get(0).(bool)
3761	}
3762	return r0
3763}
3764
3765// MockBoxWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
3766type MockBoxWidget_GrabFocus_Call struct {
3767	*mock.Call
3768}
3769
3770// GrabFocus is a helper method to define mock.On call
3771func (_e *MockBoxWidget_Expecter) GrabFocus() *MockBoxWidget_GrabFocus_Call {
3772	return &MockBoxWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
3773}
3774
3775func (_c *MockBoxWidget_GrabFocus_Call) Run(run func()) *MockBoxWidget_GrabFocus_Call {
3776	_c.Call.Run(func(args mock.Arguments) {
3777		run()
3778	})
3779	return _c
3780}
3781
3782func (_c *MockBoxWidget_GrabFocus_Call) Return(b bool) *MockBoxWidget_GrabFocus_Call {
3783	_c.Call.Return(b)
3784	return _c
3785}
3786
3787func (_c *MockBoxWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockBoxWidget_GrabFocus_Call {
3788	_c.Call.Return(run)
3789	return _c
3790}
3791
3792// GtkWidget provides a mock function for the type MockBoxWidget
3793func (_mock *MockBoxWidget) GtkWidget() *gtk.Widget {
3794	ret := _mock.Called()
3795
3796	if len(ret) == 0 {
3797		panic("no return value specified for GtkWidget")
3798	}
3799
3800	var r0 *gtk.Widget
3801	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
3802		r0 = returnFunc()
3803	} else {
3804		if ret.Get(0) != nil {
3805			r0 = ret.Get(0).(*gtk.Widget)
3806		}
3807	}
3808	return r0
3809}
3810
3811// MockBoxWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
3812type MockBoxWidget_GtkWidget_Call struct {
3813	*mock.Call
3814}
3815
3816// GtkWidget is a helper method to define mock.On call
3817func (_e *MockBoxWidget_Expecter) GtkWidget() *MockBoxWidget_GtkWidget_Call {
3818	return &MockBoxWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
3819}
3820
3821func (_c *MockBoxWidget_GtkWidget_Call) Run(run func()) *MockBoxWidget_GtkWidget_Call {
3822	_c.Call.Run(func(args mock.Arguments) {
3823		run()
3824	})
3825	return _c
3826}
3827
3828func (_c *MockBoxWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockBoxWidget_GtkWidget_Call {
3829	_c.Call.Return(widget)
3830	return _c
3831}
3832
3833func (_c *MockBoxWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockBoxWidget_GtkWidget_Call {
3834	_c.Call.Return(run)
3835	return _c
3836}
3837
3838// HasCssClass provides a mock function for the type MockBoxWidget
3839func (_mock *MockBoxWidget) HasCssClass(cssClass string) bool {
3840	ret := _mock.Called(cssClass)
3841
3842	if len(ret) == 0 {
3843		panic("no return value specified for HasCssClass")
3844	}
3845
3846	var r0 bool
3847	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
3848		r0 = returnFunc(cssClass)
3849	} else {
3850		r0 = ret.Get(0).(bool)
3851	}
3852	return r0
3853}
3854
3855// MockBoxWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
3856type MockBoxWidget_HasCssClass_Call struct {
3857	*mock.Call
3858}
3859
3860// HasCssClass is a helper method to define mock.On call
3861//   - cssClass string
3862func (_e *MockBoxWidget_Expecter) HasCssClass(cssClass interface{}) *MockBoxWidget_HasCssClass_Call {
3863	return &MockBoxWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
3864}
3865
3866func (_c *MockBoxWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_HasCssClass_Call {
3867	_c.Call.Run(func(args mock.Arguments) {
3868		var arg0 string
3869		if args[0] != nil {
3870			arg0 = args[0].(string)
3871		}
3872		run(
3873			arg0,
3874		)
3875	})
3876	return _c
3877}
3878
3879func (_c *MockBoxWidget_HasCssClass_Call) Return(b bool) *MockBoxWidget_HasCssClass_Call {
3880	_c.Call.Return(b)
3881	return _c
3882}
3883
3884func (_c *MockBoxWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockBoxWidget_HasCssClass_Call {
3885	_c.Call.Return(run)
3886	return _c
3887}
3888
3889// HasFocus provides a mock function for the type MockBoxWidget
3890func (_mock *MockBoxWidget) HasFocus() bool {
3891	ret := _mock.Called()
3892
3893	if len(ret) == 0 {
3894		panic("no return value specified for HasFocus")
3895	}
3896
3897	var r0 bool
3898	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3899		r0 = returnFunc()
3900	} else {
3901		r0 = ret.Get(0).(bool)
3902	}
3903	return r0
3904}
3905
3906// MockBoxWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
3907type MockBoxWidget_HasFocus_Call struct {
3908	*mock.Call
3909}
3910
3911// HasFocus is a helper method to define mock.On call
3912func (_e *MockBoxWidget_Expecter) HasFocus() *MockBoxWidget_HasFocus_Call {
3913	return &MockBoxWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
3914}
3915
3916func (_c *MockBoxWidget_HasFocus_Call) Run(run func()) *MockBoxWidget_HasFocus_Call {
3917	_c.Call.Run(func(args mock.Arguments) {
3918		run()
3919	})
3920	return _c
3921}
3922
3923func (_c *MockBoxWidget_HasFocus_Call) Return(b bool) *MockBoxWidget_HasFocus_Call {
3924	_c.Call.Return(b)
3925	return _c
3926}
3927
3928func (_c *MockBoxWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockBoxWidget_HasFocus_Call {
3929	_c.Call.Return(run)
3930	return _c
3931}
3932
3933// Hide provides a mock function for the type MockBoxWidget
3934func (_mock *MockBoxWidget) Hide() {
3935	_mock.Called()
3936	return
3937}
3938
3939// MockBoxWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
3940type MockBoxWidget_Hide_Call struct {
3941	*mock.Call
3942}
3943
3944// Hide is a helper method to define mock.On call
3945func (_e *MockBoxWidget_Expecter) Hide() *MockBoxWidget_Hide_Call {
3946	return &MockBoxWidget_Hide_Call{Call: _e.mock.On("Hide")}
3947}
3948
3949func (_c *MockBoxWidget_Hide_Call) Run(run func()) *MockBoxWidget_Hide_Call {
3950	_c.Call.Run(func(args mock.Arguments) {
3951		run()
3952	})
3953	return _c
3954}
3955
3956func (_c *MockBoxWidget_Hide_Call) Return() *MockBoxWidget_Hide_Call {
3957	_c.Call.Return()
3958	return _c
3959}
3960
3961func (_c *MockBoxWidget_Hide_Call) RunAndReturn(run func()) *MockBoxWidget_Hide_Call {
3962	_c.Run(run)
3963	return _c
3964}
3965
3966// InsertChildAfter provides a mock function for the type MockBoxWidget
3967func (_mock *MockBoxWidget) InsertChildAfter(child layout.Widget, sibling layout.Widget) {
3968	_mock.Called(child, sibling)
3969	return
3970}
3971
3972// MockBoxWidget_InsertChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertChildAfter'
3973type MockBoxWidget_InsertChildAfter_Call struct {
3974	*mock.Call
3975}
3976
3977// InsertChildAfter is a helper method to define mock.On call
3978//   - child layout.Widget
3979//   - sibling layout.Widget
3980func (_e *MockBoxWidget_Expecter) InsertChildAfter(child interface{}, sibling interface{}) *MockBoxWidget_InsertChildAfter_Call {
3981	return &MockBoxWidget_InsertChildAfter_Call{Call: _e.mock.On("InsertChildAfter", child, sibling)}
3982}
3983
3984func (_c *MockBoxWidget_InsertChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_InsertChildAfter_Call {
3985	_c.Call.Run(func(args mock.Arguments) {
3986		var arg0 layout.Widget
3987		if args[0] != nil {
3988			arg0 = args[0].(layout.Widget)
3989		}
3990		var arg1 layout.Widget
3991		if args[1] != nil {
3992			arg1 = args[1].(layout.Widget)
3993		}
3994		run(
3995			arg0,
3996			arg1,
3997		)
3998	})
3999	return _c
4000}
4001
4002func (_c *MockBoxWidget_InsertChildAfter_Call) Return() *MockBoxWidget_InsertChildAfter_Call {
4003	_c.Call.Return()
4004	return _c
4005}
4006
4007func (_c *MockBoxWidget_InsertChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_InsertChildAfter_Call {
4008	_c.Run(run)
4009	return _c
4010}
4011
4012// IsVisible provides a mock function for the type MockBoxWidget
4013func (_mock *MockBoxWidget) IsVisible() bool {
4014	ret := _mock.Called()
4015
4016	if len(ret) == 0 {
4017		panic("no return value specified for IsVisible")
4018	}
4019
4020	var r0 bool
4021	if returnFunc, ok := ret.Get(0).(func() bool); ok {
4022		r0 = returnFunc()
4023	} else {
4024		r0 = ret.Get(0).(bool)
4025	}
4026	return r0
4027}
4028
4029// MockBoxWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
4030type MockBoxWidget_IsVisible_Call struct {
4031	*mock.Call
4032}
4033
4034// IsVisible is a helper method to define mock.On call
4035func (_e *MockBoxWidget_Expecter) IsVisible() *MockBoxWidget_IsVisible_Call {
4036	return &MockBoxWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
4037}
4038
4039func (_c *MockBoxWidget_IsVisible_Call) Run(run func()) *MockBoxWidget_IsVisible_Call {
4040	_c.Call.Run(func(args mock.Arguments) {
4041		run()
4042	})
4043	return _c
4044}
4045
4046func (_c *MockBoxWidget_IsVisible_Call) Return(b bool) *MockBoxWidget_IsVisible_Call {
4047	_c.Call.Return(b)
4048	return _c
4049}
4050
4051func (_c *MockBoxWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockBoxWidget_IsVisible_Call {
4052	_c.Call.Return(run)
4053	return _c
4054}
4055
4056// Prepend provides a mock function for the type MockBoxWidget
4057func (_mock *MockBoxWidget) Prepend(child layout.Widget) {
4058	_mock.Called(child)
4059	return
4060}
4061
4062// MockBoxWidget_Prepend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prepend'
4063type MockBoxWidget_Prepend_Call struct {
4064	*mock.Call
4065}
4066
4067// Prepend is a helper method to define mock.On call
4068//   - child layout.Widget
4069func (_e *MockBoxWidget_Expecter) Prepend(child interface{}) *MockBoxWidget_Prepend_Call {
4070	return &MockBoxWidget_Prepend_Call{Call: _e.mock.On("Prepend", child)}
4071}
4072
4073func (_c *MockBoxWidget_Prepend_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Prepend_Call {
4074	_c.Call.Run(func(args mock.Arguments) {
4075		var arg0 layout.Widget
4076		if args[0] != nil {
4077			arg0 = args[0].(layout.Widget)
4078		}
4079		run(
4080			arg0,
4081		)
4082	})
4083	return _c
4084}
4085
4086func (_c *MockBoxWidget_Prepend_Call) Return() *MockBoxWidget_Prepend_Call {
4087	_c.Call.Return()
4088	return _c
4089}
4090
4091func (_c *MockBoxWidget_Prepend_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Prepend_Call {
4092	_c.Run(run)
4093	return _c
4094}
4095
4096// Remove provides a mock function for the type MockBoxWidget
4097func (_mock *MockBoxWidget) Remove(child layout.Widget) {
4098	_mock.Called(child)
4099	return
4100}
4101
4102// MockBoxWidget_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
4103type MockBoxWidget_Remove_Call struct {
4104	*mock.Call
4105}
4106
4107// Remove is a helper method to define mock.On call
4108//   - child layout.Widget
4109func (_e *MockBoxWidget_Expecter) Remove(child interface{}) *MockBoxWidget_Remove_Call {
4110	return &MockBoxWidget_Remove_Call{Call: _e.mock.On("Remove", child)}
4111}
4112
4113func (_c *MockBoxWidget_Remove_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Remove_Call {
4114	_c.Call.Run(func(args mock.Arguments) {
4115		var arg0 layout.Widget
4116		if args[0] != nil {
4117			arg0 = args[0].(layout.Widget)
4118		}
4119		run(
4120			arg0,
4121		)
4122	})
4123	return _c
4124}
4125
4126func (_c *MockBoxWidget_Remove_Call) Return() *MockBoxWidget_Remove_Call {
4127	_c.Call.Return()
4128	return _c
4129}
4130
4131func (_c *MockBoxWidget_Remove_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Remove_Call {
4132	_c.Run(run)
4133	return _c
4134}
4135
4136// RemoveCssClass provides a mock function for the type MockBoxWidget
4137func (_mock *MockBoxWidget) RemoveCssClass(cssClass string) {
4138	_mock.Called(cssClass)
4139	return
4140}
4141
4142// MockBoxWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
4143type MockBoxWidget_RemoveCssClass_Call struct {
4144	*mock.Call
4145}
4146
4147// RemoveCssClass is a helper method to define mock.On call
4148//   - cssClass string
4149func (_e *MockBoxWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockBoxWidget_RemoveCssClass_Call {
4150	return &MockBoxWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
4151}
4152
4153func (_c *MockBoxWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_RemoveCssClass_Call {
4154	_c.Call.Run(func(args mock.Arguments) {
4155		var arg0 string
4156		if args[0] != nil {
4157			arg0 = args[0].(string)
4158		}
4159		run(
4160			arg0,
4161		)
4162	})
4163	return _c
4164}
4165
4166func (_c *MockBoxWidget_RemoveCssClass_Call) Return() *MockBoxWidget_RemoveCssClass_Call {
4167	_c.Call.Return()
4168	return _c
4169}
4170
4171func (_c *MockBoxWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockBoxWidget_RemoveCssClass_Call {
4172	_c.Run(run)
4173	return _c
4174}
4175
4176// ReorderChildAfter provides a mock function for the type MockBoxWidget
4177func (_mock *MockBoxWidget) ReorderChildAfter(child layout.Widget, sibling layout.Widget) {
4178	_mock.Called(child, sibling)
4179	return
4180}
4181
4182// MockBoxWidget_ReorderChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReorderChildAfter'
4183type MockBoxWidget_ReorderChildAfter_Call struct {
4184	*mock.Call
4185}
4186
4187// ReorderChildAfter is a helper method to define mock.On call
4188//   - child layout.Widget
4189//   - sibling layout.Widget
4190func (_e *MockBoxWidget_Expecter) ReorderChildAfter(child interface{}, sibling interface{}) *MockBoxWidget_ReorderChildAfter_Call {
4191	return &MockBoxWidget_ReorderChildAfter_Call{Call: _e.mock.On("ReorderChildAfter", child, sibling)}
4192}
4193
4194func (_c *MockBoxWidget_ReorderChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_ReorderChildAfter_Call {
4195	_c.Call.Run(func(args mock.Arguments) {
4196		var arg0 layout.Widget
4197		if args[0] != nil {
4198			arg0 = args[0].(layout.Widget)
4199		}
4200		var arg1 layout.Widget
4201		if args[1] != nil {
4202			arg1 = args[1].(layout.Widget)
4203		}
4204		run(
4205			arg0,
4206			arg1,
4207		)
4208	})
4209	return _c
4210}
4211
4212func (_c *MockBoxWidget_ReorderChildAfter_Call) Return() *MockBoxWidget_ReorderChildAfter_Call {
4213	_c.Call.Return()
4214	return _c
4215}
4216
4217func (_c *MockBoxWidget_ReorderChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_ReorderChildAfter_Call {
4218	_c.Run(run)
4219	return _c
4220}
4221
4222// SetCanFocus provides a mock function for the type MockBoxWidget
4223func (_mock *MockBoxWidget) SetCanFocus(canFocus bool) {
4224	_mock.Called(canFocus)
4225	return
4226}
4227
4228// MockBoxWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
4229type MockBoxWidget_SetCanFocus_Call struct {
4230	*mock.Call
4231}
4232
4233// SetCanFocus is a helper method to define mock.On call
4234//   - canFocus bool
4235func (_e *MockBoxWidget_Expecter) SetCanFocus(canFocus interface{}) *MockBoxWidget_SetCanFocus_Call {
4236	return &MockBoxWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
4237}
4238
4239func (_c *MockBoxWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockBoxWidget_SetCanFocus_Call {
4240	_c.Call.Run(func(args mock.Arguments) {
4241		var arg0 bool
4242		if args[0] != nil {
4243			arg0 = args[0].(bool)
4244		}
4245		run(
4246			arg0,
4247		)
4248	})
4249	return _c
4250}
4251
4252func (_c *MockBoxWidget_SetCanFocus_Call) Return() *MockBoxWidget_SetCanFocus_Call {
4253	_c.Call.Return()
4254	return _c
4255}
4256
4257func (_c *MockBoxWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockBoxWidget_SetCanFocus_Call {
4258	_c.Run(run)
4259	return _c
4260}
4261
4262// SetCanTarget provides a mock function for the type MockBoxWidget
4263func (_mock *MockBoxWidget) SetCanTarget(canTarget bool) {
4264	_mock.Called(canTarget)
4265	return
4266}
4267
4268// MockBoxWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
4269type MockBoxWidget_SetCanTarget_Call struct {
4270	*mock.Call
4271}
4272
4273// SetCanTarget is a helper method to define mock.On call
4274//   - canTarget bool
4275func (_e *MockBoxWidget_Expecter) SetCanTarget(canTarget interface{}) *MockBoxWidget_SetCanTarget_Call {
4276	return &MockBoxWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
4277}
4278
4279func (_c *MockBoxWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockBoxWidget_SetCanTarget_Call {
4280	_c.Call.Run(func(args mock.Arguments) {
4281		var arg0 bool
4282		if args[0] != nil {
4283			arg0 = args[0].(bool)
4284		}
4285		run(
4286			arg0,
4287		)
4288	})
4289	return _c
4290}
4291
4292func (_c *MockBoxWidget_SetCanTarget_Call) Return() *MockBoxWidget_SetCanTarget_Call {
4293	_c.Call.Return()
4294	return _c
4295}
4296
4297func (_c *MockBoxWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockBoxWidget_SetCanTarget_Call {
4298	_c.Run(run)
4299	return _c
4300}
4301
4302// SetFocusOnClick provides a mock function for the type MockBoxWidget
4303func (_mock *MockBoxWidget) SetFocusOnClick(focusOnClick bool) {
4304	_mock.Called(focusOnClick)
4305	return
4306}
4307
4308// MockBoxWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
4309type MockBoxWidget_SetFocusOnClick_Call struct {
4310	*mock.Call
4311}
4312
4313// SetFocusOnClick is a helper method to define mock.On call
4314//   - focusOnClick bool
4315func (_e *MockBoxWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockBoxWidget_SetFocusOnClick_Call {
4316	return &MockBoxWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
4317}
4318
4319func (_c *MockBoxWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockBoxWidget_SetFocusOnClick_Call {
4320	_c.Call.Run(func(args mock.Arguments) {
4321		var arg0 bool
4322		if args[0] != nil {
4323			arg0 = args[0].(bool)
4324		}
4325		run(
4326			arg0,
4327		)
4328	})
4329	return _c
4330}
4331
4332func (_c *MockBoxWidget_SetFocusOnClick_Call) Return() *MockBoxWidget_SetFocusOnClick_Call {
4333	_c.Call.Return()
4334	return _c
4335}
4336
4337func (_c *MockBoxWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockBoxWidget_SetFocusOnClick_Call {
4338	_c.Run(run)
4339	return _c
4340}
4341
4342// SetHalign provides a mock function for the type MockBoxWidget
4343func (_mock *MockBoxWidget) SetHalign(align gtk.Align) {
4344	_mock.Called(align)
4345	return
4346}
4347
4348// MockBoxWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
4349type MockBoxWidget_SetHalign_Call struct {
4350	*mock.Call
4351}
4352
4353// SetHalign is a helper method to define mock.On call
4354//   - align gtk.Align
4355func (_e *MockBoxWidget_Expecter) SetHalign(align interface{}) *MockBoxWidget_SetHalign_Call {
4356	return &MockBoxWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
4357}
4358
4359func (_c *MockBoxWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockBoxWidget_SetHalign_Call {
4360	_c.Call.Run(func(args mock.Arguments) {
4361		var arg0 gtk.Align
4362		if args[0] != nil {
4363			arg0 = args[0].(gtk.Align)
4364		}
4365		run(
4366			arg0,
4367		)
4368	})
4369	return _c
4370}
4371
4372func (_c *MockBoxWidget_SetHalign_Call) Return() *MockBoxWidget_SetHalign_Call {
4373	_c.Call.Return()
4374	return _c
4375}
4376
4377func (_c *MockBoxWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockBoxWidget_SetHalign_Call {
4378	_c.Run(run)
4379	return _c
4380}
4381
4382// SetHexpand provides a mock function for the type MockBoxWidget
4383func (_mock *MockBoxWidget) SetHexpand(expand bool) {
4384	_mock.Called(expand)
4385	return
4386}
4387
4388// MockBoxWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
4389type MockBoxWidget_SetHexpand_Call struct {
4390	*mock.Call
4391}
4392
4393// SetHexpand is a helper method to define mock.On call
4394//   - expand bool
4395func (_e *MockBoxWidget_Expecter) SetHexpand(expand interface{}) *MockBoxWidget_SetHexpand_Call {
4396	return &MockBoxWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
4397}
4398
4399func (_c *MockBoxWidget_SetHexpand_Call) Run(run func(expand bool)) *MockBoxWidget_SetHexpand_Call {
4400	_c.Call.Run(func(args mock.Arguments) {
4401		var arg0 bool
4402		if args[0] != nil {
4403			arg0 = args[0].(bool)
4404		}
4405		run(
4406			arg0,
4407		)
4408	})
4409	return _c
4410}
4411
4412func (_c *MockBoxWidget_SetHexpand_Call) Return() *MockBoxWidget_SetHexpand_Call {
4413	_c.Call.Return()
4414	return _c
4415}
4416
4417func (_c *MockBoxWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockBoxWidget_SetHexpand_Call {
4418	_c.Run(run)
4419	return _c
4420}
4421
4422// SetHomogeneous provides a mock function for the type MockBoxWidget
4423func (_mock *MockBoxWidget) SetHomogeneous(homogeneous bool) {
4424	_mock.Called(homogeneous)
4425	return
4426}
4427
4428// MockBoxWidget_SetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHomogeneous'
4429type MockBoxWidget_SetHomogeneous_Call struct {
4430	*mock.Call
4431}
4432
4433// SetHomogeneous is a helper method to define mock.On call
4434//   - homogeneous bool
4435func (_e *MockBoxWidget_Expecter) SetHomogeneous(homogeneous interface{}) *MockBoxWidget_SetHomogeneous_Call {
4436	return &MockBoxWidget_SetHomogeneous_Call{Call: _e.mock.On("SetHomogeneous", homogeneous)}
4437}
4438
4439func (_c *MockBoxWidget_SetHomogeneous_Call) Run(run func(homogeneous bool)) *MockBoxWidget_SetHomogeneous_Call {
4440	_c.Call.Run(func(args mock.Arguments) {
4441		var arg0 bool
4442		if args[0] != nil {
4443			arg0 = args[0].(bool)
4444		}
4445		run(
4446			arg0,
4447		)
4448	})
4449	return _c
4450}
4451
4452func (_c *MockBoxWidget_SetHomogeneous_Call) Return() *MockBoxWidget_SetHomogeneous_Call {
4453	_c.Call.Return()
4454	return _c
4455}
4456
4457func (_c *MockBoxWidget_SetHomogeneous_Call) RunAndReturn(run func(homogeneous bool)) *MockBoxWidget_SetHomogeneous_Call {
4458	_c.Run(run)
4459	return _c
4460}
4461
4462// SetOrientation provides a mock function for the type MockBoxWidget
4463func (_mock *MockBoxWidget) SetOrientation(orientation layout.Orientation) {
4464	_mock.Called(orientation)
4465	return
4466}
4467
4468// MockBoxWidget_SetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOrientation'
4469type MockBoxWidget_SetOrientation_Call struct {
4470	*mock.Call
4471}
4472
4473// SetOrientation is a helper method to define mock.On call
4474//   - orientation layout.Orientation
4475func (_e *MockBoxWidget_Expecter) SetOrientation(orientation interface{}) *MockBoxWidget_SetOrientation_Call {
4476	return &MockBoxWidget_SetOrientation_Call{Call: _e.mock.On("SetOrientation", orientation)}
4477}
4478
4479func (_c *MockBoxWidget_SetOrientation_Call) Run(run func(orientation layout.Orientation)) *MockBoxWidget_SetOrientation_Call {
4480	_c.Call.Run(func(args mock.Arguments) {
4481		var arg0 layout.Orientation
4482		if args[0] != nil {
4483			arg0 = args[0].(layout.Orientation)
4484		}
4485		run(
4486			arg0,
4487		)
4488	})
4489	return _c
4490}
4491
4492func (_c *MockBoxWidget_SetOrientation_Call) Return() *MockBoxWidget_SetOrientation_Call {
4493	_c.Call.Return()
4494	return _c
4495}
4496
4497func (_c *MockBoxWidget_SetOrientation_Call) RunAndReturn(run func(orientation layout.Orientation)) *MockBoxWidget_SetOrientation_Call {
4498	_c.Run(run)
4499	return _c
4500}
4501
4502// SetSizeRequest provides a mock function for the type MockBoxWidget
4503func (_mock *MockBoxWidget) SetSizeRequest(width int, height int) {
4504	_mock.Called(width, height)
4505	return
4506}
4507
4508// MockBoxWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
4509type MockBoxWidget_SetSizeRequest_Call struct {
4510	*mock.Call
4511}
4512
4513// SetSizeRequest is a helper method to define mock.On call
4514//   - width int
4515//   - height int
4516func (_e *MockBoxWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockBoxWidget_SetSizeRequest_Call {
4517	return &MockBoxWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
4518}
4519
4520func (_c *MockBoxWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockBoxWidget_SetSizeRequest_Call {
4521	_c.Call.Run(func(args mock.Arguments) {
4522		var arg0 int
4523		if args[0] != nil {
4524			arg0 = args[0].(int)
4525		}
4526		var arg1 int
4527		if args[1] != nil {
4528			arg1 = args[1].(int)
4529		}
4530		run(
4531			arg0,
4532			arg1,
4533		)
4534	})
4535	return _c
4536}
4537
4538func (_c *MockBoxWidget_SetSizeRequest_Call) Return() *MockBoxWidget_SetSizeRequest_Call {
4539	_c.Call.Return()
4540	return _c
4541}
4542
4543func (_c *MockBoxWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockBoxWidget_SetSizeRequest_Call {
4544	_c.Run(run)
4545	return _c
4546}
4547
4548// SetSpacing provides a mock function for the type MockBoxWidget
4549func (_mock *MockBoxWidget) SetSpacing(spacing int) {
4550	_mock.Called(spacing)
4551	return
4552}
4553
4554// MockBoxWidget_SetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpacing'
4555type MockBoxWidget_SetSpacing_Call struct {
4556	*mock.Call
4557}
4558
4559// SetSpacing is a helper method to define mock.On call
4560//   - spacing int
4561func (_e *MockBoxWidget_Expecter) SetSpacing(spacing interface{}) *MockBoxWidget_SetSpacing_Call {
4562	return &MockBoxWidget_SetSpacing_Call{Call: _e.mock.On("SetSpacing", spacing)}
4563}
4564
4565func (_c *MockBoxWidget_SetSpacing_Call) Run(run func(spacing int)) *MockBoxWidget_SetSpacing_Call {
4566	_c.Call.Run(func(args mock.Arguments) {
4567		var arg0 int
4568		if args[0] != nil {
4569			arg0 = args[0].(int)
4570		}
4571		run(
4572			arg0,
4573		)
4574	})
4575	return _c
4576}
4577
4578func (_c *MockBoxWidget_SetSpacing_Call) Return() *MockBoxWidget_SetSpacing_Call {
4579	_c.Call.Return()
4580	return _c
4581}
4582
4583func (_c *MockBoxWidget_SetSpacing_Call) RunAndReturn(run func(spacing int)) *MockBoxWidget_SetSpacing_Call {
4584	_c.Run(run)
4585	return _c
4586}
4587
4588// SetValign provides a mock function for the type MockBoxWidget
4589func (_mock *MockBoxWidget) SetValign(align gtk.Align) {
4590	_mock.Called(align)
4591	return
4592}
4593
4594// MockBoxWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
4595type MockBoxWidget_SetValign_Call struct {
4596	*mock.Call
4597}
4598
4599// SetValign is a helper method to define mock.On call
4600//   - align gtk.Align
4601func (_e *MockBoxWidget_Expecter) SetValign(align interface{}) *MockBoxWidget_SetValign_Call {
4602	return &MockBoxWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
4603}
4604
4605func (_c *MockBoxWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockBoxWidget_SetValign_Call {
4606	_c.Call.Run(func(args mock.Arguments) {
4607		var arg0 gtk.Align
4608		if args[0] != nil {
4609			arg0 = args[0].(gtk.Align)
4610		}
4611		run(
4612			arg0,
4613		)
4614	})
4615	return _c
4616}
4617
4618func (_c *MockBoxWidget_SetValign_Call) Return() *MockBoxWidget_SetValign_Call {
4619	_c.Call.Return()
4620	return _c
4621}
4622
4623func (_c *MockBoxWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockBoxWidget_SetValign_Call {
4624	_c.Run(run)
4625	return _c
4626}
4627
4628// SetVexpand provides a mock function for the type MockBoxWidget
4629func (_mock *MockBoxWidget) SetVexpand(expand bool) {
4630	_mock.Called(expand)
4631	return
4632}
4633
4634// MockBoxWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
4635type MockBoxWidget_SetVexpand_Call struct {
4636	*mock.Call
4637}
4638
4639// SetVexpand is a helper method to define mock.On call
4640//   - expand bool
4641func (_e *MockBoxWidget_Expecter) SetVexpand(expand interface{}) *MockBoxWidget_SetVexpand_Call {
4642	return &MockBoxWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
4643}
4644
4645func (_c *MockBoxWidget_SetVexpand_Call) Run(run func(expand bool)) *MockBoxWidget_SetVexpand_Call {
4646	_c.Call.Run(func(args mock.Arguments) {
4647		var arg0 bool
4648		if args[0] != nil {
4649			arg0 = args[0].(bool)
4650		}
4651		run(
4652			arg0,
4653		)
4654	})
4655	return _c
4656}
4657
4658func (_c *MockBoxWidget_SetVexpand_Call) Return() *MockBoxWidget_SetVexpand_Call {
4659	_c.Call.Return()
4660	return _c
4661}
4662
4663func (_c *MockBoxWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockBoxWidget_SetVexpand_Call {
4664	_c.Run(run)
4665	return _c
4666}
4667
4668// SetVisible provides a mock function for the type MockBoxWidget
4669func (_mock *MockBoxWidget) SetVisible(visible bool) {
4670	_mock.Called(visible)
4671	return
4672}
4673
4674// MockBoxWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
4675type MockBoxWidget_SetVisible_Call struct {
4676	*mock.Call
4677}
4678
4679// SetVisible is a helper method to define mock.On call
4680//   - visible bool
4681func (_e *MockBoxWidget_Expecter) SetVisible(visible interface{}) *MockBoxWidget_SetVisible_Call {
4682	return &MockBoxWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
4683}
4684
4685func (_c *MockBoxWidget_SetVisible_Call) Run(run func(visible bool)) *MockBoxWidget_SetVisible_Call {
4686	_c.Call.Run(func(args mock.Arguments) {
4687		var arg0 bool
4688		if args[0] != nil {
4689			arg0 = args[0].(bool)
4690		}
4691		run(
4692			arg0,
4693		)
4694	})
4695	return _c
4696}
4697
4698func (_c *MockBoxWidget_SetVisible_Call) Return() *MockBoxWidget_SetVisible_Call {
4699	_c.Call.Return()
4700	return _c
4701}
4702
4703func (_c *MockBoxWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockBoxWidget_SetVisible_Call {
4704	_c.Run(run)
4705	return _c
4706}
4707
4708// Show provides a mock function for the type MockBoxWidget
4709func (_mock *MockBoxWidget) Show() {
4710	_mock.Called()
4711	return
4712}
4713
4714// MockBoxWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
4715type MockBoxWidget_Show_Call struct {
4716	*mock.Call
4717}
4718
4719// Show is a helper method to define mock.On call
4720func (_e *MockBoxWidget_Expecter) Show() *MockBoxWidget_Show_Call {
4721	return &MockBoxWidget_Show_Call{Call: _e.mock.On("Show")}
4722}
4723
4724func (_c *MockBoxWidget_Show_Call) Run(run func()) *MockBoxWidget_Show_Call {
4725	_c.Call.Run(func(args mock.Arguments) {
4726		run()
4727	})
4728	return _c
4729}
4730
4731func (_c *MockBoxWidget_Show_Call) Return() *MockBoxWidget_Show_Call {
4732	_c.Call.Return()
4733	return _c
4734}
4735
4736func (_c *MockBoxWidget_Show_Call) RunAndReturn(run func()) *MockBoxWidget_Show_Call {
4737	_c.Run(run)
4738	return _c
4739}
4740
4741// Unparent provides a mock function for the type MockBoxWidget
4742func (_mock *MockBoxWidget) Unparent() {
4743	_mock.Called()
4744	return
4745}
4746
4747// MockBoxWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
4748type MockBoxWidget_Unparent_Call struct {
4749	*mock.Call
4750}
4751
4752// Unparent is a helper method to define mock.On call
4753func (_e *MockBoxWidget_Expecter) Unparent() *MockBoxWidget_Unparent_Call {
4754	return &MockBoxWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
4755}
4756
4757func (_c *MockBoxWidget_Unparent_Call) Run(run func()) *MockBoxWidget_Unparent_Call {
4758	_c.Call.Run(func(args mock.Arguments) {
4759		run()
4760	})
4761	return _c
4762}
4763
4764func (_c *MockBoxWidget_Unparent_Call) Return() *MockBoxWidget_Unparent_Call {
4765	_c.Call.Return()
4766	return _c
4767}
4768
4769func (_c *MockBoxWidget_Unparent_Call) RunAndReturn(run func()) *MockBoxWidget_Unparent_Call {
4770	_c.Run(run)
4771	return _c
4772}
4773
4774// 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.
4775// The first argument is typically a *testing.T value.
4776func NewMockOverlayWidget(t interface {
4777	mock.TestingT
4778	Cleanup(func())
4779}) *MockOverlayWidget {
4780	mock := &MockOverlayWidget{}
4781	mock.Mock.Test(t)
4782
4783	t.Cleanup(func() { mock.AssertExpectations(t) })
4784
4785	return mock
4786}
4787
4788// MockOverlayWidget is an autogenerated mock type for the OverlayWidget type
4789type MockOverlayWidget struct {
4790	mock.Mock
4791}
4792
4793type MockOverlayWidget_Expecter struct {
4794	mock *mock.Mock
4795}
4796
4797func (_m *MockOverlayWidget) EXPECT() *MockOverlayWidget_Expecter {
4798	return &MockOverlayWidget_Expecter{mock: &_m.Mock}
4799}
4800
4801// AddController provides a mock function for the type MockOverlayWidget
4802func (_mock *MockOverlayWidget) AddController(controller *gtk.EventController) {
4803	_mock.Called(controller)
4804	return
4805}
4806
4807// MockOverlayWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
4808type MockOverlayWidget_AddController_Call struct {
4809	*mock.Call
4810}
4811
4812// AddController is a helper method to define mock.On call
4813//   - controller *gtk.EventController
4814func (_e *MockOverlayWidget_Expecter) AddController(controller interface{}) *MockOverlayWidget_AddController_Call {
4815	return &MockOverlayWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
4816}
4817
4818func (_c *MockOverlayWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockOverlayWidget_AddController_Call {
4819	_c.Call.Run(func(args mock.Arguments) {
4820		var arg0 *gtk.EventController
4821		if args[0] != nil {
4822			arg0 = args[0].(*gtk.EventController)
4823		}
4824		run(
4825			arg0,
4826		)
4827	})
4828	return _c
4829}
4830
4831func (_c *MockOverlayWidget_AddController_Call) Return() *MockOverlayWidget_AddController_Call {
4832	_c.Call.Return()
4833	return _c
4834}
4835
4836func (_c *MockOverlayWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockOverlayWidget_AddController_Call {
4837	_c.Run(run)
4838	return _c
4839}
4840
4841// AddCssClass provides a mock function for the type MockOverlayWidget
4842func (_mock *MockOverlayWidget) AddCssClass(cssClass string) {
4843	_mock.Called(cssClass)
4844	return
4845}
4846
4847// MockOverlayWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
4848type MockOverlayWidget_AddCssClass_Call struct {
4849	*mock.Call
4850}
4851
4852// AddCssClass is a helper method to define mock.On call
4853//   - cssClass string
4854func (_e *MockOverlayWidget_Expecter) AddCssClass(cssClass interface{}) *MockOverlayWidget_AddCssClass_Call {
4855	return &MockOverlayWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
4856}
4857
4858func (_c *MockOverlayWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_AddCssClass_Call {
4859	_c.Call.Run(func(args mock.Arguments) {
4860		var arg0 string
4861		if args[0] != nil {
4862			arg0 = args[0].(string)
4863		}
4864		run(
4865			arg0,
4866		)
4867	})
4868	return _c
4869}
4870
4871func (_c *MockOverlayWidget_AddCssClass_Call) Return() *MockOverlayWidget_AddCssClass_Call {
4872	_c.Call.Return()
4873	return _c
4874}
4875
4876func (_c *MockOverlayWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockOverlayWidget_AddCssClass_Call {
4877	_c.Run(run)
4878	return _c
4879}
4880
4881// AddOverlay provides a mock function for the type MockOverlayWidget
4882func (_mock *MockOverlayWidget) AddOverlay(overlay layout.Widget) {
4883	_mock.Called(overlay)
4884	return
4885}
4886
4887// MockOverlayWidget_AddOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOverlay'
4888type MockOverlayWidget_AddOverlay_Call struct {
4889	*mock.Call
4890}
4891
4892// AddOverlay is a helper method to define mock.On call
4893//   - overlay layout.Widget
4894func (_e *MockOverlayWidget_Expecter) AddOverlay(overlay interface{}) *MockOverlayWidget_AddOverlay_Call {
4895	return &MockOverlayWidget_AddOverlay_Call{Call: _e.mock.On("AddOverlay", overlay)}
4896}
4897
4898func (_c *MockOverlayWidget_AddOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_AddOverlay_Call {
4899	_c.Call.Run(func(args mock.Arguments) {
4900		var arg0 layout.Widget
4901		if args[0] != nil {
4902			arg0 = args[0].(layout.Widget)
4903		}
4904		run(
4905			arg0,
4906		)
4907	})
4908	return _c
4909}
4910
4911func (_c *MockOverlayWidget_AddOverlay_Call) Return() *MockOverlayWidget_AddOverlay_Call {
4912	_c.Call.Return()
4913	return _c
4914}
4915
4916func (_c *MockOverlayWidget_AddOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) *MockOverlayWidget_AddOverlay_Call {
4917	_c.Run(run)
4918	return _c
4919}
4920
4921// ComputePoint provides a mock function for the type MockOverlayWidget
4922func (_mock *MockOverlayWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
4923	ret := _mock.Called(target)
4924
4925	if len(ret) == 0 {
4926		panic("no return value specified for ComputePoint")
4927	}
4928
4929	var r0 float64
4930	var r1 float64
4931	var r2 bool
4932	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
4933		return returnFunc(target)
4934	}
4935	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
4936		r0 = returnFunc(target)
4937	} else {
4938		r0 = ret.Get(0).(float64)
4939	}
4940	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
4941		r1 = returnFunc(target)
4942	} else {
4943		r1 = ret.Get(1).(float64)
4944	}
4945	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
4946		r2 = returnFunc(target)
4947	} else {
4948		r2 = ret.Get(2).(bool)
4949	}
4950	return r0, r1, r2
4951}
4952
4953// MockOverlayWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
4954type MockOverlayWidget_ComputePoint_Call struct {
4955	*mock.Call
4956}
4957
4958// ComputePoint is a helper method to define mock.On call
4959//   - target layout.Widget
4960func (_e *MockOverlayWidget_Expecter) ComputePoint(target interface{}) *MockOverlayWidget_ComputePoint_Call {
4961	return &MockOverlayWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
4962}
4963
4964func (_c *MockOverlayWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockOverlayWidget_ComputePoint_Call {
4965	_c.Call.Run(func(args mock.Arguments) {
4966		var arg0 layout.Widget
4967		if args[0] != nil {
4968			arg0 = args[0].(layout.Widget)
4969		}
4970		run(
4971			arg0,
4972		)
4973	})
4974	return _c
4975}
4976
4977func (_c *MockOverlayWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockOverlayWidget_ComputePoint_Call {
4978	_c.Call.Return(x, y, ok)
4979	return _c
4980}
4981
4982func (_c *MockOverlayWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockOverlayWidget_ComputePoint_Call {
4983	_c.Call.Return(run)
4984	return _c
4985}
4986
4987// GetAllocatedHeight provides a mock function for the type MockOverlayWidget
4988func (_mock *MockOverlayWidget) GetAllocatedHeight() int {
4989	ret := _mock.Called()
4990
4991	if len(ret) == 0 {
4992		panic("no return value specified for GetAllocatedHeight")
4993	}
4994
4995	var r0 int
4996	if returnFunc, ok := ret.Get(0).(func() int); ok {
4997		r0 = returnFunc()
4998	} else {
4999		r0 = ret.Get(0).(int)
5000	}
5001	return r0
5002}
5003
5004// MockOverlayWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
5005type MockOverlayWidget_GetAllocatedHeight_Call struct {
5006	*mock.Call
5007}
5008
5009// GetAllocatedHeight is a helper method to define mock.On call
5010func (_e *MockOverlayWidget_Expecter) GetAllocatedHeight() *MockOverlayWidget_GetAllocatedHeight_Call {
5011	return &MockOverlayWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
5012}
5013
5014func (_c *MockOverlayWidget_GetAllocatedHeight_Call) Run(run func()) *MockOverlayWidget_GetAllocatedHeight_Call {
5015	_c.Call.Run(func(args mock.Arguments) {
5016		run()
5017	})
5018	return _c
5019}
5020
5021func (_c *MockOverlayWidget_GetAllocatedHeight_Call) Return(n int) *MockOverlayWidget_GetAllocatedHeight_Call {
5022	_c.Call.Return(n)
5023	return _c
5024}
5025
5026func (_c *MockOverlayWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockOverlayWidget_GetAllocatedHeight_Call {
5027	_c.Call.Return(run)
5028	return _c
5029}
5030
5031// GetAllocatedWidth provides a mock function for the type MockOverlayWidget
5032func (_mock *MockOverlayWidget) GetAllocatedWidth() int {
5033	ret := _mock.Called()
5034
5035	if len(ret) == 0 {
5036		panic("no return value specified for GetAllocatedWidth")
5037	}
5038
5039	var r0 int
5040	if returnFunc, ok := ret.Get(0).(func() int); ok {
5041		r0 = returnFunc()
5042	} else {
5043		r0 = ret.Get(0).(int)
5044	}
5045	return r0
5046}
5047
5048// MockOverlayWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
5049type MockOverlayWidget_GetAllocatedWidth_Call struct {
5050	*mock.Call
5051}
5052
5053// GetAllocatedWidth is a helper method to define mock.On call
5054func (_e *MockOverlayWidget_Expecter) GetAllocatedWidth() *MockOverlayWidget_GetAllocatedWidth_Call {
5055	return &MockOverlayWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
5056}
5057
5058func (_c *MockOverlayWidget_GetAllocatedWidth_Call) Run(run func()) *MockOverlayWidget_GetAllocatedWidth_Call {
5059	_c.Call.Run(func(args mock.Arguments) {
5060		run()
5061	})
5062	return _c
5063}
5064
5065func (_c *MockOverlayWidget_GetAllocatedWidth_Call) Return(n int) *MockOverlayWidget_GetAllocatedWidth_Call {
5066	_c.Call.Return(n)
5067	return _c
5068}
5069
5070func (_c *MockOverlayWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockOverlayWidget_GetAllocatedWidth_Call {
5071	_c.Call.Return(run)
5072	return _c
5073}
5074
5075// GetChild provides a mock function for the type MockOverlayWidget
5076func (_mock *MockOverlayWidget) GetChild() layout.Widget {
5077	ret := _mock.Called()
5078
5079	if len(ret) == 0 {
5080		panic("no return value specified for GetChild")
5081	}
5082
5083	var r0 layout.Widget
5084	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
5085		r0 = returnFunc()
5086	} else {
5087		if ret.Get(0) != nil {
5088			r0 = ret.Get(0).(layout.Widget)
5089		}
5090	}
5091	return r0
5092}
5093
5094// MockOverlayWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
5095type MockOverlayWidget_GetChild_Call struct {
5096	*mock.Call
5097}
5098
5099// GetChild is a helper method to define mock.On call
5100func (_e *MockOverlayWidget_Expecter) GetChild() *MockOverlayWidget_GetChild_Call {
5101	return &MockOverlayWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
5102}
5103
5104func (_c *MockOverlayWidget_GetChild_Call) Run(run func()) *MockOverlayWidget_GetChild_Call {
5105	_c.Call.Run(func(args mock.Arguments) {
5106		run()
5107	})
5108	return _c
5109}
5110
5111func (_c *MockOverlayWidget_GetChild_Call) Return(widget layout.Widget) *MockOverlayWidget_GetChild_Call {
5112	_c.Call.Return(widget)
5113	return _c
5114}
5115
5116func (_c *MockOverlayWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) *MockOverlayWidget_GetChild_Call {
5117	_c.Call.Return(run)
5118	return _c
5119}
5120
5121// GetClipOverlay provides a mock function for the type MockOverlayWidget
5122func (_mock *MockOverlayWidget) GetClipOverlay(overlay layout.Widget) bool {
5123	ret := _mock.Called(overlay)
5124
5125	if len(ret) == 0 {
5126		panic("no return value specified for GetClipOverlay")
5127	}
5128
5129	var r0 bool
5130	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
5131		r0 = returnFunc(overlay)
5132	} else {
5133		r0 = ret.Get(0).(bool)
5134	}
5135	return r0
5136}
5137
5138// MockOverlayWidget_GetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClipOverlay'
5139type MockOverlayWidget_GetClipOverlay_Call struct {
5140	*mock.Call
5141}
5142
5143// GetClipOverlay is a helper method to define mock.On call
5144//   - overlay layout.Widget
5145func (_e *MockOverlayWidget_Expecter) GetClipOverlay(overlay interface{}) *MockOverlayWidget_GetClipOverlay_Call {
5146	return &MockOverlayWidget_GetClipOverlay_Call{Call: _e.mock.On("GetClipOverlay", overlay)}
5147}
5148
5149func (_c *MockOverlayWidget_GetClipOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_GetClipOverlay_Call {
5150	_c.Call.Run(func(args mock.Arguments) {
5151		var arg0 layout.Widget
5152		if args[0] != nil {
5153			arg0 = args[0].(layout.Widget)
5154		}
5155		run(
5156			arg0,
5157		)
5158	})
5159	return _c
5160}
5161
5162func (_c *MockOverlayWidget_GetClipOverlay_Call) Return(b bool) *MockOverlayWidget_GetClipOverlay_Call {
5163	_c.Call.Return(b)
5164	return _c
5165}
5166
5167func (_c *MockOverlayWidget_GetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) *MockOverlayWidget_GetClipOverlay_Call {
5168	_c.Call.Return(run)
5169	return _c
5170}
5171
5172// GetHexpand provides a mock function for the type MockOverlayWidget
5173func (_mock *MockOverlayWidget) GetHexpand() bool {
5174	ret := _mock.Called()
5175
5176	if len(ret) == 0 {
5177		panic("no return value specified for GetHexpand")
5178	}
5179
5180	var r0 bool
5181	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5182		r0 = returnFunc()
5183	} else {
5184		r0 = ret.Get(0).(bool)
5185	}
5186	return r0
5187}
5188
5189// MockOverlayWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
5190type MockOverlayWidget_GetHexpand_Call struct {
5191	*mock.Call
5192}
5193
5194// GetHexpand is a helper method to define mock.On call
5195func (_e *MockOverlayWidget_Expecter) GetHexpand() *MockOverlayWidget_GetHexpand_Call {
5196	return &MockOverlayWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
5197}
5198
5199func (_c *MockOverlayWidget_GetHexpand_Call) Run(run func()) *MockOverlayWidget_GetHexpand_Call {
5200	_c.Call.Run(func(args mock.Arguments) {
5201		run()
5202	})
5203	return _c
5204}
5205
5206func (_c *MockOverlayWidget_GetHexpand_Call) Return(b bool) *MockOverlayWidget_GetHexpand_Call {
5207	_c.Call.Return(b)
5208	return _c
5209}
5210
5211func (_c *MockOverlayWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GetHexpand_Call {
5212	_c.Call.Return(run)
5213	return _c
5214}
5215
5216// GetMeasureOverlay provides a mock function for the type MockOverlayWidget
5217func (_mock *MockOverlayWidget) GetMeasureOverlay(overlay layout.Widget) bool {
5218	ret := _mock.Called(overlay)
5219
5220	if len(ret) == 0 {
5221		panic("no return value specified for GetMeasureOverlay")
5222	}
5223
5224	var r0 bool
5225	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
5226		r0 = returnFunc(overlay)
5227	} else {
5228		r0 = ret.Get(0).(bool)
5229	}
5230	return r0
5231}
5232
5233// MockOverlayWidget_GetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasureOverlay'
5234type MockOverlayWidget_GetMeasureOverlay_Call struct {
5235	*mock.Call
5236}
5237
5238// GetMeasureOverlay is a helper method to define mock.On call
5239//   - overlay layout.Widget
5240func (_e *MockOverlayWidget_Expecter) GetMeasureOverlay(overlay interface{}) *MockOverlayWidget_GetMeasureOverlay_Call {
5241	return &MockOverlayWidget_GetMeasureOverlay_Call{Call: _e.mock.On("GetMeasureOverlay", overlay)}
5242}
5243
5244func (_c *MockOverlayWidget_GetMeasureOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_GetMeasureOverlay_Call {
5245	_c.Call.Run(func(args mock.Arguments) {
5246		var arg0 layout.Widget
5247		if args[0] != nil {
5248			arg0 = args[0].(layout.Widget)
5249		}
5250		run(
5251			arg0,
5252		)
5253	})
5254	return _c
5255}
5256
5257func (_c *MockOverlayWidget_GetMeasureOverlay_Call) Return(b bool) *MockOverlayWidget_GetMeasureOverlay_Call {
5258	_c.Call.Return(b)
5259	return _c
5260}
5261
5262func (_c *MockOverlayWidget_GetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) *MockOverlayWidget_GetMeasureOverlay_Call {
5263	_c.Call.Return(run)
5264	return _c
5265}
5266
5267// GetParent provides a mock function for the type MockOverlayWidget
5268func (_mock *MockOverlayWidget) GetParent() layout.Widget {
5269	ret := _mock.Called()
5270
5271	if len(ret) == 0 {
5272		panic("no return value specified for GetParent")
5273	}
5274
5275	var r0 layout.Widget
5276	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
5277		r0 = returnFunc()
5278	} else {
5279		if ret.Get(0) != nil {
5280			r0 = ret.Get(0).(layout.Widget)
5281		}
5282	}
5283	return r0
5284}
5285
5286// MockOverlayWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
5287type MockOverlayWidget_GetParent_Call struct {
5288	*mock.Call
5289}
5290
5291// GetParent is a helper method to define mock.On call
5292func (_e *MockOverlayWidget_Expecter) GetParent() *MockOverlayWidget_GetParent_Call {
5293	return &MockOverlayWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
5294}
5295
5296func (_c *MockOverlayWidget_GetParent_Call) Run(run func()) *MockOverlayWidget_GetParent_Call {
5297	_c.Call.Run(func(args mock.Arguments) {
5298		run()
5299	})
5300	return _c
5301}
5302
5303func (_c *MockOverlayWidget_GetParent_Call) Return(widget layout.Widget) *MockOverlayWidget_GetParent_Call {
5304	_c.Call.Return(widget)
5305	return _c
5306}
5307
5308func (_c *MockOverlayWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockOverlayWidget_GetParent_Call {
5309	_c.Call.Return(run)
5310	return _c
5311}
5312
5313// GetVexpand provides a mock function for the type MockOverlayWidget
5314func (_mock *MockOverlayWidget) GetVexpand() bool {
5315	ret := _mock.Called()
5316
5317	if len(ret) == 0 {
5318		panic("no return value specified for GetVexpand")
5319	}
5320
5321	var r0 bool
5322	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5323		r0 = returnFunc()
5324	} else {
5325		r0 = ret.Get(0).(bool)
5326	}
5327	return r0
5328}
5329
5330// MockOverlayWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
5331type MockOverlayWidget_GetVexpand_Call struct {
5332	*mock.Call
5333}
5334
5335// GetVexpand is a helper method to define mock.On call
5336func (_e *MockOverlayWidget_Expecter) GetVexpand() *MockOverlayWidget_GetVexpand_Call {
5337	return &MockOverlayWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
5338}
5339
5340func (_c *MockOverlayWidget_GetVexpand_Call) Run(run func()) *MockOverlayWidget_GetVexpand_Call {
5341	_c.Call.Run(func(args mock.Arguments) {
5342		run()
5343	})
5344	return _c
5345}
5346
5347func (_c *MockOverlayWidget_GetVexpand_Call) Return(b bool) *MockOverlayWidget_GetVexpand_Call {
5348	_c.Call.Return(b)
5349	return _c
5350}
5351
5352func (_c *MockOverlayWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GetVexpand_Call {
5353	_c.Call.Return(run)
5354	return _c
5355}
5356
5357// GrabFocus provides a mock function for the type MockOverlayWidget
5358func (_mock *MockOverlayWidget) GrabFocus() bool {
5359	ret := _mock.Called()
5360
5361	if len(ret) == 0 {
5362		panic("no return value specified for GrabFocus")
5363	}
5364
5365	var r0 bool
5366	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5367		r0 = returnFunc()
5368	} else {
5369		r0 = ret.Get(0).(bool)
5370	}
5371	return r0
5372}
5373
5374// MockOverlayWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
5375type MockOverlayWidget_GrabFocus_Call struct {
5376	*mock.Call
5377}
5378
5379// GrabFocus is a helper method to define mock.On call
5380func (_e *MockOverlayWidget_Expecter) GrabFocus() *MockOverlayWidget_GrabFocus_Call {
5381	return &MockOverlayWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
5382}
5383
5384func (_c *MockOverlayWidget_GrabFocus_Call) Run(run func()) *MockOverlayWidget_GrabFocus_Call {
5385	_c.Call.Run(func(args mock.Arguments) {
5386		run()
5387	})
5388	return _c
5389}
5390
5391func (_c *MockOverlayWidget_GrabFocus_Call) Return(b bool) *MockOverlayWidget_GrabFocus_Call {
5392	_c.Call.Return(b)
5393	return _c
5394}
5395
5396func (_c *MockOverlayWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GrabFocus_Call {
5397	_c.Call.Return(run)
5398	return _c
5399}
5400
5401// GtkWidget provides a mock function for the type MockOverlayWidget
5402func (_mock *MockOverlayWidget) GtkWidget() *gtk.Widget {
5403	ret := _mock.Called()
5404
5405	if len(ret) == 0 {
5406		panic("no return value specified for GtkWidget")
5407	}
5408
5409	var r0 *gtk.Widget
5410	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
5411		r0 = returnFunc()
5412	} else {
5413		if ret.Get(0) != nil {
5414			r0 = ret.Get(0).(*gtk.Widget)
5415		}
5416	}
5417	return r0
5418}
5419
5420// MockOverlayWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
5421type MockOverlayWidget_GtkWidget_Call struct {
5422	*mock.Call
5423}
5424
5425// GtkWidget is a helper method to define mock.On call
5426func (_e *MockOverlayWidget_Expecter) GtkWidget() *MockOverlayWidget_GtkWidget_Call {
5427	return &MockOverlayWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
5428}
5429
5430func (_c *MockOverlayWidget_GtkWidget_Call) Run(run func()) *MockOverlayWidget_GtkWidget_Call {
5431	_c.Call.Run(func(args mock.Arguments) {
5432		run()
5433	})
5434	return _c
5435}
5436
5437func (_c *MockOverlayWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
5438	_c.Call.Return(widget)
5439	return _c
5440}
5441
5442func (_c *MockOverlayWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
5443	_c.Call.Return(run)
5444	return _c
5445}
5446
5447// HasCssClass provides a mock function for the type MockOverlayWidget
5448func (_mock *MockOverlayWidget) HasCssClass(cssClass string) bool {
5449	ret := _mock.Called(cssClass)
5450
5451	if len(ret) == 0 {
5452		panic("no return value specified for HasCssClass")
5453	}
5454
5455	var r0 bool
5456	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
5457		r0 = returnFunc(cssClass)
5458	} else {
5459		r0 = ret.Get(0).(bool)
5460	}
5461	return r0
5462}
5463
5464// MockOverlayWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
5465type MockOverlayWidget_HasCssClass_Call struct {
5466	*mock.Call
5467}
5468
5469// HasCssClass is a helper method to define mock.On call
5470//   - cssClass string
5471func (_e *MockOverlayWidget_Expecter) HasCssClass(cssClass interface{}) *MockOverlayWidget_HasCssClass_Call {
5472	return &MockOverlayWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
5473}
5474
5475func (_c *MockOverlayWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_HasCssClass_Call {
5476	_c.Call.Run(func(args mock.Arguments) {
5477		var arg0 string
5478		if args[0] != nil {
5479			arg0 = args[0].(string)
5480		}
5481		run(
5482			arg0,
5483		)
5484	})
5485	return _c
5486}
5487
5488func (_c *MockOverlayWidget_HasCssClass_Call) Return(b bool) *MockOverlayWidget_HasCssClass_Call {
5489	_c.Call.Return(b)
5490	return _c
5491}
5492
5493func (_c *MockOverlayWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockOverlayWidget_HasCssClass_Call {
5494	_c.Call.Return(run)
5495	return _c
5496}
5497
5498// HasFocus provides a mock function for the type MockOverlayWidget
5499func (_mock *MockOverlayWidget) HasFocus() bool {
5500	ret := _mock.Called()
5501
5502	if len(ret) == 0 {
5503		panic("no return value specified for HasFocus")
5504	}
5505
5506	var r0 bool
5507	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5508		r0 = returnFunc()
5509	} else {
5510		r0 = ret.Get(0).(bool)
5511	}
5512	return r0
5513}
5514
5515// MockOverlayWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
5516type MockOverlayWidget_HasFocus_Call struct {
5517	*mock.Call
5518}
5519
5520// HasFocus is a helper method to define mock.On call
5521func (_e *MockOverlayWidget_Expecter) HasFocus() *MockOverlayWidget_HasFocus_Call {
5522	return &MockOverlayWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
5523}
5524
5525func (_c *MockOverlayWidget_HasFocus_Call) Run(run func()) *MockOverlayWidget_HasFocus_Call {
5526	_c.Call.Run(func(args mock.Arguments) {
5527		run()
5528	})
5529	return _c
5530}
5531
5532func (_c *MockOverlayWidget_HasFocus_Call) Return(b bool) *MockOverlayWidget_HasFocus_Call {
5533	_c.Call.Return(b)
5534	return _c
5535}
5536
5537func (_c *MockOverlayWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockOverlayWidget_HasFocus_Call {
5538	_c.Call.Return(run)
5539	return _c
5540}
5541
5542// Hide provides a mock function for the type MockOverlayWidget
5543func (_mock *MockOverlayWidget) Hide() {
5544	_mock.Called()
5545	return
5546}
5547
5548// MockOverlayWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
5549type MockOverlayWidget_Hide_Call struct {
5550	*mock.Call
5551}
5552
5553// Hide is a helper method to define mock.On call
5554func (_e *MockOverlayWidget_Expecter) Hide() *MockOverlayWidget_Hide_Call {
5555	return &MockOverlayWidget_Hide_Call{Call: _e.mock.On("Hide")}
5556}
5557
5558func (_c *MockOverlayWidget_Hide_Call) Run(run func()) *MockOverlayWidget_Hide_Call {
5559	_c.Call.Run(func(args mock.Arguments) {
5560		run()
5561	})
5562	return _c
5563}
5564
5565func (_c *MockOverlayWidget_Hide_Call) Return() *MockOverlayWidget_Hide_Call {
5566	_c.Call.Return()
5567	return _c
5568}
5569
5570func (_c *MockOverlayWidget_Hide_Call) RunAndReturn(run func()) *MockOverlayWidget_Hide_Call {
5571	_c.Run(run)
5572	return _c
5573}
5574
5575// IsVisible provides a mock function for the type MockOverlayWidget
5576func (_mock *MockOverlayWidget) IsVisible() bool {
5577	ret := _mock.Called()
5578
5579	if len(ret) == 0 {
5580		panic("no return value specified for IsVisible")
5581	}
5582
5583	var r0 bool
5584	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5585		r0 = returnFunc()
5586	} else {
5587		r0 = ret.Get(0).(bool)
5588	}
5589	return r0
5590}
5591
5592// MockOverlayWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
5593type MockOverlayWidget_IsVisible_Call struct {
5594	*mock.Call
5595}
5596
5597// IsVisible is a helper method to define mock.On call
5598func (_e *MockOverlayWidget_Expecter) IsVisible() *MockOverlayWidget_IsVisible_Call {
5599	return &MockOverlayWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
5600}
5601
5602func (_c *MockOverlayWidget_IsVisible_Call) Run(run func()) *MockOverlayWidget_IsVisible_Call {
5603	_c.Call.Run(func(args mock.Arguments) {
5604		run()
5605	})
5606	return _c
5607}
5608
5609func (_c *MockOverlayWidget_IsVisible_Call) Return(b bool) *MockOverlayWidget_IsVisible_Call {
5610	_c.Call.Return(b)
5611	return _c
5612}
5613
5614func (_c *MockOverlayWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockOverlayWidget_IsVisible_Call {
5615	_c.Call.Return(run)
5616	return _c
5617}
5618
5619// RemoveCssClass provides a mock function for the type MockOverlayWidget
5620func (_mock *MockOverlayWidget) RemoveCssClass(cssClass string) {
5621	_mock.Called(cssClass)
5622	return
5623}
5624
5625// MockOverlayWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
5626type MockOverlayWidget_RemoveCssClass_Call struct {
5627	*mock.Call
5628}
5629
5630// RemoveCssClass is a helper method to define mock.On call
5631//   - cssClass string
5632func (_e *MockOverlayWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockOverlayWidget_RemoveCssClass_Call {
5633	return &MockOverlayWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
5634}
5635
5636func (_c *MockOverlayWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_RemoveCssClass_Call {
5637	_c.Call.Run(func(args mock.Arguments) {
5638		var arg0 string
5639		if args[0] != nil {
5640			arg0 = args[0].(string)
5641		}
5642		run(
5643			arg0,
5644		)
5645	})
5646	return _c
5647}
5648
5649func (_c *MockOverlayWidget_RemoveCssClass_Call) Return() *MockOverlayWidget_RemoveCssClass_Call {
5650	_c.Call.Return()
5651	return _c
5652}
5653
5654func (_c *MockOverlayWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockOverlayWidget_RemoveCssClass_Call {
5655	_c.Run(run)
5656	return _c
5657}
5658
5659// RemoveOverlay provides a mock function for the type MockOverlayWidget
5660func (_mock *MockOverlayWidget) RemoveOverlay(overlay layout.Widget) {
5661	_mock.Called(overlay)
5662	return
5663}
5664
5665// MockOverlayWidget_RemoveOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOverlay'
5666type MockOverlayWidget_RemoveOverlay_Call struct {
5667	*mock.Call
5668}
5669
5670// RemoveOverlay is a helper method to define mock.On call
5671//   - overlay layout.Widget
5672func (_e *MockOverlayWidget_Expecter) RemoveOverlay(overlay interface{}) *MockOverlayWidget_RemoveOverlay_Call {
5673	return &MockOverlayWidget_RemoveOverlay_Call{Call: _e.mock.On("RemoveOverlay", overlay)}
5674}
5675
5676func (_c *MockOverlayWidget_RemoveOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_RemoveOverlay_Call {
5677	_c.Call.Run(func(args mock.Arguments) {
5678		var arg0 layout.Widget
5679		if args[0] != nil {
5680			arg0 = args[0].(layout.Widget)
5681		}
5682		run(
5683			arg0,
5684		)
5685	})
5686	return _c
5687}
5688
5689func (_c *MockOverlayWidget_RemoveOverlay_Call) Return() *MockOverlayWidget_RemoveOverlay_Call {
5690	_c.Call.Return()
5691	return _c
5692}
5693
5694func (_c *MockOverlayWidget_RemoveOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) *MockOverlayWidget_RemoveOverlay_Call {
5695	_c.Run(run)
5696	return _c
5697}
5698
5699// SetCanFocus provides a mock function for the type MockOverlayWidget
5700func (_mock *MockOverlayWidget) SetCanFocus(canFocus bool) {
5701	_mock.Called(canFocus)
5702	return
5703}
5704
5705// MockOverlayWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
5706type MockOverlayWidget_SetCanFocus_Call struct {
5707	*mock.Call
5708}
5709
5710// SetCanFocus is a helper method to define mock.On call
5711//   - canFocus bool
5712func (_e *MockOverlayWidget_Expecter) SetCanFocus(canFocus interface{}) *MockOverlayWidget_SetCanFocus_Call {
5713	return &MockOverlayWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
5714}
5715
5716func (_c *MockOverlayWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockOverlayWidget_SetCanFocus_Call {
5717	_c.Call.Run(func(args mock.Arguments) {
5718		var arg0 bool
5719		if args[0] != nil {
5720			arg0 = args[0].(bool)
5721		}
5722		run(
5723			arg0,
5724		)
5725	})
5726	return _c
5727}
5728
5729func (_c *MockOverlayWidget_SetCanFocus_Call) Return() *MockOverlayWidget_SetCanFocus_Call {
5730	_c.Call.Return()
5731	return _c
5732}
5733
5734func (_c *MockOverlayWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockOverlayWidget_SetCanFocus_Call {
5735	_c.Run(run)
5736	return _c
5737}
5738
5739// SetCanTarget provides a mock function for the type MockOverlayWidget
5740func (_mock *MockOverlayWidget) SetCanTarget(canTarget bool) {
5741	_mock.Called(canTarget)
5742	return
5743}
5744
5745// MockOverlayWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
5746type MockOverlayWidget_SetCanTarget_Call struct {
5747	*mock.Call
5748}
5749
5750// SetCanTarget is a helper method to define mock.On call
5751//   - canTarget bool
5752func (_e *MockOverlayWidget_Expecter) SetCanTarget(canTarget interface{}) *MockOverlayWidget_SetCanTarget_Call {
5753	return &MockOverlayWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
5754}
5755
5756func (_c *MockOverlayWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockOverlayWidget_SetCanTarget_Call {
5757	_c.Call.Run(func(args mock.Arguments) {
5758		var arg0 bool
5759		if args[0] != nil {
5760			arg0 = args[0].(bool)
5761		}
5762		run(
5763			arg0,
5764		)
5765	})
5766	return _c
5767}
5768
5769func (_c *MockOverlayWidget_SetCanTarget_Call) Return() *MockOverlayWidget_SetCanTarget_Call {
5770	_c.Call.Return()
5771	return _c
5772}
5773
5774func (_c *MockOverlayWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockOverlayWidget_SetCanTarget_Call {
5775	_c.Run(run)
5776	return _c
5777}
5778
5779// SetChild provides a mock function for the type MockOverlayWidget
5780func (_mock *MockOverlayWidget) SetChild(child layout.Widget) {
5781	_mock.Called(child)
5782	return
5783}
5784
5785// MockOverlayWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
5786type MockOverlayWidget_SetChild_Call struct {
5787	*mock.Call
5788}
5789
5790// SetChild is a helper method to define mock.On call
5791//   - child layout.Widget
5792func (_e *MockOverlayWidget_Expecter) SetChild(child interface{}) *MockOverlayWidget_SetChild_Call {
5793	return &MockOverlayWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
5794}
5795
5796func (_c *MockOverlayWidget_SetChild_Call) Run(run func(child layout.Widget)) *MockOverlayWidget_SetChild_Call {
5797	_c.Call.Run(func(args mock.Arguments) {
5798		var arg0 layout.Widget
5799		if args[0] != nil {
5800			arg0 = args[0].(layout.Widget)
5801		}
5802		run(
5803			arg0,
5804		)
5805	})
5806	return _c
5807}
5808
5809func (_c *MockOverlayWidget_SetChild_Call) Return() *MockOverlayWidget_SetChild_Call {
5810	_c.Call.Return()
5811	return _c
5812}
5813
5814func (_c *MockOverlayWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) *MockOverlayWidget_SetChild_Call {
5815	_c.Run(run)
5816	return _c
5817}
5818
5819// SetClipOverlay provides a mock function for the type MockOverlayWidget
5820func (_mock *MockOverlayWidget) SetClipOverlay(overlay layout.Widget, clip bool) {
5821	_mock.Called(overlay, clip)
5822	return
5823}
5824
5825// MockOverlayWidget_SetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetClipOverlay'
5826type MockOverlayWidget_SetClipOverlay_Call struct {
5827	*mock.Call
5828}
5829
5830// SetClipOverlay is a helper method to define mock.On call
5831//   - overlay layout.Widget
5832//   - clip bool
5833func (_e *MockOverlayWidget_Expecter) SetClipOverlay(overlay interface{}, clip interface{}) *MockOverlayWidget_SetClipOverlay_Call {
5834	return &MockOverlayWidget_SetClipOverlay_Call{Call: _e.mock.On("SetClipOverlay", overlay, clip)}
5835}
5836
5837func (_c *MockOverlayWidget_SetClipOverlay_Call) Run(run func(overlay layout.Widget, clip bool)) *MockOverlayWidget_SetClipOverlay_Call {
5838	_c.Call.Run(func(args mock.Arguments) {
5839		var arg0 layout.Widget
5840		if args[0] != nil {
5841			arg0 = args[0].(layout.Widget)
5842		}
5843		var arg1 bool
5844		if args[1] != nil {
5845			arg1 = args[1].(bool)
5846		}
5847		run(
5848			arg0,
5849			arg1,
5850		)
5851	})
5852	return _c
5853}
5854
5855func (_c *MockOverlayWidget_SetClipOverlay_Call) Return() *MockOverlayWidget_SetClipOverlay_Call {
5856	_c.Call.Return()
5857	return _c
5858}
5859
5860func (_c *MockOverlayWidget_SetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget, clip bool)) *MockOverlayWidget_SetClipOverlay_Call {
5861	_c.Run(run)
5862	return _c
5863}
5864
5865// SetFocusOnClick provides a mock function for the type MockOverlayWidget
5866func (_mock *MockOverlayWidget) SetFocusOnClick(focusOnClick bool) {
5867	_mock.Called(focusOnClick)
5868	return
5869}
5870
5871// MockOverlayWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
5872type MockOverlayWidget_SetFocusOnClick_Call struct {
5873	*mock.Call
5874}
5875
5876// SetFocusOnClick is a helper method to define mock.On call
5877//   - focusOnClick bool
5878func (_e *MockOverlayWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockOverlayWidget_SetFocusOnClick_Call {
5879	return &MockOverlayWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
5880}
5881
5882func (_c *MockOverlayWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockOverlayWidget_SetFocusOnClick_Call {
5883	_c.Call.Run(func(args mock.Arguments) {
5884		var arg0 bool
5885		if args[0] != nil {
5886			arg0 = args[0].(bool)
5887		}
5888		run(
5889			arg0,
5890		)
5891	})
5892	return _c
5893}
5894
5895func (_c *MockOverlayWidget_SetFocusOnClick_Call) Return() *MockOverlayWidget_SetFocusOnClick_Call {
5896	_c.Call.Return()
5897	return _c
5898}
5899
5900func (_c *MockOverlayWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockOverlayWidget_SetFocusOnClick_Call {
5901	_c.Run(run)
5902	return _c
5903}
5904
5905// SetHalign provides a mock function for the type MockOverlayWidget
5906func (_mock *MockOverlayWidget) SetHalign(align gtk.Align) {
5907	_mock.Called(align)
5908	return
5909}
5910
5911// MockOverlayWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
5912type MockOverlayWidget_SetHalign_Call struct {
5913	*mock.Call
5914}
5915
5916// SetHalign is a helper method to define mock.On call
5917//   - align gtk.Align
5918func (_e *MockOverlayWidget_Expecter) SetHalign(align interface{}) *MockOverlayWidget_SetHalign_Call {
5919	return &MockOverlayWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
5920}
5921
5922func (_c *MockOverlayWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockOverlayWidget_SetHalign_Call {
5923	_c.Call.Run(func(args mock.Arguments) {
5924		var arg0 gtk.Align
5925		if args[0] != nil {
5926			arg0 = args[0].(gtk.Align)
5927		}
5928		run(
5929			arg0,
5930		)
5931	})
5932	return _c
5933}
5934
5935func (_c *MockOverlayWidget_SetHalign_Call) Return() *MockOverlayWidget_SetHalign_Call {
5936	_c.Call.Return()
5937	return _c
5938}
5939
5940func (_c *MockOverlayWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockOverlayWidget_SetHalign_Call {
5941	_c.Run(run)
5942	return _c
5943}
5944
5945// SetHexpand provides a mock function for the type MockOverlayWidget
5946func (_mock *MockOverlayWidget) SetHexpand(expand bool) {
5947	_mock.Called(expand)
5948	return
5949}
5950
5951// MockOverlayWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
5952type MockOverlayWidget_SetHexpand_Call struct {
5953	*mock.Call
5954}
5955
5956// SetHexpand is a helper method to define mock.On call
5957//   - expand bool
5958func (_e *MockOverlayWidget_Expecter) SetHexpand(expand interface{}) *MockOverlayWidget_SetHexpand_Call {
5959	return &MockOverlayWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
5960}
5961
5962func (_c *MockOverlayWidget_SetHexpand_Call) Run(run func(expand bool)) *MockOverlayWidget_SetHexpand_Call {
5963	_c.Call.Run(func(args mock.Arguments) {
5964		var arg0 bool
5965		if args[0] != nil {
5966			arg0 = args[0].(bool)
5967		}
5968		run(
5969			arg0,
5970		)
5971	})
5972	return _c
5973}
5974
5975func (_c *MockOverlayWidget_SetHexpand_Call) Return() *MockOverlayWidget_SetHexpand_Call {
5976	_c.Call.Return()
5977	return _c
5978}
5979
5980func (_c *MockOverlayWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockOverlayWidget_SetHexpand_Call {
5981	_c.Run(run)
5982	return _c
5983}
5984
5985// SetMeasureOverlay provides a mock function for the type MockOverlayWidget
5986func (_mock *MockOverlayWidget) SetMeasureOverlay(overlay layout.Widget, measure bool) {
5987	_mock.Called(overlay, measure)
5988	return
5989}
5990
5991// MockOverlayWidget_SetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMeasureOverlay'
5992type MockOverlayWidget_SetMeasureOverlay_Call struct {
5993	*mock.Call
5994}
5995
5996// SetMeasureOverlay is a helper method to define mock.On call
5997//   - overlay layout.Widget
5998//   - measure bool
5999func (_e *MockOverlayWidget_Expecter) SetMeasureOverlay(overlay interface{}, measure interface{}) *MockOverlayWidget_SetMeasureOverlay_Call {
6000	return &MockOverlayWidget_SetMeasureOverlay_Call{Call: _e.mock.On("SetMeasureOverlay", overlay, measure)}
6001}
6002
6003func (_c *MockOverlayWidget_SetMeasureOverlay_Call) Run(run func(overlay layout.Widget, measure bool)) *MockOverlayWidget_SetMeasureOverlay_Call {
6004	_c.Call.Run(func(args mock.Arguments) {
6005		var arg0 layout.Widget
6006		if args[0] != nil {
6007			arg0 = args[0].(layout.Widget)
6008		}
6009		var arg1 bool
6010		if args[1] != nil {
6011			arg1 = args[1].(bool)
6012		}
6013		run(
6014			arg0,
6015			arg1,
6016		)
6017	})
6018	return _c
6019}
6020
6021func (_c *MockOverlayWidget_SetMeasureOverlay_Call) Return() *MockOverlayWidget_SetMeasureOverlay_Call {
6022	_c.Call.Return()
6023	return _c
6024}
6025
6026func (_c *MockOverlayWidget_SetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget, measure bool)) *MockOverlayWidget_SetMeasureOverlay_Call {
6027	_c.Run(run)
6028	return _c
6029}
6030
6031// SetSizeRequest provides a mock function for the type MockOverlayWidget
6032func (_mock *MockOverlayWidget) SetSizeRequest(width int, height int) {
6033	_mock.Called(width, height)
6034	return
6035}
6036
6037// MockOverlayWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
6038type MockOverlayWidget_SetSizeRequest_Call struct {
6039	*mock.Call
6040}
6041
6042// SetSizeRequest is a helper method to define mock.On call
6043//   - width int
6044//   - height int
6045func (_e *MockOverlayWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockOverlayWidget_SetSizeRequest_Call {
6046	return &MockOverlayWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
6047}
6048
6049func (_c *MockOverlayWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockOverlayWidget_SetSizeRequest_Call {
6050	_c.Call.Run(func(args mock.Arguments) {
6051		var arg0 int
6052		if args[0] != nil {
6053			arg0 = args[0].(int)
6054		}
6055		var arg1 int
6056		if args[1] != nil {
6057			arg1 = args[1].(int)
6058		}
6059		run(
6060			arg0,
6061			arg1,
6062		)
6063	})
6064	return _c
6065}
6066
6067func (_c *MockOverlayWidget_SetSizeRequest_Call) Return() *MockOverlayWidget_SetSizeRequest_Call {
6068	_c.Call.Return()
6069	return _c
6070}
6071
6072func (_c *MockOverlayWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockOverlayWidget_SetSizeRequest_Call {
6073	_c.Run(run)
6074	return _c
6075}
6076
6077// SetValign provides a mock function for the type MockOverlayWidget
6078func (_mock *MockOverlayWidget) SetValign(align gtk.Align) {
6079	_mock.Called(align)
6080	return
6081}
6082
6083// MockOverlayWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
6084type MockOverlayWidget_SetValign_Call struct {
6085	*mock.Call
6086}
6087
6088// SetValign is a helper method to define mock.On call
6089//   - align gtk.Align
6090func (_e *MockOverlayWidget_Expecter) SetValign(align interface{}) *MockOverlayWidget_SetValign_Call {
6091	return &MockOverlayWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
6092}
6093
6094func (_c *MockOverlayWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockOverlayWidget_SetValign_Call {
6095	_c.Call.Run(func(args mock.Arguments) {
6096		var arg0 gtk.Align
6097		if args[0] != nil {
6098			arg0 = args[0].(gtk.Align)
6099		}
6100		run(
6101			arg0,
6102		)
6103	})
6104	return _c
6105}
6106
6107func (_c *MockOverlayWidget_SetValign_Call) Return() *MockOverlayWidget_SetValign_Call {
6108	_c.Call.Return()
6109	return _c
6110}
6111
6112func (_c *MockOverlayWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockOverlayWidget_SetValign_Call {
6113	_c.Run(run)
6114	return _c
6115}
6116
6117// SetVexpand provides a mock function for the type MockOverlayWidget
6118func (_mock *MockOverlayWidget) SetVexpand(expand bool) {
6119	_mock.Called(expand)
6120	return
6121}
6122
6123// MockOverlayWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
6124type MockOverlayWidget_SetVexpand_Call struct {
6125	*mock.Call
6126}
6127
6128// SetVexpand is a helper method to define mock.On call
6129//   - expand bool
6130func (_e *MockOverlayWidget_Expecter) SetVexpand(expand interface{}) *MockOverlayWidget_SetVexpand_Call {
6131	return &MockOverlayWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
6132}
6133
6134func (_c *MockOverlayWidget_SetVexpand_Call) Run(run func(expand bool)) *MockOverlayWidget_SetVexpand_Call {
6135	_c.Call.Run(func(args mock.Arguments) {
6136		var arg0 bool
6137		if args[0] != nil {
6138			arg0 = args[0].(bool)
6139		}
6140		run(
6141			arg0,
6142		)
6143	})
6144	return _c
6145}
6146
6147func (_c *MockOverlayWidget_SetVexpand_Call) Return() *MockOverlayWidget_SetVexpand_Call {
6148	_c.Call.Return()
6149	return _c
6150}
6151
6152func (_c *MockOverlayWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockOverlayWidget_SetVexpand_Call {
6153	_c.Run(run)
6154	return _c
6155}
6156
6157// SetVisible provides a mock function for the type MockOverlayWidget
6158func (_mock *MockOverlayWidget) SetVisible(visible bool) {
6159	_mock.Called(visible)
6160	return
6161}
6162
6163// MockOverlayWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
6164type MockOverlayWidget_SetVisible_Call struct {
6165	*mock.Call
6166}
6167
6168// SetVisible is a helper method to define mock.On call
6169//   - visible bool
6170func (_e *MockOverlayWidget_Expecter) SetVisible(visible interface{}) *MockOverlayWidget_SetVisible_Call {
6171	return &MockOverlayWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
6172}
6173
6174func (_c *MockOverlayWidget_SetVisible_Call) Run(run func(visible bool)) *MockOverlayWidget_SetVisible_Call {
6175	_c.Call.Run(func(args mock.Arguments) {
6176		var arg0 bool
6177		if args[0] != nil {
6178			arg0 = args[0].(bool)
6179		}
6180		run(
6181			arg0,
6182		)
6183	})
6184	return _c
6185}
6186
6187func (_c *MockOverlayWidget_SetVisible_Call) Return() *MockOverlayWidget_SetVisible_Call {
6188	_c.Call.Return()
6189	return _c
6190}
6191
6192func (_c *MockOverlayWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockOverlayWidget_SetVisible_Call {
6193	_c.Run(run)
6194	return _c
6195}
6196
6197// Show provides a mock function for the type MockOverlayWidget
6198func (_mock *MockOverlayWidget) Show() {
6199	_mock.Called()
6200	return
6201}
6202
6203// MockOverlayWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
6204type MockOverlayWidget_Show_Call struct {
6205	*mock.Call
6206}
6207
6208// Show is a helper method to define mock.On call
6209func (_e *MockOverlayWidget_Expecter) Show() *MockOverlayWidget_Show_Call {
6210	return &MockOverlayWidget_Show_Call{Call: _e.mock.On("Show")}
6211}
6212
6213func (_c *MockOverlayWidget_Show_Call) Run(run func()) *MockOverlayWidget_Show_Call {
6214	_c.Call.Run(func(args mock.Arguments) {
6215		run()
6216	})
6217	return _c
6218}
6219
6220func (_c *MockOverlayWidget_Show_Call) Return() *MockOverlayWidget_Show_Call {
6221	_c.Call.Return()
6222	return _c
6223}
6224
6225func (_c *MockOverlayWidget_Show_Call) RunAndReturn(run func()) *MockOverlayWidget_Show_Call {
6226	_c.Run(run)
6227	return _c
6228}
6229
6230// Unparent provides a mock function for the type MockOverlayWidget
6231func (_mock *MockOverlayWidget) Unparent() {
6232	_mock.Called()
6233	return
6234}
6235
6236// MockOverlayWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
6237type MockOverlayWidget_Unparent_Call struct {
6238	*mock.Call
6239}
6240
6241// Unparent is a helper method to define mock.On call
6242func (_e *MockOverlayWidget_Expecter) Unparent() *MockOverlayWidget_Unparent_Call {
6243	return &MockOverlayWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
6244}
6245
6246func (_c *MockOverlayWidget_Unparent_Call) Run(run func()) *MockOverlayWidget_Unparent_Call {
6247	_c.Call.Run(func(args mock.Arguments) {
6248		run()
6249	})
6250	return _c
6251}
6252
6253func (_c *MockOverlayWidget_Unparent_Call) Return() *MockOverlayWidget_Unparent_Call {
6254	_c.Call.Return()
6255	return _c
6256}
6257
6258func (_c *MockOverlayWidget_Unparent_Call) RunAndReturn(run func()) *MockOverlayWidget_Unparent_Call {
6259	_c.Run(run)
6260	return _c
6261}
6262
6263// 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.
6264// The first argument is typically a *testing.T value.
6265func NewMockLabelWidget(t interface {
6266	mock.TestingT
6267	Cleanup(func())
6268}) *MockLabelWidget {
6269	mock := &MockLabelWidget{}
6270	mock.Mock.Test(t)
6271
6272	t.Cleanup(func() { mock.AssertExpectations(t) })
6273
6274	return mock
6275}
6276
6277// MockLabelWidget is an autogenerated mock type for the LabelWidget type
6278type MockLabelWidget struct {
6279	mock.Mock
6280}
6281
6282type MockLabelWidget_Expecter struct {
6283	mock *mock.Mock
6284}
6285
6286func (_m *MockLabelWidget) EXPECT() *MockLabelWidget_Expecter {
6287	return &MockLabelWidget_Expecter{mock: &_m.Mock}
6288}
6289
6290// AddController provides a mock function for the type MockLabelWidget
6291func (_mock *MockLabelWidget) AddController(controller *gtk.EventController) {
6292	_mock.Called(controller)
6293	return
6294}
6295
6296// MockLabelWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
6297type MockLabelWidget_AddController_Call struct {
6298	*mock.Call
6299}
6300
6301// AddController is a helper method to define mock.On call
6302//   - controller *gtk.EventController
6303func (_e *MockLabelWidget_Expecter) AddController(controller interface{}) *MockLabelWidget_AddController_Call {
6304	return &MockLabelWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
6305}
6306
6307func (_c *MockLabelWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockLabelWidget_AddController_Call {
6308	_c.Call.Run(func(args mock.Arguments) {
6309		var arg0 *gtk.EventController
6310		if args[0] != nil {
6311			arg0 = args[0].(*gtk.EventController)
6312		}
6313		run(
6314			arg0,
6315		)
6316	})
6317	return _c
6318}
6319
6320func (_c *MockLabelWidget_AddController_Call) Return() *MockLabelWidget_AddController_Call {
6321	_c.Call.Return()
6322	return _c
6323}
6324
6325func (_c *MockLabelWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockLabelWidget_AddController_Call {
6326	_c.Run(run)
6327	return _c
6328}
6329
6330// AddCssClass provides a mock function for the type MockLabelWidget
6331func (_mock *MockLabelWidget) AddCssClass(cssClass string) {
6332	_mock.Called(cssClass)
6333	return
6334}
6335
6336// MockLabelWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
6337type MockLabelWidget_AddCssClass_Call struct {
6338	*mock.Call
6339}
6340
6341// AddCssClass is a helper method to define mock.On call
6342//   - cssClass string
6343func (_e *MockLabelWidget_Expecter) AddCssClass(cssClass interface{}) *MockLabelWidget_AddCssClass_Call {
6344	return &MockLabelWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
6345}
6346
6347func (_c *MockLabelWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_AddCssClass_Call {
6348	_c.Call.Run(func(args mock.Arguments) {
6349		var arg0 string
6350		if args[0] != nil {
6351			arg0 = args[0].(string)
6352		}
6353		run(
6354			arg0,
6355		)
6356	})
6357	return _c
6358}
6359
6360func (_c *MockLabelWidget_AddCssClass_Call) Return() *MockLabelWidget_AddCssClass_Call {
6361	_c.Call.Return()
6362	return _c
6363}
6364
6365func (_c *MockLabelWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockLabelWidget_AddCssClass_Call {
6366	_c.Run(run)
6367	return _c
6368}
6369
6370// ComputePoint provides a mock function for the type MockLabelWidget
6371func (_mock *MockLabelWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
6372	ret := _mock.Called(target)
6373
6374	if len(ret) == 0 {
6375		panic("no return value specified for ComputePoint")
6376	}
6377
6378	var r0 float64
6379	var r1 float64
6380	var r2 bool
6381	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
6382		return returnFunc(target)
6383	}
6384	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
6385		r0 = returnFunc(target)
6386	} else {
6387		r0 = ret.Get(0).(float64)
6388	}
6389	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
6390		r1 = returnFunc(target)
6391	} else {
6392		r1 = ret.Get(1).(float64)
6393	}
6394	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
6395		r2 = returnFunc(target)
6396	} else {
6397		r2 = ret.Get(2).(bool)
6398	}
6399	return r0, r1, r2
6400}
6401
6402// MockLabelWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
6403type MockLabelWidget_ComputePoint_Call struct {
6404	*mock.Call
6405}
6406
6407// ComputePoint is a helper method to define mock.On call
6408//   - target layout.Widget
6409func (_e *MockLabelWidget_Expecter) ComputePoint(target interface{}) *MockLabelWidget_ComputePoint_Call {
6410	return &MockLabelWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
6411}
6412
6413func (_c *MockLabelWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockLabelWidget_ComputePoint_Call {
6414	_c.Call.Run(func(args mock.Arguments) {
6415		var arg0 layout.Widget
6416		if args[0] != nil {
6417			arg0 = args[0].(layout.Widget)
6418		}
6419		run(
6420			arg0,
6421		)
6422	})
6423	return _c
6424}
6425
6426func (_c *MockLabelWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockLabelWidget_ComputePoint_Call {
6427	_c.Call.Return(x, y, ok)
6428	return _c
6429}
6430
6431func (_c *MockLabelWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockLabelWidget_ComputePoint_Call {
6432	_c.Call.Return(run)
6433	return _c
6434}
6435
6436// GetAllocatedHeight provides a mock function for the type MockLabelWidget
6437func (_mock *MockLabelWidget) GetAllocatedHeight() int {
6438	ret := _mock.Called()
6439
6440	if len(ret) == 0 {
6441		panic("no return value specified for GetAllocatedHeight")
6442	}
6443
6444	var r0 int
6445	if returnFunc, ok := ret.Get(0).(func() int); ok {
6446		r0 = returnFunc()
6447	} else {
6448		r0 = ret.Get(0).(int)
6449	}
6450	return r0
6451}
6452
6453// MockLabelWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
6454type MockLabelWidget_GetAllocatedHeight_Call struct {
6455	*mock.Call
6456}
6457
6458// GetAllocatedHeight is a helper method to define mock.On call
6459func (_e *MockLabelWidget_Expecter) GetAllocatedHeight() *MockLabelWidget_GetAllocatedHeight_Call {
6460	return &MockLabelWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
6461}
6462
6463func (_c *MockLabelWidget_GetAllocatedHeight_Call) Run(run func()) *MockLabelWidget_GetAllocatedHeight_Call {
6464	_c.Call.Run(func(args mock.Arguments) {
6465		run()
6466	})
6467	return _c
6468}
6469
6470func (_c *MockLabelWidget_GetAllocatedHeight_Call) Return(n int) *MockLabelWidget_GetAllocatedHeight_Call {
6471	_c.Call.Return(n)
6472	return _c
6473}
6474
6475func (_c *MockLabelWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockLabelWidget_GetAllocatedHeight_Call {
6476	_c.Call.Return(run)
6477	return _c
6478}
6479
6480// GetAllocatedWidth provides a mock function for the type MockLabelWidget
6481func (_mock *MockLabelWidget) GetAllocatedWidth() int {
6482	ret := _mock.Called()
6483
6484	if len(ret) == 0 {
6485		panic("no return value specified for GetAllocatedWidth")
6486	}
6487
6488	var r0 int
6489	if returnFunc, ok := ret.Get(0).(func() int); ok {
6490		r0 = returnFunc()
6491	} else {
6492		r0 = ret.Get(0).(int)
6493	}
6494	return r0
6495}
6496
6497// MockLabelWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
6498type MockLabelWidget_GetAllocatedWidth_Call struct {
6499	*mock.Call
6500}
6501
6502// GetAllocatedWidth is a helper method to define mock.On call
6503func (_e *MockLabelWidget_Expecter) GetAllocatedWidth() *MockLabelWidget_GetAllocatedWidth_Call {
6504	return &MockLabelWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
6505}
6506
6507func (_c *MockLabelWidget_GetAllocatedWidth_Call) Run(run func()) *MockLabelWidget_GetAllocatedWidth_Call {
6508	_c.Call.Run(func(args mock.Arguments) {
6509		run()
6510	})
6511	return _c
6512}
6513
6514func (_c *MockLabelWidget_GetAllocatedWidth_Call) Return(n int) *MockLabelWidget_GetAllocatedWidth_Call {
6515	_c.Call.Return(n)
6516	return _c
6517}
6518
6519func (_c *MockLabelWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockLabelWidget_GetAllocatedWidth_Call {
6520	_c.Call.Return(run)
6521	return _c
6522}
6523
6524// GetHexpand provides a mock function for the type MockLabelWidget
6525func (_mock *MockLabelWidget) GetHexpand() bool {
6526	ret := _mock.Called()
6527
6528	if len(ret) == 0 {
6529		panic("no return value specified for GetHexpand")
6530	}
6531
6532	var r0 bool
6533	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6534		r0 = returnFunc()
6535	} else {
6536		r0 = ret.Get(0).(bool)
6537	}
6538	return r0
6539}
6540
6541// MockLabelWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
6542type MockLabelWidget_GetHexpand_Call struct {
6543	*mock.Call
6544}
6545
6546// GetHexpand is a helper method to define mock.On call
6547func (_e *MockLabelWidget_Expecter) GetHexpand() *MockLabelWidget_GetHexpand_Call {
6548	return &MockLabelWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
6549}
6550
6551func (_c *MockLabelWidget_GetHexpand_Call) Run(run func()) *MockLabelWidget_GetHexpand_Call {
6552	_c.Call.Run(func(args mock.Arguments) {
6553		run()
6554	})
6555	return _c
6556}
6557
6558func (_c *MockLabelWidget_GetHexpand_Call) Return(b bool) *MockLabelWidget_GetHexpand_Call {
6559	_c.Call.Return(b)
6560	return _c
6561}
6562
6563func (_c *MockLabelWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockLabelWidget_GetHexpand_Call {
6564	_c.Call.Return(run)
6565	return _c
6566}
6567
6568// GetParent provides a mock function for the type MockLabelWidget
6569func (_mock *MockLabelWidget) GetParent() layout.Widget {
6570	ret := _mock.Called()
6571
6572	if len(ret) == 0 {
6573		panic("no return value specified for GetParent")
6574	}
6575
6576	var r0 layout.Widget
6577	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
6578		r0 = returnFunc()
6579	} else {
6580		if ret.Get(0) != nil {
6581			r0 = ret.Get(0).(layout.Widget)
6582		}
6583	}
6584	return r0
6585}
6586
6587// MockLabelWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
6588type MockLabelWidget_GetParent_Call struct {
6589	*mock.Call
6590}
6591
6592// GetParent is a helper method to define mock.On call
6593func (_e *MockLabelWidget_Expecter) GetParent() *MockLabelWidget_GetParent_Call {
6594	return &MockLabelWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
6595}
6596
6597func (_c *MockLabelWidget_GetParent_Call) Run(run func()) *MockLabelWidget_GetParent_Call {
6598	_c.Call.Run(func(args mock.Arguments) {
6599		run()
6600	})
6601	return _c
6602}
6603
6604func (_c *MockLabelWidget_GetParent_Call) Return(widget layout.Widget) *MockLabelWidget_GetParent_Call {
6605	_c.Call.Return(widget)
6606	return _c
6607}
6608
6609func (_c *MockLabelWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockLabelWidget_GetParent_Call {
6610	_c.Call.Return(run)
6611	return _c
6612}
6613
6614// GetText provides a mock function for the type MockLabelWidget
6615func (_mock *MockLabelWidget) GetText() string {
6616	ret := _mock.Called()
6617
6618	if len(ret) == 0 {
6619		panic("no return value specified for GetText")
6620	}
6621
6622	var r0 string
6623	if returnFunc, ok := ret.Get(0).(func() string); ok {
6624		r0 = returnFunc()
6625	} else {
6626		r0 = ret.Get(0).(string)
6627	}
6628	return r0
6629}
6630
6631// MockLabelWidget_GetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetText'
6632type MockLabelWidget_GetText_Call struct {
6633	*mock.Call
6634}
6635
6636// GetText is a helper method to define mock.On call
6637func (_e *MockLabelWidget_Expecter) GetText() *MockLabelWidget_GetText_Call {
6638	return &MockLabelWidget_GetText_Call{Call: _e.mock.On("GetText")}
6639}
6640
6641func (_c *MockLabelWidget_GetText_Call) Run(run func()) *MockLabelWidget_GetText_Call {
6642	_c.Call.Run(func(args mock.Arguments) {
6643		run()
6644	})
6645	return _c
6646}
6647
6648func (_c *MockLabelWidget_GetText_Call) Return(s string) *MockLabelWidget_GetText_Call {
6649	_c.Call.Return(s)
6650	return _c
6651}
6652
6653func (_c *MockLabelWidget_GetText_Call) RunAndReturn(run func() string) *MockLabelWidget_GetText_Call {
6654	_c.Call.Return(run)
6655	return _c
6656}
6657
6658// GetVexpand provides a mock function for the type MockLabelWidget
6659func (_mock *MockLabelWidget) GetVexpand() bool {
6660	ret := _mock.Called()
6661
6662	if len(ret) == 0 {
6663		panic("no return value specified for GetVexpand")
6664	}
6665
6666	var r0 bool
6667	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6668		r0 = returnFunc()
6669	} else {
6670		r0 = ret.Get(0).(bool)
6671	}
6672	return r0
6673}
6674
6675// MockLabelWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
6676type MockLabelWidget_GetVexpand_Call struct {
6677	*mock.Call
6678}
6679
6680// GetVexpand is a helper method to define mock.On call
6681func (_e *MockLabelWidget_Expecter) GetVexpand() *MockLabelWidget_GetVexpand_Call {
6682	return &MockLabelWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
6683}
6684
6685func (_c *MockLabelWidget_GetVexpand_Call) Run(run func()) *MockLabelWidget_GetVexpand_Call {
6686	_c.Call.Run(func(args mock.Arguments) {
6687		run()
6688	})
6689	return _c
6690}
6691
6692func (_c *MockLabelWidget_GetVexpand_Call) Return(b bool) *MockLabelWidget_GetVexpand_Call {
6693	_c.Call.Return(b)
6694	return _c
6695}
6696
6697func (_c *MockLabelWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockLabelWidget_GetVexpand_Call {
6698	_c.Call.Return(run)
6699	return _c
6700}
6701
6702// GrabFocus provides a mock function for the type MockLabelWidget
6703func (_mock *MockLabelWidget) GrabFocus() bool {
6704	ret := _mock.Called()
6705
6706	if len(ret) == 0 {
6707		panic("no return value specified for GrabFocus")
6708	}
6709
6710	var r0 bool
6711	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6712		r0 = returnFunc()
6713	} else {
6714		r0 = ret.Get(0).(bool)
6715	}
6716	return r0
6717}
6718
6719// MockLabelWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
6720type MockLabelWidget_GrabFocus_Call struct {
6721	*mock.Call
6722}
6723
6724// GrabFocus is a helper method to define mock.On call
6725func (_e *MockLabelWidget_Expecter) GrabFocus() *MockLabelWidget_GrabFocus_Call {
6726	return &MockLabelWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
6727}
6728
6729func (_c *MockLabelWidget_GrabFocus_Call) Run(run func()) *MockLabelWidget_GrabFocus_Call {
6730	_c.Call.Run(func(args mock.Arguments) {
6731		run()
6732	})
6733	return _c
6734}
6735
6736func (_c *MockLabelWidget_GrabFocus_Call) Return(b bool) *MockLabelWidget_GrabFocus_Call {
6737	_c.Call.Return(b)
6738	return _c
6739}
6740
6741func (_c *MockLabelWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockLabelWidget_GrabFocus_Call {
6742	_c.Call.Return(run)
6743	return _c
6744}
6745
6746// GtkWidget provides a mock function for the type MockLabelWidget
6747func (_mock *MockLabelWidget) GtkWidget() *gtk.Widget {
6748	ret := _mock.Called()
6749
6750	if len(ret) == 0 {
6751		panic("no return value specified for GtkWidget")
6752	}
6753
6754	var r0 *gtk.Widget
6755	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
6756		r0 = returnFunc()
6757	} else {
6758		if ret.Get(0) != nil {
6759			r0 = ret.Get(0).(*gtk.Widget)
6760		}
6761	}
6762	return r0
6763}
6764
6765// MockLabelWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
6766type MockLabelWidget_GtkWidget_Call struct {
6767	*mock.Call
6768}
6769
6770// GtkWidget is a helper method to define mock.On call
6771func (_e *MockLabelWidget_Expecter) GtkWidget() *MockLabelWidget_GtkWidget_Call {
6772	return &MockLabelWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
6773}
6774
6775func (_c *MockLabelWidget_GtkWidget_Call) Run(run func()) *MockLabelWidget_GtkWidget_Call {
6776	_c.Call.Run(func(args mock.Arguments) {
6777		run()
6778	})
6779	return _c
6780}
6781
6782func (_c *MockLabelWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockLabelWidget_GtkWidget_Call {
6783	_c.Call.Return(widget)
6784	return _c
6785}
6786
6787func (_c *MockLabelWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockLabelWidget_GtkWidget_Call {
6788	_c.Call.Return(run)
6789	return _c
6790}
6791
6792// HasCssClass provides a mock function for the type MockLabelWidget
6793func (_mock *MockLabelWidget) HasCssClass(cssClass string) bool {
6794	ret := _mock.Called(cssClass)
6795
6796	if len(ret) == 0 {
6797		panic("no return value specified for HasCssClass")
6798	}
6799
6800	var r0 bool
6801	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
6802		r0 = returnFunc(cssClass)
6803	} else {
6804		r0 = ret.Get(0).(bool)
6805	}
6806	return r0
6807}
6808
6809// MockLabelWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
6810type MockLabelWidget_HasCssClass_Call struct {
6811	*mock.Call
6812}
6813
6814// HasCssClass is a helper method to define mock.On call
6815//   - cssClass string
6816func (_e *MockLabelWidget_Expecter) HasCssClass(cssClass interface{}) *MockLabelWidget_HasCssClass_Call {
6817	return &MockLabelWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
6818}
6819
6820func (_c *MockLabelWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_HasCssClass_Call {
6821	_c.Call.Run(func(args mock.Arguments) {
6822		var arg0 string
6823		if args[0] != nil {
6824			arg0 = args[0].(string)
6825		}
6826		run(
6827			arg0,
6828		)
6829	})
6830	return _c
6831}
6832
6833func (_c *MockLabelWidget_HasCssClass_Call) Return(b bool) *MockLabelWidget_HasCssClass_Call {
6834	_c.Call.Return(b)
6835	return _c
6836}
6837
6838func (_c *MockLabelWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockLabelWidget_HasCssClass_Call {
6839	_c.Call.Return(run)
6840	return _c
6841}
6842
6843// HasFocus provides a mock function for the type MockLabelWidget
6844func (_mock *MockLabelWidget) HasFocus() bool {
6845	ret := _mock.Called()
6846
6847	if len(ret) == 0 {
6848		panic("no return value specified for HasFocus")
6849	}
6850
6851	var r0 bool
6852	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6853		r0 = returnFunc()
6854	} else {
6855		r0 = ret.Get(0).(bool)
6856	}
6857	return r0
6858}
6859
6860// MockLabelWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
6861type MockLabelWidget_HasFocus_Call struct {
6862	*mock.Call
6863}
6864
6865// HasFocus is a helper method to define mock.On call
6866func (_e *MockLabelWidget_Expecter) HasFocus() *MockLabelWidget_HasFocus_Call {
6867	return &MockLabelWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
6868}
6869
6870func (_c *MockLabelWidget_HasFocus_Call) Run(run func()) *MockLabelWidget_HasFocus_Call {
6871	_c.Call.Run(func(args mock.Arguments) {
6872		run()
6873	})
6874	return _c
6875}
6876
6877func (_c *MockLabelWidget_HasFocus_Call) Return(b bool) *MockLabelWidget_HasFocus_Call {
6878	_c.Call.Return(b)
6879	return _c
6880}
6881
6882func (_c *MockLabelWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockLabelWidget_HasFocus_Call {
6883	_c.Call.Return(run)
6884	return _c
6885}
6886
6887// Hide provides a mock function for the type MockLabelWidget
6888func (_mock *MockLabelWidget) Hide() {
6889	_mock.Called()
6890	return
6891}
6892
6893// MockLabelWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
6894type MockLabelWidget_Hide_Call struct {
6895	*mock.Call
6896}
6897
6898// Hide is a helper method to define mock.On call
6899func (_e *MockLabelWidget_Expecter) Hide() *MockLabelWidget_Hide_Call {
6900	return &MockLabelWidget_Hide_Call{Call: _e.mock.On("Hide")}
6901}
6902
6903func (_c *MockLabelWidget_Hide_Call) Run(run func()) *MockLabelWidget_Hide_Call {
6904	_c.Call.Run(func(args mock.Arguments) {
6905		run()
6906	})
6907	return _c
6908}
6909
6910func (_c *MockLabelWidget_Hide_Call) Return() *MockLabelWidget_Hide_Call {
6911	_c.Call.Return()
6912	return _c
6913}
6914
6915func (_c *MockLabelWidget_Hide_Call) RunAndReturn(run func()) *MockLabelWidget_Hide_Call {
6916	_c.Run(run)
6917	return _c
6918}
6919
6920// IsVisible provides a mock function for the type MockLabelWidget
6921func (_mock *MockLabelWidget) IsVisible() bool {
6922	ret := _mock.Called()
6923
6924	if len(ret) == 0 {
6925		panic("no return value specified for IsVisible")
6926	}
6927
6928	var r0 bool
6929	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6930		r0 = returnFunc()
6931	} else {
6932		r0 = ret.Get(0).(bool)
6933	}
6934	return r0
6935}
6936
6937// MockLabelWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
6938type MockLabelWidget_IsVisible_Call struct {
6939	*mock.Call
6940}
6941
6942// IsVisible is a helper method to define mock.On call
6943func (_e *MockLabelWidget_Expecter) IsVisible() *MockLabelWidget_IsVisible_Call {
6944	return &MockLabelWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
6945}
6946
6947func (_c *MockLabelWidget_IsVisible_Call) Run(run func()) *MockLabelWidget_IsVisible_Call {
6948	_c.Call.Run(func(args mock.Arguments) {
6949		run()
6950	})
6951	return _c
6952}
6953
6954func (_c *MockLabelWidget_IsVisible_Call) Return(b bool) *MockLabelWidget_IsVisible_Call {
6955	_c.Call.Return(b)
6956	return _c
6957}
6958
6959func (_c *MockLabelWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockLabelWidget_IsVisible_Call {
6960	_c.Call.Return(run)
6961	return _c
6962}
6963
6964// RemoveCssClass provides a mock function for the type MockLabelWidget
6965func (_mock *MockLabelWidget) RemoveCssClass(cssClass string) {
6966	_mock.Called(cssClass)
6967	return
6968}
6969
6970// MockLabelWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
6971type MockLabelWidget_RemoveCssClass_Call struct {
6972	*mock.Call
6973}
6974
6975// RemoveCssClass is a helper method to define mock.On call
6976//   - cssClass string
6977func (_e *MockLabelWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockLabelWidget_RemoveCssClass_Call {
6978	return &MockLabelWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
6979}
6980
6981func (_c *MockLabelWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_RemoveCssClass_Call {
6982	_c.Call.Run(func(args mock.Arguments) {
6983		var arg0 string
6984		if args[0] != nil {
6985			arg0 = args[0].(string)
6986		}
6987		run(
6988			arg0,
6989		)
6990	})
6991	return _c
6992}
6993
6994func (_c *MockLabelWidget_RemoveCssClass_Call) Return() *MockLabelWidget_RemoveCssClass_Call {
6995	_c.Call.Return()
6996	return _c
6997}
6998
6999func (_c *MockLabelWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockLabelWidget_RemoveCssClass_Call {
7000	_c.Run(run)
7001	return _c
7002}
7003
7004// SetCanFocus provides a mock function for the type MockLabelWidget
7005func (_mock *MockLabelWidget) SetCanFocus(canFocus bool) {
7006	_mock.Called(canFocus)
7007	return
7008}
7009
7010// MockLabelWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
7011type MockLabelWidget_SetCanFocus_Call struct {
7012	*mock.Call
7013}
7014
7015// SetCanFocus is a helper method to define mock.On call
7016//   - canFocus bool
7017func (_e *MockLabelWidget_Expecter) SetCanFocus(canFocus interface{}) *MockLabelWidget_SetCanFocus_Call {
7018	return &MockLabelWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
7019}
7020
7021func (_c *MockLabelWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockLabelWidget_SetCanFocus_Call {
7022	_c.Call.Run(func(args mock.Arguments) {
7023		var arg0 bool
7024		if args[0] != nil {
7025			arg0 = args[0].(bool)
7026		}
7027		run(
7028			arg0,
7029		)
7030	})
7031	return _c
7032}
7033
7034func (_c *MockLabelWidget_SetCanFocus_Call) Return() *MockLabelWidget_SetCanFocus_Call {
7035	_c.Call.Return()
7036	return _c
7037}
7038
7039func (_c *MockLabelWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockLabelWidget_SetCanFocus_Call {
7040	_c.Run(run)
7041	return _c
7042}
7043
7044// SetCanTarget provides a mock function for the type MockLabelWidget
7045func (_mock *MockLabelWidget) SetCanTarget(canTarget bool) {
7046	_mock.Called(canTarget)
7047	return
7048}
7049
7050// MockLabelWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
7051type MockLabelWidget_SetCanTarget_Call struct {
7052	*mock.Call
7053}
7054
7055// SetCanTarget is a helper method to define mock.On call
7056//   - canTarget bool
7057func (_e *MockLabelWidget_Expecter) SetCanTarget(canTarget interface{}) *MockLabelWidget_SetCanTarget_Call {
7058	return &MockLabelWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
7059}
7060
7061func (_c *MockLabelWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockLabelWidget_SetCanTarget_Call {
7062	_c.Call.Run(func(args mock.Arguments) {
7063		var arg0 bool
7064		if args[0] != nil {
7065			arg0 = args[0].(bool)
7066		}
7067		run(
7068			arg0,
7069		)
7070	})
7071	return _c
7072}
7073
7074func (_c *MockLabelWidget_SetCanTarget_Call) Return() *MockLabelWidget_SetCanTarget_Call {
7075	_c.Call.Return()
7076	return _c
7077}
7078
7079func (_c *MockLabelWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockLabelWidget_SetCanTarget_Call {
7080	_c.Run(run)
7081	return _c
7082}
7083
7084// SetEllipsize provides a mock function for the type MockLabelWidget
7085func (_mock *MockLabelWidget) SetEllipsize(mode layout.EllipsizeMode) {
7086	_mock.Called(mode)
7087	return
7088}
7089
7090// MockLabelWidget_SetEllipsize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEllipsize'
7091type MockLabelWidget_SetEllipsize_Call struct {
7092	*mock.Call
7093}
7094
7095// SetEllipsize is a helper method to define mock.On call
7096//   - mode layout.EllipsizeMode
7097func (_e *MockLabelWidget_Expecter) SetEllipsize(mode interface{}) *MockLabelWidget_SetEllipsize_Call {
7098	return &MockLabelWidget_SetEllipsize_Call{Call: _e.mock.On("SetEllipsize", mode)}
7099}
7100
7101func (_c *MockLabelWidget_SetEllipsize_Call) Run(run func(mode layout.EllipsizeMode)) *MockLabelWidget_SetEllipsize_Call {
7102	_c.Call.Run(func(args mock.Arguments) {
7103		var arg0 layout.EllipsizeMode
7104		if args[0] != nil {
7105			arg0 = args[0].(layout.EllipsizeMode)
7106		}
7107		run(
7108			arg0,
7109		)
7110	})
7111	return _c
7112}
7113
7114func (_c *MockLabelWidget_SetEllipsize_Call) Return() *MockLabelWidget_SetEllipsize_Call {
7115	_c.Call.Return()
7116	return _c
7117}
7118
7119func (_c *MockLabelWidget_SetEllipsize_Call) RunAndReturn(run func(mode layout.EllipsizeMode)) *MockLabelWidget_SetEllipsize_Call {
7120	_c.Run(run)
7121	return _c
7122}
7123
7124// SetFocusOnClick provides a mock function for the type MockLabelWidget
7125func (_mock *MockLabelWidget) SetFocusOnClick(focusOnClick bool) {
7126	_mock.Called(focusOnClick)
7127	return
7128}
7129
7130// MockLabelWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
7131type MockLabelWidget_SetFocusOnClick_Call struct {
7132	*mock.Call
7133}
7134
7135// SetFocusOnClick is a helper method to define mock.On call
7136//   - focusOnClick bool
7137func (_e *MockLabelWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockLabelWidget_SetFocusOnClick_Call {
7138	return &MockLabelWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
7139}
7140
7141func (_c *MockLabelWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockLabelWidget_SetFocusOnClick_Call {
7142	_c.Call.Run(func(args mock.Arguments) {
7143		var arg0 bool
7144		if args[0] != nil {
7145			arg0 = args[0].(bool)
7146		}
7147		run(
7148			arg0,
7149		)
7150	})
7151	return _c
7152}
7153
7154func (_c *MockLabelWidget_SetFocusOnClick_Call) Return() *MockLabelWidget_SetFocusOnClick_Call {
7155	_c.Call.Return()
7156	return _c
7157}
7158
7159func (_c *MockLabelWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockLabelWidget_SetFocusOnClick_Call {
7160	_c.Run(run)
7161	return _c
7162}
7163
7164// SetHalign provides a mock function for the type MockLabelWidget
7165func (_mock *MockLabelWidget) SetHalign(align gtk.Align) {
7166	_mock.Called(align)
7167	return
7168}
7169
7170// MockLabelWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
7171type MockLabelWidget_SetHalign_Call struct {
7172	*mock.Call
7173}
7174
7175// SetHalign is a helper method to define mock.On call
7176//   - align gtk.Align
7177func (_e *MockLabelWidget_Expecter) SetHalign(align interface{}) *MockLabelWidget_SetHalign_Call {
7178	return &MockLabelWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
7179}
7180
7181func (_c *MockLabelWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockLabelWidget_SetHalign_Call {
7182	_c.Call.Run(func(args mock.Arguments) {
7183		var arg0 gtk.Align
7184		if args[0] != nil {
7185			arg0 = args[0].(gtk.Align)
7186		}
7187		run(
7188			arg0,
7189		)
7190	})
7191	return _c
7192}
7193
7194func (_c *MockLabelWidget_SetHalign_Call) Return() *MockLabelWidget_SetHalign_Call {
7195	_c.Call.Return()
7196	return _c
7197}
7198
7199func (_c *MockLabelWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockLabelWidget_SetHalign_Call {
7200	_c.Run(run)
7201	return _c
7202}
7203
7204// SetHexpand provides a mock function for the type MockLabelWidget
7205func (_mock *MockLabelWidget) SetHexpand(expand bool) {
7206	_mock.Called(expand)
7207	return
7208}
7209
7210// MockLabelWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
7211type MockLabelWidget_SetHexpand_Call struct {
7212	*mock.Call
7213}
7214
7215// SetHexpand is a helper method to define mock.On call
7216//   - expand bool
7217func (_e *MockLabelWidget_Expecter) SetHexpand(expand interface{}) *MockLabelWidget_SetHexpand_Call {
7218	return &MockLabelWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
7219}
7220
7221func (_c *MockLabelWidget_SetHexpand_Call) Run(run func(expand bool)) *MockLabelWidget_SetHexpand_Call {
7222	_c.Call.Run(func(args mock.Arguments) {
7223		var arg0 bool
7224		if args[0] != nil {
7225			arg0 = args[0].(bool)
7226		}
7227		run(
7228			arg0,
7229		)
7230	})
7231	return _c
7232}
7233
7234func (_c *MockLabelWidget_SetHexpand_Call) Return() *MockLabelWidget_SetHexpand_Call {
7235	_c.Call.Return()
7236	return _c
7237}
7238
7239func (_c *MockLabelWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockLabelWidget_SetHexpand_Call {
7240	_c.Run(run)
7241	return _c
7242}
7243
7244// SetMarkup provides a mock function for the type MockLabelWidget
7245func (_mock *MockLabelWidget) SetMarkup(markup string) {
7246	_mock.Called(markup)
7247	return
7248}
7249
7250// MockLabelWidget_SetMarkup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMarkup'
7251type MockLabelWidget_SetMarkup_Call struct {
7252	*mock.Call
7253}
7254
7255// SetMarkup is a helper method to define mock.On call
7256//   - markup string
7257func (_e *MockLabelWidget_Expecter) SetMarkup(markup interface{}) *MockLabelWidget_SetMarkup_Call {
7258	return &MockLabelWidget_SetMarkup_Call{Call: _e.mock.On("SetMarkup", markup)}
7259}
7260
7261func (_c *MockLabelWidget_SetMarkup_Call) Run(run func(markup string)) *MockLabelWidget_SetMarkup_Call {
7262	_c.Call.Run(func(args mock.Arguments) {
7263		var arg0 string
7264		if args[0] != nil {
7265			arg0 = args[0].(string)
7266		}
7267		run(
7268			arg0,
7269		)
7270	})
7271	return _c
7272}
7273
7274func (_c *MockLabelWidget_SetMarkup_Call) Return() *MockLabelWidget_SetMarkup_Call {
7275	_c.Call.Return()
7276	return _c
7277}
7278
7279func (_c *MockLabelWidget_SetMarkup_Call) RunAndReturn(run func(markup string)) *MockLabelWidget_SetMarkup_Call {
7280	_c.Run(run)
7281	return _c
7282}
7283
7284// SetMaxWidthChars provides a mock function for the type MockLabelWidget
7285func (_mock *MockLabelWidget) SetMaxWidthChars(nChars int) {
7286	_mock.Called(nChars)
7287	return
7288}
7289
7290// MockLabelWidget_SetMaxWidthChars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMaxWidthChars'
7291type MockLabelWidget_SetMaxWidthChars_Call struct {
7292	*mock.Call
7293}
7294
7295// SetMaxWidthChars is a helper method to define mock.On call
7296//   - nChars int
7297func (_e *MockLabelWidget_Expecter) SetMaxWidthChars(nChars interface{}) *MockLabelWidget_SetMaxWidthChars_Call {
7298	return &MockLabelWidget_SetMaxWidthChars_Call{Call: _e.mock.On("SetMaxWidthChars", nChars)}
7299}
7300
7301func (_c *MockLabelWidget_SetMaxWidthChars_Call) Run(run func(nChars int)) *MockLabelWidget_SetMaxWidthChars_Call {
7302	_c.Call.Run(func(args mock.Arguments) {
7303		var arg0 int
7304		if args[0] != nil {
7305			arg0 = args[0].(int)
7306		}
7307		run(
7308			arg0,
7309		)
7310	})
7311	return _c
7312}
7313
7314func (_c *MockLabelWidget_SetMaxWidthChars_Call) Return() *MockLabelWidget_SetMaxWidthChars_Call {
7315	_c.Call.Return()
7316	return _c
7317}
7318
7319func (_c *MockLabelWidget_SetMaxWidthChars_Call) RunAndReturn(run func(nChars int)) *MockLabelWidget_SetMaxWidthChars_Call {
7320	_c.Run(run)
7321	return _c
7322}
7323
7324// SetSizeRequest provides a mock function for the type MockLabelWidget
7325func (_mock *MockLabelWidget) SetSizeRequest(width int, height int) {
7326	_mock.Called(width, height)
7327	return
7328}
7329
7330// MockLabelWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
7331type MockLabelWidget_SetSizeRequest_Call struct {
7332	*mock.Call
7333}
7334
7335// SetSizeRequest is a helper method to define mock.On call
7336//   - width int
7337//   - height int
7338func (_e *MockLabelWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockLabelWidget_SetSizeRequest_Call {
7339	return &MockLabelWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
7340}
7341
7342func (_c *MockLabelWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockLabelWidget_SetSizeRequest_Call {
7343	_c.Call.Run(func(args mock.Arguments) {
7344		var arg0 int
7345		if args[0] != nil {
7346			arg0 = args[0].(int)
7347		}
7348		var arg1 int
7349		if args[1] != nil {
7350			arg1 = args[1].(int)
7351		}
7352		run(
7353			arg0,
7354			arg1,
7355		)
7356	})
7357	return _c
7358}
7359
7360func (_c *MockLabelWidget_SetSizeRequest_Call) Return() *MockLabelWidget_SetSizeRequest_Call {
7361	_c.Call.Return()
7362	return _c
7363}
7364
7365func (_c *MockLabelWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockLabelWidget_SetSizeRequest_Call {
7366	_c.Run(run)
7367	return _c
7368}
7369
7370// SetText provides a mock function for the type MockLabelWidget
7371func (_mock *MockLabelWidget) SetText(text string) {
7372	_mock.Called(text)
7373	return
7374}
7375
7376// MockLabelWidget_SetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetText'
7377type MockLabelWidget_SetText_Call struct {
7378	*mock.Call
7379}
7380
7381// SetText is a helper method to define mock.On call
7382//   - text string
7383func (_e *MockLabelWidget_Expecter) SetText(text interface{}) *MockLabelWidget_SetText_Call {
7384	return &MockLabelWidget_SetText_Call{Call: _e.mock.On("SetText", text)}
7385}
7386
7387func (_c *MockLabelWidget_SetText_Call) Run(run func(text string)) *MockLabelWidget_SetText_Call {
7388	_c.Call.Run(func(args mock.Arguments) {
7389		var arg0 string
7390		if args[0] != nil {
7391			arg0 = args[0].(string)
7392		}
7393		run(
7394			arg0,
7395		)
7396	})
7397	return _c
7398}
7399
7400func (_c *MockLabelWidget_SetText_Call) Return() *MockLabelWidget_SetText_Call {
7401	_c.Call.Return()
7402	return _c
7403}
7404
7405func (_c *MockLabelWidget_SetText_Call) RunAndReturn(run func(text string)) *MockLabelWidget_SetText_Call {
7406	_c.Run(run)
7407	return _c
7408}
7409
7410// SetValign provides a mock function for the type MockLabelWidget
7411func (_mock *MockLabelWidget) SetValign(align gtk.Align) {
7412	_mock.Called(align)
7413	return
7414}
7415
7416// MockLabelWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
7417type MockLabelWidget_SetValign_Call struct {
7418	*mock.Call
7419}
7420
7421// SetValign is a helper method to define mock.On call
7422//   - align gtk.Align
7423func (_e *MockLabelWidget_Expecter) SetValign(align interface{}) *MockLabelWidget_SetValign_Call {
7424	return &MockLabelWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
7425}
7426
7427func (_c *MockLabelWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockLabelWidget_SetValign_Call {
7428	_c.Call.Run(func(args mock.Arguments) {
7429		var arg0 gtk.Align
7430		if args[0] != nil {
7431			arg0 = args[0].(gtk.Align)
7432		}
7433		run(
7434			arg0,
7435		)
7436	})
7437	return _c
7438}
7439
7440func (_c *MockLabelWidget_SetValign_Call) Return() *MockLabelWidget_SetValign_Call {
7441	_c.Call.Return()
7442	return _c
7443}
7444
7445func (_c *MockLabelWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockLabelWidget_SetValign_Call {
7446	_c.Run(run)
7447	return _c
7448}
7449
7450// SetVexpand provides a mock function for the type MockLabelWidget
7451func (_mock *MockLabelWidget) SetVexpand(expand bool) {
7452	_mock.Called(expand)
7453	return
7454}
7455
7456// MockLabelWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
7457type MockLabelWidget_SetVexpand_Call struct {
7458	*mock.Call
7459}
7460
7461// SetVexpand is a helper method to define mock.On call
7462//   - expand bool
7463func (_e *MockLabelWidget_Expecter) SetVexpand(expand interface{}) *MockLabelWidget_SetVexpand_Call {
7464	return &MockLabelWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
7465}
7466
7467func (_c *MockLabelWidget_SetVexpand_Call) Run(run func(expand bool)) *MockLabelWidget_SetVexpand_Call {
7468	_c.Call.Run(func(args mock.Arguments) {
7469		var arg0 bool
7470		if args[0] != nil {
7471			arg0 = args[0].(bool)
7472		}
7473		run(
7474			arg0,
7475		)
7476	})
7477	return _c
7478}
7479
7480func (_c *MockLabelWidget_SetVexpand_Call) Return() *MockLabelWidget_SetVexpand_Call {
7481	_c.Call.Return()
7482	return _c
7483}
7484
7485func (_c *MockLabelWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockLabelWidget_SetVexpand_Call {
7486	_c.Run(run)
7487	return _c
7488}
7489
7490// SetVisible provides a mock function for the type MockLabelWidget
7491func (_mock *MockLabelWidget) SetVisible(visible bool) {
7492	_mock.Called(visible)
7493	return
7494}
7495
7496// MockLabelWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
7497type MockLabelWidget_SetVisible_Call struct {
7498	*mock.Call
7499}
7500
7501// SetVisible is a helper method to define mock.On call
7502//   - visible bool
7503func (_e *MockLabelWidget_Expecter) SetVisible(visible interface{}) *MockLabelWidget_SetVisible_Call {
7504	return &MockLabelWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
7505}
7506
7507func (_c *MockLabelWidget_SetVisible_Call) Run(run func(visible bool)) *MockLabelWidget_SetVisible_Call {
7508	_c.Call.Run(func(args mock.Arguments) {
7509		var arg0 bool
7510		if args[0] != nil {
7511			arg0 = args[0].(bool)
7512		}
7513		run(
7514			arg0,
7515		)
7516	})
7517	return _c
7518}
7519
7520func (_c *MockLabelWidget_SetVisible_Call) Return() *MockLabelWidget_SetVisible_Call {
7521	_c.Call.Return()
7522	return _c
7523}
7524
7525func (_c *MockLabelWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockLabelWidget_SetVisible_Call {
7526	_c.Run(run)
7527	return _c
7528}
7529
7530// SetXalign provides a mock function for the type MockLabelWidget
7531func (_mock *MockLabelWidget) SetXalign(xalign float32) {
7532	_mock.Called(xalign)
7533	return
7534}
7535
7536// MockLabelWidget_SetXalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXalign'
7537type MockLabelWidget_SetXalign_Call struct {
7538	*mock.Call
7539}
7540
7541// SetXalign is a helper method to define mock.On call
7542//   - xalign float32
7543func (_e *MockLabelWidget_Expecter) SetXalign(xalign interface{}) *MockLabelWidget_SetXalign_Call {
7544	return &MockLabelWidget_SetXalign_Call{Call: _e.mock.On("SetXalign", xalign)}
7545}
7546
7547func (_c *MockLabelWidget_SetXalign_Call) Run(run func(xalign float32)) *MockLabelWidget_SetXalign_Call {
7548	_c.Call.Run(func(args mock.Arguments) {
7549		var arg0 float32
7550		if args[0] != nil {
7551			arg0 = args[0].(float32)
7552		}
7553		run(
7554			arg0,
7555		)
7556	})
7557	return _c
7558}
7559
7560func (_c *MockLabelWidget_SetXalign_Call) Return() *MockLabelWidget_SetXalign_Call {
7561	_c.Call.Return()
7562	return _c
7563}
7564
7565func (_c *MockLabelWidget_SetXalign_Call) RunAndReturn(run func(xalign float32)) *MockLabelWidget_SetXalign_Call {
7566	_c.Run(run)
7567	return _c
7568}
7569
7570// Show provides a mock function for the type MockLabelWidget
7571func (_mock *MockLabelWidget) Show() {
7572	_mock.Called()
7573	return
7574}
7575
7576// MockLabelWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
7577type MockLabelWidget_Show_Call struct {
7578	*mock.Call
7579}
7580
7581// Show is a helper method to define mock.On call
7582func (_e *MockLabelWidget_Expecter) Show() *MockLabelWidget_Show_Call {
7583	return &MockLabelWidget_Show_Call{Call: _e.mock.On("Show")}
7584}
7585
7586func (_c *MockLabelWidget_Show_Call) Run(run func()) *MockLabelWidget_Show_Call {
7587	_c.Call.Run(func(args mock.Arguments) {
7588		run()
7589	})
7590	return _c
7591}
7592
7593func (_c *MockLabelWidget_Show_Call) Return() *MockLabelWidget_Show_Call {
7594	_c.Call.Return()
7595	return _c
7596}
7597
7598func (_c *MockLabelWidget_Show_Call) RunAndReturn(run func()) *MockLabelWidget_Show_Call {
7599	_c.Run(run)
7600	return _c
7601}
7602
7603// Unparent provides a mock function for the type MockLabelWidget
7604func (_mock *MockLabelWidget) Unparent() {
7605	_mock.Called()
7606	return
7607}
7608
7609// MockLabelWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
7610type MockLabelWidget_Unparent_Call struct {
7611	*mock.Call
7612}
7613
7614// Unparent is a helper method to define mock.On call
7615func (_e *MockLabelWidget_Expecter) Unparent() *MockLabelWidget_Unparent_Call {
7616	return &MockLabelWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
7617}
7618
7619func (_c *MockLabelWidget_Unparent_Call) Run(run func()) *MockLabelWidget_Unparent_Call {
7620	_c.Call.Run(func(args mock.Arguments) {
7621		run()
7622	})
7623	return _c
7624}
7625
7626func (_c *MockLabelWidget_Unparent_Call) Return() *MockLabelWidget_Unparent_Call {
7627	_c.Call.Return()
7628	return _c
7629}
7630
7631func (_c *MockLabelWidget_Unparent_Call) RunAndReturn(run func()) *MockLabelWidget_Unparent_Call {
7632	_c.Run(run)
7633	return _c
7634}
7635
7636// 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.
7637// The first argument is typically a *testing.T value.
7638func NewMockButtonWidget(t interface {
7639	mock.TestingT
7640	Cleanup(func())
7641}) *MockButtonWidget {
7642	mock := &MockButtonWidget{}
7643	mock.Mock.Test(t)
7644
7645	t.Cleanup(func() { mock.AssertExpectations(t) })
7646
7647	return mock
7648}
7649
7650// MockButtonWidget is an autogenerated mock type for the ButtonWidget type
7651type MockButtonWidget struct {
7652	mock.Mock
7653}
7654
7655type MockButtonWidget_Expecter struct {
7656	mock *mock.Mock
7657}
7658
7659func (_m *MockButtonWidget) EXPECT() *MockButtonWidget_Expecter {
7660	return &MockButtonWidget_Expecter{mock: &_m.Mock}
7661}
7662
7663// AddController provides a mock function for the type MockButtonWidget
7664func (_mock *MockButtonWidget) AddController(controller *gtk.EventController) {
7665	_mock.Called(controller)
7666	return
7667}
7668
7669// MockButtonWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
7670type MockButtonWidget_AddController_Call struct {
7671	*mock.Call
7672}
7673
7674// AddController is a helper method to define mock.On call
7675//   - controller *gtk.EventController
7676func (_e *MockButtonWidget_Expecter) AddController(controller interface{}) *MockButtonWidget_AddController_Call {
7677	return &MockButtonWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
7678}
7679
7680func (_c *MockButtonWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockButtonWidget_AddController_Call {
7681	_c.Call.Run(func(args mock.Arguments) {
7682		var arg0 *gtk.EventController
7683		if args[0] != nil {
7684			arg0 = args[0].(*gtk.EventController)
7685		}
7686		run(
7687			arg0,
7688		)
7689	})
7690	return _c
7691}
7692
7693func (_c *MockButtonWidget_AddController_Call) Return() *MockButtonWidget_AddController_Call {
7694	_c.Call.Return()
7695	return _c
7696}
7697
7698func (_c *MockButtonWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockButtonWidget_AddController_Call {
7699	_c.Run(run)
7700	return _c
7701}
7702
7703// AddCssClass provides a mock function for the type MockButtonWidget
7704func (_mock *MockButtonWidget) AddCssClass(cssClass string) {
7705	_mock.Called(cssClass)
7706	return
7707}
7708
7709// MockButtonWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
7710type MockButtonWidget_AddCssClass_Call struct {
7711	*mock.Call
7712}
7713
7714// AddCssClass is a helper method to define mock.On call
7715//   - cssClass string
7716func (_e *MockButtonWidget_Expecter) AddCssClass(cssClass interface{}) *MockButtonWidget_AddCssClass_Call {
7717	return &MockButtonWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
7718}
7719
7720func (_c *MockButtonWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_AddCssClass_Call {
7721	_c.Call.Run(func(args mock.Arguments) {
7722		var arg0 string
7723		if args[0] != nil {
7724			arg0 = args[0].(string)
7725		}
7726		run(
7727			arg0,
7728		)
7729	})
7730	return _c
7731}
7732
7733func (_c *MockButtonWidget_AddCssClass_Call) Return() *MockButtonWidget_AddCssClass_Call {
7734	_c.Call.Return()
7735	return _c
7736}
7737
7738func (_c *MockButtonWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockButtonWidget_AddCssClass_Call {
7739	_c.Run(run)
7740	return _c
7741}
7742
7743// ComputePoint provides a mock function for the type MockButtonWidget
7744func (_mock *MockButtonWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
7745	ret := _mock.Called(target)
7746
7747	if len(ret) == 0 {
7748		panic("no return value specified for ComputePoint")
7749	}
7750
7751	var r0 float64
7752	var r1 float64
7753	var r2 bool
7754	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
7755		return returnFunc(target)
7756	}
7757	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
7758		r0 = returnFunc(target)
7759	} else {
7760		r0 = ret.Get(0).(float64)
7761	}
7762	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
7763		r1 = returnFunc(target)
7764	} else {
7765		r1 = ret.Get(1).(float64)
7766	}
7767	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
7768		r2 = returnFunc(target)
7769	} else {
7770		r2 = ret.Get(2).(bool)
7771	}
7772	return r0, r1, r2
7773}
7774
7775// MockButtonWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
7776type MockButtonWidget_ComputePoint_Call struct {
7777	*mock.Call
7778}
7779
7780// ComputePoint is a helper method to define mock.On call
7781//   - target layout.Widget
7782func (_e *MockButtonWidget_Expecter) ComputePoint(target interface{}) *MockButtonWidget_ComputePoint_Call {
7783	return &MockButtonWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
7784}
7785
7786func (_c *MockButtonWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockButtonWidget_ComputePoint_Call {
7787	_c.Call.Run(func(args mock.Arguments) {
7788		var arg0 layout.Widget
7789		if args[0] != nil {
7790			arg0 = args[0].(layout.Widget)
7791		}
7792		run(
7793			arg0,
7794		)
7795	})
7796	return _c
7797}
7798
7799func (_c *MockButtonWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockButtonWidget_ComputePoint_Call {
7800	_c.Call.Return(x, y, ok)
7801	return _c
7802}
7803
7804func (_c *MockButtonWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockButtonWidget_ComputePoint_Call {
7805	_c.Call.Return(run)
7806	return _c
7807}
7808
7809// ConnectClicked provides a mock function for the type MockButtonWidget
7810func (_mock *MockButtonWidget) ConnectClicked(callback func()) uint32 {
7811	ret := _mock.Called(callback)
7812
7813	if len(ret) == 0 {
7814		panic("no return value specified for ConnectClicked")
7815	}
7816
7817	var r0 uint32
7818	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
7819		r0 = returnFunc(callback)
7820	} else {
7821		r0 = ret.Get(0).(uint32)
7822	}
7823	return r0
7824}
7825
7826// MockButtonWidget_ConnectClicked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectClicked'
7827type MockButtonWidget_ConnectClicked_Call struct {
7828	*mock.Call
7829}
7830
7831// ConnectClicked is a helper method to define mock.On call
7832//   - callback func()
7833func (_e *MockButtonWidget_Expecter) ConnectClicked(callback interface{}) *MockButtonWidget_ConnectClicked_Call {
7834	return &MockButtonWidget_ConnectClicked_Call{Call: _e.mock.On("ConnectClicked", callback)}
7835}
7836
7837func (_c *MockButtonWidget_ConnectClicked_Call) Run(run func(callback func())) *MockButtonWidget_ConnectClicked_Call {
7838	_c.Call.Run(func(args mock.Arguments) {
7839		var arg0 func()
7840		if args[0] != nil {
7841			arg0 = args[0].(func())
7842		}
7843		run(
7844			arg0,
7845		)
7846	})
7847	return _c
7848}
7849
7850func (_c *MockButtonWidget_ConnectClicked_Call) Return(v uint32) *MockButtonWidget_ConnectClicked_Call {
7851	_c.Call.Return(v)
7852	return _c
7853}
7854
7855func (_c *MockButtonWidget_ConnectClicked_Call) RunAndReturn(run func(callback func()) uint32) *MockButtonWidget_ConnectClicked_Call {
7856	_c.Call.Return(run)
7857	return _c
7858}
7859
7860// GetAllocatedHeight provides a mock function for the type MockButtonWidget
7861func (_mock *MockButtonWidget) GetAllocatedHeight() int {
7862	ret := _mock.Called()
7863
7864	if len(ret) == 0 {
7865		panic("no return value specified for GetAllocatedHeight")
7866	}
7867
7868	var r0 int
7869	if returnFunc, ok := ret.Get(0).(func() int); ok {
7870		r0 = returnFunc()
7871	} else {
7872		r0 = ret.Get(0).(int)
7873	}
7874	return r0
7875}
7876
7877// MockButtonWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
7878type MockButtonWidget_GetAllocatedHeight_Call struct {
7879	*mock.Call
7880}
7881
7882// GetAllocatedHeight is a helper method to define mock.On call
7883func (_e *MockButtonWidget_Expecter) GetAllocatedHeight() *MockButtonWidget_GetAllocatedHeight_Call {
7884	return &MockButtonWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
7885}
7886
7887func (_c *MockButtonWidget_GetAllocatedHeight_Call) Run(run func()) *MockButtonWidget_GetAllocatedHeight_Call {
7888	_c.Call.Run(func(args mock.Arguments) {
7889		run()
7890	})
7891	return _c
7892}
7893
7894func (_c *MockButtonWidget_GetAllocatedHeight_Call) Return(n int) *MockButtonWidget_GetAllocatedHeight_Call {
7895	_c.Call.Return(n)
7896	return _c
7897}
7898
7899func (_c *MockButtonWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockButtonWidget_GetAllocatedHeight_Call {
7900	_c.Call.Return(run)
7901	return _c
7902}
7903
7904// GetAllocatedWidth provides a mock function for the type MockButtonWidget
7905func (_mock *MockButtonWidget) GetAllocatedWidth() int {
7906	ret := _mock.Called()
7907
7908	if len(ret) == 0 {
7909		panic("no return value specified for GetAllocatedWidth")
7910	}
7911
7912	var r0 int
7913	if returnFunc, ok := ret.Get(0).(func() int); ok {
7914		r0 = returnFunc()
7915	} else {
7916		r0 = ret.Get(0).(int)
7917	}
7918	return r0
7919}
7920
7921// MockButtonWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
7922type MockButtonWidget_GetAllocatedWidth_Call struct {
7923	*mock.Call
7924}
7925
7926// GetAllocatedWidth is a helper method to define mock.On call
7927func (_e *MockButtonWidget_Expecter) GetAllocatedWidth() *MockButtonWidget_GetAllocatedWidth_Call {
7928	return &MockButtonWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
7929}
7930
7931func (_c *MockButtonWidget_GetAllocatedWidth_Call) Run(run func()) *MockButtonWidget_GetAllocatedWidth_Call {
7932	_c.Call.Run(func(args mock.Arguments) {
7933		run()
7934	})
7935	return _c
7936}
7937
7938func (_c *MockButtonWidget_GetAllocatedWidth_Call) Return(n int) *MockButtonWidget_GetAllocatedWidth_Call {
7939	_c.Call.Return(n)
7940	return _c
7941}
7942
7943func (_c *MockButtonWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockButtonWidget_GetAllocatedWidth_Call {
7944	_c.Call.Return(run)
7945	return _c
7946}
7947
7948// GetChild provides a mock function for the type MockButtonWidget
7949func (_mock *MockButtonWidget) GetChild() layout.Widget {
7950	ret := _mock.Called()
7951
7952	if len(ret) == 0 {
7953		panic("no return value specified for GetChild")
7954	}
7955
7956	var r0 layout.Widget
7957	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
7958		r0 = returnFunc()
7959	} else {
7960		if ret.Get(0) != nil {
7961			r0 = ret.Get(0).(layout.Widget)
7962		}
7963	}
7964	return r0
7965}
7966
7967// MockButtonWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
7968type MockButtonWidget_GetChild_Call struct {
7969	*mock.Call
7970}
7971
7972// GetChild is a helper method to define mock.On call
7973func (_e *MockButtonWidget_Expecter) GetChild() *MockButtonWidget_GetChild_Call {
7974	return &MockButtonWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
7975}
7976
7977func (_c *MockButtonWidget_GetChild_Call) Run(run func()) *MockButtonWidget_GetChild_Call {
7978	_c.Call.Run(func(args mock.Arguments) {
7979		run()
7980	})
7981	return _c
7982}
7983
7984func (_c *MockButtonWidget_GetChild_Call) Return(widget layout.Widget) *MockButtonWidget_GetChild_Call {
7985	_c.Call.Return(widget)
7986	return _c
7987}
7988
7989func (_c *MockButtonWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) *MockButtonWidget_GetChild_Call {
7990	_c.Call.Return(run)
7991	return _c
7992}
7993
7994// GetHexpand provides a mock function for the type MockButtonWidget
7995func (_mock *MockButtonWidget) GetHexpand() bool {
7996	ret := _mock.Called()
7997
7998	if len(ret) == 0 {
7999		panic("no return value specified for GetHexpand")
8000	}
8001
8002	var r0 bool
8003	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8004		r0 = returnFunc()
8005	} else {
8006		r0 = ret.Get(0).(bool)
8007	}
8008	return r0
8009}
8010
8011// MockButtonWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
8012type MockButtonWidget_GetHexpand_Call struct {
8013	*mock.Call
8014}
8015
8016// GetHexpand is a helper method to define mock.On call
8017func (_e *MockButtonWidget_Expecter) GetHexpand() *MockButtonWidget_GetHexpand_Call {
8018	return &MockButtonWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
8019}
8020
8021func (_c *MockButtonWidget_GetHexpand_Call) Run(run func()) *MockButtonWidget_GetHexpand_Call {
8022	_c.Call.Run(func(args mock.Arguments) {
8023		run()
8024	})
8025	return _c
8026}
8027
8028func (_c *MockButtonWidget_GetHexpand_Call) Return(b bool) *MockButtonWidget_GetHexpand_Call {
8029	_c.Call.Return(b)
8030	return _c
8031}
8032
8033func (_c *MockButtonWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockButtonWidget_GetHexpand_Call {
8034	_c.Call.Return(run)
8035	return _c
8036}
8037
8038// GetLabel provides a mock function for the type MockButtonWidget
8039func (_mock *MockButtonWidget) GetLabel() string {
8040	ret := _mock.Called()
8041
8042	if len(ret) == 0 {
8043		panic("no return value specified for GetLabel")
8044	}
8045
8046	var r0 string
8047	if returnFunc, ok := ret.Get(0).(func() string); ok {
8048		r0 = returnFunc()
8049	} else {
8050		r0 = ret.Get(0).(string)
8051	}
8052	return r0
8053}
8054
8055// MockButtonWidget_GetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabel'
8056type MockButtonWidget_GetLabel_Call struct {
8057	*mock.Call
8058}
8059
8060// GetLabel is a helper method to define mock.On call
8061func (_e *MockButtonWidget_Expecter) GetLabel() *MockButtonWidget_GetLabel_Call {
8062	return &MockButtonWidget_GetLabel_Call{Call: _e.mock.On("GetLabel")}
8063}
8064
8065func (_c *MockButtonWidget_GetLabel_Call) Run(run func()) *MockButtonWidget_GetLabel_Call {
8066	_c.Call.Run(func(args mock.Arguments) {
8067		run()
8068	})
8069	return _c
8070}
8071
8072func (_c *MockButtonWidget_GetLabel_Call) Return(s string) *MockButtonWidget_GetLabel_Call {
8073	_c.Call.Return(s)
8074	return _c
8075}
8076
8077func (_c *MockButtonWidget_GetLabel_Call) RunAndReturn(run func() string) *MockButtonWidget_GetLabel_Call {
8078	_c.Call.Return(run)
8079	return _c
8080}
8081
8082// GetParent provides a mock function for the type MockButtonWidget
8083func (_mock *MockButtonWidget) GetParent() layout.Widget {
8084	ret := _mock.Called()
8085
8086	if len(ret) == 0 {
8087		panic("no return value specified for GetParent")
8088	}
8089
8090	var r0 layout.Widget
8091	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
8092		r0 = returnFunc()
8093	} else {
8094		if ret.Get(0) != nil {
8095			r0 = ret.Get(0).(layout.Widget)
8096		}
8097	}
8098	return r0
8099}
8100
8101// MockButtonWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
8102type MockButtonWidget_GetParent_Call struct {
8103	*mock.Call
8104}
8105
8106// GetParent is a helper method to define mock.On call
8107func (_e *MockButtonWidget_Expecter) GetParent() *MockButtonWidget_GetParent_Call {
8108	return &MockButtonWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
8109}
8110
8111func (_c *MockButtonWidget_GetParent_Call) Run(run func()) *MockButtonWidget_GetParent_Call {
8112	_c.Call.Run(func(args mock.Arguments) {
8113		run()
8114	})
8115	return _c
8116}
8117
8118func (_c *MockButtonWidget_GetParent_Call) Return(widget layout.Widget) *MockButtonWidget_GetParent_Call {
8119	_c.Call.Return(widget)
8120	return _c
8121}
8122
8123func (_c *MockButtonWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockButtonWidget_GetParent_Call {
8124	_c.Call.Return(run)
8125	return _c
8126}
8127
8128// GetVexpand provides a mock function for the type MockButtonWidget
8129func (_mock *MockButtonWidget) GetVexpand() bool {
8130	ret := _mock.Called()
8131
8132	if len(ret) == 0 {
8133		panic("no return value specified for GetVexpand")
8134	}
8135
8136	var r0 bool
8137	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8138		r0 = returnFunc()
8139	} else {
8140		r0 = ret.Get(0).(bool)
8141	}
8142	return r0
8143}
8144
8145// MockButtonWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
8146type MockButtonWidget_GetVexpand_Call struct {
8147	*mock.Call
8148}
8149
8150// GetVexpand is a helper method to define mock.On call
8151func (_e *MockButtonWidget_Expecter) GetVexpand() *MockButtonWidget_GetVexpand_Call {
8152	return &MockButtonWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
8153}
8154
8155func (_c *MockButtonWidget_GetVexpand_Call) Run(run func()) *MockButtonWidget_GetVexpand_Call {
8156	_c.Call.Run(func(args mock.Arguments) {
8157		run()
8158	})
8159	return _c
8160}
8161
8162func (_c *MockButtonWidget_GetVexpand_Call) Return(b bool) *MockButtonWidget_GetVexpand_Call {
8163	_c.Call.Return(b)
8164	return _c
8165}
8166
8167func (_c *MockButtonWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockButtonWidget_GetVexpand_Call {
8168	_c.Call.Return(run)
8169	return _c
8170}
8171
8172// GrabFocus provides a mock function for the type MockButtonWidget
8173func (_mock *MockButtonWidget) GrabFocus() bool {
8174	ret := _mock.Called()
8175
8176	if len(ret) == 0 {
8177		panic("no return value specified for GrabFocus")
8178	}
8179
8180	var r0 bool
8181	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8182		r0 = returnFunc()
8183	} else {
8184		r0 = ret.Get(0).(bool)
8185	}
8186	return r0
8187}
8188
8189// MockButtonWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
8190type MockButtonWidget_GrabFocus_Call struct {
8191	*mock.Call
8192}
8193
8194// GrabFocus is a helper method to define mock.On call
8195func (_e *MockButtonWidget_Expecter) GrabFocus() *MockButtonWidget_GrabFocus_Call {
8196	return &MockButtonWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
8197}
8198
8199func (_c *MockButtonWidget_GrabFocus_Call) Run(run func()) *MockButtonWidget_GrabFocus_Call {
8200	_c.Call.Run(func(args mock.Arguments) {
8201		run()
8202	})
8203	return _c
8204}
8205
8206func (_c *MockButtonWidget_GrabFocus_Call) Return(b bool) *MockButtonWidget_GrabFocus_Call {
8207	_c.Call.Return(b)
8208	return _c
8209}
8210
8211func (_c *MockButtonWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockButtonWidget_GrabFocus_Call {
8212	_c.Call.Return(run)
8213	return _c
8214}
8215
8216// GtkWidget provides a mock function for the type MockButtonWidget
8217func (_mock *MockButtonWidget) GtkWidget() *gtk.Widget {
8218	ret := _mock.Called()
8219
8220	if len(ret) == 0 {
8221		panic("no return value specified for GtkWidget")
8222	}
8223
8224	var r0 *gtk.Widget
8225	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
8226		r0 = returnFunc()
8227	} else {
8228		if ret.Get(0) != nil {
8229			r0 = ret.Get(0).(*gtk.Widget)
8230		}
8231	}
8232	return r0
8233}
8234
8235// MockButtonWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
8236type MockButtonWidget_GtkWidget_Call struct {
8237	*mock.Call
8238}
8239
8240// GtkWidget is a helper method to define mock.On call
8241func (_e *MockButtonWidget_Expecter) GtkWidget() *MockButtonWidget_GtkWidget_Call {
8242	return &MockButtonWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
8243}
8244
8245func (_c *MockButtonWidget_GtkWidget_Call) Run(run func()) *MockButtonWidget_GtkWidget_Call {
8246	_c.Call.Run(func(args mock.Arguments) {
8247		run()
8248	})
8249	return _c
8250}
8251
8252func (_c *MockButtonWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockButtonWidget_GtkWidget_Call {
8253	_c.Call.Return(widget)
8254	return _c
8255}
8256
8257func (_c *MockButtonWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockButtonWidget_GtkWidget_Call {
8258	_c.Call.Return(run)
8259	return _c
8260}
8261
8262// HasCssClass provides a mock function for the type MockButtonWidget
8263func (_mock *MockButtonWidget) HasCssClass(cssClass string) bool {
8264	ret := _mock.Called(cssClass)
8265
8266	if len(ret) == 0 {
8267		panic("no return value specified for HasCssClass")
8268	}
8269
8270	var r0 bool
8271	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
8272		r0 = returnFunc(cssClass)
8273	} else {
8274		r0 = ret.Get(0).(bool)
8275	}
8276	return r0
8277}
8278
8279// MockButtonWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
8280type MockButtonWidget_HasCssClass_Call struct {
8281	*mock.Call
8282}
8283
8284// HasCssClass is a helper method to define mock.On call
8285//   - cssClass string
8286func (_e *MockButtonWidget_Expecter) HasCssClass(cssClass interface{}) *MockButtonWidget_HasCssClass_Call {
8287	return &MockButtonWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
8288}
8289
8290func (_c *MockButtonWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_HasCssClass_Call {
8291	_c.Call.Run(func(args mock.Arguments) {
8292		var arg0 string
8293		if args[0] != nil {
8294			arg0 = args[0].(string)
8295		}
8296		run(
8297			arg0,
8298		)
8299	})
8300	return _c
8301}
8302
8303func (_c *MockButtonWidget_HasCssClass_Call) Return(b bool) *MockButtonWidget_HasCssClass_Call {
8304	_c.Call.Return(b)
8305	return _c
8306}
8307
8308func (_c *MockButtonWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockButtonWidget_HasCssClass_Call {
8309	_c.Call.Return(run)
8310	return _c
8311}
8312
8313// HasFocus provides a mock function for the type MockButtonWidget
8314func (_mock *MockButtonWidget) HasFocus() bool {
8315	ret := _mock.Called()
8316
8317	if len(ret) == 0 {
8318		panic("no return value specified for HasFocus")
8319	}
8320
8321	var r0 bool
8322	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8323		r0 = returnFunc()
8324	} else {
8325		r0 = ret.Get(0).(bool)
8326	}
8327	return r0
8328}
8329
8330// MockButtonWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
8331type MockButtonWidget_HasFocus_Call struct {
8332	*mock.Call
8333}
8334
8335// HasFocus is a helper method to define mock.On call
8336func (_e *MockButtonWidget_Expecter) HasFocus() *MockButtonWidget_HasFocus_Call {
8337	return &MockButtonWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
8338}
8339
8340func (_c *MockButtonWidget_HasFocus_Call) Run(run func()) *MockButtonWidget_HasFocus_Call {
8341	_c.Call.Run(func(args mock.Arguments) {
8342		run()
8343	})
8344	return _c
8345}
8346
8347func (_c *MockButtonWidget_HasFocus_Call) Return(b bool) *MockButtonWidget_HasFocus_Call {
8348	_c.Call.Return(b)
8349	return _c
8350}
8351
8352func (_c *MockButtonWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockButtonWidget_HasFocus_Call {
8353	_c.Call.Return(run)
8354	return _c
8355}
8356
8357// Hide provides a mock function for the type MockButtonWidget
8358func (_mock *MockButtonWidget) Hide() {
8359	_mock.Called()
8360	return
8361}
8362
8363// MockButtonWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
8364type MockButtonWidget_Hide_Call struct {
8365	*mock.Call
8366}
8367
8368// Hide is a helper method to define mock.On call
8369func (_e *MockButtonWidget_Expecter) Hide() *MockButtonWidget_Hide_Call {
8370	return &MockButtonWidget_Hide_Call{Call: _e.mock.On("Hide")}
8371}
8372
8373func (_c *MockButtonWidget_Hide_Call) Run(run func()) *MockButtonWidget_Hide_Call {
8374	_c.Call.Run(func(args mock.Arguments) {
8375		run()
8376	})
8377	return _c
8378}
8379
8380func (_c *MockButtonWidget_Hide_Call) Return() *MockButtonWidget_Hide_Call {
8381	_c.Call.Return()
8382	return _c
8383}
8384
8385func (_c *MockButtonWidget_Hide_Call) RunAndReturn(run func()) *MockButtonWidget_Hide_Call {
8386	_c.Run(run)
8387	return _c
8388}
8389
8390// IsVisible provides a mock function for the type MockButtonWidget
8391func (_mock *MockButtonWidget) IsVisible() bool {
8392	ret := _mock.Called()
8393
8394	if len(ret) == 0 {
8395		panic("no return value specified for IsVisible")
8396	}
8397
8398	var r0 bool
8399	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8400		r0 = returnFunc()
8401	} else {
8402		r0 = ret.Get(0).(bool)
8403	}
8404	return r0
8405}
8406
8407// MockButtonWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
8408type MockButtonWidget_IsVisible_Call struct {
8409	*mock.Call
8410}
8411
8412// IsVisible is a helper method to define mock.On call
8413func (_e *MockButtonWidget_Expecter) IsVisible() *MockButtonWidget_IsVisible_Call {
8414	return &MockButtonWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
8415}
8416
8417func (_c *MockButtonWidget_IsVisible_Call) Run(run func()) *MockButtonWidget_IsVisible_Call {
8418	_c.Call.Run(func(args mock.Arguments) {
8419		run()
8420	})
8421	return _c
8422}
8423
8424func (_c *MockButtonWidget_IsVisible_Call) Return(b bool) *MockButtonWidget_IsVisible_Call {
8425	_c.Call.Return(b)
8426	return _c
8427}
8428
8429func (_c *MockButtonWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockButtonWidget_IsVisible_Call {
8430	_c.Call.Return(run)
8431	return _c
8432}
8433
8434// RemoveCssClass provides a mock function for the type MockButtonWidget
8435func (_mock *MockButtonWidget) RemoveCssClass(cssClass string) {
8436	_mock.Called(cssClass)
8437	return
8438}
8439
8440// MockButtonWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
8441type MockButtonWidget_RemoveCssClass_Call struct {
8442	*mock.Call
8443}
8444
8445// RemoveCssClass is a helper method to define mock.On call
8446//   - cssClass string
8447func (_e *MockButtonWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockButtonWidget_RemoveCssClass_Call {
8448	return &MockButtonWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
8449}
8450
8451func (_c *MockButtonWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_RemoveCssClass_Call {
8452	_c.Call.Run(func(args mock.Arguments) {
8453		var arg0 string
8454		if args[0] != nil {
8455			arg0 = args[0].(string)
8456		}
8457		run(
8458			arg0,
8459		)
8460	})
8461	return _c
8462}
8463
8464func (_c *MockButtonWidget_RemoveCssClass_Call) Return() *MockButtonWidget_RemoveCssClass_Call {
8465	_c.Call.Return()
8466	return _c
8467}
8468
8469func (_c *MockButtonWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockButtonWidget_RemoveCssClass_Call {
8470	_c.Run(run)
8471	return _c
8472}
8473
8474// SetCanFocus provides a mock function for the type MockButtonWidget
8475func (_mock *MockButtonWidget) SetCanFocus(canFocus bool) {
8476	_mock.Called(canFocus)
8477	return
8478}
8479
8480// MockButtonWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
8481type MockButtonWidget_SetCanFocus_Call struct {
8482	*mock.Call
8483}
8484
8485// SetCanFocus is a helper method to define mock.On call
8486//   - canFocus bool
8487func (_e *MockButtonWidget_Expecter) SetCanFocus(canFocus interface{}) *MockButtonWidget_SetCanFocus_Call {
8488	return &MockButtonWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
8489}
8490
8491func (_c *MockButtonWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockButtonWidget_SetCanFocus_Call {
8492	_c.Call.Run(func(args mock.Arguments) {
8493		var arg0 bool
8494		if args[0] != nil {
8495			arg0 = args[0].(bool)
8496		}
8497		run(
8498			arg0,
8499		)
8500	})
8501	return _c
8502}
8503
8504func (_c *MockButtonWidget_SetCanFocus_Call) Return() *MockButtonWidget_SetCanFocus_Call {
8505	_c.Call.Return()
8506	return _c
8507}
8508
8509func (_c *MockButtonWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockButtonWidget_SetCanFocus_Call {
8510	_c.Run(run)
8511	return _c
8512}
8513
8514// SetCanTarget provides a mock function for the type MockButtonWidget
8515func (_mock *MockButtonWidget) SetCanTarget(canTarget bool) {
8516	_mock.Called(canTarget)
8517	return
8518}
8519
8520// MockButtonWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
8521type MockButtonWidget_SetCanTarget_Call struct {
8522	*mock.Call
8523}
8524
8525// SetCanTarget is a helper method to define mock.On call
8526//   - canTarget bool
8527func (_e *MockButtonWidget_Expecter) SetCanTarget(canTarget interface{}) *MockButtonWidget_SetCanTarget_Call {
8528	return &MockButtonWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
8529}
8530
8531func (_c *MockButtonWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockButtonWidget_SetCanTarget_Call {
8532	_c.Call.Run(func(args mock.Arguments) {
8533		var arg0 bool
8534		if args[0] != nil {
8535			arg0 = args[0].(bool)
8536		}
8537		run(
8538			arg0,
8539		)
8540	})
8541	return _c
8542}
8543
8544func (_c *MockButtonWidget_SetCanTarget_Call) Return() *MockButtonWidget_SetCanTarget_Call {
8545	_c.Call.Return()
8546	return _c
8547}
8548
8549func (_c *MockButtonWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockButtonWidget_SetCanTarget_Call {
8550	_c.Run(run)
8551	return _c
8552}
8553
8554// SetChild provides a mock function for the type MockButtonWidget
8555func (_mock *MockButtonWidget) SetChild(child layout.Widget) {
8556	_mock.Called(child)
8557	return
8558}
8559
8560// MockButtonWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
8561type MockButtonWidget_SetChild_Call struct {
8562	*mock.Call
8563}
8564
8565// SetChild is a helper method to define mock.On call
8566//   - child layout.Widget
8567func (_e *MockButtonWidget_Expecter) SetChild(child interface{}) *MockButtonWidget_SetChild_Call {
8568	return &MockButtonWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
8569}
8570
8571func (_c *MockButtonWidget_SetChild_Call) Run(run func(child layout.Widget)) *MockButtonWidget_SetChild_Call {
8572	_c.Call.Run(func(args mock.Arguments) {
8573		var arg0 layout.Widget
8574		if args[0] != nil {
8575			arg0 = args[0].(layout.Widget)
8576		}
8577		run(
8578			arg0,
8579		)
8580	})
8581	return _c
8582}
8583
8584func (_c *MockButtonWidget_SetChild_Call) Return() *MockButtonWidget_SetChild_Call {
8585	_c.Call.Return()
8586	return _c
8587}
8588
8589func (_c *MockButtonWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) *MockButtonWidget_SetChild_Call {
8590	_c.Run(run)
8591	return _c
8592}
8593
8594// SetFocusOnClick provides a mock function for the type MockButtonWidget
8595func (_mock *MockButtonWidget) SetFocusOnClick(focusOnClick bool) {
8596	_mock.Called(focusOnClick)
8597	return
8598}
8599
8600// MockButtonWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
8601type MockButtonWidget_SetFocusOnClick_Call struct {
8602	*mock.Call
8603}
8604
8605// SetFocusOnClick is a helper method to define mock.On call
8606//   - focusOnClick bool
8607func (_e *MockButtonWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockButtonWidget_SetFocusOnClick_Call {
8608	return &MockButtonWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
8609}
8610
8611func (_c *MockButtonWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockButtonWidget_SetFocusOnClick_Call {
8612	_c.Call.Run(func(args mock.Arguments) {
8613		var arg0 bool
8614		if args[0] != nil {
8615			arg0 = args[0].(bool)
8616		}
8617		run(
8618			arg0,
8619		)
8620	})
8621	return _c
8622}
8623
8624func (_c *MockButtonWidget_SetFocusOnClick_Call) Return() *MockButtonWidget_SetFocusOnClick_Call {
8625	_c.Call.Return()
8626	return _c
8627}
8628
8629func (_c *MockButtonWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockButtonWidget_SetFocusOnClick_Call {
8630	_c.Run(run)
8631	return _c
8632}
8633
8634// SetHalign provides a mock function for the type MockButtonWidget
8635func (_mock *MockButtonWidget) SetHalign(align gtk.Align) {
8636	_mock.Called(align)
8637	return
8638}
8639
8640// MockButtonWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
8641type MockButtonWidget_SetHalign_Call struct {
8642	*mock.Call
8643}
8644
8645// SetHalign is a helper method to define mock.On call
8646//   - align gtk.Align
8647func (_e *MockButtonWidget_Expecter) SetHalign(align interface{}) *MockButtonWidget_SetHalign_Call {
8648	return &MockButtonWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
8649}
8650
8651func (_c *MockButtonWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetHalign_Call {
8652	_c.Call.Run(func(args mock.Arguments) {
8653		var arg0 gtk.Align
8654		if args[0] != nil {
8655			arg0 = args[0].(gtk.Align)
8656		}
8657		run(
8658			arg0,
8659		)
8660	})
8661	return _c
8662}
8663
8664func (_c *MockButtonWidget_SetHalign_Call) Return() *MockButtonWidget_SetHalign_Call {
8665	_c.Call.Return()
8666	return _c
8667}
8668
8669func (_c *MockButtonWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetHalign_Call {
8670	_c.Run(run)
8671	return _c
8672}
8673
8674// SetHexpand provides a mock function for the type MockButtonWidget
8675func (_mock *MockButtonWidget) SetHexpand(expand bool) {
8676	_mock.Called(expand)
8677	return
8678}
8679
8680// MockButtonWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
8681type MockButtonWidget_SetHexpand_Call struct {
8682	*mock.Call
8683}
8684
8685// SetHexpand is a helper method to define mock.On call
8686//   - expand bool
8687func (_e *MockButtonWidget_Expecter) SetHexpand(expand interface{}) *MockButtonWidget_SetHexpand_Call {
8688	return &MockButtonWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
8689}
8690
8691func (_c *MockButtonWidget_SetHexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetHexpand_Call {
8692	_c.Call.Run(func(args mock.Arguments) {
8693		var arg0 bool
8694		if args[0] != nil {
8695			arg0 = args[0].(bool)
8696		}
8697		run(
8698			arg0,
8699		)
8700	})
8701	return _c
8702}
8703
8704func (_c *MockButtonWidget_SetHexpand_Call) Return() *MockButtonWidget_SetHexpand_Call {
8705	_c.Call.Return()
8706	return _c
8707}
8708
8709func (_c *MockButtonWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetHexpand_Call {
8710	_c.Run(run)
8711	return _c
8712}
8713
8714// SetLabel provides a mock function for the type MockButtonWidget
8715func (_mock *MockButtonWidget) SetLabel(label string) {
8716	_mock.Called(label)
8717	return
8718}
8719
8720// MockButtonWidget_SetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabel'
8721type MockButtonWidget_SetLabel_Call struct {
8722	*mock.Call
8723}
8724
8725// SetLabel is a helper method to define mock.On call
8726//   - label string
8727func (_e *MockButtonWidget_Expecter) SetLabel(label interface{}) *MockButtonWidget_SetLabel_Call {
8728	return &MockButtonWidget_SetLabel_Call{Call: _e.mock.On("SetLabel", label)}
8729}
8730
8731func (_c *MockButtonWidget_SetLabel_Call) Run(run func(label string)) *MockButtonWidget_SetLabel_Call {
8732	_c.Call.Run(func(args mock.Arguments) {
8733		var arg0 string
8734		if args[0] != nil {
8735			arg0 = args[0].(string)
8736		}
8737		run(
8738			arg0,
8739		)
8740	})
8741	return _c
8742}
8743
8744func (_c *MockButtonWidget_SetLabel_Call) Return() *MockButtonWidget_SetLabel_Call {
8745	_c.Call.Return()
8746	return _c
8747}
8748
8749func (_c *MockButtonWidget_SetLabel_Call) RunAndReturn(run func(label string)) *MockButtonWidget_SetLabel_Call {
8750	_c.Run(run)
8751	return _c
8752}
8753
8754// SetSizeRequest provides a mock function for the type MockButtonWidget
8755func (_mock *MockButtonWidget) SetSizeRequest(width int, height int) {
8756	_mock.Called(width, height)
8757	return
8758}
8759
8760// MockButtonWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
8761type MockButtonWidget_SetSizeRequest_Call struct {
8762	*mock.Call
8763}
8764
8765// SetSizeRequest is a helper method to define mock.On call
8766//   - width int
8767//   - height int
8768func (_e *MockButtonWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockButtonWidget_SetSizeRequest_Call {
8769	return &MockButtonWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
8770}
8771
8772func (_c *MockButtonWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
8773	_c.Call.Run(func(args mock.Arguments) {
8774		var arg0 int
8775		if args[0] != nil {
8776			arg0 = args[0].(int)
8777		}
8778		var arg1 int
8779		if args[1] != nil {
8780			arg1 = args[1].(int)
8781		}
8782		run(
8783			arg0,
8784			arg1,
8785		)
8786	})
8787	return _c
8788}
8789
8790func (_c *MockButtonWidget_SetSizeRequest_Call) Return() *MockButtonWidget_SetSizeRequest_Call {
8791	_c.Call.Return()
8792	return _c
8793}
8794
8795func (_c *MockButtonWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
8796	_c.Run(run)
8797	return _c
8798}
8799
8800// SetValign provides a mock function for the type MockButtonWidget
8801func (_mock *MockButtonWidget) SetValign(align gtk.Align) {
8802	_mock.Called(align)
8803	return
8804}
8805
8806// MockButtonWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
8807type MockButtonWidget_SetValign_Call struct {
8808	*mock.Call
8809}
8810
8811// SetValign is a helper method to define mock.On call
8812//   - align gtk.Align
8813func (_e *MockButtonWidget_Expecter) SetValign(align interface{}) *MockButtonWidget_SetValign_Call {
8814	return &MockButtonWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
8815}
8816
8817func (_c *MockButtonWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
8818	_c.Call.Run(func(args mock.Arguments) {
8819		var arg0 gtk.Align
8820		if args[0] != nil {
8821			arg0 = args[0].(gtk.Align)
8822		}
8823		run(
8824			arg0,
8825		)
8826	})
8827	return _c
8828}
8829
8830func (_c *MockButtonWidget_SetValign_Call) Return() *MockButtonWidget_SetValign_Call {
8831	_c.Call.Return()
8832	return _c
8833}
8834
8835func (_c *MockButtonWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
8836	_c.Run(run)
8837	return _c
8838}
8839
8840// SetVexpand provides a mock function for the type MockButtonWidget
8841func (_mock *MockButtonWidget) SetVexpand(expand bool) {
8842	_mock.Called(expand)
8843	return
8844}
8845
8846// MockButtonWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
8847type MockButtonWidget_SetVexpand_Call struct {
8848	*mock.Call
8849}
8850
8851// SetVexpand is a helper method to define mock.On call
8852//   - expand bool
8853func (_e *MockButtonWidget_Expecter) SetVexpand(expand interface{}) *MockButtonWidget_SetVexpand_Call {
8854	return &MockButtonWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
8855}
8856
8857func (_c *MockButtonWidget_SetVexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
8858	_c.Call.Run(func(args mock.Arguments) {
8859		var arg0 bool
8860		if args[0] != nil {
8861			arg0 = args[0].(bool)
8862		}
8863		run(
8864			arg0,
8865		)
8866	})
8867	return _c
8868}
8869
8870func (_c *MockButtonWidget_SetVexpand_Call) Return() *MockButtonWidget_SetVexpand_Call {
8871	_c.Call.Return()
8872	return _c
8873}
8874
8875func (_c *MockButtonWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
8876	_c.Run(run)
8877	return _c
8878}
8879
8880// SetVisible provides a mock function for the type MockButtonWidget
8881func (_mock *MockButtonWidget) SetVisible(visible bool) {
8882	_mock.Called(visible)
8883	return
8884}
8885
8886// MockButtonWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
8887type MockButtonWidget_SetVisible_Call struct {
8888	*mock.Call
8889}
8890
8891// SetVisible is a helper method to define mock.On call
8892//   - visible bool
8893func (_e *MockButtonWidget_Expecter) SetVisible(visible interface{}) *MockButtonWidget_SetVisible_Call {
8894	return &MockButtonWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
8895}
8896
8897func (_c *MockButtonWidget_SetVisible_Call) Run(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
8898	_c.Call.Run(func(args mock.Arguments) {
8899		var arg0 bool
8900		if args[0] != nil {
8901			arg0 = args[0].(bool)
8902		}
8903		run(
8904			arg0,
8905		)
8906	})
8907	return _c
8908}
8909
8910func (_c *MockButtonWidget_SetVisible_Call) Return() *MockButtonWidget_SetVisible_Call {
8911	_c.Call.Return()
8912	return _c
8913}
8914
8915func (_c *MockButtonWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
8916	_c.Run(run)
8917	return _c
8918}
8919
8920// Show provides a mock function for the type MockButtonWidget
8921func (_mock *MockButtonWidget) Show() {
8922	_mock.Called()
8923	return
8924}
8925
8926// MockButtonWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
8927type MockButtonWidget_Show_Call struct {
8928	*mock.Call
8929}
8930
8931// Show is a helper method to define mock.On call
8932func (_e *MockButtonWidget_Expecter) Show() *MockButtonWidget_Show_Call {
8933	return &MockButtonWidget_Show_Call{Call: _e.mock.On("Show")}
8934}
8935
8936func (_c *MockButtonWidget_Show_Call) Run(run func()) *MockButtonWidget_Show_Call {
8937	_c.Call.Run(func(args mock.Arguments) {
8938		run()
8939	})
8940	return _c
8941}
8942
8943func (_c *MockButtonWidget_Show_Call) Return() *MockButtonWidget_Show_Call {
8944	_c.Call.Return()
8945	return _c
8946}
8947
8948func (_c *MockButtonWidget_Show_Call) RunAndReturn(run func()) *MockButtonWidget_Show_Call {
8949	_c.Run(run)
8950	return _c
8951}
8952
8953// Unparent provides a mock function for the type MockButtonWidget
8954func (_mock *MockButtonWidget) Unparent() {
8955	_mock.Called()
8956	return
8957}
8958
8959// MockButtonWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
8960type MockButtonWidget_Unparent_Call struct {
8961	*mock.Call
8962}
8963
8964// Unparent is a helper method to define mock.On call
8965func (_e *MockButtonWidget_Expecter) Unparent() *MockButtonWidget_Unparent_Call {
8966	return &MockButtonWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
8967}
8968
8969func (_c *MockButtonWidget_Unparent_Call) Run(run func()) *MockButtonWidget_Unparent_Call {
8970	_c.Call.Run(func(args mock.Arguments) {
8971		run()
8972	})
8973	return _c
8974}
8975
8976func (_c *MockButtonWidget_Unparent_Call) Return() *MockButtonWidget_Unparent_Call {
8977	_c.Call.Return()
8978	return _c
8979}
8980
8981func (_c *MockButtonWidget_Unparent_Call) RunAndReturn(run func()) *MockButtonWidget_Unparent_Call {
8982	_c.Run(run)
8983	return _c
8984}
8985
8986// 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.
8987// The first argument is typically a *testing.T value.
8988func NewMockImageWidget(t interface {
8989	mock.TestingT
8990	Cleanup(func())
8991}) *MockImageWidget {
8992	mock := &MockImageWidget{}
8993	mock.Mock.Test(t)
8994
8995	t.Cleanup(func() { mock.AssertExpectations(t) })
8996
8997	return mock
8998}
8999
9000// MockImageWidget is an autogenerated mock type for the ImageWidget type
9001type MockImageWidget struct {
9002	mock.Mock
9003}
9004
9005type MockImageWidget_Expecter struct {
9006	mock *mock.Mock
9007}
9008
9009func (_m *MockImageWidget) EXPECT() *MockImageWidget_Expecter {
9010	return &MockImageWidget_Expecter{mock: &_m.Mock}
9011}
9012
9013// AddController provides a mock function for the type MockImageWidget
9014func (_mock *MockImageWidget) AddController(controller *gtk.EventController) {
9015	_mock.Called(controller)
9016	return
9017}
9018
9019// MockImageWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
9020type MockImageWidget_AddController_Call struct {
9021	*mock.Call
9022}
9023
9024// AddController is a helper method to define mock.On call
9025//   - controller *gtk.EventController
9026func (_e *MockImageWidget_Expecter) AddController(controller interface{}) *MockImageWidget_AddController_Call {
9027	return &MockImageWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
9028}
9029
9030func (_c *MockImageWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
9031	_c.Call.Run(func(args mock.Arguments) {
9032		var arg0 *gtk.EventController
9033		if args[0] != nil {
9034			arg0 = args[0].(*gtk.EventController)
9035		}
9036		run(
9037			arg0,
9038		)
9039	})
9040	return _c
9041}
9042
9043func (_c *MockImageWidget_AddController_Call) Return() *MockImageWidget_AddController_Call {
9044	_c.Call.Return()
9045	return _c
9046}
9047
9048func (_c *MockImageWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
9049	_c.Run(run)
9050	return _c
9051}
9052
9053// AddCssClass provides a mock function for the type MockImageWidget
9054func (_mock *MockImageWidget) AddCssClass(cssClass string) {
9055	_mock.Called(cssClass)
9056	return
9057}
9058
9059// MockImageWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
9060type MockImageWidget_AddCssClass_Call struct {
9061	*mock.Call
9062}
9063
9064// AddCssClass is a helper method to define mock.On call
9065//   - cssClass string
9066func (_e *MockImageWidget_Expecter) AddCssClass(cssClass interface{}) *MockImageWidget_AddCssClass_Call {
9067	return &MockImageWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
9068}
9069
9070func (_c *MockImageWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
9071	_c.Call.Run(func(args mock.Arguments) {
9072		var arg0 string
9073		if args[0] != nil {
9074			arg0 = args[0].(string)
9075		}
9076		run(
9077			arg0,
9078		)
9079	})
9080	return _c
9081}
9082
9083func (_c *MockImageWidget_AddCssClass_Call) Return() *MockImageWidget_AddCssClass_Call {
9084	_c.Call.Return()
9085	return _c
9086}
9087
9088func (_c *MockImageWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
9089	_c.Run(run)
9090	return _c
9091}
9092
9093// Clear provides a mock function for the type MockImageWidget
9094func (_mock *MockImageWidget) Clear() {
9095	_mock.Called()
9096	return
9097}
9098
9099// MockImageWidget_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
9100type MockImageWidget_Clear_Call struct {
9101	*mock.Call
9102}
9103
9104// Clear is a helper method to define mock.On call
9105func (_e *MockImageWidget_Expecter) Clear() *MockImageWidget_Clear_Call {
9106	return &MockImageWidget_Clear_Call{Call: _e.mock.On("Clear")}
9107}
9108
9109func (_c *MockImageWidget_Clear_Call) Run(run func()) *MockImageWidget_Clear_Call {
9110	_c.Call.Run(func(args mock.Arguments) {
9111		run()
9112	})
9113	return _c
9114}
9115
9116func (_c *MockImageWidget_Clear_Call) Return() *MockImageWidget_Clear_Call {
9117	_c.Call.Return()
9118	return _c
9119}
9120
9121func (_c *MockImageWidget_Clear_Call) RunAndReturn(run func()) *MockImageWidget_Clear_Call {
9122	_c.Run(run)
9123	return _c
9124}
9125
9126// ComputePoint provides a mock function for the type MockImageWidget
9127func (_mock *MockImageWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
9128	ret := _mock.Called(target)
9129
9130	if len(ret) == 0 {
9131		panic("no return value specified for ComputePoint")
9132	}
9133
9134	var r0 float64
9135	var r1 float64
9136	var r2 bool
9137	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
9138		return returnFunc(target)
9139	}
9140	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
9141		r0 = returnFunc(target)
9142	} else {
9143		r0 = ret.Get(0).(float64)
9144	}
9145	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
9146		r1 = returnFunc(target)
9147	} else {
9148		r1 = ret.Get(1).(float64)
9149	}
9150	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
9151		r2 = returnFunc(target)
9152	} else {
9153		r2 = ret.Get(2).(bool)
9154	}
9155	return r0, r1, r2
9156}
9157
9158// MockImageWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
9159type MockImageWidget_ComputePoint_Call struct {
9160	*mock.Call
9161}
9162
9163// ComputePoint is a helper method to define mock.On call
9164//   - target layout.Widget
9165func (_e *MockImageWidget_Expecter) ComputePoint(target interface{}) *MockImageWidget_ComputePoint_Call {
9166	return &MockImageWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
9167}
9168
9169func (_c *MockImageWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockImageWidget_ComputePoint_Call {
9170	_c.Call.Run(func(args mock.Arguments) {
9171		var arg0 layout.Widget
9172		if args[0] != nil {
9173			arg0 = args[0].(layout.Widget)
9174		}
9175		run(
9176			arg0,
9177		)
9178	})
9179	return _c
9180}
9181
9182func (_c *MockImageWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockImageWidget_ComputePoint_Call {
9183	_c.Call.Return(x, y, ok)
9184	return _c
9185}
9186
9187func (_c *MockImageWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockImageWidget_ComputePoint_Call {
9188	_c.Call.Return(run)
9189	return _c
9190}
9191
9192// GetAllocatedHeight provides a mock function for the type MockImageWidget
9193func (_mock *MockImageWidget) GetAllocatedHeight() int {
9194	ret := _mock.Called()
9195
9196	if len(ret) == 0 {
9197		panic("no return value specified for GetAllocatedHeight")
9198	}
9199
9200	var r0 int
9201	if returnFunc, ok := ret.Get(0).(func() int); ok {
9202		r0 = returnFunc()
9203	} else {
9204		r0 = ret.Get(0).(int)
9205	}
9206	return r0
9207}
9208
9209// MockImageWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
9210type MockImageWidget_GetAllocatedHeight_Call struct {
9211	*mock.Call
9212}
9213
9214// GetAllocatedHeight is a helper method to define mock.On call
9215func (_e *MockImageWidget_Expecter) GetAllocatedHeight() *MockImageWidget_GetAllocatedHeight_Call {
9216	return &MockImageWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
9217}
9218
9219func (_c *MockImageWidget_GetAllocatedHeight_Call) Run(run func()) *MockImageWidget_GetAllocatedHeight_Call {
9220	_c.Call.Run(func(args mock.Arguments) {
9221		run()
9222	})
9223	return _c
9224}
9225
9226func (_c *MockImageWidget_GetAllocatedHeight_Call) Return(n int) *MockImageWidget_GetAllocatedHeight_Call {
9227	_c.Call.Return(n)
9228	return _c
9229}
9230
9231func (_c *MockImageWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedHeight_Call {
9232	_c.Call.Return(run)
9233	return _c
9234}
9235
9236// GetAllocatedWidth provides a mock function for the type MockImageWidget
9237func (_mock *MockImageWidget) GetAllocatedWidth() int {
9238	ret := _mock.Called()
9239
9240	if len(ret) == 0 {
9241		panic("no return value specified for GetAllocatedWidth")
9242	}
9243
9244	var r0 int
9245	if returnFunc, ok := ret.Get(0).(func() int); ok {
9246		r0 = returnFunc()
9247	} else {
9248		r0 = ret.Get(0).(int)
9249	}
9250	return r0
9251}
9252
9253// MockImageWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
9254type MockImageWidget_GetAllocatedWidth_Call struct {
9255	*mock.Call
9256}
9257
9258// GetAllocatedWidth is a helper method to define mock.On call
9259func (_e *MockImageWidget_Expecter) GetAllocatedWidth() *MockImageWidget_GetAllocatedWidth_Call {
9260	return &MockImageWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
9261}
9262
9263func (_c *MockImageWidget_GetAllocatedWidth_Call) Run(run func()) *MockImageWidget_GetAllocatedWidth_Call {
9264	_c.Call.Run(func(args mock.Arguments) {
9265		run()
9266	})
9267	return _c
9268}
9269
9270func (_c *MockImageWidget_GetAllocatedWidth_Call) Return(n int) *MockImageWidget_GetAllocatedWidth_Call {
9271	_c.Call.Return(n)
9272	return _c
9273}
9274
9275func (_c *MockImageWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedWidth_Call {
9276	_c.Call.Return(run)
9277	return _c
9278}
9279
9280// GetHexpand provides a mock function for the type MockImageWidget
9281func (_mock *MockImageWidget) GetHexpand() bool {
9282	ret := _mock.Called()
9283
9284	if len(ret) == 0 {
9285		panic("no return value specified for GetHexpand")
9286	}
9287
9288	var r0 bool
9289	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9290		r0 = returnFunc()
9291	} else {
9292		r0 = ret.Get(0).(bool)
9293	}
9294	return r0
9295}
9296
9297// MockImageWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
9298type MockImageWidget_GetHexpand_Call struct {
9299	*mock.Call
9300}
9301
9302// GetHexpand is a helper method to define mock.On call
9303func (_e *MockImageWidget_Expecter) GetHexpand() *MockImageWidget_GetHexpand_Call {
9304	return &MockImageWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
9305}
9306
9307func (_c *MockImageWidget_GetHexpand_Call) Run(run func()) *MockImageWidget_GetHexpand_Call {
9308	_c.Call.Run(func(args mock.Arguments) {
9309		run()
9310	})
9311	return _c
9312}
9313
9314func (_c *MockImageWidget_GetHexpand_Call) Return(b bool) *MockImageWidget_GetHexpand_Call {
9315	_c.Call.Return(b)
9316	return _c
9317}
9318
9319func (_c *MockImageWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetHexpand_Call {
9320	_c.Call.Return(run)
9321	return _c
9322}
9323
9324// GetParent provides a mock function for the type MockImageWidget
9325func (_mock *MockImageWidget) GetParent() layout.Widget {
9326	ret := _mock.Called()
9327
9328	if len(ret) == 0 {
9329		panic("no return value specified for GetParent")
9330	}
9331
9332	var r0 layout.Widget
9333	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
9334		r0 = returnFunc()
9335	} else {
9336		if ret.Get(0) != nil {
9337			r0 = ret.Get(0).(layout.Widget)
9338		}
9339	}
9340	return r0
9341}
9342
9343// MockImageWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
9344type MockImageWidget_GetParent_Call struct {
9345	*mock.Call
9346}
9347
9348// GetParent is a helper method to define mock.On call
9349func (_e *MockImageWidget_Expecter) GetParent() *MockImageWidget_GetParent_Call {
9350	return &MockImageWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
9351}
9352
9353func (_c *MockImageWidget_GetParent_Call) Run(run func()) *MockImageWidget_GetParent_Call {
9354	_c.Call.Run(func(args mock.Arguments) {
9355		run()
9356	})
9357	return _c
9358}
9359
9360func (_c *MockImageWidget_GetParent_Call) Return(widget layout.Widget) *MockImageWidget_GetParent_Call {
9361	_c.Call.Return(widget)
9362	return _c
9363}
9364
9365func (_c *MockImageWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockImageWidget_GetParent_Call {
9366	_c.Call.Return(run)
9367	return _c
9368}
9369
9370// GetVexpand provides a mock function for the type MockImageWidget
9371func (_mock *MockImageWidget) GetVexpand() bool {
9372	ret := _mock.Called()
9373
9374	if len(ret) == 0 {
9375		panic("no return value specified for GetVexpand")
9376	}
9377
9378	var r0 bool
9379	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9380		r0 = returnFunc()
9381	} else {
9382		r0 = ret.Get(0).(bool)
9383	}
9384	return r0
9385}
9386
9387// MockImageWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
9388type MockImageWidget_GetVexpand_Call struct {
9389	*mock.Call
9390}
9391
9392// GetVexpand is a helper method to define mock.On call
9393func (_e *MockImageWidget_Expecter) GetVexpand() *MockImageWidget_GetVexpand_Call {
9394	return &MockImageWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
9395}
9396
9397func (_c *MockImageWidget_GetVexpand_Call) Run(run func()) *MockImageWidget_GetVexpand_Call {
9398	_c.Call.Run(func(args mock.Arguments) {
9399		run()
9400	})
9401	return _c
9402}
9403
9404func (_c *MockImageWidget_GetVexpand_Call) Return(b bool) *MockImageWidget_GetVexpand_Call {
9405	_c.Call.Return(b)
9406	return _c
9407}
9408
9409func (_c *MockImageWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetVexpand_Call {
9410	_c.Call.Return(run)
9411	return _c
9412}
9413
9414// GrabFocus provides a mock function for the type MockImageWidget
9415func (_mock *MockImageWidget) GrabFocus() bool {
9416	ret := _mock.Called()
9417
9418	if len(ret) == 0 {
9419		panic("no return value specified for GrabFocus")
9420	}
9421
9422	var r0 bool
9423	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9424		r0 = returnFunc()
9425	} else {
9426		r0 = ret.Get(0).(bool)
9427	}
9428	return r0
9429}
9430
9431// MockImageWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
9432type MockImageWidget_GrabFocus_Call struct {
9433	*mock.Call
9434}
9435
9436// GrabFocus is a helper method to define mock.On call
9437func (_e *MockImageWidget_Expecter) GrabFocus() *MockImageWidget_GrabFocus_Call {
9438	return &MockImageWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
9439}
9440
9441func (_c *MockImageWidget_GrabFocus_Call) Run(run func()) *MockImageWidget_GrabFocus_Call {
9442	_c.Call.Run(func(args mock.Arguments) {
9443		run()
9444	})
9445	return _c
9446}
9447
9448func (_c *MockImageWidget_GrabFocus_Call) Return(b bool) *MockImageWidget_GrabFocus_Call {
9449	_c.Call.Return(b)
9450	return _c
9451}
9452
9453func (_c *MockImageWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_GrabFocus_Call {
9454	_c.Call.Return(run)
9455	return _c
9456}
9457
9458// GtkWidget provides a mock function for the type MockImageWidget
9459func (_mock *MockImageWidget) GtkWidget() *gtk.Widget {
9460	ret := _mock.Called()
9461
9462	if len(ret) == 0 {
9463		panic("no return value specified for GtkWidget")
9464	}
9465
9466	var r0 *gtk.Widget
9467	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
9468		r0 = returnFunc()
9469	} else {
9470		if ret.Get(0) != nil {
9471			r0 = ret.Get(0).(*gtk.Widget)
9472		}
9473	}
9474	return r0
9475}
9476
9477// MockImageWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
9478type MockImageWidget_GtkWidget_Call struct {
9479	*mock.Call
9480}
9481
9482// GtkWidget is a helper method to define mock.On call
9483func (_e *MockImageWidget_Expecter) GtkWidget() *MockImageWidget_GtkWidget_Call {
9484	return &MockImageWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
9485}
9486
9487func (_c *MockImageWidget_GtkWidget_Call) Run(run func()) *MockImageWidget_GtkWidget_Call {
9488	_c.Call.Run(func(args mock.Arguments) {
9489		run()
9490	})
9491	return _c
9492}
9493
9494func (_c *MockImageWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockImageWidget_GtkWidget_Call {
9495	_c.Call.Return(widget)
9496	return _c
9497}
9498
9499func (_c *MockImageWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockImageWidget_GtkWidget_Call {
9500	_c.Call.Return(run)
9501	return _c
9502}
9503
9504// HasCssClass provides a mock function for the type MockImageWidget
9505func (_mock *MockImageWidget) HasCssClass(cssClass string) bool {
9506	ret := _mock.Called(cssClass)
9507
9508	if len(ret) == 0 {
9509		panic("no return value specified for HasCssClass")
9510	}
9511
9512	var r0 bool
9513	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
9514		r0 = returnFunc(cssClass)
9515	} else {
9516		r0 = ret.Get(0).(bool)
9517	}
9518	return r0
9519}
9520
9521// MockImageWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
9522type MockImageWidget_HasCssClass_Call struct {
9523	*mock.Call
9524}
9525
9526// HasCssClass is a helper method to define mock.On call
9527//   - cssClass string
9528func (_e *MockImageWidget_Expecter) HasCssClass(cssClass interface{}) *MockImageWidget_HasCssClass_Call {
9529	return &MockImageWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
9530}
9531
9532func (_c *MockImageWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_HasCssClass_Call {
9533	_c.Call.Run(func(args mock.Arguments) {
9534		var arg0 string
9535		if args[0] != nil {
9536			arg0 = args[0].(string)
9537		}
9538		run(
9539			arg0,
9540		)
9541	})
9542	return _c
9543}
9544
9545func (_c *MockImageWidget_HasCssClass_Call) Return(b bool) *MockImageWidget_HasCssClass_Call {
9546	_c.Call.Return(b)
9547	return _c
9548}
9549
9550func (_c *MockImageWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockImageWidget_HasCssClass_Call {
9551	_c.Call.Return(run)
9552	return _c
9553}
9554
9555// HasFocus provides a mock function for the type MockImageWidget
9556func (_mock *MockImageWidget) HasFocus() bool {
9557	ret := _mock.Called()
9558
9559	if len(ret) == 0 {
9560		panic("no return value specified for HasFocus")
9561	}
9562
9563	var r0 bool
9564	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9565		r0 = returnFunc()
9566	} else {
9567		r0 = ret.Get(0).(bool)
9568	}
9569	return r0
9570}
9571
9572// MockImageWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
9573type MockImageWidget_HasFocus_Call struct {
9574	*mock.Call
9575}
9576
9577// HasFocus is a helper method to define mock.On call
9578func (_e *MockImageWidget_Expecter) HasFocus() *MockImageWidget_HasFocus_Call {
9579	return &MockImageWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
9580}
9581
9582func (_c *MockImageWidget_HasFocus_Call) Run(run func()) *MockImageWidget_HasFocus_Call {
9583	_c.Call.Run(func(args mock.Arguments) {
9584		run()
9585	})
9586	return _c
9587}
9588
9589func (_c *MockImageWidget_HasFocus_Call) Return(b bool) *MockImageWidget_HasFocus_Call {
9590	_c.Call.Return(b)
9591	return _c
9592}
9593
9594func (_c *MockImageWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_HasFocus_Call {
9595	_c.Call.Return(run)
9596	return _c
9597}
9598
9599// Hide provides a mock function for the type MockImageWidget
9600func (_mock *MockImageWidget) Hide() {
9601	_mock.Called()
9602	return
9603}
9604
9605// MockImageWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
9606type MockImageWidget_Hide_Call struct {
9607	*mock.Call
9608}
9609
9610// Hide is a helper method to define mock.On call
9611func (_e *MockImageWidget_Expecter) Hide() *MockImageWidget_Hide_Call {
9612	return &MockImageWidget_Hide_Call{Call: _e.mock.On("Hide")}
9613}
9614
9615func (_c *MockImageWidget_Hide_Call) Run(run func()) *MockImageWidget_Hide_Call {
9616	_c.Call.Run(func(args mock.Arguments) {
9617		run()
9618	})
9619	return _c
9620}
9621
9622func (_c *MockImageWidget_Hide_Call) Return() *MockImageWidget_Hide_Call {
9623	_c.Call.Return()
9624	return _c
9625}
9626
9627func (_c *MockImageWidget_Hide_Call) RunAndReturn(run func()) *MockImageWidget_Hide_Call {
9628	_c.Run(run)
9629	return _c
9630}
9631
9632// IsVisible provides a mock function for the type MockImageWidget
9633func (_mock *MockImageWidget) IsVisible() bool {
9634	ret := _mock.Called()
9635
9636	if len(ret) == 0 {
9637		panic("no return value specified for IsVisible")
9638	}
9639
9640	var r0 bool
9641	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9642		r0 = returnFunc()
9643	} else {
9644		r0 = ret.Get(0).(bool)
9645	}
9646	return r0
9647}
9648
9649// MockImageWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
9650type MockImageWidget_IsVisible_Call struct {
9651	*mock.Call
9652}
9653
9654// IsVisible is a helper method to define mock.On call
9655func (_e *MockImageWidget_Expecter) IsVisible() *MockImageWidget_IsVisible_Call {
9656	return &MockImageWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
9657}
9658
9659func (_c *MockImageWidget_IsVisible_Call) Run(run func()) *MockImageWidget_IsVisible_Call {
9660	_c.Call.Run(func(args mock.Arguments) {
9661		run()
9662	})
9663	return _c
9664}
9665
9666func (_c *MockImageWidget_IsVisible_Call) Return(b bool) *MockImageWidget_IsVisible_Call {
9667	_c.Call.Return(b)
9668	return _c
9669}
9670
9671func (_c *MockImageWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockImageWidget_IsVisible_Call {
9672	_c.Call.Return(run)
9673	return _c
9674}
9675
9676// RemoveCssClass provides a mock function for the type MockImageWidget
9677func (_mock *MockImageWidget) RemoveCssClass(cssClass string) {
9678	_mock.Called(cssClass)
9679	return
9680}
9681
9682// MockImageWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
9683type MockImageWidget_RemoveCssClass_Call struct {
9684	*mock.Call
9685}
9686
9687// RemoveCssClass is a helper method to define mock.On call
9688//   - cssClass string
9689func (_e *MockImageWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockImageWidget_RemoveCssClass_Call {
9690	return &MockImageWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
9691}
9692
9693func (_c *MockImageWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
9694	_c.Call.Run(func(args mock.Arguments) {
9695		var arg0 string
9696		if args[0] != nil {
9697			arg0 = args[0].(string)
9698		}
9699		run(
9700			arg0,
9701		)
9702	})
9703	return _c
9704}
9705
9706func (_c *MockImageWidget_RemoveCssClass_Call) Return() *MockImageWidget_RemoveCssClass_Call {
9707	_c.Call.Return()
9708	return _c
9709}
9710
9711func (_c *MockImageWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
9712	_c.Run(run)
9713	return _c
9714}
9715
9716// SetCanFocus provides a mock function for the type MockImageWidget
9717func (_mock *MockImageWidget) SetCanFocus(canFocus bool) {
9718	_mock.Called(canFocus)
9719	return
9720}
9721
9722// MockImageWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
9723type MockImageWidget_SetCanFocus_Call struct {
9724	*mock.Call
9725}
9726
9727// SetCanFocus is a helper method to define mock.On call
9728//   - canFocus bool
9729func (_e *MockImageWidget_Expecter) SetCanFocus(canFocus interface{}) *MockImageWidget_SetCanFocus_Call {
9730	return &MockImageWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
9731}
9732
9733func (_c *MockImageWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
9734	_c.Call.Run(func(args mock.Arguments) {
9735		var arg0 bool
9736		if args[0] != nil {
9737			arg0 = args[0].(bool)
9738		}
9739		run(
9740			arg0,
9741		)
9742	})
9743	return _c
9744}
9745
9746func (_c *MockImageWidget_SetCanFocus_Call) Return() *MockImageWidget_SetCanFocus_Call {
9747	_c.Call.Return()
9748	return _c
9749}
9750
9751func (_c *MockImageWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
9752	_c.Run(run)
9753	return _c
9754}
9755
9756// SetCanTarget provides a mock function for the type MockImageWidget
9757func (_mock *MockImageWidget) SetCanTarget(canTarget bool) {
9758	_mock.Called(canTarget)
9759	return
9760}
9761
9762// MockImageWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
9763type MockImageWidget_SetCanTarget_Call struct {
9764	*mock.Call
9765}
9766
9767// SetCanTarget is a helper method to define mock.On call
9768//   - canTarget bool
9769func (_e *MockImageWidget_Expecter) SetCanTarget(canTarget interface{}) *MockImageWidget_SetCanTarget_Call {
9770	return &MockImageWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
9771}
9772
9773func (_c *MockImageWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockImageWidget_SetCanTarget_Call {
9774	_c.Call.Run(func(args mock.Arguments) {
9775		var arg0 bool
9776		if args[0] != nil {
9777			arg0 = args[0].(bool)
9778		}
9779		run(
9780			arg0,
9781		)
9782	})
9783	return _c
9784}
9785
9786func (_c *MockImageWidget_SetCanTarget_Call) Return() *MockImageWidget_SetCanTarget_Call {
9787	_c.Call.Return()
9788	return _c
9789}
9790
9791func (_c *MockImageWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockImageWidget_SetCanTarget_Call {
9792	_c.Run(run)
9793	return _c
9794}
9795
9796// SetFocusOnClick provides a mock function for the type MockImageWidget
9797func (_mock *MockImageWidget) SetFocusOnClick(focusOnClick bool) {
9798	_mock.Called(focusOnClick)
9799	return
9800}
9801
9802// MockImageWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
9803type MockImageWidget_SetFocusOnClick_Call struct {
9804	*mock.Call
9805}
9806
9807// SetFocusOnClick is a helper method to define mock.On call
9808//   - focusOnClick bool
9809func (_e *MockImageWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockImageWidget_SetFocusOnClick_Call {
9810	return &MockImageWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
9811}
9812
9813func (_c *MockImageWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
9814	_c.Call.Run(func(args mock.Arguments) {
9815		var arg0 bool
9816		if args[0] != nil {
9817			arg0 = args[0].(bool)
9818		}
9819		run(
9820			arg0,
9821		)
9822	})
9823	return _c
9824}
9825
9826func (_c *MockImageWidget_SetFocusOnClick_Call) Return() *MockImageWidget_SetFocusOnClick_Call {
9827	_c.Call.Return()
9828	return _c
9829}
9830
9831func (_c *MockImageWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
9832	_c.Run(run)
9833	return _c
9834}
9835
9836// SetFromFile provides a mock function for the type MockImageWidget
9837func (_mock *MockImageWidget) SetFromFile(filename string) {
9838	_mock.Called(filename)
9839	return
9840}
9841
9842// MockImageWidget_SetFromFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromFile'
9843type MockImageWidget_SetFromFile_Call struct {
9844	*mock.Call
9845}
9846
9847// SetFromFile is a helper method to define mock.On call
9848//   - filename string
9849func (_e *MockImageWidget_Expecter) SetFromFile(filename interface{}) *MockImageWidget_SetFromFile_Call {
9850	return &MockImageWidget_SetFromFile_Call{Call: _e.mock.On("SetFromFile", filename)}
9851}
9852
9853func (_c *MockImageWidget_SetFromFile_Call) Run(run func(filename string)) *MockImageWidget_SetFromFile_Call {
9854	_c.Call.Run(func(args mock.Arguments) {
9855		var arg0 string
9856		if args[0] != nil {
9857			arg0 = args[0].(string)
9858		}
9859		run(
9860			arg0,
9861		)
9862	})
9863	return _c
9864}
9865
9866func (_c *MockImageWidget_SetFromFile_Call) Return() *MockImageWidget_SetFromFile_Call {
9867	_c.Call.Return()
9868	return _c
9869}
9870
9871func (_c *MockImageWidget_SetFromFile_Call) RunAndReturn(run func(filename string)) *MockImageWidget_SetFromFile_Call {
9872	_c.Run(run)
9873	return _c
9874}
9875
9876// SetFromIconName provides a mock function for the type MockImageWidget
9877func (_mock *MockImageWidget) SetFromIconName(iconName string) {
9878	_mock.Called(iconName)
9879	return
9880}
9881
9882// MockImageWidget_SetFromIconName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromIconName'
9883type MockImageWidget_SetFromIconName_Call struct {
9884	*mock.Call
9885}
9886
9887// SetFromIconName is a helper method to define mock.On call
9888//   - iconName string
9889func (_e *MockImageWidget_Expecter) SetFromIconName(iconName interface{}) *MockImageWidget_SetFromIconName_Call {
9890	return &MockImageWidget_SetFromIconName_Call{Call: _e.mock.On("SetFromIconName", iconName)}
9891}
9892
9893func (_c *MockImageWidget_SetFromIconName_Call) Run(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
9894	_c.Call.Run(func(args mock.Arguments) {
9895		var arg0 string
9896		if args[0] != nil {
9897			arg0 = args[0].(string)
9898		}
9899		run(
9900			arg0,
9901		)
9902	})
9903	return _c
9904}
9905
9906func (_c *MockImageWidget_SetFromIconName_Call) Return() *MockImageWidget_SetFromIconName_Call {
9907	_c.Call.Return()
9908	return _c
9909}
9910
9911func (_c *MockImageWidget_SetFromIconName_Call) RunAndReturn(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
9912	_c.Run(run)
9913	return _c
9914}
9915
9916// SetFromPaintable provides a mock function for the type MockImageWidget
9917func (_mock *MockImageWidget) SetFromPaintable(paintable layout.Paintable) {
9918	_mock.Called(paintable)
9919	return
9920}
9921
9922// MockImageWidget_SetFromPaintable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromPaintable'
9923type MockImageWidget_SetFromPaintable_Call struct {
9924	*mock.Call
9925}
9926
9927// SetFromPaintable is a helper method to define mock.On call
9928//   - paintable layout.Paintable
9929func (_e *MockImageWidget_Expecter) SetFromPaintable(paintable interface{}) *MockImageWidget_SetFromPaintable_Call {
9930	return &MockImageWidget_SetFromPaintable_Call{Call: _e.mock.On("SetFromPaintable", paintable)}
9931}
9932
9933func (_c *MockImageWidget_SetFromPaintable_Call) Run(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
9934	_c.Call.Run(func(args mock.Arguments) {
9935		var arg0 layout.Paintable
9936		if args[0] != nil {
9937			arg0 = args[0].(layout.Paintable)
9938		}
9939		run(
9940			arg0,
9941		)
9942	})
9943	return _c
9944}
9945
9946func (_c *MockImageWidget_SetFromPaintable_Call) Return() *MockImageWidget_SetFromPaintable_Call {
9947	_c.Call.Return()
9948	return _c
9949}
9950
9951func (_c *MockImageWidget_SetFromPaintable_Call) RunAndReturn(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
9952	_c.Run(run)
9953	return _c
9954}
9955
9956// SetHalign provides a mock function for the type MockImageWidget
9957func (_mock *MockImageWidget) SetHalign(align gtk.Align) {
9958	_mock.Called(align)
9959	return
9960}
9961
9962// MockImageWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
9963type MockImageWidget_SetHalign_Call struct {
9964	*mock.Call
9965}
9966
9967// SetHalign is a helper method to define mock.On call
9968//   - align gtk.Align
9969func (_e *MockImageWidget_Expecter) SetHalign(align interface{}) *MockImageWidget_SetHalign_Call {
9970	return &MockImageWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
9971}
9972
9973func (_c *MockImageWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
9974	_c.Call.Run(func(args mock.Arguments) {
9975		var arg0 gtk.Align
9976		if args[0] != nil {
9977			arg0 = args[0].(gtk.Align)
9978		}
9979		run(
9980			arg0,
9981		)
9982	})
9983	return _c
9984}
9985
9986func (_c *MockImageWidget_SetHalign_Call) Return() *MockImageWidget_SetHalign_Call {
9987	_c.Call.Return()
9988	return _c
9989}
9990
9991func (_c *MockImageWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
9992	_c.Run(run)
9993	return _c
9994}
9995
9996// SetHexpand provides a mock function for the type MockImageWidget
9997func (_mock *MockImageWidget) SetHexpand(expand bool) {
9998	_mock.Called(expand)
9999	return
10000}
10001
10002// MockImageWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
10003type MockImageWidget_SetHexpand_Call struct {
10004	*mock.Call
10005}
10006
10007// SetHexpand is a helper method to define mock.On call
10008//   - expand bool
10009func (_e *MockImageWidget_Expecter) SetHexpand(expand interface{}) *MockImageWidget_SetHexpand_Call {
10010	return &MockImageWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
10011}
10012
10013func (_c *MockImageWidget_SetHexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
10014	_c.Call.Run(func(args mock.Arguments) {
10015		var arg0 bool
10016		if args[0] != nil {
10017			arg0 = args[0].(bool)
10018		}
10019		run(
10020			arg0,
10021		)
10022	})
10023	return _c
10024}
10025
10026func (_c *MockImageWidget_SetHexpand_Call) Return() *MockImageWidget_SetHexpand_Call {
10027	_c.Call.Return()
10028	return _c
10029}
10030
10031func (_c *MockImageWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
10032	_c.Run(run)
10033	return _c
10034}
10035
10036// SetPixelSize provides a mock function for the type MockImageWidget
10037func (_mock *MockImageWidget) SetPixelSize(pixelSize int) {
10038	_mock.Called(pixelSize)
10039	return
10040}
10041
10042// MockImageWidget_SetPixelSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPixelSize'
10043type MockImageWidget_SetPixelSize_Call struct {
10044	*mock.Call
10045}
10046
10047// SetPixelSize is a helper method to define mock.On call
10048//   - pixelSize int
10049func (_e *MockImageWidget_Expecter) SetPixelSize(pixelSize interface{}) *MockImageWidget_SetPixelSize_Call {
10050	return &MockImageWidget_SetPixelSize_Call{Call: _e.mock.On("SetPixelSize", pixelSize)}
10051}
10052
10053func (_c *MockImageWidget_SetPixelSize_Call) Run(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
10054	_c.Call.Run(func(args mock.Arguments) {
10055		var arg0 int
10056		if args[0] != nil {
10057			arg0 = args[0].(int)
10058		}
10059		run(
10060			arg0,
10061		)
10062	})
10063	return _c
10064}
10065
10066func (_c *MockImageWidget_SetPixelSize_Call) Return() *MockImageWidget_SetPixelSize_Call {
10067	_c.Call.Return()
10068	return _c
10069}
10070
10071func (_c *MockImageWidget_SetPixelSize_Call) RunAndReturn(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
10072	_c.Run(run)
10073	return _c
10074}
10075
10076// SetSizeRequest provides a mock function for the type MockImageWidget
10077func (_mock *MockImageWidget) SetSizeRequest(width int, height int) {
10078	_mock.Called(width, height)
10079	return
10080}
10081
10082// MockImageWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
10083type MockImageWidget_SetSizeRequest_Call struct {
10084	*mock.Call
10085}
10086
10087// SetSizeRequest is a helper method to define mock.On call
10088//   - width int
10089//   - height int
10090func (_e *MockImageWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockImageWidget_SetSizeRequest_Call {
10091	return &MockImageWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
10092}
10093
10094func (_c *MockImageWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
10095	_c.Call.Run(func(args mock.Arguments) {
10096		var arg0 int
10097		if args[0] != nil {
10098			arg0 = args[0].(int)
10099		}
10100		var arg1 int
10101		if args[1] != nil {
10102			arg1 = args[1].(int)
10103		}
10104		run(
10105			arg0,
10106			arg1,
10107		)
10108	})
10109	return _c
10110}
10111
10112func (_c *MockImageWidget_SetSizeRequest_Call) Return() *MockImageWidget_SetSizeRequest_Call {
10113	_c.Call.Return()
10114	return _c
10115}
10116
10117func (_c *MockImageWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
10118	_c.Run(run)
10119	return _c
10120}
10121
10122// SetValign provides a mock function for the type MockImageWidget
10123func (_mock *MockImageWidget) SetValign(align gtk.Align) {
10124	_mock.Called(align)
10125	return
10126}
10127
10128// MockImageWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
10129type MockImageWidget_SetValign_Call struct {
10130	*mock.Call
10131}
10132
10133// SetValign is a helper method to define mock.On call
10134//   - align gtk.Align
10135func (_e *MockImageWidget_Expecter) SetValign(align interface{}) *MockImageWidget_SetValign_Call {
10136	return &MockImageWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
10137}
10138
10139func (_c *MockImageWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
10140	_c.Call.Run(func(args mock.Arguments) {
10141		var arg0 gtk.Align
10142		if args[0] != nil {
10143			arg0 = args[0].(gtk.Align)
10144		}
10145		run(
10146			arg0,
10147		)
10148	})
10149	return _c
10150}
10151
10152func (_c *MockImageWidget_SetValign_Call) Return() *MockImageWidget_SetValign_Call {
10153	_c.Call.Return()
10154	return _c
10155}
10156
10157func (_c *MockImageWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
10158	_c.Run(run)
10159	return _c
10160}
10161
10162// SetVexpand provides a mock function for the type MockImageWidget
10163func (_mock *MockImageWidget) SetVexpand(expand bool) {
10164	_mock.Called(expand)
10165	return
10166}
10167
10168// MockImageWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
10169type MockImageWidget_SetVexpand_Call struct {
10170	*mock.Call
10171}
10172
10173// SetVexpand is a helper method to define mock.On call
10174//   - expand bool
10175func (_e *MockImageWidget_Expecter) SetVexpand(expand interface{}) *MockImageWidget_SetVexpand_Call {
10176	return &MockImageWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
10177}
10178
10179func (_c *MockImageWidget_SetVexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
10180	_c.Call.Run(func(args mock.Arguments) {
10181		var arg0 bool
10182		if args[0] != nil {
10183			arg0 = args[0].(bool)
10184		}
10185		run(
10186			arg0,
10187		)
10188	})
10189	return _c
10190}
10191
10192func (_c *MockImageWidget_SetVexpand_Call) Return() *MockImageWidget_SetVexpand_Call {
10193	_c.Call.Return()
10194	return _c
10195}
10196
10197func (_c *MockImageWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
10198	_c.Run(run)
10199	return _c
10200}
10201
10202// SetVisible provides a mock function for the type MockImageWidget
10203func (_mock *MockImageWidget) SetVisible(visible bool) {
10204	_mock.Called(visible)
10205	return
10206}
10207
10208// MockImageWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
10209type MockImageWidget_SetVisible_Call struct {
10210	*mock.Call
10211}
10212
10213// SetVisible is a helper method to define mock.On call
10214//   - visible bool
10215func (_e *MockImageWidget_Expecter) SetVisible(visible interface{}) *MockImageWidget_SetVisible_Call {
10216	return &MockImageWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
10217}
10218
10219func (_c *MockImageWidget_SetVisible_Call) Run(run func(visible bool)) *MockImageWidget_SetVisible_Call {
10220	_c.Call.Run(func(args mock.Arguments) {
10221		var arg0 bool
10222		if args[0] != nil {
10223			arg0 = args[0].(bool)
10224		}
10225		run(
10226			arg0,
10227		)
10228	})
10229	return _c
10230}
10231
10232func (_c *MockImageWidget_SetVisible_Call) Return() *MockImageWidget_SetVisible_Call {
10233	_c.Call.Return()
10234	return _c
10235}
10236
10237func (_c *MockImageWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockImageWidget_SetVisible_Call {
10238	_c.Run(run)
10239	return _c
10240}
10241
10242// Show provides a mock function for the type MockImageWidget
10243func (_mock *MockImageWidget) Show() {
10244	_mock.Called()
10245	return
10246}
10247
10248// MockImageWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
10249type MockImageWidget_Show_Call struct {
10250	*mock.Call
10251}
10252
10253// Show is a helper method to define mock.On call
10254func (_e *MockImageWidget_Expecter) Show() *MockImageWidget_Show_Call {
10255	return &MockImageWidget_Show_Call{Call: _e.mock.On("Show")}
10256}
10257
10258func (_c *MockImageWidget_Show_Call) Run(run func()) *MockImageWidget_Show_Call {
10259	_c.Call.Run(func(args mock.Arguments) {
10260		run()
10261	})
10262	return _c
10263}
10264
10265func (_c *MockImageWidget_Show_Call) Return() *MockImageWidget_Show_Call {
10266	_c.Call.Return()
10267	return _c
10268}
10269
10270func (_c *MockImageWidget_Show_Call) RunAndReturn(run func()) *MockImageWidget_Show_Call {
10271	_c.Run(run)
10272	return _c
10273}
10274
10275// Unparent provides a mock function for the type MockImageWidget
10276func (_mock *MockImageWidget) Unparent() {
10277	_mock.Called()
10278	return
10279}
10280
10281// MockImageWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
10282type MockImageWidget_Unparent_Call struct {
10283	*mock.Call
10284}
10285
10286// Unparent is a helper method to define mock.On call
10287func (_e *MockImageWidget_Expecter) Unparent() *MockImageWidget_Unparent_Call {
10288	return &MockImageWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
10289}
10290
10291func (_c *MockImageWidget_Unparent_Call) Run(run func()) *MockImageWidget_Unparent_Call {
10292	_c.Call.Run(func(args mock.Arguments) {
10293		run()
10294	})
10295	return _c
10296}
10297
10298func (_c *MockImageWidget_Unparent_Call) Return() *MockImageWidget_Unparent_Call {
10299	_c.Call.Return()
10300	return _c
10301}
10302
10303func (_c *MockImageWidget_Unparent_Call) RunAndReturn(run func()) *MockImageWidget_Unparent_Call {
10304	_c.Run(run)
10305	return _c
10306}
10307
10308// NewMockProgressBarWidget creates a new instance of MockProgressBarWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10309// The first argument is typically a *testing.T value.
10310func NewMockProgressBarWidget(t interface {
10311	mock.TestingT
10312	Cleanup(func())
10313}) *MockProgressBarWidget {
10314	mock := &MockProgressBarWidget{}
10315	mock.Mock.Test(t)
10316
10317	t.Cleanup(func() { mock.AssertExpectations(t) })
10318
10319	return mock
10320}
10321
10322// MockProgressBarWidget is an autogenerated mock type for the ProgressBarWidget type
10323type MockProgressBarWidget struct {
10324	mock.Mock
10325}
10326
10327type MockProgressBarWidget_Expecter struct {
10328	mock *mock.Mock
10329}
10330
10331func (_m *MockProgressBarWidget) EXPECT() *MockProgressBarWidget_Expecter {
10332	return &MockProgressBarWidget_Expecter{mock: &_m.Mock}
10333}
10334
10335// AddController provides a mock function for the type MockProgressBarWidget
10336func (_mock *MockProgressBarWidget) AddController(controller *gtk.EventController) {
10337	_mock.Called(controller)
10338	return
10339}
10340
10341// MockProgressBarWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
10342type MockProgressBarWidget_AddController_Call struct {
10343	*mock.Call
10344}
10345
10346// AddController is a helper method to define mock.On call
10347//   - controller *gtk.EventController
10348func (_e *MockProgressBarWidget_Expecter) AddController(controller interface{}) *MockProgressBarWidget_AddController_Call {
10349	return &MockProgressBarWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
10350}
10351
10352func (_c *MockProgressBarWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
10353	_c.Call.Run(func(args mock.Arguments) {
10354		var arg0 *gtk.EventController
10355		if args[0] != nil {
10356			arg0 = args[0].(*gtk.EventController)
10357		}
10358		run(
10359			arg0,
10360		)
10361	})
10362	return _c
10363}
10364
10365func (_c *MockProgressBarWidget_AddController_Call) Return() *MockProgressBarWidget_AddController_Call {
10366	_c.Call.Return()
10367	return _c
10368}
10369
10370func (_c *MockProgressBarWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
10371	_c.Run(run)
10372	return _c
10373}
10374
10375// AddCssClass provides a mock function for the type MockProgressBarWidget
10376func (_mock *MockProgressBarWidget) AddCssClass(cssClass string) {
10377	_mock.Called(cssClass)
10378	return
10379}
10380
10381// MockProgressBarWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
10382type MockProgressBarWidget_AddCssClass_Call struct {
10383	*mock.Call
10384}
10385
10386// AddCssClass is a helper method to define mock.On call
10387//   - cssClass string
10388func (_e *MockProgressBarWidget_Expecter) AddCssClass(cssClass interface{}) *MockProgressBarWidget_AddCssClass_Call {
10389	return &MockProgressBarWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
10390}
10391
10392func (_c *MockProgressBarWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
10393	_c.Call.Run(func(args mock.Arguments) {
10394		var arg0 string
10395		if args[0] != nil {
10396			arg0 = args[0].(string)
10397		}
10398		run(
10399			arg0,
10400		)
10401	})
10402	return _c
10403}
10404
10405func (_c *MockProgressBarWidget_AddCssClass_Call) Return() *MockProgressBarWidget_AddCssClass_Call {
10406	_c.Call.Return()
10407	return _c
10408}
10409
10410func (_c *MockProgressBarWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
10411	_c.Run(run)
10412	return _c
10413}
10414
10415// ComputePoint provides a mock function for the type MockProgressBarWidget
10416func (_mock *MockProgressBarWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
10417	ret := _mock.Called(target)
10418
10419	if len(ret) == 0 {
10420		panic("no return value specified for ComputePoint")
10421	}
10422
10423	var r0 float64
10424	var r1 float64
10425	var r2 bool
10426	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
10427		return returnFunc(target)
10428	}
10429	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
10430		r0 = returnFunc(target)
10431	} else {
10432		r0 = ret.Get(0).(float64)
10433	}
10434	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
10435		r1 = returnFunc(target)
10436	} else {
10437		r1 = ret.Get(1).(float64)
10438	}
10439	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
10440		r2 = returnFunc(target)
10441	} else {
10442		r2 = ret.Get(2).(bool)
10443	}
10444	return r0, r1, r2
10445}
10446
10447// MockProgressBarWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
10448type MockProgressBarWidget_ComputePoint_Call struct {
10449	*mock.Call
10450}
10451
10452// ComputePoint is a helper method to define mock.On call
10453//   - target layout.Widget
10454func (_e *MockProgressBarWidget_Expecter) ComputePoint(target interface{}) *MockProgressBarWidget_ComputePoint_Call {
10455	return &MockProgressBarWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
10456}
10457
10458func (_c *MockProgressBarWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockProgressBarWidget_ComputePoint_Call {
10459	_c.Call.Run(func(args mock.Arguments) {
10460		var arg0 layout.Widget
10461		if args[0] != nil {
10462			arg0 = args[0].(layout.Widget)
10463		}
10464		run(
10465			arg0,
10466		)
10467	})
10468	return _c
10469}
10470
10471func (_c *MockProgressBarWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockProgressBarWidget_ComputePoint_Call {
10472	_c.Call.Return(x, y, ok)
10473	return _c
10474}
10475
10476func (_c *MockProgressBarWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockProgressBarWidget_ComputePoint_Call {
10477	_c.Call.Return(run)
10478	return _c
10479}
10480
10481// GetAllocatedHeight provides a mock function for the type MockProgressBarWidget
10482func (_mock *MockProgressBarWidget) GetAllocatedHeight() int {
10483	ret := _mock.Called()
10484
10485	if len(ret) == 0 {
10486		panic("no return value specified for GetAllocatedHeight")
10487	}
10488
10489	var r0 int
10490	if returnFunc, ok := ret.Get(0).(func() int); ok {
10491		r0 = returnFunc()
10492	} else {
10493		r0 = ret.Get(0).(int)
10494	}
10495	return r0
10496}
10497
10498// MockProgressBarWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
10499type MockProgressBarWidget_GetAllocatedHeight_Call struct {
10500	*mock.Call
10501}
10502
10503// GetAllocatedHeight is a helper method to define mock.On call
10504func (_e *MockProgressBarWidget_Expecter) GetAllocatedHeight() *MockProgressBarWidget_GetAllocatedHeight_Call {
10505	return &MockProgressBarWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
10506}
10507
10508func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedHeight_Call {
10509	_c.Call.Run(func(args mock.Arguments) {
10510		run()
10511	})
10512	return _c
10513}
10514
10515func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Return(n int) *MockProgressBarWidget_GetAllocatedHeight_Call {
10516	_c.Call.Return(n)
10517	return _c
10518}
10519
10520func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedHeight_Call {
10521	_c.Call.Return(run)
10522	return _c
10523}
10524
10525// GetAllocatedWidth provides a mock function for the type MockProgressBarWidget
10526func (_mock *MockProgressBarWidget) GetAllocatedWidth() int {
10527	ret := _mock.Called()
10528
10529	if len(ret) == 0 {
10530		panic("no return value specified for GetAllocatedWidth")
10531	}
10532
10533	var r0 int
10534	if returnFunc, ok := ret.Get(0).(func() int); ok {
10535		r0 = returnFunc()
10536	} else {
10537		r0 = ret.Get(0).(int)
10538	}
10539	return r0
10540}
10541
10542// MockProgressBarWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
10543type MockProgressBarWidget_GetAllocatedWidth_Call struct {
10544	*mock.Call
10545}
10546
10547// GetAllocatedWidth is a helper method to define mock.On call
10548func (_e *MockProgressBarWidget_Expecter) GetAllocatedWidth() *MockProgressBarWidget_GetAllocatedWidth_Call {
10549	return &MockProgressBarWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
10550}
10551
10552func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedWidth_Call {
10553	_c.Call.Run(func(args mock.Arguments) {
10554		run()
10555	})
10556	return _c
10557}
10558
10559func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Return(n int) *MockProgressBarWidget_GetAllocatedWidth_Call {
10560	_c.Call.Return(n)
10561	return _c
10562}
10563
10564func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedWidth_Call {
10565	_c.Call.Return(run)
10566	return _c
10567}
10568
10569// GetFraction provides a mock function for the type MockProgressBarWidget
10570func (_mock *MockProgressBarWidget) GetFraction() float64 {
10571	ret := _mock.Called()
10572
10573	if len(ret) == 0 {
10574		panic("no return value specified for GetFraction")
10575	}
10576
10577	var r0 float64
10578	if returnFunc, ok := ret.Get(0).(func() float64); ok {
10579		r0 = returnFunc()
10580	} else {
10581		r0 = ret.Get(0).(float64)
10582	}
10583	return r0
10584}
10585
10586// MockProgressBarWidget_GetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFraction'
10587type MockProgressBarWidget_GetFraction_Call struct {
10588	*mock.Call
10589}
10590
10591// GetFraction is a helper method to define mock.On call
10592func (_e *MockProgressBarWidget_Expecter) GetFraction() *MockProgressBarWidget_GetFraction_Call {
10593	return &MockProgressBarWidget_GetFraction_Call{Call: _e.mock.On("GetFraction")}
10594}
10595
10596func (_c *MockProgressBarWidget_GetFraction_Call) Run(run func()) *MockProgressBarWidget_GetFraction_Call {
10597	_c.Call.Run(func(args mock.Arguments) {
10598		run()
10599	})
10600	return _c
10601}
10602
10603func (_c *MockProgressBarWidget_GetFraction_Call) Return(f float64) *MockProgressBarWidget_GetFraction_Call {
10604	_c.Call.Return(f)
10605	return _c
10606}
10607
10608func (_c *MockProgressBarWidget_GetFraction_Call) RunAndReturn(run func() float64) *MockProgressBarWidget_GetFraction_Call {
10609	_c.Call.Return(run)
10610	return _c
10611}
10612
10613// GetHexpand provides a mock function for the type MockProgressBarWidget
10614func (_mock *MockProgressBarWidget) GetHexpand() bool {
10615	ret := _mock.Called()
10616
10617	if len(ret) == 0 {
10618		panic("no return value specified for GetHexpand")
10619	}
10620
10621	var r0 bool
10622	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10623		r0 = returnFunc()
10624	} else {
10625		r0 = ret.Get(0).(bool)
10626	}
10627	return r0
10628}
10629
10630// MockProgressBarWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
10631type MockProgressBarWidget_GetHexpand_Call struct {
10632	*mock.Call
10633}
10634
10635// GetHexpand is a helper method to define mock.On call
10636func (_e *MockProgressBarWidget_Expecter) GetHexpand() *MockProgressBarWidget_GetHexpand_Call {
10637	return &MockProgressBarWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
10638}
10639
10640func (_c *MockProgressBarWidget_GetHexpand_Call) Run(run func()) *MockProgressBarWidget_GetHexpand_Call {
10641	_c.Call.Run(func(args mock.Arguments) {
10642		run()
10643	})
10644	return _c
10645}
10646
10647func (_c *MockProgressBarWidget_GetHexpand_Call) Return(b bool) *MockProgressBarWidget_GetHexpand_Call {
10648	_c.Call.Return(b)
10649	return _c
10650}
10651
10652func (_c *MockProgressBarWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetHexpand_Call {
10653	_c.Call.Return(run)
10654	return _c
10655}
10656
10657// GetParent provides a mock function for the type MockProgressBarWidget
10658func (_mock *MockProgressBarWidget) GetParent() layout.Widget {
10659	ret := _mock.Called()
10660
10661	if len(ret) == 0 {
10662		panic("no return value specified for GetParent")
10663	}
10664
10665	var r0 layout.Widget
10666	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
10667		r0 = returnFunc()
10668	} else {
10669		if ret.Get(0) != nil {
10670			r0 = ret.Get(0).(layout.Widget)
10671		}
10672	}
10673	return r0
10674}
10675
10676// MockProgressBarWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
10677type MockProgressBarWidget_GetParent_Call struct {
10678	*mock.Call
10679}
10680
10681// GetParent is a helper method to define mock.On call
10682func (_e *MockProgressBarWidget_Expecter) GetParent() *MockProgressBarWidget_GetParent_Call {
10683	return &MockProgressBarWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
10684}
10685
10686func (_c *MockProgressBarWidget_GetParent_Call) Run(run func()) *MockProgressBarWidget_GetParent_Call {
10687	_c.Call.Run(func(args mock.Arguments) {
10688		run()
10689	})
10690	return _c
10691}
10692
10693func (_c *MockProgressBarWidget_GetParent_Call) Return(widget layout.Widget) *MockProgressBarWidget_GetParent_Call {
10694	_c.Call.Return(widget)
10695	return _c
10696}
10697
10698func (_c *MockProgressBarWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockProgressBarWidget_GetParent_Call {
10699	_c.Call.Return(run)
10700	return _c
10701}
10702
10703// GetVexpand provides a mock function for the type MockProgressBarWidget
10704func (_mock *MockProgressBarWidget) GetVexpand() bool {
10705	ret := _mock.Called()
10706
10707	if len(ret) == 0 {
10708		panic("no return value specified for GetVexpand")
10709	}
10710
10711	var r0 bool
10712	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10713		r0 = returnFunc()
10714	} else {
10715		r0 = ret.Get(0).(bool)
10716	}
10717	return r0
10718}
10719
10720// MockProgressBarWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
10721type MockProgressBarWidget_GetVexpand_Call struct {
10722	*mock.Call
10723}
10724
10725// GetVexpand is a helper method to define mock.On call
10726func (_e *MockProgressBarWidget_Expecter) GetVexpand() *MockProgressBarWidget_GetVexpand_Call {
10727	return &MockProgressBarWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
10728}
10729
10730func (_c *MockProgressBarWidget_GetVexpand_Call) Run(run func()) *MockProgressBarWidget_GetVexpand_Call {
10731	_c.Call.Run(func(args mock.Arguments) {
10732		run()
10733	})
10734	return _c
10735}
10736
10737func (_c *MockProgressBarWidget_GetVexpand_Call) Return(b bool) *MockProgressBarWidget_GetVexpand_Call {
10738	_c.Call.Return(b)
10739	return _c
10740}
10741
10742func (_c *MockProgressBarWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetVexpand_Call {
10743	_c.Call.Return(run)
10744	return _c
10745}
10746
10747// GrabFocus provides a mock function for the type MockProgressBarWidget
10748func (_mock *MockProgressBarWidget) GrabFocus() bool {
10749	ret := _mock.Called()
10750
10751	if len(ret) == 0 {
10752		panic("no return value specified for GrabFocus")
10753	}
10754
10755	var r0 bool
10756	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10757		r0 = returnFunc()
10758	} else {
10759		r0 = ret.Get(0).(bool)
10760	}
10761	return r0
10762}
10763
10764// MockProgressBarWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
10765type MockProgressBarWidget_GrabFocus_Call struct {
10766	*mock.Call
10767}
10768
10769// GrabFocus is a helper method to define mock.On call
10770func (_e *MockProgressBarWidget_Expecter) GrabFocus() *MockProgressBarWidget_GrabFocus_Call {
10771	return &MockProgressBarWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
10772}
10773
10774func (_c *MockProgressBarWidget_GrabFocus_Call) Run(run func()) *MockProgressBarWidget_GrabFocus_Call {
10775	_c.Call.Run(func(args mock.Arguments) {
10776		run()
10777	})
10778	return _c
10779}
10780
10781func (_c *MockProgressBarWidget_GrabFocus_Call) Return(b bool) *MockProgressBarWidget_GrabFocus_Call {
10782	_c.Call.Return(b)
10783	return _c
10784}
10785
10786func (_c *MockProgressBarWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GrabFocus_Call {
10787	_c.Call.Return(run)
10788	return _c
10789}
10790
10791// GtkWidget provides a mock function for the type MockProgressBarWidget
10792func (_mock *MockProgressBarWidget) GtkWidget() *gtk.Widget {
10793	ret := _mock.Called()
10794
10795	if len(ret) == 0 {
10796		panic("no return value specified for GtkWidget")
10797	}
10798
10799	var r0 *gtk.Widget
10800	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
10801		r0 = returnFunc()
10802	} else {
10803		if ret.Get(0) != nil {
10804			r0 = ret.Get(0).(*gtk.Widget)
10805		}
10806	}
10807	return r0
10808}
10809
10810// MockProgressBarWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
10811type MockProgressBarWidget_GtkWidget_Call struct {
10812	*mock.Call
10813}
10814
10815// GtkWidget is a helper method to define mock.On call
10816func (_e *MockProgressBarWidget_Expecter) GtkWidget() *MockProgressBarWidget_GtkWidget_Call {
10817	return &MockProgressBarWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
10818}
10819
10820func (_c *MockProgressBarWidget_GtkWidget_Call) Run(run func()) *MockProgressBarWidget_GtkWidget_Call {
10821	_c.Call.Run(func(args mock.Arguments) {
10822		run()
10823	})
10824	return _c
10825}
10826
10827func (_c *MockProgressBarWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
10828	_c.Call.Return(widget)
10829	return _c
10830}
10831
10832func (_c *MockProgressBarWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
10833	_c.Call.Return(run)
10834	return _c
10835}
10836
10837// HasCssClass provides a mock function for the type MockProgressBarWidget
10838func (_mock *MockProgressBarWidget) HasCssClass(cssClass string) bool {
10839	ret := _mock.Called(cssClass)
10840
10841	if len(ret) == 0 {
10842		panic("no return value specified for HasCssClass")
10843	}
10844
10845	var r0 bool
10846	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
10847		r0 = returnFunc(cssClass)
10848	} else {
10849		r0 = ret.Get(0).(bool)
10850	}
10851	return r0
10852}
10853
10854// MockProgressBarWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
10855type MockProgressBarWidget_HasCssClass_Call struct {
10856	*mock.Call
10857}
10858
10859// HasCssClass is a helper method to define mock.On call
10860//   - cssClass string
10861func (_e *MockProgressBarWidget_Expecter) HasCssClass(cssClass interface{}) *MockProgressBarWidget_HasCssClass_Call {
10862	return &MockProgressBarWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
10863}
10864
10865func (_c *MockProgressBarWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_HasCssClass_Call {
10866	_c.Call.Run(func(args mock.Arguments) {
10867		var arg0 string
10868		if args[0] != nil {
10869			arg0 = args[0].(string)
10870		}
10871		run(
10872			arg0,
10873		)
10874	})
10875	return _c
10876}
10877
10878func (_c *MockProgressBarWidget_HasCssClass_Call) Return(b bool) *MockProgressBarWidget_HasCssClass_Call {
10879	_c.Call.Return(b)
10880	return _c
10881}
10882
10883func (_c *MockProgressBarWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockProgressBarWidget_HasCssClass_Call {
10884	_c.Call.Return(run)
10885	return _c
10886}
10887
10888// HasFocus provides a mock function for the type MockProgressBarWidget
10889func (_mock *MockProgressBarWidget) HasFocus() bool {
10890	ret := _mock.Called()
10891
10892	if len(ret) == 0 {
10893		panic("no return value specified for HasFocus")
10894	}
10895
10896	var r0 bool
10897	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10898		r0 = returnFunc()
10899	} else {
10900		r0 = ret.Get(0).(bool)
10901	}
10902	return r0
10903}
10904
10905// MockProgressBarWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
10906type MockProgressBarWidget_HasFocus_Call struct {
10907	*mock.Call
10908}
10909
10910// HasFocus is a helper method to define mock.On call
10911func (_e *MockProgressBarWidget_Expecter) HasFocus() *MockProgressBarWidget_HasFocus_Call {
10912	return &MockProgressBarWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
10913}
10914
10915func (_c *MockProgressBarWidget_HasFocus_Call) Run(run func()) *MockProgressBarWidget_HasFocus_Call {
10916	_c.Call.Run(func(args mock.Arguments) {
10917		run()
10918	})
10919	return _c
10920}
10921
10922func (_c *MockProgressBarWidget_HasFocus_Call) Return(b bool) *MockProgressBarWidget_HasFocus_Call {
10923	_c.Call.Return(b)
10924	return _c
10925}
10926
10927func (_c *MockProgressBarWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_HasFocus_Call {
10928	_c.Call.Return(run)
10929	return _c
10930}
10931
10932// Hide provides a mock function for the type MockProgressBarWidget
10933func (_mock *MockProgressBarWidget) Hide() {
10934	_mock.Called()
10935	return
10936}
10937
10938// MockProgressBarWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
10939type MockProgressBarWidget_Hide_Call struct {
10940	*mock.Call
10941}
10942
10943// Hide is a helper method to define mock.On call
10944func (_e *MockProgressBarWidget_Expecter) Hide() *MockProgressBarWidget_Hide_Call {
10945	return &MockProgressBarWidget_Hide_Call{Call: _e.mock.On("Hide")}
10946}
10947
10948func (_c *MockProgressBarWidget_Hide_Call) Run(run func()) *MockProgressBarWidget_Hide_Call {
10949	_c.Call.Run(func(args mock.Arguments) {
10950		run()
10951	})
10952	return _c
10953}
10954
10955func (_c *MockProgressBarWidget_Hide_Call) Return() *MockProgressBarWidget_Hide_Call {
10956	_c.Call.Return()
10957	return _c
10958}
10959
10960func (_c *MockProgressBarWidget_Hide_Call) RunAndReturn(run func()) *MockProgressBarWidget_Hide_Call {
10961	_c.Run(run)
10962	return _c
10963}
10964
10965// IsVisible provides a mock function for the type MockProgressBarWidget
10966func (_mock *MockProgressBarWidget) IsVisible() bool {
10967	ret := _mock.Called()
10968
10969	if len(ret) == 0 {
10970		panic("no return value specified for IsVisible")
10971	}
10972
10973	var r0 bool
10974	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10975		r0 = returnFunc()
10976	} else {
10977		r0 = ret.Get(0).(bool)
10978	}
10979	return r0
10980}
10981
10982// MockProgressBarWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
10983type MockProgressBarWidget_IsVisible_Call struct {
10984	*mock.Call
10985}
10986
10987// IsVisible is a helper method to define mock.On call
10988func (_e *MockProgressBarWidget_Expecter) IsVisible() *MockProgressBarWidget_IsVisible_Call {
10989	return &MockProgressBarWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
10990}
10991
10992func (_c *MockProgressBarWidget_IsVisible_Call) Run(run func()) *MockProgressBarWidget_IsVisible_Call {
10993	_c.Call.Run(func(args mock.Arguments) {
10994		run()
10995	})
10996	return _c
10997}
10998
10999func (_c *MockProgressBarWidget_IsVisible_Call) Return(b bool) *MockProgressBarWidget_IsVisible_Call {
11000	_c.Call.Return(b)
11001	return _c
11002}
11003
11004func (_c *MockProgressBarWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_IsVisible_Call {
11005	_c.Call.Return(run)
11006	return _c
11007}
11008
11009// RemoveCssClass provides a mock function for the type MockProgressBarWidget
11010func (_mock *MockProgressBarWidget) RemoveCssClass(cssClass string) {
11011	_mock.Called(cssClass)
11012	return
11013}
11014
11015// MockProgressBarWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
11016type MockProgressBarWidget_RemoveCssClass_Call struct {
11017	*mock.Call
11018}
11019
11020// RemoveCssClass is a helper method to define mock.On call
11021//   - cssClass string
11022func (_e *MockProgressBarWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockProgressBarWidget_RemoveCssClass_Call {
11023	return &MockProgressBarWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
11024}
11025
11026func (_c *MockProgressBarWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
11027	_c.Call.Run(func(args mock.Arguments) {
11028		var arg0 string
11029		if args[0] != nil {
11030			arg0 = args[0].(string)
11031		}
11032		run(
11033			arg0,
11034		)
11035	})
11036	return _c
11037}
11038
11039func (_c *MockProgressBarWidget_RemoveCssClass_Call) Return() *MockProgressBarWidget_RemoveCssClass_Call {
11040	_c.Call.Return()
11041	return _c
11042}
11043
11044func (_c *MockProgressBarWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
11045	_c.Run(run)
11046	return _c
11047}
11048
11049// SetCanFocus provides a mock function for the type MockProgressBarWidget
11050func (_mock *MockProgressBarWidget) SetCanFocus(canFocus bool) {
11051	_mock.Called(canFocus)
11052	return
11053}
11054
11055// MockProgressBarWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
11056type MockProgressBarWidget_SetCanFocus_Call struct {
11057	*mock.Call
11058}
11059
11060// SetCanFocus is a helper method to define mock.On call
11061//   - canFocus bool
11062func (_e *MockProgressBarWidget_Expecter) SetCanFocus(canFocus interface{}) *MockProgressBarWidget_SetCanFocus_Call {
11063	return &MockProgressBarWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
11064}
11065
11066func (_c *MockProgressBarWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
11067	_c.Call.Run(func(args mock.Arguments) {
11068		var arg0 bool
11069		if args[0] != nil {
11070			arg0 = args[0].(bool)
11071		}
11072		run(
11073			arg0,
11074		)
11075	})
11076	return _c
11077}
11078
11079func (_c *MockProgressBarWidget_SetCanFocus_Call) Return() *MockProgressBarWidget_SetCanFocus_Call {
11080	_c.Call.Return()
11081	return _c
11082}
11083
11084func (_c *MockProgressBarWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
11085	_c.Run(run)
11086	return _c
11087}
11088
11089// SetCanTarget provides a mock function for the type MockProgressBarWidget
11090func (_mock *MockProgressBarWidget) SetCanTarget(canTarget bool) {
11091	_mock.Called(canTarget)
11092	return
11093}
11094
11095// MockProgressBarWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
11096type MockProgressBarWidget_SetCanTarget_Call struct {
11097	*mock.Call
11098}
11099
11100// SetCanTarget is a helper method to define mock.On call
11101//   - canTarget bool
11102func (_e *MockProgressBarWidget_Expecter) SetCanTarget(canTarget interface{}) *MockProgressBarWidget_SetCanTarget_Call {
11103	return &MockProgressBarWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
11104}
11105
11106func (_c *MockProgressBarWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
11107	_c.Call.Run(func(args mock.Arguments) {
11108		var arg0 bool
11109		if args[0] != nil {
11110			arg0 = args[0].(bool)
11111		}
11112		run(
11113			arg0,
11114		)
11115	})
11116	return _c
11117}
11118
11119func (_c *MockProgressBarWidget_SetCanTarget_Call) Return() *MockProgressBarWidget_SetCanTarget_Call {
11120	_c.Call.Return()
11121	return _c
11122}
11123
11124func (_c *MockProgressBarWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
11125	_c.Run(run)
11126	return _c
11127}
11128
11129// SetFocusOnClick provides a mock function for the type MockProgressBarWidget
11130func (_mock *MockProgressBarWidget) SetFocusOnClick(focusOnClick bool) {
11131	_mock.Called(focusOnClick)
11132	return
11133}
11134
11135// MockProgressBarWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
11136type MockProgressBarWidget_SetFocusOnClick_Call struct {
11137	*mock.Call
11138}
11139
11140// SetFocusOnClick is a helper method to define mock.On call
11141//   - focusOnClick bool
11142func (_e *MockProgressBarWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockProgressBarWidget_SetFocusOnClick_Call {
11143	return &MockProgressBarWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
11144}
11145
11146func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
11147	_c.Call.Run(func(args mock.Arguments) {
11148		var arg0 bool
11149		if args[0] != nil {
11150			arg0 = args[0].(bool)
11151		}
11152		run(
11153			arg0,
11154		)
11155	})
11156	return _c
11157}
11158
11159func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Return() *MockProgressBarWidget_SetFocusOnClick_Call {
11160	_c.Call.Return()
11161	return _c
11162}
11163
11164func (_c *MockProgressBarWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
11165	_c.Run(run)
11166	return _c
11167}
11168
11169// SetFraction provides a mock function for the type MockProgressBarWidget
11170func (_mock *MockProgressBarWidget) SetFraction(fraction float64) {
11171	_mock.Called(fraction)
11172	return
11173}
11174
11175// MockProgressBarWidget_SetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFraction'
11176type MockProgressBarWidget_SetFraction_Call struct {
11177	*mock.Call
11178}
11179
11180// SetFraction is a helper method to define mock.On call
11181//   - fraction float64
11182func (_e *MockProgressBarWidget_Expecter) SetFraction(fraction interface{}) *MockProgressBarWidget_SetFraction_Call {
11183	return &MockProgressBarWidget_SetFraction_Call{Call: _e.mock.On("SetFraction", fraction)}
11184}
11185
11186func (_c *MockProgressBarWidget_SetFraction_Call) Run(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
11187	_c.Call.Run(func(args mock.Arguments) {
11188		var arg0 float64
11189		if args[0] != nil {
11190			arg0 = args[0].(float64)
11191		}
11192		run(
11193			arg0,
11194		)
11195	})
11196	return _c
11197}
11198
11199func (_c *MockProgressBarWidget_SetFraction_Call) Return() *MockProgressBarWidget_SetFraction_Call {
11200	_c.Call.Return()
11201	return _c
11202}
11203
11204func (_c *MockProgressBarWidget_SetFraction_Call) RunAndReturn(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
11205	_c.Run(run)
11206	return _c
11207}
11208
11209// SetHalign provides a mock function for the type MockProgressBarWidget
11210func (_mock *MockProgressBarWidget) SetHalign(align gtk.Align) {
11211	_mock.Called(align)
11212	return
11213}
11214
11215// MockProgressBarWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
11216type MockProgressBarWidget_SetHalign_Call struct {
11217	*mock.Call
11218}
11219
11220// SetHalign is a helper method to define mock.On call
11221//   - align gtk.Align
11222func (_e *MockProgressBarWidget_Expecter) SetHalign(align interface{}) *MockProgressBarWidget_SetHalign_Call {
11223	return &MockProgressBarWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
11224}
11225
11226func (_c *MockProgressBarWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
11227	_c.Call.Run(func(args mock.Arguments) {
11228		var arg0 gtk.Align
11229		if args[0] != nil {
11230			arg0 = args[0].(gtk.Align)
11231		}
11232		run(
11233			arg0,
11234		)
11235	})
11236	return _c
11237}
11238
11239func (_c *MockProgressBarWidget_SetHalign_Call) Return() *MockProgressBarWidget_SetHalign_Call {
11240	_c.Call.Return()
11241	return _c
11242}
11243
11244func (_c *MockProgressBarWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
11245	_c.Run(run)
11246	return _c
11247}
11248
11249// SetHexpand provides a mock function for the type MockProgressBarWidget
11250func (_mock *MockProgressBarWidget) SetHexpand(expand bool) {
11251	_mock.Called(expand)
11252	return
11253}
11254
11255// MockProgressBarWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
11256type MockProgressBarWidget_SetHexpand_Call struct {
11257	*mock.Call
11258}
11259
11260// SetHexpand is a helper method to define mock.On call
11261//   - expand bool
11262func (_e *MockProgressBarWidget_Expecter) SetHexpand(expand interface{}) *MockProgressBarWidget_SetHexpand_Call {
11263	return &MockProgressBarWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
11264}
11265
11266func (_c *MockProgressBarWidget_SetHexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
11267	_c.Call.Run(func(args mock.Arguments) {
11268		var arg0 bool
11269		if args[0] != nil {
11270			arg0 = args[0].(bool)
11271		}
11272		run(
11273			arg0,
11274		)
11275	})
11276	return _c
11277}
11278
11279func (_c *MockProgressBarWidget_SetHexpand_Call) Return() *MockProgressBarWidget_SetHexpand_Call {
11280	_c.Call.Return()
11281	return _c
11282}
11283
11284func (_c *MockProgressBarWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
11285	_c.Run(run)
11286	return _c
11287}
11288
11289// SetSizeRequest provides a mock function for the type MockProgressBarWidget
11290func (_mock *MockProgressBarWidget) SetSizeRequest(width int, height int) {
11291	_mock.Called(width, height)
11292	return
11293}
11294
11295// MockProgressBarWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
11296type MockProgressBarWidget_SetSizeRequest_Call struct {
11297	*mock.Call
11298}
11299
11300// SetSizeRequest is a helper method to define mock.On call
11301//   - width int
11302//   - height int
11303func (_e *MockProgressBarWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockProgressBarWidget_SetSizeRequest_Call {
11304	return &MockProgressBarWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
11305}
11306
11307func (_c *MockProgressBarWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
11308	_c.Call.Run(func(args mock.Arguments) {
11309		var arg0 int
11310		if args[0] != nil {
11311			arg0 = args[0].(int)
11312		}
11313		var arg1 int
11314		if args[1] != nil {
11315			arg1 = args[1].(int)
11316		}
11317		run(
11318			arg0,
11319			arg1,
11320		)
11321	})
11322	return _c
11323}
11324
11325func (_c *MockProgressBarWidget_SetSizeRequest_Call) Return() *MockProgressBarWidget_SetSizeRequest_Call {
11326	_c.Call.Return()
11327	return _c
11328}
11329
11330func (_c *MockProgressBarWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
11331	_c.Run(run)
11332	return _c
11333}
11334
11335// SetValign provides a mock function for the type MockProgressBarWidget
11336func (_mock *MockProgressBarWidget) SetValign(align gtk.Align) {
11337	_mock.Called(align)
11338	return
11339}
11340
11341// MockProgressBarWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
11342type MockProgressBarWidget_SetValign_Call struct {
11343	*mock.Call
11344}
11345
11346// SetValign is a helper method to define mock.On call
11347//   - align gtk.Align
11348func (_e *MockProgressBarWidget_Expecter) SetValign(align interface{}) *MockProgressBarWidget_SetValign_Call {
11349	return &MockProgressBarWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
11350}
11351
11352func (_c *MockProgressBarWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
11353	_c.Call.Run(func(args mock.Arguments) {
11354		var arg0 gtk.Align
11355		if args[0] != nil {
11356			arg0 = args[0].(gtk.Align)
11357		}
11358		run(
11359			arg0,
11360		)
11361	})
11362	return _c
11363}
11364
11365func (_c *MockProgressBarWidget_SetValign_Call) Return() *MockProgressBarWidget_SetValign_Call {
11366	_c.Call.Return()
11367	return _c
11368}
11369
11370func (_c *MockProgressBarWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
11371	_c.Run(run)
11372	return _c
11373}
11374
11375// SetVexpand provides a mock function for the type MockProgressBarWidget
11376func (_mock *MockProgressBarWidget) SetVexpand(expand bool) {
11377	_mock.Called(expand)
11378	return
11379}
11380
11381// MockProgressBarWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
11382type MockProgressBarWidget_SetVexpand_Call struct {
11383	*mock.Call
11384}
11385
11386// SetVexpand is a helper method to define mock.On call
11387//   - expand bool
11388func (_e *MockProgressBarWidget_Expecter) SetVexpand(expand interface{}) *MockProgressBarWidget_SetVexpand_Call {
11389	return &MockProgressBarWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
11390}
11391
11392func (_c *MockProgressBarWidget_SetVexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
11393	_c.Call.Run(func(args mock.Arguments) {
11394		var arg0 bool
11395		if args[0] != nil {
11396			arg0 = args[0].(bool)
11397		}
11398		run(
11399			arg0,
11400		)
11401	})
11402	return _c
11403}
11404
11405func (_c *MockProgressBarWidget_SetVexpand_Call) Return() *MockProgressBarWidget_SetVexpand_Call {
11406	_c.Call.Return()
11407	return _c
11408}
11409
11410func (_c *MockProgressBarWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
11411	_c.Run(run)
11412	return _c
11413}
11414
11415// SetVisible provides a mock function for the type MockProgressBarWidget
11416func (_mock *MockProgressBarWidget) SetVisible(visible bool) {
11417	_mock.Called(visible)
11418	return
11419}
11420
11421// MockProgressBarWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
11422type MockProgressBarWidget_SetVisible_Call struct {
11423	*mock.Call
11424}
11425
11426// SetVisible is a helper method to define mock.On call
11427//   - visible bool
11428func (_e *MockProgressBarWidget_Expecter) SetVisible(visible interface{}) *MockProgressBarWidget_SetVisible_Call {
11429	return &MockProgressBarWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
11430}
11431
11432func (_c *MockProgressBarWidget_SetVisible_Call) Run(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
11433	_c.Call.Run(func(args mock.Arguments) {
11434		var arg0 bool
11435		if args[0] != nil {
11436			arg0 = args[0].(bool)
11437		}
11438		run(
11439			arg0,
11440		)
11441	})
11442	return _c
11443}
11444
11445func (_c *MockProgressBarWidget_SetVisible_Call) Return() *MockProgressBarWidget_SetVisible_Call {
11446	_c.Call.Return()
11447	return _c
11448}
11449
11450func (_c *MockProgressBarWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
11451	_c.Run(run)
11452	return _c
11453}
11454
11455// Show provides a mock function for the type MockProgressBarWidget
11456func (_mock *MockProgressBarWidget) Show() {
11457	_mock.Called()
11458	return
11459}
11460
11461// MockProgressBarWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
11462type MockProgressBarWidget_Show_Call struct {
11463	*mock.Call
11464}
11465
11466// Show is a helper method to define mock.On call
11467func (_e *MockProgressBarWidget_Expecter) Show() *MockProgressBarWidget_Show_Call {
11468	return &MockProgressBarWidget_Show_Call{Call: _e.mock.On("Show")}
11469}
11470
11471func (_c *MockProgressBarWidget_Show_Call) Run(run func()) *MockProgressBarWidget_Show_Call {
11472	_c.Call.Run(func(args mock.Arguments) {
11473		run()
11474	})
11475	return _c
11476}
11477
11478func (_c *MockProgressBarWidget_Show_Call) Return() *MockProgressBarWidget_Show_Call {
11479	_c.Call.Return()
11480	return _c
11481}
11482
11483func (_c *MockProgressBarWidget_Show_Call) RunAndReturn(run func()) *MockProgressBarWidget_Show_Call {
11484	_c.Run(run)
11485	return _c
11486}
11487
11488// Unparent provides a mock function for the type MockProgressBarWidget
11489func (_mock *MockProgressBarWidget) Unparent() {
11490	_mock.Called()
11491	return
11492}
11493
11494// MockProgressBarWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
11495type MockProgressBarWidget_Unparent_Call struct {
11496	*mock.Call
11497}
11498
11499// Unparent is a helper method to define mock.On call
11500func (_e *MockProgressBarWidget_Expecter) Unparent() *MockProgressBarWidget_Unparent_Call {
11501	return &MockProgressBarWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
11502}
11503
11504func (_c *MockProgressBarWidget_Unparent_Call) Run(run func()) *MockProgressBarWidget_Unparent_Call {
11505	_c.Call.Run(func(args mock.Arguments) {
11506		run()
11507	})
11508	return _c
11509}
11510
11511func (_c *MockProgressBarWidget_Unparent_Call) Return() *MockProgressBarWidget_Unparent_Call {
11512	_c.Call.Return()
11513	return _c
11514}
11515
11516func (_c *MockProgressBarWidget_Unparent_Call) RunAndReturn(run func()) *MockProgressBarWidget_Unparent_Call {
11517	_c.Run(run)
11518	return _c
11519}
11520
11521// 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.
11522// The first argument is typically a *testing.T value.
11523func NewMockWidgetFactory(t interface {
11524	mock.TestingT
11525	Cleanup(func())
11526}) *MockWidgetFactory {
11527	mock := &MockWidgetFactory{}
11528	mock.Mock.Test(t)
11529
11530	t.Cleanup(func() { mock.AssertExpectations(t) })
11531
11532	return mock
11533}
11534
11535// MockWidgetFactory is an autogenerated mock type for the WidgetFactory type
11536type MockWidgetFactory struct {
11537	mock.Mock
11538}
11539
11540type MockWidgetFactory_Expecter struct {
11541	mock *mock.Mock
11542}
11543
11544func (_m *MockWidgetFactory) EXPECT() *MockWidgetFactory_Expecter {
11545	return &MockWidgetFactory_Expecter{mock: &_m.Mock}
11546}
11547
11548// NewBox provides a mock function for the type MockWidgetFactory
11549func (_mock *MockWidgetFactory) NewBox(orientation layout.Orientation, spacing int) layout.BoxWidget {
11550	ret := _mock.Called(orientation, spacing)
11551
11552	if len(ret) == 0 {
11553		panic("no return value specified for NewBox")
11554	}
11555
11556	var r0 layout.BoxWidget
11557	if returnFunc, ok := ret.Get(0).(func(layout.Orientation, int) layout.BoxWidget); ok {
11558		r0 = returnFunc(orientation, spacing)
11559	} else {
11560		if ret.Get(0) != nil {
11561			r0 = ret.Get(0).(layout.BoxWidget)
11562		}
11563	}
11564	return r0
11565}
11566
11567// MockWidgetFactory_NewBox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBox'
11568type MockWidgetFactory_NewBox_Call struct {
11569	*mock.Call
11570}
11571
11572// NewBox is a helper method to define mock.On call
11573//   - orientation layout.Orientation
11574//   - spacing int
11575func (_e *MockWidgetFactory_Expecter) NewBox(orientation interface{}, spacing interface{}) *MockWidgetFactory_NewBox_Call {
11576	return &MockWidgetFactory_NewBox_Call{Call: _e.mock.On("NewBox", orientation, spacing)}
11577}
11578
11579func (_c *MockWidgetFactory_NewBox_Call) Run(run func(orientation layout.Orientation, spacing int)) *MockWidgetFactory_NewBox_Call {
11580	_c.Call.Run(func(args mock.Arguments) {
11581		var arg0 layout.Orientation
11582		if args[0] != nil {
11583			arg0 = args[0].(layout.Orientation)
11584		}
11585		var arg1 int
11586		if args[1] != nil {
11587			arg1 = args[1].(int)
11588		}
11589		run(
11590			arg0,
11591			arg1,
11592		)
11593	})
11594	return _c
11595}
11596
11597func (_c *MockWidgetFactory_NewBox_Call) Return(boxWidget layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
11598	_c.Call.Return(boxWidget)
11599	return _c
11600}
11601
11602func (_c *MockWidgetFactory_NewBox_Call) RunAndReturn(run func(orientation layout.Orientation, spacing int) layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
11603	_c.Call.Return(run)
11604	return _c
11605}
11606
11607// NewButton provides a mock function for the type MockWidgetFactory
11608func (_mock *MockWidgetFactory) NewButton() layout.ButtonWidget {
11609	ret := _mock.Called()
11610
11611	if len(ret) == 0 {
11612		panic("no return value specified for NewButton")
11613	}
11614
11615	var r0 layout.ButtonWidget
11616	if returnFunc, ok := ret.Get(0).(func() layout.ButtonWidget); ok {
11617		r0 = returnFunc()
11618	} else {
11619		if ret.Get(0) != nil {
11620			r0 = ret.Get(0).(layout.ButtonWidget)
11621		}
11622	}
11623	return r0
11624}
11625
11626// MockWidgetFactory_NewButton_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewButton'
11627type MockWidgetFactory_NewButton_Call struct {
11628	*mock.Call
11629}
11630
11631// NewButton is a helper method to define mock.On call
11632func (_e *MockWidgetFactory_Expecter) NewButton() *MockWidgetFactory_NewButton_Call {
11633	return &MockWidgetFactory_NewButton_Call{Call: _e.mock.On("NewButton")}
11634}
11635
11636func (_c *MockWidgetFactory_NewButton_Call) Run(run func()) *MockWidgetFactory_NewButton_Call {
11637	_c.Call.Run(func(args mock.Arguments) {
11638		run()
11639	})
11640	return _c
11641}
11642
11643func (_c *MockWidgetFactory_NewButton_Call) Return(buttonWidget layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
11644	_c.Call.Return(buttonWidget)
11645	return _c
11646}
11647
11648func (_c *MockWidgetFactory_NewButton_Call) RunAndReturn(run func() layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
11649	_c.Call.Return(run)
11650	return _c
11651}
11652
11653// NewImage provides a mock function for the type MockWidgetFactory
11654func (_mock *MockWidgetFactory) NewImage() layout.ImageWidget {
11655	ret := _mock.Called()
11656
11657	if len(ret) == 0 {
11658		panic("no return value specified for NewImage")
11659	}
11660
11661	var r0 layout.ImageWidget
11662	if returnFunc, ok := ret.Get(0).(func() layout.ImageWidget); ok {
11663		r0 = returnFunc()
11664	} else {
11665		if ret.Get(0) != nil {
11666			r0 = ret.Get(0).(layout.ImageWidget)
11667		}
11668	}
11669	return r0
11670}
11671
11672// MockWidgetFactory_NewImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewImage'
11673type MockWidgetFactory_NewImage_Call struct {
11674	*mock.Call
11675}
11676
11677// NewImage is a helper method to define mock.On call
11678func (_e *MockWidgetFactory_Expecter) NewImage() *MockWidgetFactory_NewImage_Call {
11679	return &MockWidgetFactory_NewImage_Call{Call: _e.mock.On("NewImage")}
11680}
11681
11682func (_c *MockWidgetFactory_NewImage_Call) Run(run func()) *MockWidgetFactory_NewImage_Call {
11683	_c.Call.Run(func(args mock.Arguments) {
11684		run()
11685	})
11686	return _c
11687}
11688
11689func (_c *MockWidgetFactory_NewImage_Call) Return(imageWidget layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
11690	_c.Call.Return(imageWidget)
11691	return _c
11692}
11693
11694func (_c *MockWidgetFactory_NewImage_Call) RunAndReturn(run func() layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
11695	_c.Call.Return(run)
11696	return _c
11697}
11698
11699// NewLabel provides a mock function for the type MockWidgetFactory
11700func (_mock *MockWidgetFactory) NewLabel(text string) layout.LabelWidget {
11701	ret := _mock.Called(text)
11702
11703	if len(ret) == 0 {
11704		panic("no return value specified for NewLabel")
11705	}
11706
11707	var r0 layout.LabelWidget
11708	if returnFunc, ok := ret.Get(0).(func(string) layout.LabelWidget); ok {
11709		r0 = returnFunc(text)
11710	} else {
11711		if ret.Get(0) != nil {
11712			r0 = ret.Get(0).(layout.LabelWidget)
11713		}
11714	}
11715	return r0
11716}
11717
11718// MockWidgetFactory_NewLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewLabel'
11719type MockWidgetFactory_NewLabel_Call struct {
11720	*mock.Call
11721}
11722
11723// NewLabel is a helper method to define mock.On call
11724//   - text string
11725func (_e *MockWidgetFactory_Expecter) NewLabel(text interface{}) *MockWidgetFactory_NewLabel_Call {
11726	return &MockWidgetFactory_NewLabel_Call{Call: _e.mock.On("NewLabel", text)}
11727}
11728
11729func (_c *MockWidgetFactory_NewLabel_Call) Run(run func(text string)) *MockWidgetFactory_NewLabel_Call {
11730	_c.Call.Run(func(args mock.Arguments) {
11731		var arg0 string
11732		if args[0] != nil {
11733			arg0 = args[0].(string)
11734		}
11735		run(
11736			arg0,
11737		)
11738	})
11739	return _c
11740}
11741
11742func (_c *MockWidgetFactory_NewLabel_Call) Return(labelWidget layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
11743	_c.Call.Return(labelWidget)
11744	return _c
11745}
11746
11747func (_c *MockWidgetFactory_NewLabel_Call) RunAndReturn(run func(text string) layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
11748	_c.Call.Return(run)
11749	return _c
11750}
11751
11752// NewOverlay provides a mock function for the type MockWidgetFactory
11753func (_mock *MockWidgetFactory) NewOverlay() layout.OverlayWidget {
11754	ret := _mock.Called()
11755
11756	if len(ret) == 0 {
11757		panic("no return value specified for NewOverlay")
11758	}
11759
11760	var r0 layout.OverlayWidget
11761	if returnFunc, ok := ret.Get(0).(func() layout.OverlayWidget); ok {
11762		r0 = returnFunc()
11763	} else {
11764		if ret.Get(0) != nil {
11765			r0 = ret.Get(0).(layout.OverlayWidget)
11766		}
11767	}
11768	return r0
11769}
11770
11771// MockWidgetFactory_NewOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewOverlay'
11772type MockWidgetFactory_NewOverlay_Call struct {
11773	*mock.Call
11774}
11775
11776// NewOverlay is a helper method to define mock.On call
11777func (_e *MockWidgetFactory_Expecter) NewOverlay() *MockWidgetFactory_NewOverlay_Call {
11778	return &MockWidgetFactory_NewOverlay_Call{Call: _e.mock.On("NewOverlay")}
11779}
11780
11781func (_c *MockWidgetFactory_NewOverlay_Call) Run(run func()) *MockWidgetFactory_NewOverlay_Call {
11782	_c.Call.Run(func(args mock.Arguments) {
11783		run()
11784	})
11785	return _c
11786}
11787
11788func (_c *MockWidgetFactory_NewOverlay_Call) Return(overlayWidget layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
11789	_c.Call.Return(overlayWidget)
11790	return _c
11791}
11792
11793func (_c *MockWidgetFactory_NewOverlay_Call) RunAndReturn(run func() layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
11794	_c.Call.Return(run)
11795	return _c
11796}
11797
11798// NewPaned provides a mock function for the type MockWidgetFactory
11799func (_mock *MockWidgetFactory) NewPaned(orientation layout.Orientation) layout.PanedWidget {
11800	ret := _mock.Called(orientation)
11801
11802	if len(ret) == 0 {
11803		panic("no return value specified for NewPaned")
11804	}
11805
11806	var r0 layout.PanedWidget
11807	if returnFunc, ok := ret.Get(0).(func(layout.Orientation) layout.PanedWidget); ok {
11808		r0 = returnFunc(orientation)
11809	} else {
11810		if ret.Get(0) != nil {
11811			r0 = ret.Get(0).(layout.PanedWidget)
11812		}
11813	}
11814	return r0
11815}
11816
11817// MockWidgetFactory_NewPaned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewPaned'
11818type MockWidgetFactory_NewPaned_Call struct {
11819	*mock.Call
11820}
11821
11822// NewPaned is a helper method to define mock.On call
11823//   - orientation layout.Orientation
11824func (_e *MockWidgetFactory_Expecter) NewPaned(orientation interface{}) *MockWidgetFactory_NewPaned_Call {
11825	return &MockWidgetFactory_NewPaned_Call{Call: _e.mock.On("NewPaned", orientation)}
11826}
11827
11828func (_c *MockWidgetFactory_NewPaned_Call) Run(run func(orientation layout.Orientation)) *MockWidgetFactory_NewPaned_Call {
11829	_c.Call.Run(func(args mock.Arguments) {
11830		var arg0 layout.Orientation
11831		if args[0] != nil {
11832			arg0 = args[0].(layout.Orientation)
11833		}
11834		run(
11835			arg0,
11836		)
11837	})
11838	return _c
11839}
11840
11841func (_c *MockWidgetFactory_NewPaned_Call) Return(panedWidget layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
11842	_c.Call.Return(panedWidget)
11843	return _c
11844}
11845
11846func (_c *MockWidgetFactory_NewPaned_Call) RunAndReturn(run func(orientation layout.Orientation) layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
11847	_c.Call.Return(run)
11848	return _c
11849}
11850
11851// NewProgressBar provides a mock function for the type MockWidgetFactory
11852func (_mock *MockWidgetFactory) NewProgressBar() layout.ProgressBarWidget {
11853	ret := _mock.Called()
11854
11855	if len(ret) == 0 {
11856		panic("no return value specified for NewProgressBar")
11857	}
11858
11859	var r0 layout.ProgressBarWidget
11860	if returnFunc, ok := ret.Get(0).(func() layout.ProgressBarWidget); ok {
11861		r0 = returnFunc()
11862	} else {
11863		if ret.Get(0) != nil {
11864			r0 = ret.Get(0).(layout.ProgressBarWidget)
11865		}
11866	}
11867	return r0
11868}
11869
11870// MockWidgetFactory_NewProgressBar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewProgressBar'
11871type MockWidgetFactory_NewProgressBar_Call struct {
11872	*mock.Call
11873}
11874
11875// NewProgressBar is a helper method to define mock.On call
11876func (_e *MockWidgetFactory_Expecter) NewProgressBar() *MockWidgetFactory_NewProgressBar_Call {
11877	return &MockWidgetFactory_NewProgressBar_Call{Call: _e.mock.On("NewProgressBar")}
11878}
11879
11880func (_c *MockWidgetFactory_NewProgressBar_Call) Run(run func()) *MockWidgetFactory_NewProgressBar_Call {
11881	_c.Call.Run(func(args mock.Arguments) {
11882		run()
11883	})
11884	return _c
11885}
11886
11887func (_c *MockWidgetFactory_NewProgressBar_Call) Return(progressBarWidget layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
11888	_c.Call.Return(progressBarWidget)
11889	return _c
11890}
11891
11892func (_c *MockWidgetFactory_NewProgressBar_Call) RunAndReturn(run func() layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
11893	_c.Call.Return(run)
11894	return _c
11895}
11896
11897// WrapWidget provides a mock function for the type MockWidgetFactory
11898func (_mock *MockWidgetFactory) WrapWidget(w *gtk.Widget) layout.Widget {
11899	ret := _mock.Called(w)
11900
11901	if len(ret) == 0 {
11902		panic("no return value specified for WrapWidget")
11903	}
11904
11905	var r0 layout.Widget
11906	if returnFunc, ok := ret.Get(0).(func(*gtk.Widget) layout.Widget); ok {
11907		r0 = returnFunc(w)
11908	} else {
11909		if ret.Get(0) != nil {
11910			r0 = ret.Get(0).(layout.Widget)
11911		}
11912	}
11913	return r0
11914}
11915
11916// MockWidgetFactory_WrapWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WrapWidget'
11917type MockWidgetFactory_WrapWidget_Call struct {
11918	*mock.Call
11919}
11920
11921// WrapWidget is a helper method to define mock.On call
11922//   - w *gtk.Widget
11923func (_e *MockWidgetFactory_Expecter) WrapWidget(w interface{}) *MockWidgetFactory_WrapWidget_Call {
11924	return &MockWidgetFactory_WrapWidget_Call{Call: _e.mock.On("WrapWidget", w)}
11925}
11926
11927func (_c *MockWidgetFactory_WrapWidget_Call) Run(run func(w *gtk.Widget)) *MockWidgetFactory_WrapWidget_Call {
11928	_c.Call.Run(func(args mock.Arguments) {
11929		var arg0 *gtk.Widget
11930		if args[0] != nil {
11931			arg0 = args[0].(*gtk.Widget)
11932		}
11933		run(
11934			arg0,
11935		)
11936	})
11937	return _c
11938}
11939
11940func (_c *MockWidgetFactory_WrapWidget_Call) Return(widget layout.Widget) *MockWidgetFactory_WrapWidget_Call {
11941	_c.Call.Return(widget)
11942	return _c
11943}
11944
11945func (_c *MockWidgetFactory_WrapWidget_Call) RunAndReturn(run func(w *gtk.Widget) layout.Widget) *MockWidgetFactory_WrapWidget_Call {
11946	_c.Call.Return(run)
11947	return _c
11948}
11949
11950// 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.
11951// The first argument is typically a *testing.T value.
11952func NewMockPaneRenderer(t interface {
11953	mock.TestingT
11954	Cleanup(func())
11955}) *MockPaneRenderer {
11956	mock := &MockPaneRenderer{}
11957	mock.Mock.Test(t)
11958
11959	t.Cleanup(func() { mock.AssertExpectations(t) })
11960
11961	return mock
11962}
11963
11964// MockPaneRenderer is an autogenerated mock type for the PaneRenderer type
11965type MockPaneRenderer struct {
11966	mock.Mock
11967}
11968
11969type MockPaneRenderer_Expecter struct {
11970	mock *mock.Mock
11971}
11972
11973func (_m *MockPaneRenderer) EXPECT() *MockPaneRenderer_Expecter {
11974	return &MockPaneRenderer_Expecter{mock: &_m.Mock}
11975}
11976
11977// RenderPane provides a mock function for the type MockPaneRenderer
11978func (_mock *MockPaneRenderer) RenderPane(paneID string, webViewWidget layout.Widget) layout.Widget {
11979	ret := _mock.Called(paneID, webViewWidget)
11980
11981	if len(ret) == 0 {
11982		panic("no return value specified for RenderPane")
11983	}
11984
11985	var r0 layout.Widget
11986	if returnFunc, ok := ret.Get(0).(func(string, layout.Widget) layout.Widget); ok {
11987		r0 = returnFunc(paneID, webViewWidget)
11988	} else {
11989		if ret.Get(0) != nil {
11990			r0 = ret.Get(0).(layout.Widget)
11991		}
11992	}
11993	return r0
11994}
11995
11996// MockPaneRenderer_RenderPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenderPane'
11997type MockPaneRenderer_RenderPane_Call struct {
11998	*mock.Call
11999}
12000
12001// RenderPane is a helper method to define mock.On call
12002//   - paneID string
12003//   - webViewWidget layout.Widget
12004func (_e *MockPaneRenderer_Expecter) RenderPane(paneID interface{}, webViewWidget interface{}) *MockPaneRenderer_RenderPane_Call {
12005	return &MockPaneRenderer_RenderPane_Call{Call: _e.mock.On("RenderPane", paneID, webViewWidget)}
12006}
12007
12008func (_c *MockPaneRenderer_RenderPane_Call) Run(run func(paneID string, webViewWidget layout.Widget)) *MockPaneRenderer_RenderPane_Call {
12009	_c.Call.Run(func(args mock.Arguments) {
12010		var arg0 string
12011		if args[0] != nil {
12012			arg0 = args[0].(string)
12013		}
12014		var arg1 layout.Widget
12015		if args[1] != nil {
12016			arg1 = args[1].(layout.Widget)
12017		}
12018		run(
12019			arg0,
12020			arg1,
12021		)
12022	})
12023	return _c
12024}
12025
12026func (_c *MockPaneRenderer_RenderPane_Call) Return(widget layout.Widget) *MockPaneRenderer_RenderPane_Call {
12027	_c.Call.Return(widget)
12028	return _c
12029}
12030
12031func (_c *MockPaneRenderer_RenderPane_Call) RunAndReturn(run func(paneID string, webViewWidget layout.Widget) layout.Widget) *MockPaneRenderer_RenderPane_Call {
12032	_c.Call.Return(run)
12033	return _c
12034}