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// SetFocusable provides a mock function for the type MockWidget
912func (_mock *MockWidget) SetFocusable(focusable bool) {
913	_mock.Called(focusable)
914	return
915}
916
917// MockWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
918type MockWidget_SetFocusable_Call struct {
919	*mock.Call
920}
921
922// SetFocusable is a helper method to define mock.On call
923//   - focusable bool
924func (_e *MockWidget_Expecter) SetFocusable(focusable interface{}) *MockWidget_SetFocusable_Call {
925	return &MockWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
926}
927
928func (_c *MockWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockWidget_SetFocusable_Call {
929	_c.Call.Run(func(args mock.Arguments) {
930		var arg0 bool
931		if args[0] != nil {
932			arg0 = args[0].(bool)
933		}
934		run(
935			arg0,
936		)
937	})
938	return _c
939}
940
941func (_c *MockWidget_SetFocusable_Call) Return() *MockWidget_SetFocusable_Call {
942	_c.Call.Return()
943	return _c
944}
945
946func (_c *MockWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockWidget_SetFocusable_Call {
947	_c.Run(run)
948	return _c
949}
950
951// SetHalign provides a mock function for the type MockWidget
952func (_mock *MockWidget) SetHalign(align gtk.Align) {
953	_mock.Called(align)
954	return
955}
956
957// MockWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
958type MockWidget_SetHalign_Call struct {
959	*mock.Call
960}
961
962// SetHalign is a helper method to define mock.On call
963//   - align gtk.Align
964func (_e *MockWidget_Expecter) SetHalign(align interface{}) *MockWidget_SetHalign_Call {
965	return &MockWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
966}
967
968func (_c *MockWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockWidget_SetHalign_Call {
969	_c.Call.Run(func(args mock.Arguments) {
970		var arg0 gtk.Align
971		if args[0] != nil {
972			arg0 = args[0].(gtk.Align)
973		}
974		run(
975			arg0,
976		)
977	})
978	return _c
979}
980
981func (_c *MockWidget_SetHalign_Call) Return() *MockWidget_SetHalign_Call {
982	_c.Call.Return()
983	return _c
984}
985
986func (_c *MockWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockWidget_SetHalign_Call {
987	_c.Run(run)
988	return _c
989}
990
991// SetHexpand provides a mock function for the type MockWidget
992func (_mock *MockWidget) SetHexpand(expand bool) {
993	_mock.Called(expand)
994	return
995}
996
997// MockWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
998type MockWidget_SetHexpand_Call struct {
999	*mock.Call
1000}
1001
1002// SetHexpand is a helper method to define mock.On call
1003//   - expand bool
1004func (_e *MockWidget_Expecter) SetHexpand(expand interface{}) *MockWidget_SetHexpand_Call {
1005	return &MockWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
1006}
1007
1008func (_c *MockWidget_SetHexpand_Call) Run(run func(expand bool)) *MockWidget_SetHexpand_Call {
1009	_c.Call.Run(func(args mock.Arguments) {
1010		var arg0 bool
1011		if args[0] != nil {
1012			arg0 = args[0].(bool)
1013		}
1014		run(
1015			arg0,
1016		)
1017	})
1018	return _c
1019}
1020
1021func (_c *MockWidget_SetHexpand_Call) Return() *MockWidget_SetHexpand_Call {
1022	_c.Call.Return()
1023	return _c
1024}
1025
1026func (_c *MockWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockWidget_SetHexpand_Call {
1027	_c.Run(run)
1028	return _c
1029}
1030
1031// SetSizeRequest provides a mock function for the type MockWidget
1032func (_mock *MockWidget) SetSizeRequest(width int, height int) {
1033	_mock.Called(width, height)
1034	return
1035}
1036
1037// MockWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
1038type MockWidget_SetSizeRequest_Call struct {
1039	*mock.Call
1040}
1041
1042// SetSizeRequest is a helper method to define mock.On call
1043//   - width int
1044//   - height int
1045func (_e *MockWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockWidget_SetSizeRequest_Call {
1046	return &MockWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
1047}
1048
1049func (_c *MockWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockWidget_SetSizeRequest_Call {
1050	_c.Call.Run(func(args mock.Arguments) {
1051		var arg0 int
1052		if args[0] != nil {
1053			arg0 = args[0].(int)
1054		}
1055		var arg1 int
1056		if args[1] != nil {
1057			arg1 = args[1].(int)
1058		}
1059		run(
1060			arg0,
1061			arg1,
1062		)
1063	})
1064	return _c
1065}
1066
1067func (_c *MockWidget_SetSizeRequest_Call) Return() *MockWidget_SetSizeRequest_Call {
1068	_c.Call.Return()
1069	return _c
1070}
1071
1072func (_c *MockWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockWidget_SetSizeRequest_Call {
1073	_c.Run(run)
1074	return _c
1075}
1076
1077// SetValign provides a mock function for the type MockWidget
1078func (_mock *MockWidget) SetValign(align gtk.Align) {
1079	_mock.Called(align)
1080	return
1081}
1082
1083// MockWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
1084type MockWidget_SetValign_Call struct {
1085	*mock.Call
1086}
1087
1088// SetValign is a helper method to define mock.On call
1089//   - align gtk.Align
1090func (_e *MockWidget_Expecter) SetValign(align interface{}) *MockWidget_SetValign_Call {
1091	return &MockWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
1092}
1093
1094func (_c *MockWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockWidget_SetValign_Call {
1095	_c.Call.Run(func(args mock.Arguments) {
1096		var arg0 gtk.Align
1097		if args[0] != nil {
1098			arg0 = args[0].(gtk.Align)
1099		}
1100		run(
1101			arg0,
1102		)
1103	})
1104	return _c
1105}
1106
1107func (_c *MockWidget_SetValign_Call) Return() *MockWidget_SetValign_Call {
1108	_c.Call.Return()
1109	return _c
1110}
1111
1112func (_c *MockWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockWidget_SetValign_Call {
1113	_c.Run(run)
1114	return _c
1115}
1116
1117// SetVexpand provides a mock function for the type MockWidget
1118func (_mock *MockWidget) SetVexpand(expand bool) {
1119	_mock.Called(expand)
1120	return
1121}
1122
1123// MockWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
1124type MockWidget_SetVexpand_Call struct {
1125	*mock.Call
1126}
1127
1128// SetVexpand is a helper method to define mock.On call
1129//   - expand bool
1130func (_e *MockWidget_Expecter) SetVexpand(expand interface{}) *MockWidget_SetVexpand_Call {
1131	return &MockWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
1132}
1133
1134func (_c *MockWidget_SetVexpand_Call) Run(run func(expand bool)) *MockWidget_SetVexpand_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_SetVexpand_Call) Return() *MockWidget_SetVexpand_Call {
1148	_c.Call.Return()
1149	return _c
1150}
1151
1152func (_c *MockWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockWidget_SetVexpand_Call {
1153	_c.Run(run)
1154	return _c
1155}
1156
1157// SetVisible provides a mock function for the type MockWidget
1158func (_mock *MockWidget) SetVisible(visible bool) {
1159	_mock.Called(visible)
1160	return
1161}
1162
1163// MockWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
1164type MockWidget_SetVisible_Call struct {
1165	*mock.Call
1166}
1167
1168// SetVisible is a helper method to define mock.On call
1169//   - visible bool
1170func (_e *MockWidget_Expecter) SetVisible(visible interface{}) *MockWidget_SetVisible_Call {
1171	return &MockWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
1172}
1173
1174func (_c *MockWidget_SetVisible_Call) Run(run func(visible bool)) *MockWidget_SetVisible_Call {
1175	_c.Call.Run(func(args mock.Arguments) {
1176		var arg0 bool
1177		if args[0] != nil {
1178			arg0 = args[0].(bool)
1179		}
1180		run(
1181			arg0,
1182		)
1183	})
1184	return _c
1185}
1186
1187func (_c *MockWidget_SetVisible_Call) Return() *MockWidget_SetVisible_Call {
1188	_c.Call.Return()
1189	return _c
1190}
1191
1192func (_c *MockWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockWidget_SetVisible_Call {
1193	_c.Run(run)
1194	return _c
1195}
1196
1197// Show provides a mock function for the type MockWidget
1198func (_mock *MockWidget) Show() {
1199	_mock.Called()
1200	return
1201}
1202
1203// MockWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
1204type MockWidget_Show_Call struct {
1205	*mock.Call
1206}
1207
1208// Show is a helper method to define mock.On call
1209func (_e *MockWidget_Expecter) Show() *MockWidget_Show_Call {
1210	return &MockWidget_Show_Call{Call: _e.mock.On("Show")}
1211}
1212
1213func (_c *MockWidget_Show_Call) Run(run func()) *MockWidget_Show_Call {
1214	_c.Call.Run(func(args mock.Arguments) {
1215		run()
1216	})
1217	return _c
1218}
1219
1220func (_c *MockWidget_Show_Call) Return() *MockWidget_Show_Call {
1221	_c.Call.Return()
1222	return _c
1223}
1224
1225func (_c *MockWidget_Show_Call) RunAndReturn(run func()) *MockWidget_Show_Call {
1226	_c.Run(run)
1227	return _c
1228}
1229
1230// Unparent provides a mock function for the type MockWidget
1231func (_mock *MockWidget) Unparent() {
1232	_mock.Called()
1233	return
1234}
1235
1236// MockWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
1237type MockWidget_Unparent_Call struct {
1238	*mock.Call
1239}
1240
1241// Unparent is a helper method to define mock.On call
1242func (_e *MockWidget_Expecter) Unparent() *MockWidget_Unparent_Call {
1243	return &MockWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
1244}
1245
1246func (_c *MockWidget_Unparent_Call) Run(run func()) *MockWidget_Unparent_Call {
1247	_c.Call.Run(func(args mock.Arguments) {
1248		run()
1249	})
1250	return _c
1251}
1252
1253func (_c *MockWidget_Unparent_Call) Return() *MockWidget_Unparent_Call {
1254	_c.Call.Return()
1255	return _c
1256}
1257
1258func (_c *MockWidget_Unparent_Call) RunAndReturn(run func()) *MockWidget_Unparent_Call {
1259	_c.Run(run)
1260	return _c
1261}
1262
1263// 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.
1264// The first argument is typically a *testing.T value.
1265func NewMockPanedWidget(t interface {
1266	mock.TestingT
1267	Cleanup(func())
1268}) *MockPanedWidget {
1269	mock := &MockPanedWidget{}
1270	mock.Mock.Test(t)
1271
1272	t.Cleanup(func() { mock.AssertExpectations(t) })
1273
1274	return mock
1275}
1276
1277// MockPanedWidget is an autogenerated mock type for the PanedWidget type
1278type MockPanedWidget struct {
1279	mock.Mock
1280}
1281
1282type MockPanedWidget_Expecter struct {
1283	mock *mock.Mock
1284}
1285
1286func (_m *MockPanedWidget) EXPECT() *MockPanedWidget_Expecter {
1287	return &MockPanedWidget_Expecter{mock: &_m.Mock}
1288}
1289
1290// AddController provides a mock function for the type MockPanedWidget
1291func (_mock *MockPanedWidget) AddController(controller *gtk.EventController) {
1292	_mock.Called(controller)
1293	return
1294}
1295
1296// MockPanedWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
1297type MockPanedWidget_AddController_Call struct {
1298	*mock.Call
1299}
1300
1301// AddController is a helper method to define mock.On call
1302//   - controller *gtk.EventController
1303func (_e *MockPanedWidget_Expecter) AddController(controller interface{}) *MockPanedWidget_AddController_Call {
1304	return &MockPanedWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
1305}
1306
1307func (_c *MockPanedWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockPanedWidget_AddController_Call {
1308	_c.Call.Run(func(args mock.Arguments) {
1309		var arg0 *gtk.EventController
1310		if args[0] != nil {
1311			arg0 = args[0].(*gtk.EventController)
1312		}
1313		run(
1314			arg0,
1315		)
1316	})
1317	return _c
1318}
1319
1320func (_c *MockPanedWidget_AddController_Call) Return() *MockPanedWidget_AddController_Call {
1321	_c.Call.Return()
1322	return _c
1323}
1324
1325func (_c *MockPanedWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockPanedWidget_AddController_Call {
1326	_c.Run(run)
1327	return _c
1328}
1329
1330// AddCssClass provides a mock function for the type MockPanedWidget
1331func (_mock *MockPanedWidget) AddCssClass(cssClass string) {
1332	_mock.Called(cssClass)
1333	return
1334}
1335
1336// MockPanedWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
1337type MockPanedWidget_AddCssClass_Call struct {
1338	*mock.Call
1339}
1340
1341// AddCssClass is a helper method to define mock.On call
1342//   - cssClass string
1343func (_e *MockPanedWidget_Expecter) AddCssClass(cssClass interface{}) *MockPanedWidget_AddCssClass_Call {
1344	return &MockPanedWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
1345}
1346
1347func (_c *MockPanedWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_AddCssClass_Call {
1348	_c.Call.Run(func(args mock.Arguments) {
1349		var arg0 string
1350		if args[0] != nil {
1351			arg0 = args[0].(string)
1352		}
1353		run(
1354			arg0,
1355		)
1356	})
1357	return _c
1358}
1359
1360func (_c *MockPanedWidget_AddCssClass_Call) Return() *MockPanedWidget_AddCssClass_Call {
1361	_c.Call.Return()
1362	return _c
1363}
1364
1365func (_c *MockPanedWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockPanedWidget_AddCssClass_Call {
1366	_c.Run(run)
1367	return _c
1368}
1369
1370// AddTickCallback provides a mock function for the type MockPanedWidget
1371func (_mock *MockPanedWidget) AddTickCallback(callback func() bool) uint {
1372	ret := _mock.Called(callback)
1373
1374	if len(ret) == 0 {
1375		panic("no return value specified for AddTickCallback")
1376	}
1377
1378	var r0 uint
1379	if returnFunc, ok := ret.Get(0).(func(func() bool) uint); ok {
1380		r0 = returnFunc(callback)
1381	} else {
1382		r0 = ret.Get(0).(uint)
1383	}
1384	return r0
1385}
1386
1387// MockPanedWidget_AddTickCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTickCallback'
1388type MockPanedWidget_AddTickCallback_Call struct {
1389	*mock.Call
1390}
1391
1392// AddTickCallback is a helper method to define mock.On call
1393//   - callback func() bool
1394func (_e *MockPanedWidget_Expecter) AddTickCallback(callback interface{}) *MockPanedWidget_AddTickCallback_Call {
1395	return &MockPanedWidget_AddTickCallback_Call{Call: _e.mock.On("AddTickCallback", callback)}
1396}
1397
1398func (_c *MockPanedWidget_AddTickCallback_Call) Run(run func(callback func() bool)) *MockPanedWidget_AddTickCallback_Call {
1399	_c.Call.Run(func(args mock.Arguments) {
1400		var arg0 func() bool
1401		if args[0] != nil {
1402			arg0 = args[0].(func() bool)
1403		}
1404		run(
1405			arg0,
1406		)
1407	})
1408	return _c
1409}
1410
1411func (_c *MockPanedWidget_AddTickCallback_Call) Return(v uint) *MockPanedWidget_AddTickCallback_Call {
1412	_c.Call.Return(v)
1413	return _c
1414}
1415
1416func (_c *MockPanedWidget_AddTickCallback_Call) RunAndReturn(run func(callback func() bool) uint) *MockPanedWidget_AddTickCallback_Call {
1417	_c.Call.Return(run)
1418	return _c
1419}
1420
1421// ComputePoint provides a mock function for the type MockPanedWidget
1422func (_mock *MockPanedWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
1423	ret := _mock.Called(target)
1424
1425	if len(ret) == 0 {
1426		panic("no return value specified for ComputePoint")
1427	}
1428
1429	var r0 float64
1430	var r1 float64
1431	var r2 bool
1432	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
1433		return returnFunc(target)
1434	}
1435	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
1436		r0 = returnFunc(target)
1437	} else {
1438		r0 = ret.Get(0).(float64)
1439	}
1440	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
1441		r1 = returnFunc(target)
1442	} else {
1443		r1 = ret.Get(1).(float64)
1444	}
1445	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
1446		r2 = returnFunc(target)
1447	} else {
1448		r2 = ret.Get(2).(bool)
1449	}
1450	return r0, r1, r2
1451}
1452
1453// MockPanedWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
1454type MockPanedWidget_ComputePoint_Call struct {
1455	*mock.Call
1456}
1457
1458// ComputePoint is a helper method to define mock.On call
1459//   - target layout.Widget
1460func (_e *MockPanedWidget_Expecter) ComputePoint(target interface{}) *MockPanedWidget_ComputePoint_Call {
1461	return &MockPanedWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
1462}
1463
1464func (_c *MockPanedWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockPanedWidget_ComputePoint_Call {
1465	_c.Call.Run(func(args mock.Arguments) {
1466		var arg0 layout.Widget
1467		if args[0] != nil {
1468			arg0 = args[0].(layout.Widget)
1469		}
1470		run(
1471			arg0,
1472		)
1473	})
1474	return _c
1475}
1476
1477func (_c *MockPanedWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockPanedWidget_ComputePoint_Call {
1478	_c.Call.Return(x, y, ok)
1479	return _c
1480}
1481
1482func (_c *MockPanedWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockPanedWidget_ComputePoint_Call {
1483	_c.Call.Return(run)
1484	return _c
1485}
1486
1487// ConnectMap provides a mock function for the type MockPanedWidget
1488func (_mock *MockPanedWidget) ConnectMap(callback func()) uint32 {
1489	ret := _mock.Called(callback)
1490
1491	if len(ret) == 0 {
1492		panic("no return value specified for ConnectMap")
1493	}
1494
1495	var r0 uint32
1496	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
1497		r0 = returnFunc(callback)
1498	} else {
1499		r0 = ret.Get(0).(uint32)
1500	}
1501	return r0
1502}
1503
1504// MockPanedWidget_ConnectMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectMap'
1505type MockPanedWidget_ConnectMap_Call struct {
1506	*mock.Call
1507}
1508
1509// ConnectMap is a helper method to define mock.On call
1510//   - callback func()
1511func (_e *MockPanedWidget_Expecter) ConnectMap(callback interface{}) *MockPanedWidget_ConnectMap_Call {
1512	return &MockPanedWidget_ConnectMap_Call{Call: _e.mock.On("ConnectMap", callback)}
1513}
1514
1515func (_c *MockPanedWidget_ConnectMap_Call) Run(run func(callback func())) *MockPanedWidget_ConnectMap_Call {
1516	_c.Call.Run(func(args mock.Arguments) {
1517		var arg0 func()
1518		if args[0] != nil {
1519			arg0 = args[0].(func())
1520		}
1521		run(
1522			arg0,
1523		)
1524	})
1525	return _c
1526}
1527
1528func (_c *MockPanedWidget_ConnectMap_Call) Return(v uint32) *MockPanedWidget_ConnectMap_Call {
1529	_c.Call.Return(v)
1530	return _c
1531}
1532
1533func (_c *MockPanedWidget_ConnectMap_Call) RunAndReturn(run func(callback func()) uint32) *MockPanedWidget_ConnectMap_Call {
1534	_c.Call.Return(run)
1535	return _c
1536}
1537
1538// ConnectNotifyPosition provides a mock function for the type MockPanedWidget
1539func (_mock *MockPanedWidget) ConnectNotifyPosition(callback func()) uint32 {
1540	ret := _mock.Called(callback)
1541
1542	if len(ret) == 0 {
1543		panic("no return value specified for ConnectNotifyPosition")
1544	}
1545
1546	var r0 uint32
1547	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
1548		r0 = returnFunc(callback)
1549	} else {
1550		r0 = ret.Get(0).(uint32)
1551	}
1552	return r0
1553}
1554
1555// MockPanedWidget_ConnectNotifyPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectNotifyPosition'
1556type MockPanedWidget_ConnectNotifyPosition_Call struct {
1557	*mock.Call
1558}
1559
1560// ConnectNotifyPosition is a helper method to define mock.On call
1561//   - callback func()
1562func (_e *MockPanedWidget_Expecter) ConnectNotifyPosition(callback interface{}) *MockPanedWidget_ConnectNotifyPosition_Call {
1563	return &MockPanedWidget_ConnectNotifyPosition_Call{Call: _e.mock.On("ConnectNotifyPosition", callback)}
1564}
1565
1566func (_c *MockPanedWidget_ConnectNotifyPosition_Call) Run(run func(callback func())) *MockPanedWidget_ConnectNotifyPosition_Call {
1567	_c.Call.Run(func(args mock.Arguments) {
1568		var arg0 func()
1569		if args[0] != nil {
1570			arg0 = args[0].(func())
1571		}
1572		run(
1573			arg0,
1574		)
1575	})
1576	return _c
1577}
1578
1579func (_c *MockPanedWidget_ConnectNotifyPosition_Call) Return(v uint32) *MockPanedWidget_ConnectNotifyPosition_Call {
1580	_c.Call.Return(v)
1581	return _c
1582}
1583
1584func (_c *MockPanedWidget_ConnectNotifyPosition_Call) RunAndReturn(run func(callback func()) uint32) *MockPanedWidget_ConnectNotifyPosition_Call {
1585	_c.Call.Return(run)
1586	return _c
1587}
1588
1589// GetAllocatedHeight provides a mock function for the type MockPanedWidget
1590func (_mock *MockPanedWidget) GetAllocatedHeight() int {
1591	ret := _mock.Called()
1592
1593	if len(ret) == 0 {
1594		panic("no return value specified for GetAllocatedHeight")
1595	}
1596
1597	var r0 int
1598	if returnFunc, ok := ret.Get(0).(func() int); ok {
1599		r0 = returnFunc()
1600	} else {
1601		r0 = ret.Get(0).(int)
1602	}
1603	return r0
1604}
1605
1606// MockPanedWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
1607type MockPanedWidget_GetAllocatedHeight_Call struct {
1608	*mock.Call
1609}
1610
1611// GetAllocatedHeight is a helper method to define mock.On call
1612func (_e *MockPanedWidget_Expecter) GetAllocatedHeight() *MockPanedWidget_GetAllocatedHeight_Call {
1613	return &MockPanedWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
1614}
1615
1616func (_c *MockPanedWidget_GetAllocatedHeight_Call) Run(run func()) *MockPanedWidget_GetAllocatedHeight_Call {
1617	_c.Call.Run(func(args mock.Arguments) {
1618		run()
1619	})
1620	return _c
1621}
1622
1623func (_c *MockPanedWidget_GetAllocatedHeight_Call) Return(n int) *MockPanedWidget_GetAllocatedHeight_Call {
1624	_c.Call.Return(n)
1625	return _c
1626}
1627
1628func (_c *MockPanedWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockPanedWidget_GetAllocatedHeight_Call {
1629	_c.Call.Return(run)
1630	return _c
1631}
1632
1633// GetAllocatedWidth provides a mock function for the type MockPanedWidget
1634func (_mock *MockPanedWidget) GetAllocatedWidth() int {
1635	ret := _mock.Called()
1636
1637	if len(ret) == 0 {
1638		panic("no return value specified for GetAllocatedWidth")
1639	}
1640
1641	var r0 int
1642	if returnFunc, ok := ret.Get(0).(func() int); ok {
1643		r0 = returnFunc()
1644	} else {
1645		r0 = ret.Get(0).(int)
1646	}
1647	return r0
1648}
1649
1650// MockPanedWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
1651type MockPanedWidget_GetAllocatedWidth_Call struct {
1652	*mock.Call
1653}
1654
1655// GetAllocatedWidth is a helper method to define mock.On call
1656func (_e *MockPanedWidget_Expecter) GetAllocatedWidth() *MockPanedWidget_GetAllocatedWidth_Call {
1657	return &MockPanedWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
1658}
1659
1660func (_c *MockPanedWidget_GetAllocatedWidth_Call) Run(run func()) *MockPanedWidget_GetAllocatedWidth_Call {
1661	_c.Call.Run(func(args mock.Arguments) {
1662		run()
1663	})
1664	return _c
1665}
1666
1667func (_c *MockPanedWidget_GetAllocatedWidth_Call) Return(n int) *MockPanedWidget_GetAllocatedWidth_Call {
1668	_c.Call.Return(n)
1669	return _c
1670}
1671
1672func (_c *MockPanedWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockPanedWidget_GetAllocatedWidth_Call {
1673	_c.Call.Return(run)
1674	return _c
1675}
1676
1677// GetEndChild provides a mock function for the type MockPanedWidget
1678func (_mock *MockPanedWidget) GetEndChild() layout.Widget {
1679	ret := _mock.Called()
1680
1681	if len(ret) == 0 {
1682		panic("no return value specified for GetEndChild")
1683	}
1684
1685	var r0 layout.Widget
1686	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
1687		r0 = returnFunc()
1688	} else {
1689		if ret.Get(0) != nil {
1690			r0 = ret.Get(0).(layout.Widget)
1691		}
1692	}
1693	return r0
1694}
1695
1696// MockPanedWidget_GetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEndChild'
1697type MockPanedWidget_GetEndChild_Call struct {
1698	*mock.Call
1699}
1700
1701// GetEndChild is a helper method to define mock.On call
1702func (_e *MockPanedWidget_Expecter) GetEndChild() *MockPanedWidget_GetEndChild_Call {
1703	return &MockPanedWidget_GetEndChild_Call{Call: _e.mock.On("GetEndChild")}
1704}
1705
1706func (_c *MockPanedWidget_GetEndChild_Call) Run(run func()) *MockPanedWidget_GetEndChild_Call {
1707	_c.Call.Run(func(args mock.Arguments) {
1708		run()
1709	})
1710	return _c
1711}
1712
1713func (_c *MockPanedWidget_GetEndChild_Call) Return(widget layout.Widget) *MockPanedWidget_GetEndChild_Call {
1714	_c.Call.Return(widget)
1715	return _c
1716}
1717
1718func (_c *MockPanedWidget_GetEndChild_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetEndChild_Call {
1719	_c.Call.Return(run)
1720	return _c
1721}
1722
1723// GetHexpand provides a mock function for the type MockPanedWidget
1724func (_mock *MockPanedWidget) GetHexpand() bool {
1725	ret := _mock.Called()
1726
1727	if len(ret) == 0 {
1728		panic("no return value specified for GetHexpand")
1729	}
1730
1731	var r0 bool
1732	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1733		r0 = returnFunc()
1734	} else {
1735		r0 = ret.Get(0).(bool)
1736	}
1737	return r0
1738}
1739
1740// MockPanedWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
1741type MockPanedWidget_GetHexpand_Call struct {
1742	*mock.Call
1743}
1744
1745// GetHexpand is a helper method to define mock.On call
1746func (_e *MockPanedWidget_Expecter) GetHexpand() *MockPanedWidget_GetHexpand_Call {
1747	return &MockPanedWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
1748}
1749
1750func (_c *MockPanedWidget_GetHexpand_Call) Run(run func()) *MockPanedWidget_GetHexpand_Call {
1751	_c.Call.Run(func(args mock.Arguments) {
1752		run()
1753	})
1754	return _c
1755}
1756
1757func (_c *MockPanedWidget_GetHexpand_Call) Return(b bool) *MockPanedWidget_GetHexpand_Call {
1758	_c.Call.Return(b)
1759	return _c
1760}
1761
1762func (_c *MockPanedWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetHexpand_Call {
1763	_c.Call.Return(run)
1764	return _c
1765}
1766
1767// GetParent provides a mock function for the type MockPanedWidget
1768func (_mock *MockPanedWidget) GetParent() layout.Widget {
1769	ret := _mock.Called()
1770
1771	if len(ret) == 0 {
1772		panic("no return value specified for GetParent")
1773	}
1774
1775	var r0 layout.Widget
1776	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
1777		r0 = returnFunc()
1778	} else {
1779		if ret.Get(0) != nil {
1780			r0 = ret.Get(0).(layout.Widget)
1781		}
1782	}
1783	return r0
1784}
1785
1786// MockPanedWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
1787type MockPanedWidget_GetParent_Call struct {
1788	*mock.Call
1789}
1790
1791// GetParent is a helper method to define mock.On call
1792func (_e *MockPanedWidget_Expecter) GetParent() *MockPanedWidget_GetParent_Call {
1793	return &MockPanedWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
1794}
1795
1796func (_c *MockPanedWidget_GetParent_Call) Run(run func()) *MockPanedWidget_GetParent_Call {
1797	_c.Call.Run(func(args mock.Arguments) {
1798		run()
1799	})
1800	return _c
1801}
1802
1803func (_c *MockPanedWidget_GetParent_Call) Return(widget layout.Widget) *MockPanedWidget_GetParent_Call {
1804	_c.Call.Return(widget)
1805	return _c
1806}
1807
1808func (_c *MockPanedWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetParent_Call {
1809	_c.Call.Return(run)
1810	return _c
1811}
1812
1813// GetPosition provides a mock function for the type MockPanedWidget
1814func (_mock *MockPanedWidget) GetPosition() int {
1815	ret := _mock.Called()
1816
1817	if len(ret) == 0 {
1818		panic("no return value specified for GetPosition")
1819	}
1820
1821	var r0 int
1822	if returnFunc, ok := ret.Get(0).(func() int); ok {
1823		r0 = returnFunc()
1824	} else {
1825		r0 = ret.Get(0).(int)
1826	}
1827	return r0
1828}
1829
1830// MockPanedWidget_GetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPosition'
1831type MockPanedWidget_GetPosition_Call struct {
1832	*mock.Call
1833}
1834
1835// GetPosition is a helper method to define mock.On call
1836func (_e *MockPanedWidget_Expecter) GetPosition() *MockPanedWidget_GetPosition_Call {
1837	return &MockPanedWidget_GetPosition_Call{Call: _e.mock.On("GetPosition")}
1838}
1839
1840func (_c *MockPanedWidget_GetPosition_Call) Run(run func()) *MockPanedWidget_GetPosition_Call {
1841	_c.Call.Run(func(args mock.Arguments) {
1842		run()
1843	})
1844	return _c
1845}
1846
1847func (_c *MockPanedWidget_GetPosition_Call) Return(n int) *MockPanedWidget_GetPosition_Call {
1848	_c.Call.Return(n)
1849	return _c
1850}
1851
1852func (_c *MockPanedWidget_GetPosition_Call) RunAndReturn(run func() int) *MockPanedWidget_GetPosition_Call {
1853	_c.Call.Return(run)
1854	return _c
1855}
1856
1857// GetResizeEndChild provides a mock function for the type MockPanedWidget
1858func (_mock *MockPanedWidget) GetResizeEndChild() bool {
1859	ret := _mock.Called()
1860
1861	if len(ret) == 0 {
1862		panic("no return value specified for GetResizeEndChild")
1863	}
1864
1865	var r0 bool
1866	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1867		r0 = returnFunc()
1868	} else {
1869		r0 = ret.Get(0).(bool)
1870	}
1871	return r0
1872}
1873
1874// MockPanedWidget_GetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeEndChild'
1875type MockPanedWidget_GetResizeEndChild_Call struct {
1876	*mock.Call
1877}
1878
1879// GetResizeEndChild is a helper method to define mock.On call
1880func (_e *MockPanedWidget_Expecter) GetResizeEndChild() *MockPanedWidget_GetResizeEndChild_Call {
1881	return &MockPanedWidget_GetResizeEndChild_Call{Call: _e.mock.On("GetResizeEndChild")}
1882}
1883
1884func (_c *MockPanedWidget_GetResizeEndChild_Call) Run(run func()) *MockPanedWidget_GetResizeEndChild_Call {
1885	_c.Call.Run(func(args mock.Arguments) {
1886		run()
1887	})
1888	return _c
1889}
1890
1891func (_c *MockPanedWidget_GetResizeEndChild_Call) Return(b bool) *MockPanedWidget_GetResizeEndChild_Call {
1892	_c.Call.Return(b)
1893	return _c
1894}
1895
1896func (_c *MockPanedWidget_GetResizeEndChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetResizeEndChild_Call {
1897	_c.Call.Return(run)
1898	return _c
1899}
1900
1901// GetResizeStartChild provides a mock function for the type MockPanedWidget
1902func (_mock *MockPanedWidget) GetResizeStartChild() bool {
1903	ret := _mock.Called()
1904
1905	if len(ret) == 0 {
1906		panic("no return value specified for GetResizeStartChild")
1907	}
1908
1909	var r0 bool
1910	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1911		r0 = returnFunc()
1912	} else {
1913		r0 = ret.Get(0).(bool)
1914	}
1915	return r0
1916}
1917
1918// MockPanedWidget_GetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeStartChild'
1919type MockPanedWidget_GetResizeStartChild_Call struct {
1920	*mock.Call
1921}
1922
1923// GetResizeStartChild is a helper method to define mock.On call
1924func (_e *MockPanedWidget_Expecter) GetResizeStartChild() *MockPanedWidget_GetResizeStartChild_Call {
1925	return &MockPanedWidget_GetResizeStartChild_Call{Call: _e.mock.On("GetResizeStartChild")}
1926}
1927
1928func (_c *MockPanedWidget_GetResizeStartChild_Call) Run(run func()) *MockPanedWidget_GetResizeStartChild_Call {
1929	_c.Call.Run(func(args mock.Arguments) {
1930		run()
1931	})
1932	return _c
1933}
1934
1935func (_c *MockPanedWidget_GetResizeStartChild_Call) Return(b bool) *MockPanedWidget_GetResizeStartChild_Call {
1936	_c.Call.Return(b)
1937	return _c
1938}
1939
1940func (_c *MockPanedWidget_GetResizeStartChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetResizeStartChild_Call {
1941	_c.Call.Return(run)
1942	return _c
1943}
1944
1945// GetShrinkEndChild provides a mock function for the type MockPanedWidget
1946func (_mock *MockPanedWidget) GetShrinkEndChild() bool {
1947	ret := _mock.Called()
1948
1949	if len(ret) == 0 {
1950		panic("no return value specified for GetShrinkEndChild")
1951	}
1952
1953	var r0 bool
1954	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1955		r0 = returnFunc()
1956	} else {
1957		r0 = ret.Get(0).(bool)
1958	}
1959	return r0
1960}
1961
1962// MockPanedWidget_GetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkEndChild'
1963type MockPanedWidget_GetShrinkEndChild_Call struct {
1964	*mock.Call
1965}
1966
1967// GetShrinkEndChild is a helper method to define mock.On call
1968func (_e *MockPanedWidget_Expecter) GetShrinkEndChild() *MockPanedWidget_GetShrinkEndChild_Call {
1969	return &MockPanedWidget_GetShrinkEndChild_Call{Call: _e.mock.On("GetShrinkEndChild")}
1970}
1971
1972func (_c *MockPanedWidget_GetShrinkEndChild_Call) Run(run func()) *MockPanedWidget_GetShrinkEndChild_Call {
1973	_c.Call.Run(func(args mock.Arguments) {
1974		run()
1975	})
1976	return _c
1977}
1978
1979func (_c *MockPanedWidget_GetShrinkEndChild_Call) Return(b bool) *MockPanedWidget_GetShrinkEndChild_Call {
1980	_c.Call.Return(b)
1981	return _c
1982}
1983
1984func (_c *MockPanedWidget_GetShrinkEndChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetShrinkEndChild_Call {
1985	_c.Call.Return(run)
1986	return _c
1987}
1988
1989// GetShrinkStartChild provides a mock function for the type MockPanedWidget
1990func (_mock *MockPanedWidget) GetShrinkStartChild() bool {
1991	ret := _mock.Called()
1992
1993	if len(ret) == 0 {
1994		panic("no return value specified for GetShrinkStartChild")
1995	}
1996
1997	var r0 bool
1998	if returnFunc, ok := ret.Get(0).(func() bool); ok {
1999		r0 = returnFunc()
2000	} else {
2001		r0 = ret.Get(0).(bool)
2002	}
2003	return r0
2004}
2005
2006// MockPanedWidget_GetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkStartChild'
2007type MockPanedWidget_GetShrinkStartChild_Call struct {
2008	*mock.Call
2009}
2010
2011// GetShrinkStartChild is a helper method to define mock.On call
2012func (_e *MockPanedWidget_Expecter) GetShrinkStartChild() *MockPanedWidget_GetShrinkStartChild_Call {
2013	return &MockPanedWidget_GetShrinkStartChild_Call{Call: _e.mock.On("GetShrinkStartChild")}
2014}
2015
2016func (_c *MockPanedWidget_GetShrinkStartChild_Call) Run(run func()) *MockPanedWidget_GetShrinkStartChild_Call {
2017	_c.Call.Run(func(args mock.Arguments) {
2018		run()
2019	})
2020	return _c
2021}
2022
2023func (_c *MockPanedWidget_GetShrinkStartChild_Call) Return(b bool) *MockPanedWidget_GetShrinkStartChild_Call {
2024	_c.Call.Return(b)
2025	return _c
2026}
2027
2028func (_c *MockPanedWidget_GetShrinkStartChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetShrinkStartChild_Call {
2029	_c.Call.Return(run)
2030	return _c
2031}
2032
2033// GetStartChild provides a mock function for the type MockPanedWidget
2034func (_mock *MockPanedWidget) GetStartChild() layout.Widget {
2035	ret := _mock.Called()
2036
2037	if len(ret) == 0 {
2038		panic("no return value specified for GetStartChild")
2039	}
2040
2041	var r0 layout.Widget
2042	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
2043		r0 = returnFunc()
2044	} else {
2045		if ret.Get(0) != nil {
2046			r0 = ret.Get(0).(layout.Widget)
2047		}
2048	}
2049	return r0
2050}
2051
2052// MockPanedWidget_GetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStartChild'
2053type MockPanedWidget_GetStartChild_Call struct {
2054	*mock.Call
2055}
2056
2057// GetStartChild is a helper method to define mock.On call
2058func (_e *MockPanedWidget_Expecter) GetStartChild() *MockPanedWidget_GetStartChild_Call {
2059	return &MockPanedWidget_GetStartChild_Call{Call: _e.mock.On("GetStartChild")}
2060}
2061
2062func (_c *MockPanedWidget_GetStartChild_Call) Run(run func()) *MockPanedWidget_GetStartChild_Call {
2063	_c.Call.Run(func(args mock.Arguments) {
2064		run()
2065	})
2066	return _c
2067}
2068
2069func (_c *MockPanedWidget_GetStartChild_Call) Return(widget layout.Widget) *MockPanedWidget_GetStartChild_Call {
2070	_c.Call.Return(widget)
2071	return _c
2072}
2073
2074func (_c *MockPanedWidget_GetStartChild_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetStartChild_Call {
2075	_c.Call.Return(run)
2076	return _c
2077}
2078
2079// GetVexpand provides a mock function for the type MockPanedWidget
2080func (_mock *MockPanedWidget) GetVexpand() bool {
2081	ret := _mock.Called()
2082
2083	if len(ret) == 0 {
2084		panic("no return value specified for GetVexpand")
2085	}
2086
2087	var r0 bool
2088	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2089		r0 = returnFunc()
2090	} else {
2091		r0 = ret.Get(0).(bool)
2092	}
2093	return r0
2094}
2095
2096// MockPanedWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
2097type MockPanedWidget_GetVexpand_Call struct {
2098	*mock.Call
2099}
2100
2101// GetVexpand is a helper method to define mock.On call
2102func (_e *MockPanedWidget_Expecter) GetVexpand() *MockPanedWidget_GetVexpand_Call {
2103	return &MockPanedWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
2104}
2105
2106func (_c *MockPanedWidget_GetVexpand_Call) Run(run func()) *MockPanedWidget_GetVexpand_Call {
2107	_c.Call.Run(func(args mock.Arguments) {
2108		run()
2109	})
2110	return _c
2111}
2112
2113func (_c *MockPanedWidget_GetVexpand_Call) Return(b bool) *MockPanedWidget_GetVexpand_Call {
2114	_c.Call.Return(b)
2115	return _c
2116}
2117
2118func (_c *MockPanedWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetVexpand_Call {
2119	_c.Call.Return(run)
2120	return _c
2121}
2122
2123// GetWideHandle provides a mock function for the type MockPanedWidget
2124func (_mock *MockPanedWidget) GetWideHandle() bool {
2125	ret := _mock.Called()
2126
2127	if len(ret) == 0 {
2128		panic("no return value specified for GetWideHandle")
2129	}
2130
2131	var r0 bool
2132	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2133		r0 = returnFunc()
2134	} else {
2135		r0 = ret.Get(0).(bool)
2136	}
2137	return r0
2138}
2139
2140// MockPanedWidget_GetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWideHandle'
2141type MockPanedWidget_GetWideHandle_Call struct {
2142	*mock.Call
2143}
2144
2145// GetWideHandle is a helper method to define mock.On call
2146func (_e *MockPanedWidget_Expecter) GetWideHandle() *MockPanedWidget_GetWideHandle_Call {
2147	return &MockPanedWidget_GetWideHandle_Call{Call: _e.mock.On("GetWideHandle")}
2148}
2149
2150func (_c *MockPanedWidget_GetWideHandle_Call) Run(run func()) *MockPanedWidget_GetWideHandle_Call {
2151	_c.Call.Run(func(args mock.Arguments) {
2152		run()
2153	})
2154	return _c
2155}
2156
2157func (_c *MockPanedWidget_GetWideHandle_Call) Return(b bool) *MockPanedWidget_GetWideHandle_Call {
2158	_c.Call.Return(b)
2159	return _c
2160}
2161
2162func (_c *MockPanedWidget_GetWideHandle_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetWideHandle_Call {
2163	_c.Call.Return(run)
2164	return _c
2165}
2166
2167// GrabFocus provides a mock function for the type MockPanedWidget
2168func (_mock *MockPanedWidget) GrabFocus() bool {
2169	ret := _mock.Called()
2170
2171	if len(ret) == 0 {
2172		panic("no return value specified for GrabFocus")
2173	}
2174
2175	var r0 bool
2176	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2177		r0 = returnFunc()
2178	} else {
2179		r0 = ret.Get(0).(bool)
2180	}
2181	return r0
2182}
2183
2184// MockPanedWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
2185type MockPanedWidget_GrabFocus_Call struct {
2186	*mock.Call
2187}
2188
2189// GrabFocus is a helper method to define mock.On call
2190func (_e *MockPanedWidget_Expecter) GrabFocus() *MockPanedWidget_GrabFocus_Call {
2191	return &MockPanedWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
2192}
2193
2194func (_c *MockPanedWidget_GrabFocus_Call) Run(run func()) *MockPanedWidget_GrabFocus_Call {
2195	_c.Call.Run(func(args mock.Arguments) {
2196		run()
2197	})
2198	return _c
2199}
2200
2201func (_c *MockPanedWidget_GrabFocus_Call) Return(b bool) *MockPanedWidget_GrabFocus_Call {
2202	_c.Call.Return(b)
2203	return _c
2204}
2205
2206func (_c *MockPanedWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockPanedWidget_GrabFocus_Call {
2207	_c.Call.Return(run)
2208	return _c
2209}
2210
2211// GtkWidget provides a mock function for the type MockPanedWidget
2212func (_mock *MockPanedWidget) GtkWidget() *gtk.Widget {
2213	ret := _mock.Called()
2214
2215	if len(ret) == 0 {
2216		panic("no return value specified for GtkWidget")
2217	}
2218
2219	var r0 *gtk.Widget
2220	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
2221		r0 = returnFunc()
2222	} else {
2223		if ret.Get(0) != nil {
2224			r0 = ret.Get(0).(*gtk.Widget)
2225		}
2226	}
2227	return r0
2228}
2229
2230// MockPanedWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
2231type MockPanedWidget_GtkWidget_Call struct {
2232	*mock.Call
2233}
2234
2235// GtkWidget is a helper method to define mock.On call
2236func (_e *MockPanedWidget_Expecter) GtkWidget() *MockPanedWidget_GtkWidget_Call {
2237	return &MockPanedWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
2238}
2239
2240func (_c *MockPanedWidget_GtkWidget_Call) Run(run func()) *MockPanedWidget_GtkWidget_Call {
2241	_c.Call.Run(func(args mock.Arguments) {
2242		run()
2243	})
2244	return _c
2245}
2246
2247func (_c *MockPanedWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockPanedWidget_GtkWidget_Call {
2248	_c.Call.Return(widget)
2249	return _c
2250}
2251
2252func (_c *MockPanedWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockPanedWidget_GtkWidget_Call {
2253	_c.Call.Return(run)
2254	return _c
2255}
2256
2257// HasCssClass provides a mock function for the type MockPanedWidget
2258func (_mock *MockPanedWidget) HasCssClass(cssClass string) bool {
2259	ret := _mock.Called(cssClass)
2260
2261	if len(ret) == 0 {
2262		panic("no return value specified for HasCssClass")
2263	}
2264
2265	var r0 bool
2266	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
2267		r0 = returnFunc(cssClass)
2268	} else {
2269		r0 = ret.Get(0).(bool)
2270	}
2271	return r0
2272}
2273
2274// MockPanedWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
2275type MockPanedWidget_HasCssClass_Call struct {
2276	*mock.Call
2277}
2278
2279// HasCssClass is a helper method to define mock.On call
2280//   - cssClass string
2281func (_e *MockPanedWidget_Expecter) HasCssClass(cssClass interface{}) *MockPanedWidget_HasCssClass_Call {
2282	return &MockPanedWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
2283}
2284
2285func (_c *MockPanedWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_HasCssClass_Call {
2286	_c.Call.Run(func(args mock.Arguments) {
2287		var arg0 string
2288		if args[0] != nil {
2289			arg0 = args[0].(string)
2290		}
2291		run(
2292			arg0,
2293		)
2294	})
2295	return _c
2296}
2297
2298func (_c *MockPanedWidget_HasCssClass_Call) Return(b bool) *MockPanedWidget_HasCssClass_Call {
2299	_c.Call.Return(b)
2300	return _c
2301}
2302
2303func (_c *MockPanedWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockPanedWidget_HasCssClass_Call {
2304	_c.Call.Return(run)
2305	return _c
2306}
2307
2308// HasFocus provides a mock function for the type MockPanedWidget
2309func (_mock *MockPanedWidget) HasFocus() bool {
2310	ret := _mock.Called()
2311
2312	if len(ret) == 0 {
2313		panic("no return value specified for HasFocus")
2314	}
2315
2316	var r0 bool
2317	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2318		r0 = returnFunc()
2319	} else {
2320		r0 = ret.Get(0).(bool)
2321	}
2322	return r0
2323}
2324
2325// MockPanedWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
2326type MockPanedWidget_HasFocus_Call struct {
2327	*mock.Call
2328}
2329
2330// HasFocus is a helper method to define mock.On call
2331func (_e *MockPanedWidget_Expecter) HasFocus() *MockPanedWidget_HasFocus_Call {
2332	return &MockPanedWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
2333}
2334
2335func (_c *MockPanedWidget_HasFocus_Call) Run(run func()) *MockPanedWidget_HasFocus_Call {
2336	_c.Call.Run(func(args mock.Arguments) {
2337		run()
2338	})
2339	return _c
2340}
2341
2342func (_c *MockPanedWidget_HasFocus_Call) Return(b bool) *MockPanedWidget_HasFocus_Call {
2343	_c.Call.Return(b)
2344	return _c
2345}
2346
2347func (_c *MockPanedWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockPanedWidget_HasFocus_Call {
2348	_c.Call.Return(run)
2349	return _c
2350}
2351
2352// Hide provides a mock function for the type MockPanedWidget
2353func (_mock *MockPanedWidget) Hide() {
2354	_mock.Called()
2355	return
2356}
2357
2358// MockPanedWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
2359type MockPanedWidget_Hide_Call struct {
2360	*mock.Call
2361}
2362
2363// Hide is a helper method to define mock.On call
2364func (_e *MockPanedWidget_Expecter) Hide() *MockPanedWidget_Hide_Call {
2365	return &MockPanedWidget_Hide_Call{Call: _e.mock.On("Hide")}
2366}
2367
2368func (_c *MockPanedWidget_Hide_Call) Run(run func()) *MockPanedWidget_Hide_Call {
2369	_c.Call.Run(func(args mock.Arguments) {
2370		run()
2371	})
2372	return _c
2373}
2374
2375func (_c *MockPanedWidget_Hide_Call) Return() *MockPanedWidget_Hide_Call {
2376	_c.Call.Return()
2377	return _c
2378}
2379
2380func (_c *MockPanedWidget_Hide_Call) RunAndReturn(run func()) *MockPanedWidget_Hide_Call {
2381	_c.Run(run)
2382	return _c
2383}
2384
2385// IsVisible provides a mock function for the type MockPanedWidget
2386func (_mock *MockPanedWidget) IsVisible() bool {
2387	ret := _mock.Called()
2388
2389	if len(ret) == 0 {
2390		panic("no return value specified for IsVisible")
2391	}
2392
2393	var r0 bool
2394	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2395		r0 = returnFunc()
2396	} else {
2397		r0 = ret.Get(0).(bool)
2398	}
2399	return r0
2400}
2401
2402// MockPanedWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
2403type MockPanedWidget_IsVisible_Call struct {
2404	*mock.Call
2405}
2406
2407// IsVisible is a helper method to define mock.On call
2408func (_e *MockPanedWidget_Expecter) IsVisible() *MockPanedWidget_IsVisible_Call {
2409	return &MockPanedWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
2410}
2411
2412func (_c *MockPanedWidget_IsVisible_Call) Run(run func()) *MockPanedWidget_IsVisible_Call {
2413	_c.Call.Run(func(args mock.Arguments) {
2414		run()
2415	})
2416	return _c
2417}
2418
2419func (_c *MockPanedWidget_IsVisible_Call) Return(b bool) *MockPanedWidget_IsVisible_Call {
2420	_c.Call.Return(b)
2421	return _c
2422}
2423
2424func (_c *MockPanedWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockPanedWidget_IsVisible_Call {
2425	_c.Call.Return(run)
2426	return _c
2427}
2428
2429// RemoveCssClass provides a mock function for the type MockPanedWidget
2430func (_mock *MockPanedWidget) RemoveCssClass(cssClass string) {
2431	_mock.Called(cssClass)
2432	return
2433}
2434
2435// MockPanedWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
2436type MockPanedWidget_RemoveCssClass_Call struct {
2437	*mock.Call
2438}
2439
2440// RemoveCssClass is a helper method to define mock.On call
2441//   - cssClass string
2442func (_e *MockPanedWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockPanedWidget_RemoveCssClass_Call {
2443	return &MockPanedWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
2444}
2445
2446func (_c *MockPanedWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_RemoveCssClass_Call {
2447	_c.Call.Run(func(args mock.Arguments) {
2448		var arg0 string
2449		if args[0] != nil {
2450			arg0 = args[0].(string)
2451		}
2452		run(
2453			arg0,
2454		)
2455	})
2456	return _c
2457}
2458
2459func (_c *MockPanedWidget_RemoveCssClass_Call) Return() *MockPanedWidget_RemoveCssClass_Call {
2460	_c.Call.Return()
2461	return _c
2462}
2463
2464func (_c *MockPanedWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockPanedWidget_RemoveCssClass_Call {
2465	_c.Run(run)
2466	return _c
2467}
2468
2469// SetCanFocus provides a mock function for the type MockPanedWidget
2470func (_mock *MockPanedWidget) SetCanFocus(canFocus bool) {
2471	_mock.Called(canFocus)
2472	return
2473}
2474
2475// MockPanedWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
2476type MockPanedWidget_SetCanFocus_Call struct {
2477	*mock.Call
2478}
2479
2480// SetCanFocus is a helper method to define mock.On call
2481//   - canFocus bool
2482func (_e *MockPanedWidget_Expecter) SetCanFocus(canFocus interface{}) *MockPanedWidget_SetCanFocus_Call {
2483	return &MockPanedWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
2484}
2485
2486func (_c *MockPanedWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockPanedWidget_SetCanFocus_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_SetCanFocus_Call) Return() *MockPanedWidget_SetCanFocus_Call {
2500	_c.Call.Return()
2501	return _c
2502}
2503
2504func (_c *MockPanedWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockPanedWidget_SetCanFocus_Call {
2505	_c.Run(run)
2506	return _c
2507}
2508
2509// SetCanTarget provides a mock function for the type MockPanedWidget
2510func (_mock *MockPanedWidget) SetCanTarget(canTarget bool) {
2511	_mock.Called(canTarget)
2512	return
2513}
2514
2515// MockPanedWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
2516type MockPanedWidget_SetCanTarget_Call struct {
2517	*mock.Call
2518}
2519
2520// SetCanTarget is a helper method to define mock.On call
2521//   - canTarget bool
2522func (_e *MockPanedWidget_Expecter) SetCanTarget(canTarget interface{}) *MockPanedWidget_SetCanTarget_Call {
2523	return &MockPanedWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
2524}
2525
2526func (_c *MockPanedWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockPanedWidget_SetCanTarget_Call {
2527	_c.Call.Run(func(args mock.Arguments) {
2528		var arg0 bool
2529		if args[0] != nil {
2530			arg0 = args[0].(bool)
2531		}
2532		run(
2533			arg0,
2534		)
2535	})
2536	return _c
2537}
2538
2539func (_c *MockPanedWidget_SetCanTarget_Call) Return() *MockPanedWidget_SetCanTarget_Call {
2540	_c.Call.Return()
2541	return _c
2542}
2543
2544func (_c *MockPanedWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockPanedWidget_SetCanTarget_Call {
2545	_c.Run(run)
2546	return _c
2547}
2548
2549// SetEndChild provides a mock function for the type MockPanedWidget
2550func (_mock *MockPanedWidget) SetEndChild(child layout.Widget) {
2551	_mock.Called(child)
2552	return
2553}
2554
2555// MockPanedWidget_SetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEndChild'
2556type MockPanedWidget_SetEndChild_Call struct {
2557	*mock.Call
2558}
2559
2560// SetEndChild is a helper method to define mock.On call
2561//   - child layout.Widget
2562func (_e *MockPanedWidget_Expecter) SetEndChild(child interface{}) *MockPanedWidget_SetEndChild_Call {
2563	return &MockPanedWidget_SetEndChild_Call{Call: _e.mock.On("SetEndChild", child)}
2564}
2565
2566func (_c *MockPanedWidget_SetEndChild_Call) Run(run func(child layout.Widget)) *MockPanedWidget_SetEndChild_Call {
2567	_c.Call.Run(func(args mock.Arguments) {
2568		var arg0 layout.Widget
2569		if args[0] != nil {
2570			arg0 = args[0].(layout.Widget)
2571		}
2572		run(
2573			arg0,
2574		)
2575	})
2576	return _c
2577}
2578
2579func (_c *MockPanedWidget_SetEndChild_Call) Return() *MockPanedWidget_SetEndChild_Call {
2580	_c.Call.Return()
2581	return _c
2582}
2583
2584func (_c *MockPanedWidget_SetEndChild_Call) RunAndReturn(run func(child layout.Widget)) *MockPanedWidget_SetEndChild_Call {
2585	_c.Run(run)
2586	return _c
2587}
2588
2589// SetFocusOnClick provides a mock function for the type MockPanedWidget
2590func (_mock *MockPanedWidget) SetFocusOnClick(focusOnClick bool) {
2591	_mock.Called(focusOnClick)
2592	return
2593}
2594
2595// MockPanedWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
2596type MockPanedWidget_SetFocusOnClick_Call struct {
2597	*mock.Call
2598}
2599
2600// SetFocusOnClick is a helper method to define mock.On call
2601//   - focusOnClick bool
2602func (_e *MockPanedWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockPanedWidget_SetFocusOnClick_Call {
2603	return &MockPanedWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
2604}
2605
2606func (_c *MockPanedWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockPanedWidget_SetFocusOnClick_Call {
2607	_c.Call.Run(func(args mock.Arguments) {
2608		var arg0 bool
2609		if args[0] != nil {
2610			arg0 = args[0].(bool)
2611		}
2612		run(
2613			arg0,
2614		)
2615	})
2616	return _c
2617}
2618
2619func (_c *MockPanedWidget_SetFocusOnClick_Call) Return() *MockPanedWidget_SetFocusOnClick_Call {
2620	_c.Call.Return()
2621	return _c
2622}
2623
2624func (_c *MockPanedWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockPanedWidget_SetFocusOnClick_Call {
2625	_c.Run(run)
2626	return _c
2627}
2628
2629// SetFocusable provides a mock function for the type MockPanedWidget
2630func (_mock *MockPanedWidget) SetFocusable(focusable bool) {
2631	_mock.Called(focusable)
2632	return
2633}
2634
2635// MockPanedWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
2636type MockPanedWidget_SetFocusable_Call struct {
2637	*mock.Call
2638}
2639
2640// SetFocusable is a helper method to define mock.On call
2641//   - focusable bool
2642func (_e *MockPanedWidget_Expecter) SetFocusable(focusable interface{}) *MockPanedWidget_SetFocusable_Call {
2643	return &MockPanedWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
2644}
2645
2646func (_c *MockPanedWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockPanedWidget_SetFocusable_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_SetFocusable_Call) Return() *MockPanedWidget_SetFocusable_Call {
2660	_c.Call.Return()
2661	return _c
2662}
2663
2664func (_c *MockPanedWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockPanedWidget_SetFocusable_Call {
2665	_c.Run(run)
2666	return _c
2667}
2668
2669// SetHalign provides a mock function for the type MockPanedWidget
2670func (_mock *MockPanedWidget) SetHalign(align gtk.Align) {
2671	_mock.Called(align)
2672	return
2673}
2674
2675// MockPanedWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
2676type MockPanedWidget_SetHalign_Call struct {
2677	*mock.Call
2678}
2679
2680// SetHalign is a helper method to define mock.On call
2681//   - align gtk.Align
2682func (_e *MockPanedWidget_Expecter) SetHalign(align interface{}) *MockPanedWidget_SetHalign_Call {
2683	return &MockPanedWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
2684}
2685
2686func (_c *MockPanedWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockPanedWidget_SetHalign_Call {
2687	_c.Call.Run(func(args mock.Arguments) {
2688		var arg0 gtk.Align
2689		if args[0] != nil {
2690			arg0 = args[0].(gtk.Align)
2691		}
2692		run(
2693			arg0,
2694		)
2695	})
2696	return _c
2697}
2698
2699func (_c *MockPanedWidget_SetHalign_Call) Return() *MockPanedWidget_SetHalign_Call {
2700	_c.Call.Return()
2701	return _c
2702}
2703
2704func (_c *MockPanedWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockPanedWidget_SetHalign_Call {
2705	_c.Run(run)
2706	return _c
2707}
2708
2709// SetHexpand provides a mock function for the type MockPanedWidget
2710func (_mock *MockPanedWidget) SetHexpand(expand bool) {
2711	_mock.Called(expand)
2712	return
2713}
2714
2715// MockPanedWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
2716type MockPanedWidget_SetHexpand_Call struct {
2717	*mock.Call
2718}
2719
2720// SetHexpand is a helper method to define mock.On call
2721//   - expand bool
2722func (_e *MockPanedWidget_Expecter) SetHexpand(expand interface{}) *MockPanedWidget_SetHexpand_Call {
2723	return &MockPanedWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
2724}
2725
2726func (_c *MockPanedWidget_SetHexpand_Call) Run(run func(expand bool)) *MockPanedWidget_SetHexpand_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_SetHexpand_Call) Return() *MockPanedWidget_SetHexpand_Call {
2740	_c.Call.Return()
2741	return _c
2742}
2743
2744func (_c *MockPanedWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockPanedWidget_SetHexpand_Call {
2745	_c.Run(run)
2746	return _c
2747}
2748
2749// SetPosition provides a mock function for the type MockPanedWidget
2750func (_mock *MockPanedWidget) SetPosition(position int) {
2751	_mock.Called(position)
2752	return
2753}
2754
2755// MockPanedWidget_SetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPosition'
2756type MockPanedWidget_SetPosition_Call struct {
2757	*mock.Call
2758}
2759
2760// SetPosition is a helper method to define mock.On call
2761//   - position int
2762func (_e *MockPanedWidget_Expecter) SetPosition(position interface{}) *MockPanedWidget_SetPosition_Call {
2763	return &MockPanedWidget_SetPosition_Call{Call: _e.mock.On("SetPosition", position)}
2764}
2765
2766func (_c *MockPanedWidget_SetPosition_Call) Run(run func(position int)) *MockPanedWidget_SetPosition_Call {
2767	_c.Call.Run(func(args mock.Arguments) {
2768		var arg0 int
2769		if args[0] != nil {
2770			arg0 = args[0].(int)
2771		}
2772		run(
2773			arg0,
2774		)
2775	})
2776	return _c
2777}
2778
2779func (_c *MockPanedWidget_SetPosition_Call) Return() *MockPanedWidget_SetPosition_Call {
2780	_c.Call.Return()
2781	return _c
2782}
2783
2784func (_c *MockPanedWidget_SetPosition_Call) RunAndReturn(run func(position int)) *MockPanedWidget_SetPosition_Call {
2785	_c.Run(run)
2786	return _c
2787}
2788
2789// SetResizeEndChild provides a mock function for the type MockPanedWidget
2790func (_mock *MockPanedWidget) SetResizeEndChild(resize bool) {
2791	_mock.Called(resize)
2792	return
2793}
2794
2795// MockPanedWidget_SetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeEndChild'
2796type MockPanedWidget_SetResizeEndChild_Call struct {
2797	*mock.Call
2798}
2799
2800// SetResizeEndChild is a helper method to define mock.On call
2801//   - resize bool
2802func (_e *MockPanedWidget_Expecter) SetResizeEndChild(resize interface{}) *MockPanedWidget_SetResizeEndChild_Call {
2803	return &MockPanedWidget_SetResizeEndChild_Call{Call: _e.mock.On("SetResizeEndChild", resize)}
2804}
2805
2806func (_c *MockPanedWidget_SetResizeEndChild_Call) Run(run func(resize bool)) *MockPanedWidget_SetResizeEndChild_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_SetResizeEndChild_Call) Return() *MockPanedWidget_SetResizeEndChild_Call {
2820	_c.Call.Return()
2821	return _c
2822}
2823
2824func (_c *MockPanedWidget_SetResizeEndChild_Call) RunAndReturn(run func(resize bool)) *MockPanedWidget_SetResizeEndChild_Call {
2825	_c.Run(run)
2826	return _c
2827}
2828
2829// SetResizeStartChild provides a mock function for the type MockPanedWidget
2830func (_mock *MockPanedWidget) SetResizeStartChild(resize bool) {
2831	_mock.Called(resize)
2832	return
2833}
2834
2835// MockPanedWidget_SetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeStartChild'
2836type MockPanedWidget_SetResizeStartChild_Call struct {
2837	*mock.Call
2838}
2839
2840// SetResizeStartChild is a helper method to define mock.On call
2841//   - resize bool
2842func (_e *MockPanedWidget_Expecter) SetResizeStartChild(resize interface{}) *MockPanedWidget_SetResizeStartChild_Call {
2843	return &MockPanedWidget_SetResizeStartChild_Call{Call: _e.mock.On("SetResizeStartChild", resize)}
2844}
2845
2846func (_c *MockPanedWidget_SetResizeStartChild_Call) Run(run func(resize bool)) *MockPanedWidget_SetResizeStartChild_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_SetResizeStartChild_Call) Return() *MockPanedWidget_SetResizeStartChild_Call {
2860	_c.Call.Return()
2861	return _c
2862}
2863
2864func (_c *MockPanedWidget_SetResizeStartChild_Call) RunAndReturn(run func(resize bool)) *MockPanedWidget_SetResizeStartChild_Call {
2865	_c.Run(run)
2866	return _c
2867}
2868
2869// SetShrinkEndChild provides a mock function for the type MockPanedWidget
2870func (_mock *MockPanedWidget) SetShrinkEndChild(shrink bool) {
2871	_mock.Called(shrink)
2872	return
2873}
2874
2875// MockPanedWidget_SetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkEndChild'
2876type MockPanedWidget_SetShrinkEndChild_Call struct {
2877	*mock.Call
2878}
2879
2880// SetShrinkEndChild is a helper method to define mock.On call
2881//   - shrink bool
2882func (_e *MockPanedWidget_Expecter) SetShrinkEndChild(shrink interface{}) *MockPanedWidget_SetShrinkEndChild_Call {
2883	return &MockPanedWidget_SetShrinkEndChild_Call{Call: _e.mock.On("SetShrinkEndChild", shrink)}
2884}
2885
2886func (_c *MockPanedWidget_SetShrinkEndChild_Call) Run(run func(shrink bool)) *MockPanedWidget_SetShrinkEndChild_Call {
2887	_c.Call.Run(func(args mock.Arguments) {
2888		var arg0 bool
2889		if args[0] != nil {
2890			arg0 = args[0].(bool)
2891		}
2892		run(
2893			arg0,
2894		)
2895	})
2896	return _c
2897}
2898
2899func (_c *MockPanedWidget_SetShrinkEndChild_Call) Return() *MockPanedWidget_SetShrinkEndChild_Call {
2900	_c.Call.Return()
2901	return _c
2902}
2903
2904func (_c *MockPanedWidget_SetShrinkEndChild_Call) RunAndReturn(run func(shrink bool)) *MockPanedWidget_SetShrinkEndChild_Call {
2905	_c.Run(run)
2906	return _c
2907}
2908
2909// SetShrinkStartChild provides a mock function for the type MockPanedWidget
2910func (_mock *MockPanedWidget) SetShrinkStartChild(shrink bool) {
2911	_mock.Called(shrink)
2912	return
2913}
2914
2915// MockPanedWidget_SetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkStartChild'
2916type MockPanedWidget_SetShrinkStartChild_Call struct {
2917	*mock.Call
2918}
2919
2920// SetShrinkStartChild is a helper method to define mock.On call
2921//   - shrink bool
2922func (_e *MockPanedWidget_Expecter) SetShrinkStartChild(shrink interface{}) *MockPanedWidget_SetShrinkStartChild_Call {
2923	return &MockPanedWidget_SetShrinkStartChild_Call{Call: _e.mock.On("SetShrinkStartChild", shrink)}
2924}
2925
2926func (_c *MockPanedWidget_SetShrinkStartChild_Call) Run(run func(shrink bool)) *MockPanedWidget_SetShrinkStartChild_Call {
2927	_c.Call.Run(func(args mock.Arguments) {
2928		var arg0 bool
2929		if args[0] != nil {
2930			arg0 = args[0].(bool)
2931		}
2932		run(
2933			arg0,
2934		)
2935	})
2936	return _c
2937}
2938
2939func (_c *MockPanedWidget_SetShrinkStartChild_Call) Return() *MockPanedWidget_SetShrinkStartChild_Call {
2940	_c.Call.Return()
2941	return _c
2942}
2943
2944func (_c *MockPanedWidget_SetShrinkStartChild_Call) RunAndReturn(run func(shrink bool)) *MockPanedWidget_SetShrinkStartChild_Call {
2945	_c.Run(run)
2946	return _c
2947}
2948
2949// SetSizeRequest provides a mock function for the type MockPanedWidget
2950func (_mock *MockPanedWidget) SetSizeRequest(width int, height int) {
2951	_mock.Called(width, height)
2952	return
2953}
2954
2955// MockPanedWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
2956type MockPanedWidget_SetSizeRequest_Call struct {
2957	*mock.Call
2958}
2959
2960// SetSizeRequest is a helper method to define mock.On call
2961//   - width int
2962//   - height int
2963func (_e *MockPanedWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockPanedWidget_SetSizeRequest_Call {
2964	return &MockPanedWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
2965}
2966
2967func (_c *MockPanedWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockPanedWidget_SetSizeRequest_Call {
2968	_c.Call.Run(func(args mock.Arguments) {
2969		var arg0 int
2970		if args[0] != nil {
2971			arg0 = args[0].(int)
2972		}
2973		var arg1 int
2974		if args[1] != nil {
2975			arg1 = args[1].(int)
2976		}
2977		run(
2978			arg0,
2979			arg1,
2980		)
2981	})
2982	return _c
2983}
2984
2985func (_c *MockPanedWidget_SetSizeRequest_Call) Return() *MockPanedWidget_SetSizeRequest_Call {
2986	_c.Call.Return()
2987	return _c
2988}
2989
2990func (_c *MockPanedWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockPanedWidget_SetSizeRequest_Call {
2991	_c.Run(run)
2992	return _c
2993}
2994
2995// SetStartChild provides a mock function for the type MockPanedWidget
2996func (_mock *MockPanedWidget) SetStartChild(child layout.Widget) {
2997	_mock.Called(child)
2998	return
2999}
3000
3001// MockPanedWidget_SetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStartChild'
3002type MockPanedWidget_SetStartChild_Call struct {
3003	*mock.Call
3004}
3005
3006// SetStartChild is a helper method to define mock.On call
3007//   - child layout.Widget
3008func (_e *MockPanedWidget_Expecter) SetStartChild(child interface{}) *MockPanedWidget_SetStartChild_Call {
3009	return &MockPanedWidget_SetStartChild_Call{Call: _e.mock.On("SetStartChild", child)}
3010}
3011
3012func (_c *MockPanedWidget_SetStartChild_Call) Run(run func(child layout.Widget)) *MockPanedWidget_SetStartChild_Call {
3013	_c.Call.Run(func(args mock.Arguments) {
3014		var arg0 layout.Widget
3015		if args[0] != nil {
3016			arg0 = args[0].(layout.Widget)
3017		}
3018		run(
3019			arg0,
3020		)
3021	})
3022	return _c
3023}
3024
3025func (_c *MockPanedWidget_SetStartChild_Call) Return() *MockPanedWidget_SetStartChild_Call {
3026	_c.Call.Return()
3027	return _c
3028}
3029
3030func (_c *MockPanedWidget_SetStartChild_Call) RunAndReturn(run func(child layout.Widget)) *MockPanedWidget_SetStartChild_Call {
3031	_c.Run(run)
3032	return _c
3033}
3034
3035// SetValign provides a mock function for the type MockPanedWidget
3036func (_mock *MockPanedWidget) SetValign(align gtk.Align) {
3037	_mock.Called(align)
3038	return
3039}
3040
3041// MockPanedWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
3042type MockPanedWidget_SetValign_Call struct {
3043	*mock.Call
3044}
3045
3046// SetValign is a helper method to define mock.On call
3047//   - align gtk.Align
3048func (_e *MockPanedWidget_Expecter) SetValign(align interface{}) *MockPanedWidget_SetValign_Call {
3049	return &MockPanedWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
3050}
3051
3052func (_c *MockPanedWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockPanedWidget_SetValign_Call {
3053	_c.Call.Run(func(args mock.Arguments) {
3054		var arg0 gtk.Align
3055		if args[0] != nil {
3056			arg0 = args[0].(gtk.Align)
3057		}
3058		run(
3059			arg0,
3060		)
3061	})
3062	return _c
3063}
3064
3065func (_c *MockPanedWidget_SetValign_Call) Return() *MockPanedWidget_SetValign_Call {
3066	_c.Call.Return()
3067	return _c
3068}
3069
3070func (_c *MockPanedWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockPanedWidget_SetValign_Call {
3071	_c.Run(run)
3072	return _c
3073}
3074
3075// SetVexpand provides a mock function for the type MockPanedWidget
3076func (_mock *MockPanedWidget) SetVexpand(expand bool) {
3077	_mock.Called(expand)
3078	return
3079}
3080
3081// MockPanedWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
3082type MockPanedWidget_SetVexpand_Call struct {
3083	*mock.Call
3084}
3085
3086// SetVexpand is a helper method to define mock.On call
3087//   - expand bool
3088func (_e *MockPanedWidget_Expecter) SetVexpand(expand interface{}) *MockPanedWidget_SetVexpand_Call {
3089	return &MockPanedWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
3090}
3091
3092func (_c *MockPanedWidget_SetVexpand_Call) Run(run func(expand bool)) *MockPanedWidget_SetVexpand_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_SetVexpand_Call) Return() *MockPanedWidget_SetVexpand_Call {
3106	_c.Call.Return()
3107	return _c
3108}
3109
3110func (_c *MockPanedWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockPanedWidget_SetVexpand_Call {
3111	_c.Run(run)
3112	return _c
3113}
3114
3115// SetVisible provides a mock function for the type MockPanedWidget
3116func (_mock *MockPanedWidget) SetVisible(visible bool) {
3117	_mock.Called(visible)
3118	return
3119}
3120
3121// MockPanedWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
3122type MockPanedWidget_SetVisible_Call struct {
3123	*mock.Call
3124}
3125
3126// SetVisible is a helper method to define mock.On call
3127//   - visible bool
3128func (_e *MockPanedWidget_Expecter) SetVisible(visible interface{}) *MockPanedWidget_SetVisible_Call {
3129	return &MockPanedWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
3130}
3131
3132func (_c *MockPanedWidget_SetVisible_Call) Run(run func(visible bool)) *MockPanedWidget_SetVisible_Call {
3133	_c.Call.Run(func(args mock.Arguments) {
3134		var arg0 bool
3135		if args[0] != nil {
3136			arg0 = args[0].(bool)
3137		}
3138		run(
3139			arg0,
3140		)
3141	})
3142	return _c
3143}
3144
3145func (_c *MockPanedWidget_SetVisible_Call) Return() *MockPanedWidget_SetVisible_Call {
3146	_c.Call.Return()
3147	return _c
3148}
3149
3150func (_c *MockPanedWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockPanedWidget_SetVisible_Call {
3151	_c.Run(run)
3152	return _c
3153}
3154
3155// SetWideHandle provides a mock function for the type MockPanedWidget
3156func (_mock *MockPanedWidget) SetWideHandle(wide bool) {
3157	_mock.Called(wide)
3158	return
3159}
3160
3161// MockPanedWidget_SetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWideHandle'
3162type MockPanedWidget_SetWideHandle_Call struct {
3163	*mock.Call
3164}
3165
3166// SetWideHandle is a helper method to define mock.On call
3167//   - wide bool
3168func (_e *MockPanedWidget_Expecter) SetWideHandle(wide interface{}) *MockPanedWidget_SetWideHandle_Call {
3169	return &MockPanedWidget_SetWideHandle_Call{Call: _e.mock.On("SetWideHandle", wide)}
3170}
3171
3172func (_c *MockPanedWidget_SetWideHandle_Call) Run(run func(wide bool)) *MockPanedWidget_SetWideHandle_Call {
3173	_c.Call.Run(func(args mock.Arguments) {
3174		var arg0 bool
3175		if args[0] != nil {
3176			arg0 = args[0].(bool)
3177		}
3178		run(
3179			arg0,
3180		)
3181	})
3182	return _c
3183}
3184
3185func (_c *MockPanedWidget_SetWideHandle_Call) Return() *MockPanedWidget_SetWideHandle_Call {
3186	_c.Call.Return()
3187	return _c
3188}
3189
3190func (_c *MockPanedWidget_SetWideHandle_Call) RunAndReturn(run func(wide bool)) *MockPanedWidget_SetWideHandle_Call {
3191	_c.Run(run)
3192	return _c
3193}
3194
3195// Show provides a mock function for the type MockPanedWidget
3196func (_mock *MockPanedWidget) Show() {
3197	_mock.Called()
3198	return
3199}
3200
3201// MockPanedWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
3202type MockPanedWidget_Show_Call struct {
3203	*mock.Call
3204}
3205
3206// Show is a helper method to define mock.On call
3207func (_e *MockPanedWidget_Expecter) Show() *MockPanedWidget_Show_Call {
3208	return &MockPanedWidget_Show_Call{Call: _e.mock.On("Show")}
3209}
3210
3211func (_c *MockPanedWidget_Show_Call) Run(run func()) *MockPanedWidget_Show_Call {
3212	_c.Call.Run(func(args mock.Arguments) {
3213		run()
3214	})
3215	return _c
3216}
3217
3218func (_c *MockPanedWidget_Show_Call) Return() *MockPanedWidget_Show_Call {
3219	_c.Call.Return()
3220	return _c
3221}
3222
3223func (_c *MockPanedWidget_Show_Call) RunAndReturn(run func()) *MockPanedWidget_Show_Call {
3224	_c.Run(run)
3225	return _c
3226}
3227
3228// Unparent provides a mock function for the type MockPanedWidget
3229func (_mock *MockPanedWidget) Unparent() {
3230	_mock.Called()
3231	return
3232}
3233
3234// MockPanedWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
3235type MockPanedWidget_Unparent_Call struct {
3236	*mock.Call
3237}
3238
3239// Unparent is a helper method to define mock.On call
3240func (_e *MockPanedWidget_Expecter) Unparent() *MockPanedWidget_Unparent_Call {
3241	return &MockPanedWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
3242}
3243
3244func (_c *MockPanedWidget_Unparent_Call) Run(run func()) *MockPanedWidget_Unparent_Call {
3245	_c.Call.Run(func(args mock.Arguments) {
3246		run()
3247	})
3248	return _c
3249}
3250
3251func (_c *MockPanedWidget_Unparent_Call) Return() *MockPanedWidget_Unparent_Call {
3252	_c.Call.Return()
3253	return _c
3254}
3255
3256func (_c *MockPanedWidget_Unparent_Call) RunAndReturn(run func()) *MockPanedWidget_Unparent_Call {
3257	_c.Run(run)
3258	return _c
3259}
3260
3261// 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.
3262// The first argument is typically a *testing.T value.
3263func NewMockBoxWidget(t interface {
3264	mock.TestingT
3265	Cleanup(func())
3266}) *MockBoxWidget {
3267	mock := &MockBoxWidget{}
3268	mock.Mock.Test(t)
3269
3270	t.Cleanup(func() { mock.AssertExpectations(t) })
3271
3272	return mock
3273}
3274
3275// MockBoxWidget is an autogenerated mock type for the BoxWidget type
3276type MockBoxWidget struct {
3277	mock.Mock
3278}
3279
3280type MockBoxWidget_Expecter struct {
3281	mock *mock.Mock
3282}
3283
3284func (_m *MockBoxWidget) EXPECT() *MockBoxWidget_Expecter {
3285	return &MockBoxWidget_Expecter{mock: &_m.Mock}
3286}
3287
3288// AddController provides a mock function for the type MockBoxWidget
3289func (_mock *MockBoxWidget) AddController(controller *gtk.EventController) {
3290	_mock.Called(controller)
3291	return
3292}
3293
3294// MockBoxWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
3295type MockBoxWidget_AddController_Call struct {
3296	*mock.Call
3297}
3298
3299// AddController is a helper method to define mock.On call
3300//   - controller *gtk.EventController
3301func (_e *MockBoxWidget_Expecter) AddController(controller interface{}) *MockBoxWidget_AddController_Call {
3302	return &MockBoxWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
3303}
3304
3305func (_c *MockBoxWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockBoxWidget_AddController_Call {
3306	_c.Call.Run(func(args mock.Arguments) {
3307		var arg0 *gtk.EventController
3308		if args[0] != nil {
3309			arg0 = args[0].(*gtk.EventController)
3310		}
3311		run(
3312			arg0,
3313		)
3314	})
3315	return _c
3316}
3317
3318func (_c *MockBoxWidget_AddController_Call) Return() *MockBoxWidget_AddController_Call {
3319	_c.Call.Return()
3320	return _c
3321}
3322
3323func (_c *MockBoxWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockBoxWidget_AddController_Call {
3324	_c.Run(run)
3325	return _c
3326}
3327
3328// AddCssClass provides a mock function for the type MockBoxWidget
3329func (_mock *MockBoxWidget) AddCssClass(cssClass string) {
3330	_mock.Called(cssClass)
3331	return
3332}
3333
3334// MockBoxWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
3335type MockBoxWidget_AddCssClass_Call struct {
3336	*mock.Call
3337}
3338
3339// AddCssClass is a helper method to define mock.On call
3340//   - cssClass string
3341func (_e *MockBoxWidget_Expecter) AddCssClass(cssClass interface{}) *MockBoxWidget_AddCssClass_Call {
3342	return &MockBoxWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
3343}
3344
3345func (_c *MockBoxWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_AddCssClass_Call {
3346	_c.Call.Run(func(args mock.Arguments) {
3347		var arg0 string
3348		if args[0] != nil {
3349			arg0 = args[0].(string)
3350		}
3351		run(
3352			arg0,
3353		)
3354	})
3355	return _c
3356}
3357
3358func (_c *MockBoxWidget_AddCssClass_Call) Return() *MockBoxWidget_AddCssClass_Call {
3359	_c.Call.Return()
3360	return _c
3361}
3362
3363func (_c *MockBoxWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockBoxWidget_AddCssClass_Call {
3364	_c.Run(run)
3365	return _c
3366}
3367
3368// Append provides a mock function for the type MockBoxWidget
3369func (_mock *MockBoxWidget) Append(child layout.Widget) {
3370	_mock.Called(child)
3371	return
3372}
3373
3374// MockBoxWidget_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append'
3375type MockBoxWidget_Append_Call struct {
3376	*mock.Call
3377}
3378
3379// Append is a helper method to define mock.On call
3380//   - child layout.Widget
3381func (_e *MockBoxWidget_Expecter) Append(child interface{}) *MockBoxWidget_Append_Call {
3382	return &MockBoxWidget_Append_Call{Call: _e.mock.On("Append", child)}
3383}
3384
3385func (_c *MockBoxWidget_Append_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Append_Call {
3386	_c.Call.Run(func(args mock.Arguments) {
3387		var arg0 layout.Widget
3388		if args[0] != nil {
3389			arg0 = args[0].(layout.Widget)
3390		}
3391		run(
3392			arg0,
3393		)
3394	})
3395	return _c
3396}
3397
3398func (_c *MockBoxWidget_Append_Call) Return() *MockBoxWidget_Append_Call {
3399	_c.Call.Return()
3400	return _c
3401}
3402
3403func (_c *MockBoxWidget_Append_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Append_Call {
3404	_c.Run(run)
3405	return _c
3406}
3407
3408// ComputePoint provides a mock function for the type MockBoxWidget
3409func (_mock *MockBoxWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
3410	ret := _mock.Called(target)
3411
3412	if len(ret) == 0 {
3413		panic("no return value specified for ComputePoint")
3414	}
3415
3416	var r0 float64
3417	var r1 float64
3418	var r2 bool
3419	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
3420		return returnFunc(target)
3421	}
3422	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
3423		r0 = returnFunc(target)
3424	} else {
3425		r0 = ret.Get(0).(float64)
3426	}
3427	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
3428		r1 = returnFunc(target)
3429	} else {
3430		r1 = ret.Get(1).(float64)
3431	}
3432	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
3433		r2 = returnFunc(target)
3434	} else {
3435		r2 = ret.Get(2).(bool)
3436	}
3437	return r0, r1, r2
3438}
3439
3440// MockBoxWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
3441type MockBoxWidget_ComputePoint_Call struct {
3442	*mock.Call
3443}
3444
3445// ComputePoint is a helper method to define mock.On call
3446//   - target layout.Widget
3447func (_e *MockBoxWidget_Expecter) ComputePoint(target interface{}) *MockBoxWidget_ComputePoint_Call {
3448	return &MockBoxWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
3449}
3450
3451func (_c *MockBoxWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockBoxWidget_ComputePoint_Call {
3452	_c.Call.Run(func(args mock.Arguments) {
3453		var arg0 layout.Widget
3454		if args[0] != nil {
3455			arg0 = args[0].(layout.Widget)
3456		}
3457		run(
3458			arg0,
3459		)
3460	})
3461	return _c
3462}
3463
3464func (_c *MockBoxWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockBoxWidget_ComputePoint_Call {
3465	_c.Call.Return(x, y, ok)
3466	return _c
3467}
3468
3469func (_c *MockBoxWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockBoxWidget_ComputePoint_Call {
3470	_c.Call.Return(run)
3471	return _c
3472}
3473
3474// GetAllocatedHeight provides a mock function for the type MockBoxWidget
3475func (_mock *MockBoxWidget) GetAllocatedHeight() int {
3476	ret := _mock.Called()
3477
3478	if len(ret) == 0 {
3479		panic("no return value specified for GetAllocatedHeight")
3480	}
3481
3482	var r0 int
3483	if returnFunc, ok := ret.Get(0).(func() int); ok {
3484		r0 = returnFunc()
3485	} else {
3486		r0 = ret.Get(0).(int)
3487	}
3488	return r0
3489}
3490
3491// MockBoxWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
3492type MockBoxWidget_GetAllocatedHeight_Call struct {
3493	*mock.Call
3494}
3495
3496// GetAllocatedHeight is a helper method to define mock.On call
3497func (_e *MockBoxWidget_Expecter) GetAllocatedHeight() *MockBoxWidget_GetAllocatedHeight_Call {
3498	return &MockBoxWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
3499}
3500
3501func (_c *MockBoxWidget_GetAllocatedHeight_Call) Run(run func()) *MockBoxWidget_GetAllocatedHeight_Call {
3502	_c.Call.Run(func(args mock.Arguments) {
3503		run()
3504	})
3505	return _c
3506}
3507
3508func (_c *MockBoxWidget_GetAllocatedHeight_Call) Return(n int) *MockBoxWidget_GetAllocatedHeight_Call {
3509	_c.Call.Return(n)
3510	return _c
3511}
3512
3513func (_c *MockBoxWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockBoxWidget_GetAllocatedHeight_Call {
3514	_c.Call.Return(run)
3515	return _c
3516}
3517
3518// GetAllocatedWidth provides a mock function for the type MockBoxWidget
3519func (_mock *MockBoxWidget) GetAllocatedWidth() int {
3520	ret := _mock.Called()
3521
3522	if len(ret) == 0 {
3523		panic("no return value specified for GetAllocatedWidth")
3524	}
3525
3526	var r0 int
3527	if returnFunc, ok := ret.Get(0).(func() int); ok {
3528		r0 = returnFunc()
3529	} else {
3530		r0 = ret.Get(0).(int)
3531	}
3532	return r0
3533}
3534
3535// MockBoxWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
3536type MockBoxWidget_GetAllocatedWidth_Call struct {
3537	*mock.Call
3538}
3539
3540// GetAllocatedWidth is a helper method to define mock.On call
3541func (_e *MockBoxWidget_Expecter) GetAllocatedWidth() *MockBoxWidget_GetAllocatedWidth_Call {
3542	return &MockBoxWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
3543}
3544
3545func (_c *MockBoxWidget_GetAllocatedWidth_Call) Run(run func()) *MockBoxWidget_GetAllocatedWidth_Call {
3546	_c.Call.Run(func(args mock.Arguments) {
3547		run()
3548	})
3549	return _c
3550}
3551
3552func (_c *MockBoxWidget_GetAllocatedWidth_Call) Return(n int) *MockBoxWidget_GetAllocatedWidth_Call {
3553	_c.Call.Return(n)
3554	return _c
3555}
3556
3557func (_c *MockBoxWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockBoxWidget_GetAllocatedWidth_Call {
3558	_c.Call.Return(run)
3559	return _c
3560}
3561
3562// GetHexpand provides a mock function for the type MockBoxWidget
3563func (_mock *MockBoxWidget) GetHexpand() bool {
3564	ret := _mock.Called()
3565
3566	if len(ret) == 0 {
3567		panic("no return value specified for GetHexpand")
3568	}
3569
3570	var r0 bool
3571	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3572		r0 = returnFunc()
3573	} else {
3574		r0 = ret.Get(0).(bool)
3575	}
3576	return r0
3577}
3578
3579// MockBoxWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
3580type MockBoxWidget_GetHexpand_Call struct {
3581	*mock.Call
3582}
3583
3584// GetHexpand is a helper method to define mock.On call
3585func (_e *MockBoxWidget_Expecter) GetHexpand() *MockBoxWidget_GetHexpand_Call {
3586	return &MockBoxWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
3587}
3588
3589func (_c *MockBoxWidget_GetHexpand_Call) Run(run func()) *MockBoxWidget_GetHexpand_Call {
3590	_c.Call.Run(func(args mock.Arguments) {
3591		run()
3592	})
3593	return _c
3594}
3595
3596func (_c *MockBoxWidget_GetHexpand_Call) Return(b bool) *MockBoxWidget_GetHexpand_Call {
3597	_c.Call.Return(b)
3598	return _c
3599}
3600
3601func (_c *MockBoxWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetHexpand_Call {
3602	_c.Call.Return(run)
3603	return _c
3604}
3605
3606// GetHomogeneous provides a mock function for the type MockBoxWidget
3607func (_mock *MockBoxWidget) GetHomogeneous() bool {
3608	ret := _mock.Called()
3609
3610	if len(ret) == 0 {
3611		panic("no return value specified for GetHomogeneous")
3612	}
3613
3614	var r0 bool
3615	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3616		r0 = returnFunc()
3617	} else {
3618		r0 = ret.Get(0).(bool)
3619	}
3620	return r0
3621}
3622
3623// MockBoxWidget_GetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomogeneous'
3624type MockBoxWidget_GetHomogeneous_Call struct {
3625	*mock.Call
3626}
3627
3628// GetHomogeneous is a helper method to define mock.On call
3629func (_e *MockBoxWidget_Expecter) GetHomogeneous() *MockBoxWidget_GetHomogeneous_Call {
3630	return &MockBoxWidget_GetHomogeneous_Call{Call: _e.mock.On("GetHomogeneous")}
3631}
3632
3633func (_c *MockBoxWidget_GetHomogeneous_Call) Run(run func()) *MockBoxWidget_GetHomogeneous_Call {
3634	_c.Call.Run(func(args mock.Arguments) {
3635		run()
3636	})
3637	return _c
3638}
3639
3640func (_c *MockBoxWidget_GetHomogeneous_Call) Return(b bool) *MockBoxWidget_GetHomogeneous_Call {
3641	_c.Call.Return(b)
3642	return _c
3643}
3644
3645func (_c *MockBoxWidget_GetHomogeneous_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetHomogeneous_Call {
3646	_c.Call.Return(run)
3647	return _c
3648}
3649
3650// GetOrientation provides a mock function for the type MockBoxWidget
3651func (_mock *MockBoxWidget) GetOrientation() layout.Orientation {
3652	ret := _mock.Called()
3653
3654	if len(ret) == 0 {
3655		panic("no return value specified for GetOrientation")
3656	}
3657
3658	var r0 layout.Orientation
3659	if returnFunc, ok := ret.Get(0).(func() layout.Orientation); ok {
3660		r0 = returnFunc()
3661	} else {
3662		r0 = ret.Get(0).(layout.Orientation)
3663	}
3664	return r0
3665}
3666
3667// MockBoxWidget_GetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrientation'
3668type MockBoxWidget_GetOrientation_Call struct {
3669	*mock.Call
3670}
3671
3672// GetOrientation is a helper method to define mock.On call
3673func (_e *MockBoxWidget_Expecter) GetOrientation() *MockBoxWidget_GetOrientation_Call {
3674	return &MockBoxWidget_GetOrientation_Call{Call: _e.mock.On("GetOrientation")}
3675}
3676
3677func (_c *MockBoxWidget_GetOrientation_Call) Run(run func()) *MockBoxWidget_GetOrientation_Call {
3678	_c.Call.Run(func(args mock.Arguments) {
3679		run()
3680	})
3681	return _c
3682}
3683
3684func (_c *MockBoxWidget_GetOrientation_Call) Return(v layout.Orientation) *MockBoxWidget_GetOrientation_Call {
3685	_c.Call.Return(v)
3686	return _c
3687}
3688
3689func (_c *MockBoxWidget_GetOrientation_Call) RunAndReturn(run func() layout.Orientation) *MockBoxWidget_GetOrientation_Call {
3690	_c.Call.Return(run)
3691	return _c
3692}
3693
3694// GetParent provides a mock function for the type MockBoxWidget
3695func (_mock *MockBoxWidget) GetParent() layout.Widget {
3696	ret := _mock.Called()
3697
3698	if len(ret) == 0 {
3699		panic("no return value specified for GetParent")
3700	}
3701
3702	var r0 layout.Widget
3703	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
3704		r0 = returnFunc()
3705	} else {
3706		if ret.Get(0) != nil {
3707			r0 = ret.Get(0).(layout.Widget)
3708		}
3709	}
3710	return r0
3711}
3712
3713// MockBoxWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
3714type MockBoxWidget_GetParent_Call struct {
3715	*mock.Call
3716}
3717
3718// GetParent is a helper method to define mock.On call
3719func (_e *MockBoxWidget_Expecter) GetParent() *MockBoxWidget_GetParent_Call {
3720	return &MockBoxWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
3721}
3722
3723func (_c *MockBoxWidget_GetParent_Call) Run(run func()) *MockBoxWidget_GetParent_Call {
3724	_c.Call.Run(func(args mock.Arguments) {
3725		run()
3726	})
3727	return _c
3728}
3729
3730func (_c *MockBoxWidget_GetParent_Call) Return(widget layout.Widget) *MockBoxWidget_GetParent_Call {
3731	_c.Call.Return(widget)
3732	return _c
3733}
3734
3735func (_c *MockBoxWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockBoxWidget_GetParent_Call {
3736	_c.Call.Return(run)
3737	return _c
3738}
3739
3740// GetSpacing provides a mock function for the type MockBoxWidget
3741func (_mock *MockBoxWidget) GetSpacing() int {
3742	ret := _mock.Called()
3743
3744	if len(ret) == 0 {
3745		panic("no return value specified for GetSpacing")
3746	}
3747
3748	var r0 int
3749	if returnFunc, ok := ret.Get(0).(func() int); ok {
3750		r0 = returnFunc()
3751	} else {
3752		r0 = ret.Get(0).(int)
3753	}
3754	return r0
3755}
3756
3757// MockBoxWidget_GetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpacing'
3758type MockBoxWidget_GetSpacing_Call struct {
3759	*mock.Call
3760}
3761
3762// GetSpacing is a helper method to define mock.On call
3763func (_e *MockBoxWidget_Expecter) GetSpacing() *MockBoxWidget_GetSpacing_Call {
3764	return &MockBoxWidget_GetSpacing_Call{Call: _e.mock.On("GetSpacing")}
3765}
3766
3767func (_c *MockBoxWidget_GetSpacing_Call) Run(run func()) *MockBoxWidget_GetSpacing_Call {
3768	_c.Call.Run(func(args mock.Arguments) {
3769		run()
3770	})
3771	return _c
3772}
3773
3774func (_c *MockBoxWidget_GetSpacing_Call) Return(n int) *MockBoxWidget_GetSpacing_Call {
3775	_c.Call.Return(n)
3776	return _c
3777}
3778
3779func (_c *MockBoxWidget_GetSpacing_Call) RunAndReturn(run func() int) *MockBoxWidget_GetSpacing_Call {
3780	_c.Call.Return(run)
3781	return _c
3782}
3783
3784// GetVexpand provides a mock function for the type MockBoxWidget
3785func (_mock *MockBoxWidget) GetVexpand() bool {
3786	ret := _mock.Called()
3787
3788	if len(ret) == 0 {
3789		panic("no return value specified for GetVexpand")
3790	}
3791
3792	var r0 bool
3793	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3794		r0 = returnFunc()
3795	} else {
3796		r0 = ret.Get(0).(bool)
3797	}
3798	return r0
3799}
3800
3801// MockBoxWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
3802type MockBoxWidget_GetVexpand_Call struct {
3803	*mock.Call
3804}
3805
3806// GetVexpand is a helper method to define mock.On call
3807func (_e *MockBoxWidget_Expecter) GetVexpand() *MockBoxWidget_GetVexpand_Call {
3808	return &MockBoxWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
3809}
3810
3811func (_c *MockBoxWidget_GetVexpand_Call) Run(run func()) *MockBoxWidget_GetVexpand_Call {
3812	_c.Call.Run(func(args mock.Arguments) {
3813		run()
3814	})
3815	return _c
3816}
3817
3818func (_c *MockBoxWidget_GetVexpand_Call) Return(b bool) *MockBoxWidget_GetVexpand_Call {
3819	_c.Call.Return(b)
3820	return _c
3821}
3822
3823func (_c *MockBoxWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetVexpand_Call {
3824	_c.Call.Return(run)
3825	return _c
3826}
3827
3828// GrabFocus provides a mock function for the type MockBoxWidget
3829func (_mock *MockBoxWidget) GrabFocus() bool {
3830	ret := _mock.Called()
3831
3832	if len(ret) == 0 {
3833		panic("no return value specified for GrabFocus")
3834	}
3835
3836	var r0 bool
3837	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3838		r0 = returnFunc()
3839	} else {
3840		r0 = ret.Get(0).(bool)
3841	}
3842	return r0
3843}
3844
3845// MockBoxWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
3846type MockBoxWidget_GrabFocus_Call struct {
3847	*mock.Call
3848}
3849
3850// GrabFocus is a helper method to define mock.On call
3851func (_e *MockBoxWidget_Expecter) GrabFocus() *MockBoxWidget_GrabFocus_Call {
3852	return &MockBoxWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
3853}
3854
3855func (_c *MockBoxWidget_GrabFocus_Call) Run(run func()) *MockBoxWidget_GrabFocus_Call {
3856	_c.Call.Run(func(args mock.Arguments) {
3857		run()
3858	})
3859	return _c
3860}
3861
3862func (_c *MockBoxWidget_GrabFocus_Call) Return(b bool) *MockBoxWidget_GrabFocus_Call {
3863	_c.Call.Return(b)
3864	return _c
3865}
3866
3867func (_c *MockBoxWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockBoxWidget_GrabFocus_Call {
3868	_c.Call.Return(run)
3869	return _c
3870}
3871
3872// GtkWidget provides a mock function for the type MockBoxWidget
3873func (_mock *MockBoxWidget) GtkWidget() *gtk.Widget {
3874	ret := _mock.Called()
3875
3876	if len(ret) == 0 {
3877		panic("no return value specified for GtkWidget")
3878	}
3879
3880	var r0 *gtk.Widget
3881	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
3882		r0 = returnFunc()
3883	} else {
3884		if ret.Get(0) != nil {
3885			r0 = ret.Get(0).(*gtk.Widget)
3886		}
3887	}
3888	return r0
3889}
3890
3891// MockBoxWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
3892type MockBoxWidget_GtkWidget_Call struct {
3893	*mock.Call
3894}
3895
3896// GtkWidget is a helper method to define mock.On call
3897func (_e *MockBoxWidget_Expecter) GtkWidget() *MockBoxWidget_GtkWidget_Call {
3898	return &MockBoxWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
3899}
3900
3901func (_c *MockBoxWidget_GtkWidget_Call) Run(run func()) *MockBoxWidget_GtkWidget_Call {
3902	_c.Call.Run(func(args mock.Arguments) {
3903		run()
3904	})
3905	return _c
3906}
3907
3908func (_c *MockBoxWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockBoxWidget_GtkWidget_Call {
3909	_c.Call.Return(widget)
3910	return _c
3911}
3912
3913func (_c *MockBoxWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockBoxWidget_GtkWidget_Call {
3914	_c.Call.Return(run)
3915	return _c
3916}
3917
3918// HasCssClass provides a mock function for the type MockBoxWidget
3919func (_mock *MockBoxWidget) HasCssClass(cssClass string) bool {
3920	ret := _mock.Called(cssClass)
3921
3922	if len(ret) == 0 {
3923		panic("no return value specified for HasCssClass")
3924	}
3925
3926	var r0 bool
3927	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
3928		r0 = returnFunc(cssClass)
3929	} else {
3930		r0 = ret.Get(0).(bool)
3931	}
3932	return r0
3933}
3934
3935// MockBoxWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
3936type MockBoxWidget_HasCssClass_Call struct {
3937	*mock.Call
3938}
3939
3940// HasCssClass is a helper method to define mock.On call
3941//   - cssClass string
3942func (_e *MockBoxWidget_Expecter) HasCssClass(cssClass interface{}) *MockBoxWidget_HasCssClass_Call {
3943	return &MockBoxWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
3944}
3945
3946func (_c *MockBoxWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_HasCssClass_Call {
3947	_c.Call.Run(func(args mock.Arguments) {
3948		var arg0 string
3949		if args[0] != nil {
3950			arg0 = args[0].(string)
3951		}
3952		run(
3953			arg0,
3954		)
3955	})
3956	return _c
3957}
3958
3959func (_c *MockBoxWidget_HasCssClass_Call) Return(b bool) *MockBoxWidget_HasCssClass_Call {
3960	_c.Call.Return(b)
3961	return _c
3962}
3963
3964func (_c *MockBoxWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockBoxWidget_HasCssClass_Call {
3965	_c.Call.Return(run)
3966	return _c
3967}
3968
3969// HasFocus provides a mock function for the type MockBoxWidget
3970func (_mock *MockBoxWidget) HasFocus() bool {
3971	ret := _mock.Called()
3972
3973	if len(ret) == 0 {
3974		panic("no return value specified for HasFocus")
3975	}
3976
3977	var r0 bool
3978	if returnFunc, ok := ret.Get(0).(func() bool); ok {
3979		r0 = returnFunc()
3980	} else {
3981		r0 = ret.Get(0).(bool)
3982	}
3983	return r0
3984}
3985
3986// MockBoxWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
3987type MockBoxWidget_HasFocus_Call struct {
3988	*mock.Call
3989}
3990
3991// HasFocus is a helper method to define mock.On call
3992func (_e *MockBoxWidget_Expecter) HasFocus() *MockBoxWidget_HasFocus_Call {
3993	return &MockBoxWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
3994}
3995
3996func (_c *MockBoxWidget_HasFocus_Call) Run(run func()) *MockBoxWidget_HasFocus_Call {
3997	_c.Call.Run(func(args mock.Arguments) {
3998		run()
3999	})
4000	return _c
4001}
4002
4003func (_c *MockBoxWidget_HasFocus_Call) Return(b bool) *MockBoxWidget_HasFocus_Call {
4004	_c.Call.Return(b)
4005	return _c
4006}
4007
4008func (_c *MockBoxWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockBoxWidget_HasFocus_Call {
4009	_c.Call.Return(run)
4010	return _c
4011}
4012
4013// Hide provides a mock function for the type MockBoxWidget
4014func (_mock *MockBoxWidget) Hide() {
4015	_mock.Called()
4016	return
4017}
4018
4019// MockBoxWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
4020type MockBoxWidget_Hide_Call struct {
4021	*mock.Call
4022}
4023
4024// Hide is a helper method to define mock.On call
4025func (_e *MockBoxWidget_Expecter) Hide() *MockBoxWidget_Hide_Call {
4026	return &MockBoxWidget_Hide_Call{Call: _e.mock.On("Hide")}
4027}
4028
4029func (_c *MockBoxWidget_Hide_Call) Run(run func()) *MockBoxWidget_Hide_Call {
4030	_c.Call.Run(func(args mock.Arguments) {
4031		run()
4032	})
4033	return _c
4034}
4035
4036func (_c *MockBoxWidget_Hide_Call) Return() *MockBoxWidget_Hide_Call {
4037	_c.Call.Return()
4038	return _c
4039}
4040
4041func (_c *MockBoxWidget_Hide_Call) RunAndReturn(run func()) *MockBoxWidget_Hide_Call {
4042	_c.Run(run)
4043	return _c
4044}
4045
4046// InsertChildAfter provides a mock function for the type MockBoxWidget
4047func (_mock *MockBoxWidget) InsertChildAfter(child layout.Widget, sibling layout.Widget) {
4048	_mock.Called(child, sibling)
4049	return
4050}
4051
4052// MockBoxWidget_InsertChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertChildAfter'
4053type MockBoxWidget_InsertChildAfter_Call struct {
4054	*mock.Call
4055}
4056
4057// InsertChildAfter is a helper method to define mock.On call
4058//   - child layout.Widget
4059//   - sibling layout.Widget
4060func (_e *MockBoxWidget_Expecter) InsertChildAfter(child interface{}, sibling interface{}) *MockBoxWidget_InsertChildAfter_Call {
4061	return &MockBoxWidget_InsertChildAfter_Call{Call: _e.mock.On("InsertChildAfter", child, sibling)}
4062}
4063
4064func (_c *MockBoxWidget_InsertChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_InsertChildAfter_Call {
4065	_c.Call.Run(func(args mock.Arguments) {
4066		var arg0 layout.Widget
4067		if args[0] != nil {
4068			arg0 = args[0].(layout.Widget)
4069		}
4070		var arg1 layout.Widget
4071		if args[1] != nil {
4072			arg1 = args[1].(layout.Widget)
4073		}
4074		run(
4075			arg0,
4076			arg1,
4077		)
4078	})
4079	return _c
4080}
4081
4082func (_c *MockBoxWidget_InsertChildAfter_Call) Return() *MockBoxWidget_InsertChildAfter_Call {
4083	_c.Call.Return()
4084	return _c
4085}
4086
4087func (_c *MockBoxWidget_InsertChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_InsertChildAfter_Call {
4088	_c.Run(run)
4089	return _c
4090}
4091
4092// IsVisible provides a mock function for the type MockBoxWidget
4093func (_mock *MockBoxWidget) IsVisible() bool {
4094	ret := _mock.Called()
4095
4096	if len(ret) == 0 {
4097		panic("no return value specified for IsVisible")
4098	}
4099
4100	var r0 bool
4101	if returnFunc, ok := ret.Get(0).(func() bool); ok {
4102		r0 = returnFunc()
4103	} else {
4104		r0 = ret.Get(0).(bool)
4105	}
4106	return r0
4107}
4108
4109// MockBoxWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
4110type MockBoxWidget_IsVisible_Call struct {
4111	*mock.Call
4112}
4113
4114// IsVisible is a helper method to define mock.On call
4115func (_e *MockBoxWidget_Expecter) IsVisible() *MockBoxWidget_IsVisible_Call {
4116	return &MockBoxWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
4117}
4118
4119func (_c *MockBoxWidget_IsVisible_Call) Run(run func()) *MockBoxWidget_IsVisible_Call {
4120	_c.Call.Run(func(args mock.Arguments) {
4121		run()
4122	})
4123	return _c
4124}
4125
4126func (_c *MockBoxWidget_IsVisible_Call) Return(b bool) *MockBoxWidget_IsVisible_Call {
4127	_c.Call.Return(b)
4128	return _c
4129}
4130
4131func (_c *MockBoxWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockBoxWidget_IsVisible_Call {
4132	_c.Call.Return(run)
4133	return _c
4134}
4135
4136// Prepend provides a mock function for the type MockBoxWidget
4137func (_mock *MockBoxWidget) Prepend(child layout.Widget) {
4138	_mock.Called(child)
4139	return
4140}
4141
4142// MockBoxWidget_Prepend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prepend'
4143type MockBoxWidget_Prepend_Call struct {
4144	*mock.Call
4145}
4146
4147// Prepend is a helper method to define mock.On call
4148//   - child layout.Widget
4149func (_e *MockBoxWidget_Expecter) Prepend(child interface{}) *MockBoxWidget_Prepend_Call {
4150	return &MockBoxWidget_Prepend_Call{Call: _e.mock.On("Prepend", child)}
4151}
4152
4153func (_c *MockBoxWidget_Prepend_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Prepend_Call {
4154	_c.Call.Run(func(args mock.Arguments) {
4155		var arg0 layout.Widget
4156		if args[0] != nil {
4157			arg0 = args[0].(layout.Widget)
4158		}
4159		run(
4160			arg0,
4161		)
4162	})
4163	return _c
4164}
4165
4166func (_c *MockBoxWidget_Prepend_Call) Return() *MockBoxWidget_Prepend_Call {
4167	_c.Call.Return()
4168	return _c
4169}
4170
4171func (_c *MockBoxWidget_Prepend_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Prepend_Call {
4172	_c.Run(run)
4173	return _c
4174}
4175
4176// Remove provides a mock function for the type MockBoxWidget
4177func (_mock *MockBoxWidget) Remove(child layout.Widget) {
4178	_mock.Called(child)
4179	return
4180}
4181
4182// MockBoxWidget_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
4183type MockBoxWidget_Remove_Call struct {
4184	*mock.Call
4185}
4186
4187// Remove is a helper method to define mock.On call
4188//   - child layout.Widget
4189func (_e *MockBoxWidget_Expecter) Remove(child interface{}) *MockBoxWidget_Remove_Call {
4190	return &MockBoxWidget_Remove_Call{Call: _e.mock.On("Remove", child)}
4191}
4192
4193func (_c *MockBoxWidget_Remove_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Remove_Call {
4194	_c.Call.Run(func(args mock.Arguments) {
4195		var arg0 layout.Widget
4196		if args[0] != nil {
4197			arg0 = args[0].(layout.Widget)
4198		}
4199		run(
4200			arg0,
4201		)
4202	})
4203	return _c
4204}
4205
4206func (_c *MockBoxWidget_Remove_Call) Return() *MockBoxWidget_Remove_Call {
4207	_c.Call.Return()
4208	return _c
4209}
4210
4211func (_c *MockBoxWidget_Remove_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Remove_Call {
4212	_c.Run(run)
4213	return _c
4214}
4215
4216// RemoveCssClass provides a mock function for the type MockBoxWidget
4217func (_mock *MockBoxWidget) RemoveCssClass(cssClass string) {
4218	_mock.Called(cssClass)
4219	return
4220}
4221
4222// MockBoxWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
4223type MockBoxWidget_RemoveCssClass_Call struct {
4224	*mock.Call
4225}
4226
4227// RemoveCssClass is a helper method to define mock.On call
4228//   - cssClass string
4229func (_e *MockBoxWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockBoxWidget_RemoveCssClass_Call {
4230	return &MockBoxWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
4231}
4232
4233func (_c *MockBoxWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_RemoveCssClass_Call {
4234	_c.Call.Run(func(args mock.Arguments) {
4235		var arg0 string
4236		if args[0] != nil {
4237			arg0 = args[0].(string)
4238		}
4239		run(
4240			arg0,
4241		)
4242	})
4243	return _c
4244}
4245
4246func (_c *MockBoxWidget_RemoveCssClass_Call) Return() *MockBoxWidget_RemoveCssClass_Call {
4247	_c.Call.Return()
4248	return _c
4249}
4250
4251func (_c *MockBoxWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockBoxWidget_RemoveCssClass_Call {
4252	_c.Run(run)
4253	return _c
4254}
4255
4256// ReorderChildAfter provides a mock function for the type MockBoxWidget
4257func (_mock *MockBoxWidget) ReorderChildAfter(child layout.Widget, sibling layout.Widget) {
4258	_mock.Called(child, sibling)
4259	return
4260}
4261
4262// MockBoxWidget_ReorderChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReorderChildAfter'
4263type MockBoxWidget_ReorderChildAfter_Call struct {
4264	*mock.Call
4265}
4266
4267// ReorderChildAfter is a helper method to define mock.On call
4268//   - child layout.Widget
4269//   - sibling layout.Widget
4270func (_e *MockBoxWidget_Expecter) ReorderChildAfter(child interface{}, sibling interface{}) *MockBoxWidget_ReorderChildAfter_Call {
4271	return &MockBoxWidget_ReorderChildAfter_Call{Call: _e.mock.On("ReorderChildAfter", child, sibling)}
4272}
4273
4274func (_c *MockBoxWidget_ReorderChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_ReorderChildAfter_Call {
4275	_c.Call.Run(func(args mock.Arguments) {
4276		var arg0 layout.Widget
4277		if args[0] != nil {
4278			arg0 = args[0].(layout.Widget)
4279		}
4280		var arg1 layout.Widget
4281		if args[1] != nil {
4282			arg1 = args[1].(layout.Widget)
4283		}
4284		run(
4285			arg0,
4286			arg1,
4287		)
4288	})
4289	return _c
4290}
4291
4292func (_c *MockBoxWidget_ReorderChildAfter_Call) Return() *MockBoxWidget_ReorderChildAfter_Call {
4293	_c.Call.Return()
4294	return _c
4295}
4296
4297func (_c *MockBoxWidget_ReorderChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_ReorderChildAfter_Call {
4298	_c.Run(run)
4299	return _c
4300}
4301
4302// SetCanFocus provides a mock function for the type MockBoxWidget
4303func (_mock *MockBoxWidget) SetCanFocus(canFocus bool) {
4304	_mock.Called(canFocus)
4305	return
4306}
4307
4308// MockBoxWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
4309type MockBoxWidget_SetCanFocus_Call struct {
4310	*mock.Call
4311}
4312
4313// SetCanFocus is a helper method to define mock.On call
4314//   - canFocus bool
4315func (_e *MockBoxWidget_Expecter) SetCanFocus(canFocus interface{}) *MockBoxWidget_SetCanFocus_Call {
4316	return &MockBoxWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
4317}
4318
4319func (_c *MockBoxWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockBoxWidget_SetCanFocus_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_SetCanFocus_Call) Return() *MockBoxWidget_SetCanFocus_Call {
4333	_c.Call.Return()
4334	return _c
4335}
4336
4337func (_c *MockBoxWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockBoxWidget_SetCanFocus_Call {
4338	_c.Run(run)
4339	return _c
4340}
4341
4342// SetCanTarget provides a mock function for the type MockBoxWidget
4343func (_mock *MockBoxWidget) SetCanTarget(canTarget bool) {
4344	_mock.Called(canTarget)
4345	return
4346}
4347
4348// MockBoxWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
4349type MockBoxWidget_SetCanTarget_Call struct {
4350	*mock.Call
4351}
4352
4353// SetCanTarget is a helper method to define mock.On call
4354//   - canTarget bool
4355func (_e *MockBoxWidget_Expecter) SetCanTarget(canTarget interface{}) *MockBoxWidget_SetCanTarget_Call {
4356	return &MockBoxWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
4357}
4358
4359func (_c *MockBoxWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockBoxWidget_SetCanTarget_Call {
4360	_c.Call.Run(func(args mock.Arguments) {
4361		var arg0 bool
4362		if args[0] != nil {
4363			arg0 = args[0].(bool)
4364		}
4365		run(
4366			arg0,
4367		)
4368	})
4369	return _c
4370}
4371
4372func (_c *MockBoxWidget_SetCanTarget_Call) Return() *MockBoxWidget_SetCanTarget_Call {
4373	_c.Call.Return()
4374	return _c
4375}
4376
4377func (_c *MockBoxWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockBoxWidget_SetCanTarget_Call {
4378	_c.Run(run)
4379	return _c
4380}
4381
4382// SetFocusOnClick provides a mock function for the type MockBoxWidget
4383func (_mock *MockBoxWidget) SetFocusOnClick(focusOnClick bool) {
4384	_mock.Called(focusOnClick)
4385	return
4386}
4387
4388// MockBoxWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
4389type MockBoxWidget_SetFocusOnClick_Call struct {
4390	*mock.Call
4391}
4392
4393// SetFocusOnClick is a helper method to define mock.On call
4394//   - focusOnClick bool
4395func (_e *MockBoxWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockBoxWidget_SetFocusOnClick_Call {
4396	return &MockBoxWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
4397}
4398
4399func (_c *MockBoxWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockBoxWidget_SetFocusOnClick_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_SetFocusOnClick_Call) Return() *MockBoxWidget_SetFocusOnClick_Call {
4413	_c.Call.Return()
4414	return _c
4415}
4416
4417func (_c *MockBoxWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockBoxWidget_SetFocusOnClick_Call {
4418	_c.Run(run)
4419	return _c
4420}
4421
4422// SetFocusable provides a mock function for the type MockBoxWidget
4423func (_mock *MockBoxWidget) SetFocusable(focusable bool) {
4424	_mock.Called(focusable)
4425	return
4426}
4427
4428// MockBoxWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
4429type MockBoxWidget_SetFocusable_Call struct {
4430	*mock.Call
4431}
4432
4433// SetFocusable is a helper method to define mock.On call
4434//   - focusable bool
4435func (_e *MockBoxWidget_Expecter) SetFocusable(focusable interface{}) *MockBoxWidget_SetFocusable_Call {
4436	return &MockBoxWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
4437}
4438
4439func (_c *MockBoxWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockBoxWidget_SetFocusable_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_SetFocusable_Call) Return() *MockBoxWidget_SetFocusable_Call {
4453	_c.Call.Return()
4454	return _c
4455}
4456
4457func (_c *MockBoxWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockBoxWidget_SetFocusable_Call {
4458	_c.Run(run)
4459	return _c
4460}
4461
4462// SetHalign provides a mock function for the type MockBoxWidget
4463func (_mock *MockBoxWidget) SetHalign(align gtk.Align) {
4464	_mock.Called(align)
4465	return
4466}
4467
4468// MockBoxWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
4469type MockBoxWidget_SetHalign_Call struct {
4470	*mock.Call
4471}
4472
4473// SetHalign is a helper method to define mock.On call
4474//   - align gtk.Align
4475func (_e *MockBoxWidget_Expecter) SetHalign(align interface{}) *MockBoxWidget_SetHalign_Call {
4476	return &MockBoxWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
4477}
4478
4479func (_c *MockBoxWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockBoxWidget_SetHalign_Call {
4480	_c.Call.Run(func(args mock.Arguments) {
4481		var arg0 gtk.Align
4482		if args[0] != nil {
4483			arg0 = args[0].(gtk.Align)
4484		}
4485		run(
4486			arg0,
4487		)
4488	})
4489	return _c
4490}
4491
4492func (_c *MockBoxWidget_SetHalign_Call) Return() *MockBoxWidget_SetHalign_Call {
4493	_c.Call.Return()
4494	return _c
4495}
4496
4497func (_c *MockBoxWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockBoxWidget_SetHalign_Call {
4498	_c.Run(run)
4499	return _c
4500}
4501
4502// SetHexpand provides a mock function for the type MockBoxWidget
4503func (_mock *MockBoxWidget) SetHexpand(expand bool) {
4504	_mock.Called(expand)
4505	return
4506}
4507
4508// MockBoxWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
4509type MockBoxWidget_SetHexpand_Call struct {
4510	*mock.Call
4511}
4512
4513// SetHexpand is a helper method to define mock.On call
4514//   - expand bool
4515func (_e *MockBoxWidget_Expecter) SetHexpand(expand interface{}) *MockBoxWidget_SetHexpand_Call {
4516	return &MockBoxWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
4517}
4518
4519func (_c *MockBoxWidget_SetHexpand_Call) Run(run func(expand bool)) *MockBoxWidget_SetHexpand_Call {
4520	_c.Call.Run(func(args mock.Arguments) {
4521		var arg0 bool
4522		if args[0] != nil {
4523			arg0 = args[0].(bool)
4524		}
4525		run(
4526			arg0,
4527		)
4528	})
4529	return _c
4530}
4531
4532func (_c *MockBoxWidget_SetHexpand_Call) Return() *MockBoxWidget_SetHexpand_Call {
4533	_c.Call.Return()
4534	return _c
4535}
4536
4537func (_c *MockBoxWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockBoxWidget_SetHexpand_Call {
4538	_c.Run(run)
4539	return _c
4540}
4541
4542// SetHomogeneous provides a mock function for the type MockBoxWidget
4543func (_mock *MockBoxWidget) SetHomogeneous(homogeneous bool) {
4544	_mock.Called(homogeneous)
4545	return
4546}
4547
4548// MockBoxWidget_SetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHomogeneous'
4549type MockBoxWidget_SetHomogeneous_Call struct {
4550	*mock.Call
4551}
4552
4553// SetHomogeneous is a helper method to define mock.On call
4554//   - homogeneous bool
4555func (_e *MockBoxWidget_Expecter) SetHomogeneous(homogeneous interface{}) *MockBoxWidget_SetHomogeneous_Call {
4556	return &MockBoxWidget_SetHomogeneous_Call{Call: _e.mock.On("SetHomogeneous", homogeneous)}
4557}
4558
4559func (_c *MockBoxWidget_SetHomogeneous_Call) Run(run func(homogeneous bool)) *MockBoxWidget_SetHomogeneous_Call {
4560	_c.Call.Run(func(args mock.Arguments) {
4561		var arg0 bool
4562		if args[0] != nil {
4563			arg0 = args[0].(bool)
4564		}
4565		run(
4566			arg0,
4567		)
4568	})
4569	return _c
4570}
4571
4572func (_c *MockBoxWidget_SetHomogeneous_Call) Return() *MockBoxWidget_SetHomogeneous_Call {
4573	_c.Call.Return()
4574	return _c
4575}
4576
4577func (_c *MockBoxWidget_SetHomogeneous_Call) RunAndReturn(run func(homogeneous bool)) *MockBoxWidget_SetHomogeneous_Call {
4578	_c.Run(run)
4579	return _c
4580}
4581
4582// SetOrientation provides a mock function for the type MockBoxWidget
4583func (_mock *MockBoxWidget) SetOrientation(orientation layout.Orientation) {
4584	_mock.Called(orientation)
4585	return
4586}
4587
4588// MockBoxWidget_SetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOrientation'
4589type MockBoxWidget_SetOrientation_Call struct {
4590	*mock.Call
4591}
4592
4593// SetOrientation is a helper method to define mock.On call
4594//   - orientation layout.Orientation
4595func (_e *MockBoxWidget_Expecter) SetOrientation(orientation interface{}) *MockBoxWidget_SetOrientation_Call {
4596	return &MockBoxWidget_SetOrientation_Call{Call: _e.mock.On("SetOrientation", orientation)}
4597}
4598
4599func (_c *MockBoxWidget_SetOrientation_Call) Run(run func(orientation layout.Orientation)) *MockBoxWidget_SetOrientation_Call {
4600	_c.Call.Run(func(args mock.Arguments) {
4601		var arg0 layout.Orientation
4602		if args[0] != nil {
4603			arg0 = args[0].(layout.Orientation)
4604		}
4605		run(
4606			arg0,
4607		)
4608	})
4609	return _c
4610}
4611
4612func (_c *MockBoxWidget_SetOrientation_Call) Return() *MockBoxWidget_SetOrientation_Call {
4613	_c.Call.Return()
4614	return _c
4615}
4616
4617func (_c *MockBoxWidget_SetOrientation_Call) RunAndReturn(run func(orientation layout.Orientation)) *MockBoxWidget_SetOrientation_Call {
4618	_c.Run(run)
4619	return _c
4620}
4621
4622// SetSizeRequest provides a mock function for the type MockBoxWidget
4623func (_mock *MockBoxWidget) SetSizeRequest(width int, height int) {
4624	_mock.Called(width, height)
4625	return
4626}
4627
4628// MockBoxWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
4629type MockBoxWidget_SetSizeRequest_Call struct {
4630	*mock.Call
4631}
4632
4633// SetSizeRequest is a helper method to define mock.On call
4634//   - width int
4635//   - height int
4636func (_e *MockBoxWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockBoxWidget_SetSizeRequest_Call {
4637	return &MockBoxWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
4638}
4639
4640func (_c *MockBoxWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockBoxWidget_SetSizeRequest_Call {
4641	_c.Call.Run(func(args mock.Arguments) {
4642		var arg0 int
4643		if args[0] != nil {
4644			arg0 = args[0].(int)
4645		}
4646		var arg1 int
4647		if args[1] != nil {
4648			arg1 = args[1].(int)
4649		}
4650		run(
4651			arg0,
4652			arg1,
4653		)
4654	})
4655	return _c
4656}
4657
4658func (_c *MockBoxWidget_SetSizeRequest_Call) Return() *MockBoxWidget_SetSizeRequest_Call {
4659	_c.Call.Return()
4660	return _c
4661}
4662
4663func (_c *MockBoxWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockBoxWidget_SetSizeRequest_Call {
4664	_c.Run(run)
4665	return _c
4666}
4667
4668// SetSpacing provides a mock function for the type MockBoxWidget
4669func (_mock *MockBoxWidget) SetSpacing(spacing int) {
4670	_mock.Called(spacing)
4671	return
4672}
4673
4674// MockBoxWidget_SetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpacing'
4675type MockBoxWidget_SetSpacing_Call struct {
4676	*mock.Call
4677}
4678
4679// SetSpacing is a helper method to define mock.On call
4680//   - spacing int
4681func (_e *MockBoxWidget_Expecter) SetSpacing(spacing interface{}) *MockBoxWidget_SetSpacing_Call {
4682	return &MockBoxWidget_SetSpacing_Call{Call: _e.mock.On("SetSpacing", spacing)}
4683}
4684
4685func (_c *MockBoxWidget_SetSpacing_Call) Run(run func(spacing int)) *MockBoxWidget_SetSpacing_Call {
4686	_c.Call.Run(func(args mock.Arguments) {
4687		var arg0 int
4688		if args[0] != nil {
4689			arg0 = args[0].(int)
4690		}
4691		run(
4692			arg0,
4693		)
4694	})
4695	return _c
4696}
4697
4698func (_c *MockBoxWidget_SetSpacing_Call) Return() *MockBoxWidget_SetSpacing_Call {
4699	_c.Call.Return()
4700	return _c
4701}
4702
4703func (_c *MockBoxWidget_SetSpacing_Call) RunAndReturn(run func(spacing int)) *MockBoxWidget_SetSpacing_Call {
4704	_c.Run(run)
4705	return _c
4706}
4707
4708// SetValign provides a mock function for the type MockBoxWidget
4709func (_mock *MockBoxWidget) SetValign(align gtk.Align) {
4710	_mock.Called(align)
4711	return
4712}
4713
4714// MockBoxWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
4715type MockBoxWidget_SetValign_Call struct {
4716	*mock.Call
4717}
4718
4719// SetValign is a helper method to define mock.On call
4720//   - align gtk.Align
4721func (_e *MockBoxWidget_Expecter) SetValign(align interface{}) *MockBoxWidget_SetValign_Call {
4722	return &MockBoxWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
4723}
4724
4725func (_c *MockBoxWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockBoxWidget_SetValign_Call {
4726	_c.Call.Run(func(args mock.Arguments) {
4727		var arg0 gtk.Align
4728		if args[0] != nil {
4729			arg0 = args[0].(gtk.Align)
4730		}
4731		run(
4732			arg0,
4733		)
4734	})
4735	return _c
4736}
4737
4738func (_c *MockBoxWidget_SetValign_Call) Return() *MockBoxWidget_SetValign_Call {
4739	_c.Call.Return()
4740	return _c
4741}
4742
4743func (_c *MockBoxWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockBoxWidget_SetValign_Call {
4744	_c.Run(run)
4745	return _c
4746}
4747
4748// SetVexpand provides a mock function for the type MockBoxWidget
4749func (_mock *MockBoxWidget) SetVexpand(expand bool) {
4750	_mock.Called(expand)
4751	return
4752}
4753
4754// MockBoxWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
4755type MockBoxWidget_SetVexpand_Call struct {
4756	*mock.Call
4757}
4758
4759// SetVexpand is a helper method to define mock.On call
4760//   - expand bool
4761func (_e *MockBoxWidget_Expecter) SetVexpand(expand interface{}) *MockBoxWidget_SetVexpand_Call {
4762	return &MockBoxWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
4763}
4764
4765func (_c *MockBoxWidget_SetVexpand_Call) Run(run func(expand bool)) *MockBoxWidget_SetVexpand_Call {
4766	_c.Call.Run(func(args mock.Arguments) {
4767		var arg0 bool
4768		if args[0] != nil {
4769			arg0 = args[0].(bool)
4770		}
4771		run(
4772			arg0,
4773		)
4774	})
4775	return _c
4776}
4777
4778func (_c *MockBoxWidget_SetVexpand_Call) Return() *MockBoxWidget_SetVexpand_Call {
4779	_c.Call.Return()
4780	return _c
4781}
4782
4783func (_c *MockBoxWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockBoxWidget_SetVexpand_Call {
4784	_c.Run(run)
4785	return _c
4786}
4787
4788// SetVisible provides a mock function for the type MockBoxWidget
4789func (_mock *MockBoxWidget) SetVisible(visible bool) {
4790	_mock.Called(visible)
4791	return
4792}
4793
4794// MockBoxWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
4795type MockBoxWidget_SetVisible_Call struct {
4796	*mock.Call
4797}
4798
4799// SetVisible is a helper method to define mock.On call
4800//   - visible bool
4801func (_e *MockBoxWidget_Expecter) SetVisible(visible interface{}) *MockBoxWidget_SetVisible_Call {
4802	return &MockBoxWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
4803}
4804
4805func (_c *MockBoxWidget_SetVisible_Call) Run(run func(visible bool)) *MockBoxWidget_SetVisible_Call {
4806	_c.Call.Run(func(args mock.Arguments) {
4807		var arg0 bool
4808		if args[0] != nil {
4809			arg0 = args[0].(bool)
4810		}
4811		run(
4812			arg0,
4813		)
4814	})
4815	return _c
4816}
4817
4818func (_c *MockBoxWidget_SetVisible_Call) Return() *MockBoxWidget_SetVisible_Call {
4819	_c.Call.Return()
4820	return _c
4821}
4822
4823func (_c *MockBoxWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockBoxWidget_SetVisible_Call {
4824	_c.Run(run)
4825	return _c
4826}
4827
4828// Show provides a mock function for the type MockBoxWidget
4829func (_mock *MockBoxWidget) Show() {
4830	_mock.Called()
4831	return
4832}
4833
4834// MockBoxWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
4835type MockBoxWidget_Show_Call struct {
4836	*mock.Call
4837}
4838
4839// Show is a helper method to define mock.On call
4840func (_e *MockBoxWidget_Expecter) Show() *MockBoxWidget_Show_Call {
4841	return &MockBoxWidget_Show_Call{Call: _e.mock.On("Show")}
4842}
4843
4844func (_c *MockBoxWidget_Show_Call) Run(run func()) *MockBoxWidget_Show_Call {
4845	_c.Call.Run(func(args mock.Arguments) {
4846		run()
4847	})
4848	return _c
4849}
4850
4851func (_c *MockBoxWidget_Show_Call) Return() *MockBoxWidget_Show_Call {
4852	_c.Call.Return()
4853	return _c
4854}
4855
4856func (_c *MockBoxWidget_Show_Call) RunAndReturn(run func()) *MockBoxWidget_Show_Call {
4857	_c.Run(run)
4858	return _c
4859}
4860
4861// Unparent provides a mock function for the type MockBoxWidget
4862func (_mock *MockBoxWidget) Unparent() {
4863	_mock.Called()
4864	return
4865}
4866
4867// MockBoxWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
4868type MockBoxWidget_Unparent_Call struct {
4869	*mock.Call
4870}
4871
4872// Unparent is a helper method to define mock.On call
4873func (_e *MockBoxWidget_Expecter) Unparent() *MockBoxWidget_Unparent_Call {
4874	return &MockBoxWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
4875}
4876
4877func (_c *MockBoxWidget_Unparent_Call) Run(run func()) *MockBoxWidget_Unparent_Call {
4878	_c.Call.Run(func(args mock.Arguments) {
4879		run()
4880	})
4881	return _c
4882}
4883
4884func (_c *MockBoxWidget_Unparent_Call) Return() *MockBoxWidget_Unparent_Call {
4885	_c.Call.Return()
4886	return _c
4887}
4888
4889func (_c *MockBoxWidget_Unparent_Call) RunAndReturn(run func()) *MockBoxWidget_Unparent_Call {
4890	_c.Run(run)
4891	return _c
4892}
4893
4894// 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.
4895// The first argument is typically a *testing.T value.
4896func NewMockOverlayWidget(t interface {
4897	mock.TestingT
4898	Cleanup(func())
4899}) *MockOverlayWidget {
4900	mock := &MockOverlayWidget{}
4901	mock.Mock.Test(t)
4902
4903	t.Cleanup(func() { mock.AssertExpectations(t) })
4904
4905	return mock
4906}
4907
4908// MockOverlayWidget is an autogenerated mock type for the OverlayWidget type
4909type MockOverlayWidget struct {
4910	mock.Mock
4911}
4912
4913type MockOverlayWidget_Expecter struct {
4914	mock *mock.Mock
4915}
4916
4917func (_m *MockOverlayWidget) EXPECT() *MockOverlayWidget_Expecter {
4918	return &MockOverlayWidget_Expecter{mock: &_m.Mock}
4919}
4920
4921// AddController provides a mock function for the type MockOverlayWidget
4922func (_mock *MockOverlayWidget) AddController(controller *gtk.EventController) {
4923	_mock.Called(controller)
4924	return
4925}
4926
4927// MockOverlayWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
4928type MockOverlayWidget_AddController_Call struct {
4929	*mock.Call
4930}
4931
4932// AddController is a helper method to define mock.On call
4933//   - controller *gtk.EventController
4934func (_e *MockOverlayWidget_Expecter) AddController(controller interface{}) *MockOverlayWidget_AddController_Call {
4935	return &MockOverlayWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
4936}
4937
4938func (_c *MockOverlayWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockOverlayWidget_AddController_Call {
4939	_c.Call.Run(func(args mock.Arguments) {
4940		var arg0 *gtk.EventController
4941		if args[0] != nil {
4942			arg0 = args[0].(*gtk.EventController)
4943		}
4944		run(
4945			arg0,
4946		)
4947	})
4948	return _c
4949}
4950
4951func (_c *MockOverlayWidget_AddController_Call) Return() *MockOverlayWidget_AddController_Call {
4952	_c.Call.Return()
4953	return _c
4954}
4955
4956func (_c *MockOverlayWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockOverlayWidget_AddController_Call {
4957	_c.Run(run)
4958	return _c
4959}
4960
4961// AddCssClass provides a mock function for the type MockOverlayWidget
4962func (_mock *MockOverlayWidget) AddCssClass(cssClass string) {
4963	_mock.Called(cssClass)
4964	return
4965}
4966
4967// MockOverlayWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
4968type MockOverlayWidget_AddCssClass_Call struct {
4969	*mock.Call
4970}
4971
4972// AddCssClass is a helper method to define mock.On call
4973//   - cssClass string
4974func (_e *MockOverlayWidget_Expecter) AddCssClass(cssClass interface{}) *MockOverlayWidget_AddCssClass_Call {
4975	return &MockOverlayWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
4976}
4977
4978func (_c *MockOverlayWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_AddCssClass_Call {
4979	_c.Call.Run(func(args mock.Arguments) {
4980		var arg0 string
4981		if args[0] != nil {
4982			arg0 = args[0].(string)
4983		}
4984		run(
4985			arg0,
4986		)
4987	})
4988	return _c
4989}
4990
4991func (_c *MockOverlayWidget_AddCssClass_Call) Return() *MockOverlayWidget_AddCssClass_Call {
4992	_c.Call.Return()
4993	return _c
4994}
4995
4996func (_c *MockOverlayWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockOverlayWidget_AddCssClass_Call {
4997	_c.Run(run)
4998	return _c
4999}
5000
5001// AddOverlay provides a mock function for the type MockOverlayWidget
5002func (_mock *MockOverlayWidget) AddOverlay(overlay layout.Widget) {
5003	_mock.Called(overlay)
5004	return
5005}
5006
5007// MockOverlayWidget_AddOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOverlay'
5008type MockOverlayWidget_AddOverlay_Call struct {
5009	*mock.Call
5010}
5011
5012// AddOverlay is a helper method to define mock.On call
5013//   - overlay layout.Widget
5014func (_e *MockOverlayWidget_Expecter) AddOverlay(overlay interface{}) *MockOverlayWidget_AddOverlay_Call {
5015	return &MockOverlayWidget_AddOverlay_Call{Call: _e.mock.On("AddOverlay", overlay)}
5016}
5017
5018func (_c *MockOverlayWidget_AddOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_AddOverlay_Call {
5019	_c.Call.Run(func(args mock.Arguments) {
5020		var arg0 layout.Widget
5021		if args[0] != nil {
5022			arg0 = args[0].(layout.Widget)
5023		}
5024		run(
5025			arg0,
5026		)
5027	})
5028	return _c
5029}
5030
5031func (_c *MockOverlayWidget_AddOverlay_Call) Return() *MockOverlayWidget_AddOverlay_Call {
5032	_c.Call.Return()
5033	return _c
5034}
5035
5036func (_c *MockOverlayWidget_AddOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) *MockOverlayWidget_AddOverlay_Call {
5037	_c.Run(run)
5038	return _c
5039}
5040
5041// ComputePoint provides a mock function for the type MockOverlayWidget
5042func (_mock *MockOverlayWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
5043	ret := _mock.Called(target)
5044
5045	if len(ret) == 0 {
5046		panic("no return value specified for ComputePoint")
5047	}
5048
5049	var r0 float64
5050	var r1 float64
5051	var r2 bool
5052	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
5053		return returnFunc(target)
5054	}
5055	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
5056		r0 = returnFunc(target)
5057	} else {
5058		r0 = ret.Get(0).(float64)
5059	}
5060	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
5061		r1 = returnFunc(target)
5062	} else {
5063		r1 = ret.Get(1).(float64)
5064	}
5065	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
5066		r2 = returnFunc(target)
5067	} else {
5068		r2 = ret.Get(2).(bool)
5069	}
5070	return r0, r1, r2
5071}
5072
5073// MockOverlayWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
5074type MockOverlayWidget_ComputePoint_Call struct {
5075	*mock.Call
5076}
5077
5078// ComputePoint is a helper method to define mock.On call
5079//   - target layout.Widget
5080func (_e *MockOverlayWidget_Expecter) ComputePoint(target interface{}) *MockOverlayWidget_ComputePoint_Call {
5081	return &MockOverlayWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
5082}
5083
5084func (_c *MockOverlayWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockOverlayWidget_ComputePoint_Call {
5085	_c.Call.Run(func(args mock.Arguments) {
5086		var arg0 layout.Widget
5087		if args[0] != nil {
5088			arg0 = args[0].(layout.Widget)
5089		}
5090		run(
5091			arg0,
5092		)
5093	})
5094	return _c
5095}
5096
5097func (_c *MockOverlayWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockOverlayWidget_ComputePoint_Call {
5098	_c.Call.Return(x, y, ok)
5099	return _c
5100}
5101
5102func (_c *MockOverlayWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockOverlayWidget_ComputePoint_Call {
5103	_c.Call.Return(run)
5104	return _c
5105}
5106
5107// GetAllocatedHeight provides a mock function for the type MockOverlayWidget
5108func (_mock *MockOverlayWidget) GetAllocatedHeight() int {
5109	ret := _mock.Called()
5110
5111	if len(ret) == 0 {
5112		panic("no return value specified for GetAllocatedHeight")
5113	}
5114
5115	var r0 int
5116	if returnFunc, ok := ret.Get(0).(func() int); ok {
5117		r0 = returnFunc()
5118	} else {
5119		r0 = ret.Get(0).(int)
5120	}
5121	return r0
5122}
5123
5124// MockOverlayWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
5125type MockOverlayWidget_GetAllocatedHeight_Call struct {
5126	*mock.Call
5127}
5128
5129// GetAllocatedHeight is a helper method to define mock.On call
5130func (_e *MockOverlayWidget_Expecter) GetAllocatedHeight() *MockOverlayWidget_GetAllocatedHeight_Call {
5131	return &MockOverlayWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
5132}
5133
5134func (_c *MockOverlayWidget_GetAllocatedHeight_Call) Run(run func()) *MockOverlayWidget_GetAllocatedHeight_Call {
5135	_c.Call.Run(func(args mock.Arguments) {
5136		run()
5137	})
5138	return _c
5139}
5140
5141func (_c *MockOverlayWidget_GetAllocatedHeight_Call) Return(n int) *MockOverlayWidget_GetAllocatedHeight_Call {
5142	_c.Call.Return(n)
5143	return _c
5144}
5145
5146func (_c *MockOverlayWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockOverlayWidget_GetAllocatedHeight_Call {
5147	_c.Call.Return(run)
5148	return _c
5149}
5150
5151// GetAllocatedWidth provides a mock function for the type MockOverlayWidget
5152func (_mock *MockOverlayWidget) GetAllocatedWidth() int {
5153	ret := _mock.Called()
5154
5155	if len(ret) == 0 {
5156		panic("no return value specified for GetAllocatedWidth")
5157	}
5158
5159	var r0 int
5160	if returnFunc, ok := ret.Get(0).(func() int); ok {
5161		r0 = returnFunc()
5162	} else {
5163		r0 = ret.Get(0).(int)
5164	}
5165	return r0
5166}
5167
5168// MockOverlayWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
5169type MockOverlayWidget_GetAllocatedWidth_Call struct {
5170	*mock.Call
5171}
5172
5173// GetAllocatedWidth is a helper method to define mock.On call
5174func (_e *MockOverlayWidget_Expecter) GetAllocatedWidth() *MockOverlayWidget_GetAllocatedWidth_Call {
5175	return &MockOverlayWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
5176}
5177
5178func (_c *MockOverlayWidget_GetAllocatedWidth_Call) Run(run func()) *MockOverlayWidget_GetAllocatedWidth_Call {
5179	_c.Call.Run(func(args mock.Arguments) {
5180		run()
5181	})
5182	return _c
5183}
5184
5185func (_c *MockOverlayWidget_GetAllocatedWidth_Call) Return(n int) *MockOverlayWidget_GetAllocatedWidth_Call {
5186	_c.Call.Return(n)
5187	return _c
5188}
5189
5190func (_c *MockOverlayWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockOverlayWidget_GetAllocatedWidth_Call {
5191	_c.Call.Return(run)
5192	return _c
5193}
5194
5195// GetChild provides a mock function for the type MockOverlayWidget
5196func (_mock *MockOverlayWidget) GetChild() layout.Widget {
5197	ret := _mock.Called()
5198
5199	if len(ret) == 0 {
5200		panic("no return value specified for GetChild")
5201	}
5202
5203	var r0 layout.Widget
5204	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
5205		r0 = returnFunc()
5206	} else {
5207		if ret.Get(0) != nil {
5208			r0 = ret.Get(0).(layout.Widget)
5209		}
5210	}
5211	return r0
5212}
5213
5214// MockOverlayWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
5215type MockOverlayWidget_GetChild_Call struct {
5216	*mock.Call
5217}
5218
5219// GetChild is a helper method to define mock.On call
5220func (_e *MockOverlayWidget_Expecter) GetChild() *MockOverlayWidget_GetChild_Call {
5221	return &MockOverlayWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
5222}
5223
5224func (_c *MockOverlayWidget_GetChild_Call) Run(run func()) *MockOverlayWidget_GetChild_Call {
5225	_c.Call.Run(func(args mock.Arguments) {
5226		run()
5227	})
5228	return _c
5229}
5230
5231func (_c *MockOverlayWidget_GetChild_Call) Return(widget layout.Widget) *MockOverlayWidget_GetChild_Call {
5232	_c.Call.Return(widget)
5233	return _c
5234}
5235
5236func (_c *MockOverlayWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) *MockOverlayWidget_GetChild_Call {
5237	_c.Call.Return(run)
5238	return _c
5239}
5240
5241// GetClipOverlay provides a mock function for the type MockOverlayWidget
5242func (_mock *MockOverlayWidget) GetClipOverlay(overlay layout.Widget) bool {
5243	ret := _mock.Called(overlay)
5244
5245	if len(ret) == 0 {
5246		panic("no return value specified for GetClipOverlay")
5247	}
5248
5249	var r0 bool
5250	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
5251		r0 = returnFunc(overlay)
5252	} else {
5253		r0 = ret.Get(0).(bool)
5254	}
5255	return r0
5256}
5257
5258// MockOverlayWidget_GetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClipOverlay'
5259type MockOverlayWidget_GetClipOverlay_Call struct {
5260	*mock.Call
5261}
5262
5263// GetClipOverlay is a helper method to define mock.On call
5264//   - overlay layout.Widget
5265func (_e *MockOverlayWidget_Expecter) GetClipOverlay(overlay interface{}) *MockOverlayWidget_GetClipOverlay_Call {
5266	return &MockOverlayWidget_GetClipOverlay_Call{Call: _e.mock.On("GetClipOverlay", overlay)}
5267}
5268
5269func (_c *MockOverlayWidget_GetClipOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_GetClipOverlay_Call {
5270	_c.Call.Run(func(args mock.Arguments) {
5271		var arg0 layout.Widget
5272		if args[0] != nil {
5273			arg0 = args[0].(layout.Widget)
5274		}
5275		run(
5276			arg0,
5277		)
5278	})
5279	return _c
5280}
5281
5282func (_c *MockOverlayWidget_GetClipOverlay_Call) Return(b bool) *MockOverlayWidget_GetClipOverlay_Call {
5283	_c.Call.Return(b)
5284	return _c
5285}
5286
5287func (_c *MockOverlayWidget_GetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) *MockOverlayWidget_GetClipOverlay_Call {
5288	_c.Call.Return(run)
5289	return _c
5290}
5291
5292// GetHexpand provides a mock function for the type MockOverlayWidget
5293func (_mock *MockOverlayWidget) GetHexpand() bool {
5294	ret := _mock.Called()
5295
5296	if len(ret) == 0 {
5297		panic("no return value specified for GetHexpand")
5298	}
5299
5300	var r0 bool
5301	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5302		r0 = returnFunc()
5303	} else {
5304		r0 = ret.Get(0).(bool)
5305	}
5306	return r0
5307}
5308
5309// MockOverlayWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
5310type MockOverlayWidget_GetHexpand_Call struct {
5311	*mock.Call
5312}
5313
5314// GetHexpand is a helper method to define mock.On call
5315func (_e *MockOverlayWidget_Expecter) GetHexpand() *MockOverlayWidget_GetHexpand_Call {
5316	return &MockOverlayWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
5317}
5318
5319func (_c *MockOverlayWidget_GetHexpand_Call) Run(run func()) *MockOverlayWidget_GetHexpand_Call {
5320	_c.Call.Run(func(args mock.Arguments) {
5321		run()
5322	})
5323	return _c
5324}
5325
5326func (_c *MockOverlayWidget_GetHexpand_Call) Return(b bool) *MockOverlayWidget_GetHexpand_Call {
5327	_c.Call.Return(b)
5328	return _c
5329}
5330
5331func (_c *MockOverlayWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GetHexpand_Call {
5332	_c.Call.Return(run)
5333	return _c
5334}
5335
5336// GetMeasureOverlay provides a mock function for the type MockOverlayWidget
5337func (_mock *MockOverlayWidget) GetMeasureOverlay(overlay layout.Widget) bool {
5338	ret := _mock.Called(overlay)
5339
5340	if len(ret) == 0 {
5341		panic("no return value specified for GetMeasureOverlay")
5342	}
5343
5344	var r0 bool
5345	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
5346		r0 = returnFunc(overlay)
5347	} else {
5348		r0 = ret.Get(0).(bool)
5349	}
5350	return r0
5351}
5352
5353// MockOverlayWidget_GetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasureOverlay'
5354type MockOverlayWidget_GetMeasureOverlay_Call struct {
5355	*mock.Call
5356}
5357
5358// GetMeasureOverlay is a helper method to define mock.On call
5359//   - overlay layout.Widget
5360func (_e *MockOverlayWidget_Expecter) GetMeasureOverlay(overlay interface{}) *MockOverlayWidget_GetMeasureOverlay_Call {
5361	return &MockOverlayWidget_GetMeasureOverlay_Call{Call: _e.mock.On("GetMeasureOverlay", overlay)}
5362}
5363
5364func (_c *MockOverlayWidget_GetMeasureOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_GetMeasureOverlay_Call {
5365	_c.Call.Run(func(args mock.Arguments) {
5366		var arg0 layout.Widget
5367		if args[0] != nil {
5368			arg0 = args[0].(layout.Widget)
5369		}
5370		run(
5371			arg0,
5372		)
5373	})
5374	return _c
5375}
5376
5377func (_c *MockOverlayWidget_GetMeasureOverlay_Call) Return(b bool) *MockOverlayWidget_GetMeasureOverlay_Call {
5378	_c.Call.Return(b)
5379	return _c
5380}
5381
5382func (_c *MockOverlayWidget_GetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) *MockOverlayWidget_GetMeasureOverlay_Call {
5383	_c.Call.Return(run)
5384	return _c
5385}
5386
5387// GetParent provides a mock function for the type MockOverlayWidget
5388func (_mock *MockOverlayWidget) GetParent() layout.Widget {
5389	ret := _mock.Called()
5390
5391	if len(ret) == 0 {
5392		panic("no return value specified for GetParent")
5393	}
5394
5395	var r0 layout.Widget
5396	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
5397		r0 = returnFunc()
5398	} else {
5399		if ret.Get(0) != nil {
5400			r0 = ret.Get(0).(layout.Widget)
5401		}
5402	}
5403	return r0
5404}
5405
5406// MockOverlayWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
5407type MockOverlayWidget_GetParent_Call struct {
5408	*mock.Call
5409}
5410
5411// GetParent is a helper method to define mock.On call
5412func (_e *MockOverlayWidget_Expecter) GetParent() *MockOverlayWidget_GetParent_Call {
5413	return &MockOverlayWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
5414}
5415
5416func (_c *MockOverlayWidget_GetParent_Call) Run(run func()) *MockOverlayWidget_GetParent_Call {
5417	_c.Call.Run(func(args mock.Arguments) {
5418		run()
5419	})
5420	return _c
5421}
5422
5423func (_c *MockOverlayWidget_GetParent_Call) Return(widget layout.Widget) *MockOverlayWidget_GetParent_Call {
5424	_c.Call.Return(widget)
5425	return _c
5426}
5427
5428func (_c *MockOverlayWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockOverlayWidget_GetParent_Call {
5429	_c.Call.Return(run)
5430	return _c
5431}
5432
5433// GetVexpand provides a mock function for the type MockOverlayWidget
5434func (_mock *MockOverlayWidget) GetVexpand() bool {
5435	ret := _mock.Called()
5436
5437	if len(ret) == 0 {
5438		panic("no return value specified for GetVexpand")
5439	}
5440
5441	var r0 bool
5442	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5443		r0 = returnFunc()
5444	} else {
5445		r0 = ret.Get(0).(bool)
5446	}
5447	return r0
5448}
5449
5450// MockOverlayWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
5451type MockOverlayWidget_GetVexpand_Call struct {
5452	*mock.Call
5453}
5454
5455// GetVexpand is a helper method to define mock.On call
5456func (_e *MockOverlayWidget_Expecter) GetVexpand() *MockOverlayWidget_GetVexpand_Call {
5457	return &MockOverlayWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
5458}
5459
5460func (_c *MockOverlayWidget_GetVexpand_Call) Run(run func()) *MockOverlayWidget_GetVexpand_Call {
5461	_c.Call.Run(func(args mock.Arguments) {
5462		run()
5463	})
5464	return _c
5465}
5466
5467func (_c *MockOverlayWidget_GetVexpand_Call) Return(b bool) *MockOverlayWidget_GetVexpand_Call {
5468	_c.Call.Return(b)
5469	return _c
5470}
5471
5472func (_c *MockOverlayWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GetVexpand_Call {
5473	_c.Call.Return(run)
5474	return _c
5475}
5476
5477// GrabFocus provides a mock function for the type MockOverlayWidget
5478func (_mock *MockOverlayWidget) GrabFocus() bool {
5479	ret := _mock.Called()
5480
5481	if len(ret) == 0 {
5482		panic("no return value specified for GrabFocus")
5483	}
5484
5485	var r0 bool
5486	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5487		r0 = returnFunc()
5488	} else {
5489		r0 = ret.Get(0).(bool)
5490	}
5491	return r0
5492}
5493
5494// MockOverlayWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
5495type MockOverlayWidget_GrabFocus_Call struct {
5496	*mock.Call
5497}
5498
5499// GrabFocus is a helper method to define mock.On call
5500func (_e *MockOverlayWidget_Expecter) GrabFocus() *MockOverlayWidget_GrabFocus_Call {
5501	return &MockOverlayWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
5502}
5503
5504func (_c *MockOverlayWidget_GrabFocus_Call) Run(run func()) *MockOverlayWidget_GrabFocus_Call {
5505	_c.Call.Run(func(args mock.Arguments) {
5506		run()
5507	})
5508	return _c
5509}
5510
5511func (_c *MockOverlayWidget_GrabFocus_Call) Return(b bool) *MockOverlayWidget_GrabFocus_Call {
5512	_c.Call.Return(b)
5513	return _c
5514}
5515
5516func (_c *MockOverlayWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GrabFocus_Call {
5517	_c.Call.Return(run)
5518	return _c
5519}
5520
5521// GtkWidget provides a mock function for the type MockOverlayWidget
5522func (_mock *MockOverlayWidget) GtkWidget() *gtk.Widget {
5523	ret := _mock.Called()
5524
5525	if len(ret) == 0 {
5526		panic("no return value specified for GtkWidget")
5527	}
5528
5529	var r0 *gtk.Widget
5530	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
5531		r0 = returnFunc()
5532	} else {
5533		if ret.Get(0) != nil {
5534			r0 = ret.Get(0).(*gtk.Widget)
5535		}
5536	}
5537	return r0
5538}
5539
5540// MockOverlayWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
5541type MockOverlayWidget_GtkWidget_Call struct {
5542	*mock.Call
5543}
5544
5545// GtkWidget is a helper method to define mock.On call
5546func (_e *MockOverlayWidget_Expecter) GtkWidget() *MockOverlayWidget_GtkWidget_Call {
5547	return &MockOverlayWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
5548}
5549
5550func (_c *MockOverlayWidget_GtkWidget_Call) Run(run func()) *MockOverlayWidget_GtkWidget_Call {
5551	_c.Call.Run(func(args mock.Arguments) {
5552		run()
5553	})
5554	return _c
5555}
5556
5557func (_c *MockOverlayWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
5558	_c.Call.Return(widget)
5559	return _c
5560}
5561
5562func (_c *MockOverlayWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
5563	_c.Call.Return(run)
5564	return _c
5565}
5566
5567// HasCssClass provides a mock function for the type MockOverlayWidget
5568func (_mock *MockOverlayWidget) HasCssClass(cssClass string) bool {
5569	ret := _mock.Called(cssClass)
5570
5571	if len(ret) == 0 {
5572		panic("no return value specified for HasCssClass")
5573	}
5574
5575	var r0 bool
5576	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
5577		r0 = returnFunc(cssClass)
5578	} else {
5579		r0 = ret.Get(0).(bool)
5580	}
5581	return r0
5582}
5583
5584// MockOverlayWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
5585type MockOverlayWidget_HasCssClass_Call struct {
5586	*mock.Call
5587}
5588
5589// HasCssClass is a helper method to define mock.On call
5590//   - cssClass string
5591func (_e *MockOverlayWidget_Expecter) HasCssClass(cssClass interface{}) *MockOverlayWidget_HasCssClass_Call {
5592	return &MockOverlayWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
5593}
5594
5595func (_c *MockOverlayWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_HasCssClass_Call {
5596	_c.Call.Run(func(args mock.Arguments) {
5597		var arg0 string
5598		if args[0] != nil {
5599			arg0 = args[0].(string)
5600		}
5601		run(
5602			arg0,
5603		)
5604	})
5605	return _c
5606}
5607
5608func (_c *MockOverlayWidget_HasCssClass_Call) Return(b bool) *MockOverlayWidget_HasCssClass_Call {
5609	_c.Call.Return(b)
5610	return _c
5611}
5612
5613func (_c *MockOverlayWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockOverlayWidget_HasCssClass_Call {
5614	_c.Call.Return(run)
5615	return _c
5616}
5617
5618// HasFocus provides a mock function for the type MockOverlayWidget
5619func (_mock *MockOverlayWidget) HasFocus() bool {
5620	ret := _mock.Called()
5621
5622	if len(ret) == 0 {
5623		panic("no return value specified for HasFocus")
5624	}
5625
5626	var r0 bool
5627	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5628		r0 = returnFunc()
5629	} else {
5630		r0 = ret.Get(0).(bool)
5631	}
5632	return r0
5633}
5634
5635// MockOverlayWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
5636type MockOverlayWidget_HasFocus_Call struct {
5637	*mock.Call
5638}
5639
5640// HasFocus is a helper method to define mock.On call
5641func (_e *MockOverlayWidget_Expecter) HasFocus() *MockOverlayWidget_HasFocus_Call {
5642	return &MockOverlayWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
5643}
5644
5645func (_c *MockOverlayWidget_HasFocus_Call) Run(run func()) *MockOverlayWidget_HasFocus_Call {
5646	_c.Call.Run(func(args mock.Arguments) {
5647		run()
5648	})
5649	return _c
5650}
5651
5652func (_c *MockOverlayWidget_HasFocus_Call) Return(b bool) *MockOverlayWidget_HasFocus_Call {
5653	_c.Call.Return(b)
5654	return _c
5655}
5656
5657func (_c *MockOverlayWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockOverlayWidget_HasFocus_Call {
5658	_c.Call.Return(run)
5659	return _c
5660}
5661
5662// Hide provides a mock function for the type MockOverlayWidget
5663func (_mock *MockOverlayWidget) Hide() {
5664	_mock.Called()
5665	return
5666}
5667
5668// MockOverlayWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
5669type MockOverlayWidget_Hide_Call struct {
5670	*mock.Call
5671}
5672
5673// Hide is a helper method to define mock.On call
5674func (_e *MockOverlayWidget_Expecter) Hide() *MockOverlayWidget_Hide_Call {
5675	return &MockOverlayWidget_Hide_Call{Call: _e.mock.On("Hide")}
5676}
5677
5678func (_c *MockOverlayWidget_Hide_Call) Run(run func()) *MockOverlayWidget_Hide_Call {
5679	_c.Call.Run(func(args mock.Arguments) {
5680		run()
5681	})
5682	return _c
5683}
5684
5685func (_c *MockOverlayWidget_Hide_Call) Return() *MockOverlayWidget_Hide_Call {
5686	_c.Call.Return()
5687	return _c
5688}
5689
5690func (_c *MockOverlayWidget_Hide_Call) RunAndReturn(run func()) *MockOverlayWidget_Hide_Call {
5691	_c.Run(run)
5692	return _c
5693}
5694
5695// IsVisible provides a mock function for the type MockOverlayWidget
5696func (_mock *MockOverlayWidget) IsVisible() bool {
5697	ret := _mock.Called()
5698
5699	if len(ret) == 0 {
5700		panic("no return value specified for IsVisible")
5701	}
5702
5703	var r0 bool
5704	if returnFunc, ok := ret.Get(0).(func() bool); ok {
5705		r0 = returnFunc()
5706	} else {
5707		r0 = ret.Get(0).(bool)
5708	}
5709	return r0
5710}
5711
5712// MockOverlayWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
5713type MockOverlayWidget_IsVisible_Call struct {
5714	*mock.Call
5715}
5716
5717// IsVisible is a helper method to define mock.On call
5718func (_e *MockOverlayWidget_Expecter) IsVisible() *MockOverlayWidget_IsVisible_Call {
5719	return &MockOverlayWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
5720}
5721
5722func (_c *MockOverlayWidget_IsVisible_Call) Run(run func()) *MockOverlayWidget_IsVisible_Call {
5723	_c.Call.Run(func(args mock.Arguments) {
5724		run()
5725	})
5726	return _c
5727}
5728
5729func (_c *MockOverlayWidget_IsVisible_Call) Return(b bool) *MockOverlayWidget_IsVisible_Call {
5730	_c.Call.Return(b)
5731	return _c
5732}
5733
5734func (_c *MockOverlayWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockOverlayWidget_IsVisible_Call {
5735	_c.Call.Return(run)
5736	return _c
5737}
5738
5739// RemoveCssClass provides a mock function for the type MockOverlayWidget
5740func (_mock *MockOverlayWidget) RemoveCssClass(cssClass string) {
5741	_mock.Called(cssClass)
5742	return
5743}
5744
5745// MockOverlayWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
5746type MockOverlayWidget_RemoveCssClass_Call struct {
5747	*mock.Call
5748}
5749
5750// RemoveCssClass is a helper method to define mock.On call
5751//   - cssClass string
5752func (_e *MockOverlayWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockOverlayWidget_RemoveCssClass_Call {
5753	return &MockOverlayWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
5754}
5755
5756func (_c *MockOverlayWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_RemoveCssClass_Call {
5757	_c.Call.Run(func(args mock.Arguments) {
5758		var arg0 string
5759		if args[0] != nil {
5760			arg0 = args[0].(string)
5761		}
5762		run(
5763			arg0,
5764		)
5765	})
5766	return _c
5767}
5768
5769func (_c *MockOverlayWidget_RemoveCssClass_Call) Return() *MockOverlayWidget_RemoveCssClass_Call {
5770	_c.Call.Return()
5771	return _c
5772}
5773
5774func (_c *MockOverlayWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockOverlayWidget_RemoveCssClass_Call {
5775	_c.Run(run)
5776	return _c
5777}
5778
5779// RemoveOverlay provides a mock function for the type MockOverlayWidget
5780func (_mock *MockOverlayWidget) RemoveOverlay(overlay layout.Widget) {
5781	_mock.Called(overlay)
5782	return
5783}
5784
5785// MockOverlayWidget_RemoveOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOverlay'
5786type MockOverlayWidget_RemoveOverlay_Call struct {
5787	*mock.Call
5788}
5789
5790// RemoveOverlay is a helper method to define mock.On call
5791//   - overlay layout.Widget
5792func (_e *MockOverlayWidget_Expecter) RemoveOverlay(overlay interface{}) *MockOverlayWidget_RemoveOverlay_Call {
5793	return &MockOverlayWidget_RemoveOverlay_Call{Call: _e.mock.On("RemoveOverlay", overlay)}
5794}
5795
5796func (_c *MockOverlayWidget_RemoveOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_RemoveOverlay_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_RemoveOverlay_Call) Return() *MockOverlayWidget_RemoveOverlay_Call {
5810	_c.Call.Return()
5811	return _c
5812}
5813
5814func (_c *MockOverlayWidget_RemoveOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) *MockOverlayWidget_RemoveOverlay_Call {
5815	_c.Run(run)
5816	return _c
5817}
5818
5819// SetCanFocus provides a mock function for the type MockOverlayWidget
5820func (_mock *MockOverlayWidget) SetCanFocus(canFocus bool) {
5821	_mock.Called(canFocus)
5822	return
5823}
5824
5825// MockOverlayWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
5826type MockOverlayWidget_SetCanFocus_Call struct {
5827	*mock.Call
5828}
5829
5830// SetCanFocus is a helper method to define mock.On call
5831//   - canFocus bool
5832func (_e *MockOverlayWidget_Expecter) SetCanFocus(canFocus interface{}) *MockOverlayWidget_SetCanFocus_Call {
5833	return &MockOverlayWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
5834}
5835
5836func (_c *MockOverlayWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockOverlayWidget_SetCanFocus_Call {
5837	_c.Call.Run(func(args mock.Arguments) {
5838		var arg0 bool
5839		if args[0] != nil {
5840			arg0 = args[0].(bool)
5841		}
5842		run(
5843			arg0,
5844		)
5845	})
5846	return _c
5847}
5848
5849func (_c *MockOverlayWidget_SetCanFocus_Call) Return() *MockOverlayWidget_SetCanFocus_Call {
5850	_c.Call.Return()
5851	return _c
5852}
5853
5854func (_c *MockOverlayWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockOverlayWidget_SetCanFocus_Call {
5855	_c.Run(run)
5856	return _c
5857}
5858
5859// SetCanTarget provides a mock function for the type MockOverlayWidget
5860func (_mock *MockOverlayWidget) SetCanTarget(canTarget bool) {
5861	_mock.Called(canTarget)
5862	return
5863}
5864
5865// MockOverlayWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
5866type MockOverlayWidget_SetCanTarget_Call struct {
5867	*mock.Call
5868}
5869
5870// SetCanTarget is a helper method to define mock.On call
5871//   - canTarget bool
5872func (_e *MockOverlayWidget_Expecter) SetCanTarget(canTarget interface{}) *MockOverlayWidget_SetCanTarget_Call {
5873	return &MockOverlayWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
5874}
5875
5876func (_c *MockOverlayWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockOverlayWidget_SetCanTarget_Call {
5877	_c.Call.Run(func(args mock.Arguments) {
5878		var arg0 bool
5879		if args[0] != nil {
5880			arg0 = args[0].(bool)
5881		}
5882		run(
5883			arg0,
5884		)
5885	})
5886	return _c
5887}
5888
5889func (_c *MockOverlayWidget_SetCanTarget_Call) Return() *MockOverlayWidget_SetCanTarget_Call {
5890	_c.Call.Return()
5891	return _c
5892}
5893
5894func (_c *MockOverlayWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockOverlayWidget_SetCanTarget_Call {
5895	_c.Run(run)
5896	return _c
5897}
5898
5899// SetChild provides a mock function for the type MockOverlayWidget
5900func (_mock *MockOverlayWidget) SetChild(child layout.Widget) {
5901	_mock.Called(child)
5902	return
5903}
5904
5905// MockOverlayWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
5906type MockOverlayWidget_SetChild_Call struct {
5907	*mock.Call
5908}
5909
5910// SetChild is a helper method to define mock.On call
5911//   - child layout.Widget
5912func (_e *MockOverlayWidget_Expecter) SetChild(child interface{}) *MockOverlayWidget_SetChild_Call {
5913	return &MockOverlayWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
5914}
5915
5916func (_c *MockOverlayWidget_SetChild_Call) Run(run func(child layout.Widget)) *MockOverlayWidget_SetChild_Call {
5917	_c.Call.Run(func(args mock.Arguments) {
5918		var arg0 layout.Widget
5919		if args[0] != nil {
5920			arg0 = args[0].(layout.Widget)
5921		}
5922		run(
5923			arg0,
5924		)
5925	})
5926	return _c
5927}
5928
5929func (_c *MockOverlayWidget_SetChild_Call) Return() *MockOverlayWidget_SetChild_Call {
5930	_c.Call.Return()
5931	return _c
5932}
5933
5934func (_c *MockOverlayWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) *MockOverlayWidget_SetChild_Call {
5935	_c.Run(run)
5936	return _c
5937}
5938
5939// SetClipOverlay provides a mock function for the type MockOverlayWidget
5940func (_mock *MockOverlayWidget) SetClipOverlay(overlay layout.Widget, clip bool) {
5941	_mock.Called(overlay, clip)
5942	return
5943}
5944
5945// MockOverlayWidget_SetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetClipOverlay'
5946type MockOverlayWidget_SetClipOverlay_Call struct {
5947	*mock.Call
5948}
5949
5950// SetClipOverlay is a helper method to define mock.On call
5951//   - overlay layout.Widget
5952//   - clip bool
5953func (_e *MockOverlayWidget_Expecter) SetClipOverlay(overlay interface{}, clip interface{}) *MockOverlayWidget_SetClipOverlay_Call {
5954	return &MockOverlayWidget_SetClipOverlay_Call{Call: _e.mock.On("SetClipOverlay", overlay, clip)}
5955}
5956
5957func (_c *MockOverlayWidget_SetClipOverlay_Call) Run(run func(overlay layout.Widget, clip bool)) *MockOverlayWidget_SetClipOverlay_Call {
5958	_c.Call.Run(func(args mock.Arguments) {
5959		var arg0 layout.Widget
5960		if args[0] != nil {
5961			arg0 = args[0].(layout.Widget)
5962		}
5963		var arg1 bool
5964		if args[1] != nil {
5965			arg1 = args[1].(bool)
5966		}
5967		run(
5968			arg0,
5969			arg1,
5970		)
5971	})
5972	return _c
5973}
5974
5975func (_c *MockOverlayWidget_SetClipOverlay_Call) Return() *MockOverlayWidget_SetClipOverlay_Call {
5976	_c.Call.Return()
5977	return _c
5978}
5979
5980func (_c *MockOverlayWidget_SetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget, clip bool)) *MockOverlayWidget_SetClipOverlay_Call {
5981	_c.Run(run)
5982	return _c
5983}
5984
5985// SetFocusOnClick provides a mock function for the type MockOverlayWidget
5986func (_mock *MockOverlayWidget) SetFocusOnClick(focusOnClick bool) {
5987	_mock.Called(focusOnClick)
5988	return
5989}
5990
5991// MockOverlayWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
5992type MockOverlayWidget_SetFocusOnClick_Call struct {
5993	*mock.Call
5994}
5995
5996// SetFocusOnClick is a helper method to define mock.On call
5997//   - focusOnClick bool
5998func (_e *MockOverlayWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockOverlayWidget_SetFocusOnClick_Call {
5999	return &MockOverlayWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
6000}
6001
6002func (_c *MockOverlayWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockOverlayWidget_SetFocusOnClick_Call {
6003	_c.Call.Run(func(args mock.Arguments) {
6004		var arg0 bool
6005		if args[0] != nil {
6006			arg0 = args[0].(bool)
6007		}
6008		run(
6009			arg0,
6010		)
6011	})
6012	return _c
6013}
6014
6015func (_c *MockOverlayWidget_SetFocusOnClick_Call) Return() *MockOverlayWidget_SetFocusOnClick_Call {
6016	_c.Call.Return()
6017	return _c
6018}
6019
6020func (_c *MockOverlayWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockOverlayWidget_SetFocusOnClick_Call {
6021	_c.Run(run)
6022	return _c
6023}
6024
6025// SetFocusable provides a mock function for the type MockOverlayWidget
6026func (_mock *MockOverlayWidget) SetFocusable(focusable bool) {
6027	_mock.Called(focusable)
6028	return
6029}
6030
6031// MockOverlayWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
6032type MockOverlayWidget_SetFocusable_Call struct {
6033	*mock.Call
6034}
6035
6036// SetFocusable is a helper method to define mock.On call
6037//   - focusable bool
6038func (_e *MockOverlayWidget_Expecter) SetFocusable(focusable interface{}) *MockOverlayWidget_SetFocusable_Call {
6039	return &MockOverlayWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
6040}
6041
6042func (_c *MockOverlayWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockOverlayWidget_SetFocusable_Call {
6043	_c.Call.Run(func(args mock.Arguments) {
6044		var arg0 bool
6045		if args[0] != nil {
6046			arg0 = args[0].(bool)
6047		}
6048		run(
6049			arg0,
6050		)
6051	})
6052	return _c
6053}
6054
6055func (_c *MockOverlayWidget_SetFocusable_Call) Return() *MockOverlayWidget_SetFocusable_Call {
6056	_c.Call.Return()
6057	return _c
6058}
6059
6060func (_c *MockOverlayWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockOverlayWidget_SetFocusable_Call {
6061	_c.Run(run)
6062	return _c
6063}
6064
6065// SetHalign provides a mock function for the type MockOverlayWidget
6066func (_mock *MockOverlayWidget) SetHalign(align gtk.Align) {
6067	_mock.Called(align)
6068	return
6069}
6070
6071// MockOverlayWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
6072type MockOverlayWidget_SetHalign_Call struct {
6073	*mock.Call
6074}
6075
6076// SetHalign is a helper method to define mock.On call
6077//   - align gtk.Align
6078func (_e *MockOverlayWidget_Expecter) SetHalign(align interface{}) *MockOverlayWidget_SetHalign_Call {
6079	return &MockOverlayWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
6080}
6081
6082func (_c *MockOverlayWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockOverlayWidget_SetHalign_Call {
6083	_c.Call.Run(func(args mock.Arguments) {
6084		var arg0 gtk.Align
6085		if args[0] != nil {
6086			arg0 = args[0].(gtk.Align)
6087		}
6088		run(
6089			arg0,
6090		)
6091	})
6092	return _c
6093}
6094
6095func (_c *MockOverlayWidget_SetHalign_Call) Return() *MockOverlayWidget_SetHalign_Call {
6096	_c.Call.Return()
6097	return _c
6098}
6099
6100func (_c *MockOverlayWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockOverlayWidget_SetHalign_Call {
6101	_c.Run(run)
6102	return _c
6103}
6104
6105// SetHexpand provides a mock function for the type MockOverlayWidget
6106func (_mock *MockOverlayWidget) SetHexpand(expand bool) {
6107	_mock.Called(expand)
6108	return
6109}
6110
6111// MockOverlayWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
6112type MockOverlayWidget_SetHexpand_Call struct {
6113	*mock.Call
6114}
6115
6116// SetHexpand is a helper method to define mock.On call
6117//   - expand bool
6118func (_e *MockOverlayWidget_Expecter) SetHexpand(expand interface{}) *MockOverlayWidget_SetHexpand_Call {
6119	return &MockOverlayWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
6120}
6121
6122func (_c *MockOverlayWidget_SetHexpand_Call) Run(run func(expand bool)) *MockOverlayWidget_SetHexpand_Call {
6123	_c.Call.Run(func(args mock.Arguments) {
6124		var arg0 bool
6125		if args[0] != nil {
6126			arg0 = args[0].(bool)
6127		}
6128		run(
6129			arg0,
6130		)
6131	})
6132	return _c
6133}
6134
6135func (_c *MockOverlayWidget_SetHexpand_Call) Return() *MockOverlayWidget_SetHexpand_Call {
6136	_c.Call.Return()
6137	return _c
6138}
6139
6140func (_c *MockOverlayWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockOverlayWidget_SetHexpand_Call {
6141	_c.Run(run)
6142	return _c
6143}
6144
6145// SetMeasureOverlay provides a mock function for the type MockOverlayWidget
6146func (_mock *MockOverlayWidget) SetMeasureOverlay(overlay layout.Widget, measure bool) {
6147	_mock.Called(overlay, measure)
6148	return
6149}
6150
6151// MockOverlayWidget_SetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMeasureOverlay'
6152type MockOverlayWidget_SetMeasureOverlay_Call struct {
6153	*mock.Call
6154}
6155
6156// SetMeasureOverlay is a helper method to define mock.On call
6157//   - overlay layout.Widget
6158//   - measure bool
6159func (_e *MockOverlayWidget_Expecter) SetMeasureOverlay(overlay interface{}, measure interface{}) *MockOverlayWidget_SetMeasureOverlay_Call {
6160	return &MockOverlayWidget_SetMeasureOverlay_Call{Call: _e.mock.On("SetMeasureOverlay", overlay, measure)}
6161}
6162
6163func (_c *MockOverlayWidget_SetMeasureOverlay_Call) Run(run func(overlay layout.Widget, measure bool)) *MockOverlayWidget_SetMeasureOverlay_Call {
6164	_c.Call.Run(func(args mock.Arguments) {
6165		var arg0 layout.Widget
6166		if args[0] != nil {
6167			arg0 = args[0].(layout.Widget)
6168		}
6169		var arg1 bool
6170		if args[1] != nil {
6171			arg1 = args[1].(bool)
6172		}
6173		run(
6174			arg0,
6175			arg1,
6176		)
6177	})
6178	return _c
6179}
6180
6181func (_c *MockOverlayWidget_SetMeasureOverlay_Call) Return() *MockOverlayWidget_SetMeasureOverlay_Call {
6182	_c.Call.Return()
6183	return _c
6184}
6185
6186func (_c *MockOverlayWidget_SetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget, measure bool)) *MockOverlayWidget_SetMeasureOverlay_Call {
6187	_c.Run(run)
6188	return _c
6189}
6190
6191// SetSizeRequest provides a mock function for the type MockOverlayWidget
6192func (_mock *MockOverlayWidget) SetSizeRequest(width int, height int) {
6193	_mock.Called(width, height)
6194	return
6195}
6196
6197// MockOverlayWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
6198type MockOverlayWidget_SetSizeRequest_Call struct {
6199	*mock.Call
6200}
6201
6202// SetSizeRequest is a helper method to define mock.On call
6203//   - width int
6204//   - height int
6205func (_e *MockOverlayWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockOverlayWidget_SetSizeRequest_Call {
6206	return &MockOverlayWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
6207}
6208
6209func (_c *MockOverlayWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockOverlayWidget_SetSizeRequest_Call {
6210	_c.Call.Run(func(args mock.Arguments) {
6211		var arg0 int
6212		if args[0] != nil {
6213			arg0 = args[0].(int)
6214		}
6215		var arg1 int
6216		if args[1] != nil {
6217			arg1 = args[1].(int)
6218		}
6219		run(
6220			arg0,
6221			arg1,
6222		)
6223	})
6224	return _c
6225}
6226
6227func (_c *MockOverlayWidget_SetSizeRequest_Call) Return() *MockOverlayWidget_SetSizeRequest_Call {
6228	_c.Call.Return()
6229	return _c
6230}
6231
6232func (_c *MockOverlayWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockOverlayWidget_SetSizeRequest_Call {
6233	_c.Run(run)
6234	return _c
6235}
6236
6237// SetValign provides a mock function for the type MockOverlayWidget
6238func (_mock *MockOverlayWidget) SetValign(align gtk.Align) {
6239	_mock.Called(align)
6240	return
6241}
6242
6243// MockOverlayWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
6244type MockOverlayWidget_SetValign_Call struct {
6245	*mock.Call
6246}
6247
6248// SetValign is a helper method to define mock.On call
6249//   - align gtk.Align
6250func (_e *MockOverlayWidget_Expecter) SetValign(align interface{}) *MockOverlayWidget_SetValign_Call {
6251	return &MockOverlayWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
6252}
6253
6254func (_c *MockOverlayWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockOverlayWidget_SetValign_Call {
6255	_c.Call.Run(func(args mock.Arguments) {
6256		var arg0 gtk.Align
6257		if args[0] != nil {
6258			arg0 = args[0].(gtk.Align)
6259		}
6260		run(
6261			arg0,
6262		)
6263	})
6264	return _c
6265}
6266
6267func (_c *MockOverlayWidget_SetValign_Call) Return() *MockOverlayWidget_SetValign_Call {
6268	_c.Call.Return()
6269	return _c
6270}
6271
6272func (_c *MockOverlayWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockOverlayWidget_SetValign_Call {
6273	_c.Run(run)
6274	return _c
6275}
6276
6277// SetVexpand provides a mock function for the type MockOverlayWidget
6278func (_mock *MockOverlayWidget) SetVexpand(expand bool) {
6279	_mock.Called(expand)
6280	return
6281}
6282
6283// MockOverlayWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
6284type MockOverlayWidget_SetVexpand_Call struct {
6285	*mock.Call
6286}
6287
6288// SetVexpand is a helper method to define mock.On call
6289//   - expand bool
6290func (_e *MockOverlayWidget_Expecter) SetVexpand(expand interface{}) *MockOverlayWidget_SetVexpand_Call {
6291	return &MockOverlayWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
6292}
6293
6294func (_c *MockOverlayWidget_SetVexpand_Call) Run(run func(expand bool)) *MockOverlayWidget_SetVexpand_Call {
6295	_c.Call.Run(func(args mock.Arguments) {
6296		var arg0 bool
6297		if args[0] != nil {
6298			arg0 = args[0].(bool)
6299		}
6300		run(
6301			arg0,
6302		)
6303	})
6304	return _c
6305}
6306
6307func (_c *MockOverlayWidget_SetVexpand_Call) Return() *MockOverlayWidget_SetVexpand_Call {
6308	_c.Call.Return()
6309	return _c
6310}
6311
6312func (_c *MockOverlayWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockOverlayWidget_SetVexpand_Call {
6313	_c.Run(run)
6314	return _c
6315}
6316
6317// SetVisible provides a mock function for the type MockOverlayWidget
6318func (_mock *MockOverlayWidget) SetVisible(visible bool) {
6319	_mock.Called(visible)
6320	return
6321}
6322
6323// MockOverlayWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
6324type MockOverlayWidget_SetVisible_Call struct {
6325	*mock.Call
6326}
6327
6328// SetVisible is a helper method to define mock.On call
6329//   - visible bool
6330func (_e *MockOverlayWidget_Expecter) SetVisible(visible interface{}) *MockOverlayWidget_SetVisible_Call {
6331	return &MockOverlayWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
6332}
6333
6334func (_c *MockOverlayWidget_SetVisible_Call) Run(run func(visible bool)) *MockOverlayWidget_SetVisible_Call {
6335	_c.Call.Run(func(args mock.Arguments) {
6336		var arg0 bool
6337		if args[0] != nil {
6338			arg0 = args[0].(bool)
6339		}
6340		run(
6341			arg0,
6342		)
6343	})
6344	return _c
6345}
6346
6347func (_c *MockOverlayWidget_SetVisible_Call) Return() *MockOverlayWidget_SetVisible_Call {
6348	_c.Call.Return()
6349	return _c
6350}
6351
6352func (_c *MockOverlayWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockOverlayWidget_SetVisible_Call {
6353	_c.Run(run)
6354	return _c
6355}
6356
6357// Show provides a mock function for the type MockOverlayWidget
6358func (_mock *MockOverlayWidget) Show() {
6359	_mock.Called()
6360	return
6361}
6362
6363// MockOverlayWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
6364type MockOverlayWidget_Show_Call struct {
6365	*mock.Call
6366}
6367
6368// Show is a helper method to define mock.On call
6369func (_e *MockOverlayWidget_Expecter) Show() *MockOverlayWidget_Show_Call {
6370	return &MockOverlayWidget_Show_Call{Call: _e.mock.On("Show")}
6371}
6372
6373func (_c *MockOverlayWidget_Show_Call) Run(run func()) *MockOverlayWidget_Show_Call {
6374	_c.Call.Run(func(args mock.Arguments) {
6375		run()
6376	})
6377	return _c
6378}
6379
6380func (_c *MockOverlayWidget_Show_Call) Return() *MockOverlayWidget_Show_Call {
6381	_c.Call.Return()
6382	return _c
6383}
6384
6385func (_c *MockOverlayWidget_Show_Call) RunAndReturn(run func()) *MockOverlayWidget_Show_Call {
6386	_c.Run(run)
6387	return _c
6388}
6389
6390// Unparent provides a mock function for the type MockOverlayWidget
6391func (_mock *MockOverlayWidget) Unparent() {
6392	_mock.Called()
6393	return
6394}
6395
6396// MockOverlayWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
6397type MockOverlayWidget_Unparent_Call struct {
6398	*mock.Call
6399}
6400
6401// Unparent is a helper method to define mock.On call
6402func (_e *MockOverlayWidget_Expecter) Unparent() *MockOverlayWidget_Unparent_Call {
6403	return &MockOverlayWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
6404}
6405
6406func (_c *MockOverlayWidget_Unparent_Call) Run(run func()) *MockOverlayWidget_Unparent_Call {
6407	_c.Call.Run(func(args mock.Arguments) {
6408		run()
6409	})
6410	return _c
6411}
6412
6413func (_c *MockOverlayWidget_Unparent_Call) Return() *MockOverlayWidget_Unparent_Call {
6414	_c.Call.Return()
6415	return _c
6416}
6417
6418func (_c *MockOverlayWidget_Unparent_Call) RunAndReturn(run func()) *MockOverlayWidget_Unparent_Call {
6419	_c.Run(run)
6420	return _c
6421}
6422
6423// 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.
6424// The first argument is typically a *testing.T value.
6425func NewMockLabelWidget(t interface {
6426	mock.TestingT
6427	Cleanup(func())
6428}) *MockLabelWidget {
6429	mock := &MockLabelWidget{}
6430	mock.Mock.Test(t)
6431
6432	t.Cleanup(func() { mock.AssertExpectations(t) })
6433
6434	return mock
6435}
6436
6437// MockLabelWidget is an autogenerated mock type for the LabelWidget type
6438type MockLabelWidget struct {
6439	mock.Mock
6440}
6441
6442type MockLabelWidget_Expecter struct {
6443	mock *mock.Mock
6444}
6445
6446func (_m *MockLabelWidget) EXPECT() *MockLabelWidget_Expecter {
6447	return &MockLabelWidget_Expecter{mock: &_m.Mock}
6448}
6449
6450// AddController provides a mock function for the type MockLabelWidget
6451func (_mock *MockLabelWidget) AddController(controller *gtk.EventController) {
6452	_mock.Called(controller)
6453	return
6454}
6455
6456// MockLabelWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
6457type MockLabelWidget_AddController_Call struct {
6458	*mock.Call
6459}
6460
6461// AddController is a helper method to define mock.On call
6462//   - controller *gtk.EventController
6463func (_e *MockLabelWidget_Expecter) AddController(controller interface{}) *MockLabelWidget_AddController_Call {
6464	return &MockLabelWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
6465}
6466
6467func (_c *MockLabelWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockLabelWidget_AddController_Call {
6468	_c.Call.Run(func(args mock.Arguments) {
6469		var arg0 *gtk.EventController
6470		if args[0] != nil {
6471			arg0 = args[0].(*gtk.EventController)
6472		}
6473		run(
6474			arg0,
6475		)
6476	})
6477	return _c
6478}
6479
6480func (_c *MockLabelWidget_AddController_Call) Return() *MockLabelWidget_AddController_Call {
6481	_c.Call.Return()
6482	return _c
6483}
6484
6485func (_c *MockLabelWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockLabelWidget_AddController_Call {
6486	_c.Run(run)
6487	return _c
6488}
6489
6490// AddCssClass provides a mock function for the type MockLabelWidget
6491func (_mock *MockLabelWidget) AddCssClass(cssClass string) {
6492	_mock.Called(cssClass)
6493	return
6494}
6495
6496// MockLabelWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
6497type MockLabelWidget_AddCssClass_Call struct {
6498	*mock.Call
6499}
6500
6501// AddCssClass is a helper method to define mock.On call
6502//   - cssClass string
6503func (_e *MockLabelWidget_Expecter) AddCssClass(cssClass interface{}) *MockLabelWidget_AddCssClass_Call {
6504	return &MockLabelWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
6505}
6506
6507func (_c *MockLabelWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_AddCssClass_Call {
6508	_c.Call.Run(func(args mock.Arguments) {
6509		var arg0 string
6510		if args[0] != nil {
6511			arg0 = args[0].(string)
6512		}
6513		run(
6514			arg0,
6515		)
6516	})
6517	return _c
6518}
6519
6520func (_c *MockLabelWidget_AddCssClass_Call) Return() *MockLabelWidget_AddCssClass_Call {
6521	_c.Call.Return()
6522	return _c
6523}
6524
6525func (_c *MockLabelWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockLabelWidget_AddCssClass_Call {
6526	_c.Run(run)
6527	return _c
6528}
6529
6530// ComputePoint provides a mock function for the type MockLabelWidget
6531func (_mock *MockLabelWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
6532	ret := _mock.Called(target)
6533
6534	if len(ret) == 0 {
6535		panic("no return value specified for ComputePoint")
6536	}
6537
6538	var r0 float64
6539	var r1 float64
6540	var r2 bool
6541	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
6542		return returnFunc(target)
6543	}
6544	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
6545		r0 = returnFunc(target)
6546	} else {
6547		r0 = ret.Get(0).(float64)
6548	}
6549	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
6550		r1 = returnFunc(target)
6551	} else {
6552		r1 = ret.Get(1).(float64)
6553	}
6554	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
6555		r2 = returnFunc(target)
6556	} else {
6557		r2 = ret.Get(2).(bool)
6558	}
6559	return r0, r1, r2
6560}
6561
6562// MockLabelWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
6563type MockLabelWidget_ComputePoint_Call struct {
6564	*mock.Call
6565}
6566
6567// ComputePoint is a helper method to define mock.On call
6568//   - target layout.Widget
6569func (_e *MockLabelWidget_Expecter) ComputePoint(target interface{}) *MockLabelWidget_ComputePoint_Call {
6570	return &MockLabelWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
6571}
6572
6573func (_c *MockLabelWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockLabelWidget_ComputePoint_Call {
6574	_c.Call.Run(func(args mock.Arguments) {
6575		var arg0 layout.Widget
6576		if args[0] != nil {
6577			arg0 = args[0].(layout.Widget)
6578		}
6579		run(
6580			arg0,
6581		)
6582	})
6583	return _c
6584}
6585
6586func (_c *MockLabelWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockLabelWidget_ComputePoint_Call {
6587	_c.Call.Return(x, y, ok)
6588	return _c
6589}
6590
6591func (_c *MockLabelWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockLabelWidget_ComputePoint_Call {
6592	_c.Call.Return(run)
6593	return _c
6594}
6595
6596// GetAllocatedHeight provides a mock function for the type MockLabelWidget
6597func (_mock *MockLabelWidget) GetAllocatedHeight() int {
6598	ret := _mock.Called()
6599
6600	if len(ret) == 0 {
6601		panic("no return value specified for GetAllocatedHeight")
6602	}
6603
6604	var r0 int
6605	if returnFunc, ok := ret.Get(0).(func() int); ok {
6606		r0 = returnFunc()
6607	} else {
6608		r0 = ret.Get(0).(int)
6609	}
6610	return r0
6611}
6612
6613// MockLabelWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
6614type MockLabelWidget_GetAllocatedHeight_Call struct {
6615	*mock.Call
6616}
6617
6618// GetAllocatedHeight is a helper method to define mock.On call
6619func (_e *MockLabelWidget_Expecter) GetAllocatedHeight() *MockLabelWidget_GetAllocatedHeight_Call {
6620	return &MockLabelWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
6621}
6622
6623func (_c *MockLabelWidget_GetAllocatedHeight_Call) Run(run func()) *MockLabelWidget_GetAllocatedHeight_Call {
6624	_c.Call.Run(func(args mock.Arguments) {
6625		run()
6626	})
6627	return _c
6628}
6629
6630func (_c *MockLabelWidget_GetAllocatedHeight_Call) Return(n int) *MockLabelWidget_GetAllocatedHeight_Call {
6631	_c.Call.Return(n)
6632	return _c
6633}
6634
6635func (_c *MockLabelWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockLabelWidget_GetAllocatedHeight_Call {
6636	_c.Call.Return(run)
6637	return _c
6638}
6639
6640// GetAllocatedWidth provides a mock function for the type MockLabelWidget
6641func (_mock *MockLabelWidget) GetAllocatedWidth() int {
6642	ret := _mock.Called()
6643
6644	if len(ret) == 0 {
6645		panic("no return value specified for GetAllocatedWidth")
6646	}
6647
6648	var r0 int
6649	if returnFunc, ok := ret.Get(0).(func() int); ok {
6650		r0 = returnFunc()
6651	} else {
6652		r0 = ret.Get(0).(int)
6653	}
6654	return r0
6655}
6656
6657// MockLabelWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
6658type MockLabelWidget_GetAllocatedWidth_Call struct {
6659	*mock.Call
6660}
6661
6662// GetAllocatedWidth is a helper method to define mock.On call
6663func (_e *MockLabelWidget_Expecter) GetAllocatedWidth() *MockLabelWidget_GetAllocatedWidth_Call {
6664	return &MockLabelWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
6665}
6666
6667func (_c *MockLabelWidget_GetAllocatedWidth_Call) Run(run func()) *MockLabelWidget_GetAllocatedWidth_Call {
6668	_c.Call.Run(func(args mock.Arguments) {
6669		run()
6670	})
6671	return _c
6672}
6673
6674func (_c *MockLabelWidget_GetAllocatedWidth_Call) Return(n int) *MockLabelWidget_GetAllocatedWidth_Call {
6675	_c.Call.Return(n)
6676	return _c
6677}
6678
6679func (_c *MockLabelWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockLabelWidget_GetAllocatedWidth_Call {
6680	_c.Call.Return(run)
6681	return _c
6682}
6683
6684// GetHexpand provides a mock function for the type MockLabelWidget
6685func (_mock *MockLabelWidget) GetHexpand() bool {
6686	ret := _mock.Called()
6687
6688	if len(ret) == 0 {
6689		panic("no return value specified for GetHexpand")
6690	}
6691
6692	var r0 bool
6693	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6694		r0 = returnFunc()
6695	} else {
6696		r0 = ret.Get(0).(bool)
6697	}
6698	return r0
6699}
6700
6701// MockLabelWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
6702type MockLabelWidget_GetHexpand_Call struct {
6703	*mock.Call
6704}
6705
6706// GetHexpand is a helper method to define mock.On call
6707func (_e *MockLabelWidget_Expecter) GetHexpand() *MockLabelWidget_GetHexpand_Call {
6708	return &MockLabelWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
6709}
6710
6711func (_c *MockLabelWidget_GetHexpand_Call) Run(run func()) *MockLabelWidget_GetHexpand_Call {
6712	_c.Call.Run(func(args mock.Arguments) {
6713		run()
6714	})
6715	return _c
6716}
6717
6718func (_c *MockLabelWidget_GetHexpand_Call) Return(b bool) *MockLabelWidget_GetHexpand_Call {
6719	_c.Call.Return(b)
6720	return _c
6721}
6722
6723func (_c *MockLabelWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockLabelWidget_GetHexpand_Call {
6724	_c.Call.Return(run)
6725	return _c
6726}
6727
6728// GetParent provides a mock function for the type MockLabelWidget
6729func (_mock *MockLabelWidget) GetParent() layout.Widget {
6730	ret := _mock.Called()
6731
6732	if len(ret) == 0 {
6733		panic("no return value specified for GetParent")
6734	}
6735
6736	var r0 layout.Widget
6737	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
6738		r0 = returnFunc()
6739	} else {
6740		if ret.Get(0) != nil {
6741			r0 = ret.Get(0).(layout.Widget)
6742		}
6743	}
6744	return r0
6745}
6746
6747// MockLabelWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
6748type MockLabelWidget_GetParent_Call struct {
6749	*mock.Call
6750}
6751
6752// GetParent is a helper method to define mock.On call
6753func (_e *MockLabelWidget_Expecter) GetParent() *MockLabelWidget_GetParent_Call {
6754	return &MockLabelWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
6755}
6756
6757func (_c *MockLabelWidget_GetParent_Call) Run(run func()) *MockLabelWidget_GetParent_Call {
6758	_c.Call.Run(func(args mock.Arguments) {
6759		run()
6760	})
6761	return _c
6762}
6763
6764func (_c *MockLabelWidget_GetParent_Call) Return(widget layout.Widget) *MockLabelWidget_GetParent_Call {
6765	_c.Call.Return(widget)
6766	return _c
6767}
6768
6769func (_c *MockLabelWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockLabelWidget_GetParent_Call {
6770	_c.Call.Return(run)
6771	return _c
6772}
6773
6774// GetText provides a mock function for the type MockLabelWidget
6775func (_mock *MockLabelWidget) GetText() string {
6776	ret := _mock.Called()
6777
6778	if len(ret) == 0 {
6779		panic("no return value specified for GetText")
6780	}
6781
6782	var r0 string
6783	if returnFunc, ok := ret.Get(0).(func() string); ok {
6784		r0 = returnFunc()
6785	} else {
6786		r0 = ret.Get(0).(string)
6787	}
6788	return r0
6789}
6790
6791// MockLabelWidget_GetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetText'
6792type MockLabelWidget_GetText_Call struct {
6793	*mock.Call
6794}
6795
6796// GetText is a helper method to define mock.On call
6797func (_e *MockLabelWidget_Expecter) GetText() *MockLabelWidget_GetText_Call {
6798	return &MockLabelWidget_GetText_Call{Call: _e.mock.On("GetText")}
6799}
6800
6801func (_c *MockLabelWidget_GetText_Call) Run(run func()) *MockLabelWidget_GetText_Call {
6802	_c.Call.Run(func(args mock.Arguments) {
6803		run()
6804	})
6805	return _c
6806}
6807
6808func (_c *MockLabelWidget_GetText_Call) Return(s string) *MockLabelWidget_GetText_Call {
6809	_c.Call.Return(s)
6810	return _c
6811}
6812
6813func (_c *MockLabelWidget_GetText_Call) RunAndReturn(run func() string) *MockLabelWidget_GetText_Call {
6814	_c.Call.Return(run)
6815	return _c
6816}
6817
6818// GetVexpand provides a mock function for the type MockLabelWidget
6819func (_mock *MockLabelWidget) GetVexpand() bool {
6820	ret := _mock.Called()
6821
6822	if len(ret) == 0 {
6823		panic("no return value specified for GetVexpand")
6824	}
6825
6826	var r0 bool
6827	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6828		r0 = returnFunc()
6829	} else {
6830		r0 = ret.Get(0).(bool)
6831	}
6832	return r0
6833}
6834
6835// MockLabelWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
6836type MockLabelWidget_GetVexpand_Call struct {
6837	*mock.Call
6838}
6839
6840// GetVexpand is a helper method to define mock.On call
6841func (_e *MockLabelWidget_Expecter) GetVexpand() *MockLabelWidget_GetVexpand_Call {
6842	return &MockLabelWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
6843}
6844
6845func (_c *MockLabelWidget_GetVexpand_Call) Run(run func()) *MockLabelWidget_GetVexpand_Call {
6846	_c.Call.Run(func(args mock.Arguments) {
6847		run()
6848	})
6849	return _c
6850}
6851
6852func (_c *MockLabelWidget_GetVexpand_Call) Return(b bool) *MockLabelWidget_GetVexpand_Call {
6853	_c.Call.Return(b)
6854	return _c
6855}
6856
6857func (_c *MockLabelWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockLabelWidget_GetVexpand_Call {
6858	_c.Call.Return(run)
6859	return _c
6860}
6861
6862// GrabFocus provides a mock function for the type MockLabelWidget
6863func (_mock *MockLabelWidget) GrabFocus() bool {
6864	ret := _mock.Called()
6865
6866	if len(ret) == 0 {
6867		panic("no return value specified for GrabFocus")
6868	}
6869
6870	var r0 bool
6871	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6872		r0 = returnFunc()
6873	} else {
6874		r0 = ret.Get(0).(bool)
6875	}
6876	return r0
6877}
6878
6879// MockLabelWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
6880type MockLabelWidget_GrabFocus_Call struct {
6881	*mock.Call
6882}
6883
6884// GrabFocus is a helper method to define mock.On call
6885func (_e *MockLabelWidget_Expecter) GrabFocus() *MockLabelWidget_GrabFocus_Call {
6886	return &MockLabelWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
6887}
6888
6889func (_c *MockLabelWidget_GrabFocus_Call) Run(run func()) *MockLabelWidget_GrabFocus_Call {
6890	_c.Call.Run(func(args mock.Arguments) {
6891		run()
6892	})
6893	return _c
6894}
6895
6896func (_c *MockLabelWidget_GrabFocus_Call) Return(b bool) *MockLabelWidget_GrabFocus_Call {
6897	_c.Call.Return(b)
6898	return _c
6899}
6900
6901func (_c *MockLabelWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockLabelWidget_GrabFocus_Call {
6902	_c.Call.Return(run)
6903	return _c
6904}
6905
6906// GtkWidget provides a mock function for the type MockLabelWidget
6907func (_mock *MockLabelWidget) GtkWidget() *gtk.Widget {
6908	ret := _mock.Called()
6909
6910	if len(ret) == 0 {
6911		panic("no return value specified for GtkWidget")
6912	}
6913
6914	var r0 *gtk.Widget
6915	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
6916		r0 = returnFunc()
6917	} else {
6918		if ret.Get(0) != nil {
6919			r0 = ret.Get(0).(*gtk.Widget)
6920		}
6921	}
6922	return r0
6923}
6924
6925// MockLabelWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
6926type MockLabelWidget_GtkWidget_Call struct {
6927	*mock.Call
6928}
6929
6930// GtkWidget is a helper method to define mock.On call
6931func (_e *MockLabelWidget_Expecter) GtkWidget() *MockLabelWidget_GtkWidget_Call {
6932	return &MockLabelWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
6933}
6934
6935func (_c *MockLabelWidget_GtkWidget_Call) Run(run func()) *MockLabelWidget_GtkWidget_Call {
6936	_c.Call.Run(func(args mock.Arguments) {
6937		run()
6938	})
6939	return _c
6940}
6941
6942func (_c *MockLabelWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockLabelWidget_GtkWidget_Call {
6943	_c.Call.Return(widget)
6944	return _c
6945}
6946
6947func (_c *MockLabelWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockLabelWidget_GtkWidget_Call {
6948	_c.Call.Return(run)
6949	return _c
6950}
6951
6952// HasCssClass provides a mock function for the type MockLabelWidget
6953func (_mock *MockLabelWidget) HasCssClass(cssClass string) bool {
6954	ret := _mock.Called(cssClass)
6955
6956	if len(ret) == 0 {
6957		panic("no return value specified for HasCssClass")
6958	}
6959
6960	var r0 bool
6961	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
6962		r0 = returnFunc(cssClass)
6963	} else {
6964		r0 = ret.Get(0).(bool)
6965	}
6966	return r0
6967}
6968
6969// MockLabelWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
6970type MockLabelWidget_HasCssClass_Call struct {
6971	*mock.Call
6972}
6973
6974// HasCssClass is a helper method to define mock.On call
6975//   - cssClass string
6976func (_e *MockLabelWidget_Expecter) HasCssClass(cssClass interface{}) *MockLabelWidget_HasCssClass_Call {
6977	return &MockLabelWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
6978}
6979
6980func (_c *MockLabelWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_HasCssClass_Call {
6981	_c.Call.Run(func(args mock.Arguments) {
6982		var arg0 string
6983		if args[0] != nil {
6984			arg0 = args[0].(string)
6985		}
6986		run(
6987			arg0,
6988		)
6989	})
6990	return _c
6991}
6992
6993func (_c *MockLabelWidget_HasCssClass_Call) Return(b bool) *MockLabelWidget_HasCssClass_Call {
6994	_c.Call.Return(b)
6995	return _c
6996}
6997
6998func (_c *MockLabelWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockLabelWidget_HasCssClass_Call {
6999	_c.Call.Return(run)
7000	return _c
7001}
7002
7003// HasFocus provides a mock function for the type MockLabelWidget
7004func (_mock *MockLabelWidget) HasFocus() bool {
7005	ret := _mock.Called()
7006
7007	if len(ret) == 0 {
7008		panic("no return value specified for HasFocus")
7009	}
7010
7011	var r0 bool
7012	if returnFunc, ok := ret.Get(0).(func() bool); ok {
7013		r0 = returnFunc()
7014	} else {
7015		r0 = ret.Get(0).(bool)
7016	}
7017	return r0
7018}
7019
7020// MockLabelWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
7021type MockLabelWidget_HasFocus_Call struct {
7022	*mock.Call
7023}
7024
7025// HasFocus is a helper method to define mock.On call
7026func (_e *MockLabelWidget_Expecter) HasFocus() *MockLabelWidget_HasFocus_Call {
7027	return &MockLabelWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
7028}
7029
7030func (_c *MockLabelWidget_HasFocus_Call) Run(run func()) *MockLabelWidget_HasFocus_Call {
7031	_c.Call.Run(func(args mock.Arguments) {
7032		run()
7033	})
7034	return _c
7035}
7036
7037func (_c *MockLabelWidget_HasFocus_Call) Return(b bool) *MockLabelWidget_HasFocus_Call {
7038	_c.Call.Return(b)
7039	return _c
7040}
7041
7042func (_c *MockLabelWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockLabelWidget_HasFocus_Call {
7043	_c.Call.Return(run)
7044	return _c
7045}
7046
7047// Hide provides a mock function for the type MockLabelWidget
7048func (_mock *MockLabelWidget) Hide() {
7049	_mock.Called()
7050	return
7051}
7052
7053// MockLabelWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
7054type MockLabelWidget_Hide_Call struct {
7055	*mock.Call
7056}
7057
7058// Hide is a helper method to define mock.On call
7059func (_e *MockLabelWidget_Expecter) Hide() *MockLabelWidget_Hide_Call {
7060	return &MockLabelWidget_Hide_Call{Call: _e.mock.On("Hide")}
7061}
7062
7063func (_c *MockLabelWidget_Hide_Call) Run(run func()) *MockLabelWidget_Hide_Call {
7064	_c.Call.Run(func(args mock.Arguments) {
7065		run()
7066	})
7067	return _c
7068}
7069
7070func (_c *MockLabelWidget_Hide_Call) Return() *MockLabelWidget_Hide_Call {
7071	_c.Call.Return()
7072	return _c
7073}
7074
7075func (_c *MockLabelWidget_Hide_Call) RunAndReturn(run func()) *MockLabelWidget_Hide_Call {
7076	_c.Run(run)
7077	return _c
7078}
7079
7080// IsVisible provides a mock function for the type MockLabelWidget
7081func (_mock *MockLabelWidget) IsVisible() bool {
7082	ret := _mock.Called()
7083
7084	if len(ret) == 0 {
7085		panic("no return value specified for IsVisible")
7086	}
7087
7088	var r0 bool
7089	if returnFunc, ok := ret.Get(0).(func() bool); ok {
7090		r0 = returnFunc()
7091	} else {
7092		r0 = ret.Get(0).(bool)
7093	}
7094	return r0
7095}
7096
7097// MockLabelWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
7098type MockLabelWidget_IsVisible_Call struct {
7099	*mock.Call
7100}
7101
7102// IsVisible is a helper method to define mock.On call
7103func (_e *MockLabelWidget_Expecter) IsVisible() *MockLabelWidget_IsVisible_Call {
7104	return &MockLabelWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
7105}
7106
7107func (_c *MockLabelWidget_IsVisible_Call) Run(run func()) *MockLabelWidget_IsVisible_Call {
7108	_c.Call.Run(func(args mock.Arguments) {
7109		run()
7110	})
7111	return _c
7112}
7113
7114func (_c *MockLabelWidget_IsVisible_Call) Return(b bool) *MockLabelWidget_IsVisible_Call {
7115	_c.Call.Return(b)
7116	return _c
7117}
7118
7119func (_c *MockLabelWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockLabelWidget_IsVisible_Call {
7120	_c.Call.Return(run)
7121	return _c
7122}
7123
7124// RemoveCssClass provides a mock function for the type MockLabelWidget
7125func (_mock *MockLabelWidget) RemoveCssClass(cssClass string) {
7126	_mock.Called(cssClass)
7127	return
7128}
7129
7130// MockLabelWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
7131type MockLabelWidget_RemoveCssClass_Call struct {
7132	*mock.Call
7133}
7134
7135// RemoveCssClass is a helper method to define mock.On call
7136//   - cssClass string
7137func (_e *MockLabelWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockLabelWidget_RemoveCssClass_Call {
7138	return &MockLabelWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
7139}
7140
7141func (_c *MockLabelWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_RemoveCssClass_Call {
7142	_c.Call.Run(func(args mock.Arguments) {
7143		var arg0 string
7144		if args[0] != nil {
7145			arg0 = args[0].(string)
7146		}
7147		run(
7148			arg0,
7149		)
7150	})
7151	return _c
7152}
7153
7154func (_c *MockLabelWidget_RemoveCssClass_Call) Return() *MockLabelWidget_RemoveCssClass_Call {
7155	_c.Call.Return()
7156	return _c
7157}
7158
7159func (_c *MockLabelWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockLabelWidget_RemoveCssClass_Call {
7160	_c.Run(run)
7161	return _c
7162}
7163
7164// SetCanFocus provides a mock function for the type MockLabelWidget
7165func (_mock *MockLabelWidget) SetCanFocus(canFocus bool) {
7166	_mock.Called(canFocus)
7167	return
7168}
7169
7170// MockLabelWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
7171type MockLabelWidget_SetCanFocus_Call struct {
7172	*mock.Call
7173}
7174
7175// SetCanFocus is a helper method to define mock.On call
7176//   - canFocus bool
7177func (_e *MockLabelWidget_Expecter) SetCanFocus(canFocus interface{}) *MockLabelWidget_SetCanFocus_Call {
7178	return &MockLabelWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
7179}
7180
7181func (_c *MockLabelWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockLabelWidget_SetCanFocus_Call {
7182	_c.Call.Run(func(args mock.Arguments) {
7183		var arg0 bool
7184		if args[0] != nil {
7185			arg0 = args[0].(bool)
7186		}
7187		run(
7188			arg0,
7189		)
7190	})
7191	return _c
7192}
7193
7194func (_c *MockLabelWidget_SetCanFocus_Call) Return() *MockLabelWidget_SetCanFocus_Call {
7195	_c.Call.Return()
7196	return _c
7197}
7198
7199func (_c *MockLabelWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockLabelWidget_SetCanFocus_Call {
7200	_c.Run(run)
7201	return _c
7202}
7203
7204// SetCanTarget provides a mock function for the type MockLabelWidget
7205func (_mock *MockLabelWidget) SetCanTarget(canTarget bool) {
7206	_mock.Called(canTarget)
7207	return
7208}
7209
7210// MockLabelWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
7211type MockLabelWidget_SetCanTarget_Call struct {
7212	*mock.Call
7213}
7214
7215// SetCanTarget is a helper method to define mock.On call
7216//   - canTarget bool
7217func (_e *MockLabelWidget_Expecter) SetCanTarget(canTarget interface{}) *MockLabelWidget_SetCanTarget_Call {
7218	return &MockLabelWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
7219}
7220
7221func (_c *MockLabelWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockLabelWidget_SetCanTarget_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_SetCanTarget_Call) Return() *MockLabelWidget_SetCanTarget_Call {
7235	_c.Call.Return()
7236	return _c
7237}
7238
7239func (_c *MockLabelWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockLabelWidget_SetCanTarget_Call {
7240	_c.Run(run)
7241	return _c
7242}
7243
7244// SetEllipsize provides a mock function for the type MockLabelWidget
7245func (_mock *MockLabelWidget) SetEllipsize(mode layout.EllipsizeMode) {
7246	_mock.Called(mode)
7247	return
7248}
7249
7250// MockLabelWidget_SetEllipsize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEllipsize'
7251type MockLabelWidget_SetEllipsize_Call struct {
7252	*mock.Call
7253}
7254
7255// SetEllipsize is a helper method to define mock.On call
7256//   - mode layout.EllipsizeMode
7257func (_e *MockLabelWidget_Expecter) SetEllipsize(mode interface{}) *MockLabelWidget_SetEllipsize_Call {
7258	return &MockLabelWidget_SetEllipsize_Call{Call: _e.mock.On("SetEllipsize", mode)}
7259}
7260
7261func (_c *MockLabelWidget_SetEllipsize_Call) Run(run func(mode layout.EllipsizeMode)) *MockLabelWidget_SetEllipsize_Call {
7262	_c.Call.Run(func(args mock.Arguments) {
7263		var arg0 layout.EllipsizeMode
7264		if args[0] != nil {
7265			arg0 = args[0].(layout.EllipsizeMode)
7266		}
7267		run(
7268			arg0,
7269		)
7270	})
7271	return _c
7272}
7273
7274func (_c *MockLabelWidget_SetEllipsize_Call) Return() *MockLabelWidget_SetEllipsize_Call {
7275	_c.Call.Return()
7276	return _c
7277}
7278
7279func (_c *MockLabelWidget_SetEllipsize_Call) RunAndReturn(run func(mode layout.EllipsizeMode)) *MockLabelWidget_SetEllipsize_Call {
7280	_c.Run(run)
7281	return _c
7282}
7283
7284// SetFocusOnClick provides a mock function for the type MockLabelWidget
7285func (_mock *MockLabelWidget) SetFocusOnClick(focusOnClick bool) {
7286	_mock.Called(focusOnClick)
7287	return
7288}
7289
7290// MockLabelWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
7291type MockLabelWidget_SetFocusOnClick_Call struct {
7292	*mock.Call
7293}
7294
7295// SetFocusOnClick is a helper method to define mock.On call
7296//   - focusOnClick bool
7297func (_e *MockLabelWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockLabelWidget_SetFocusOnClick_Call {
7298	return &MockLabelWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
7299}
7300
7301func (_c *MockLabelWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockLabelWidget_SetFocusOnClick_Call {
7302	_c.Call.Run(func(args mock.Arguments) {
7303		var arg0 bool
7304		if args[0] != nil {
7305			arg0 = args[0].(bool)
7306		}
7307		run(
7308			arg0,
7309		)
7310	})
7311	return _c
7312}
7313
7314func (_c *MockLabelWidget_SetFocusOnClick_Call) Return() *MockLabelWidget_SetFocusOnClick_Call {
7315	_c.Call.Return()
7316	return _c
7317}
7318
7319func (_c *MockLabelWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockLabelWidget_SetFocusOnClick_Call {
7320	_c.Run(run)
7321	return _c
7322}
7323
7324// SetFocusable provides a mock function for the type MockLabelWidget
7325func (_mock *MockLabelWidget) SetFocusable(focusable bool) {
7326	_mock.Called(focusable)
7327	return
7328}
7329
7330// MockLabelWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
7331type MockLabelWidget_SetFocusable_Call struct {
7332	*mock.Call
7333}
7334
7335// SetFocusable is a helper method to define mock.On call
7336//   - focusable bool
7337func (_e *MockLabelWidget_Expecter) SetFocusable(focusable interface{}) *MockLabelWidget_SetFocusable_Call {
7338	return &MockLabelWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
7339}
7340
7341func (_c *MockLabelWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockLabelWidget_SetFocusable_Call {
7342	_c.Call.Run(func(args mock.Arguments) {
7343		var arg0 bool
7344		if args[0] != nil {
7345			arg0 = args[0].(bool)
7346		}
7347		run(
7348			arg0,
7349		)
7350	})
7351	return _c
7352}
7353
7354func (_c *MockLabelWidget_SetFocusable_Call) Return() *MockLabelWidget_SetFocusable_Call {
7355	_c.Call.Return()
7356	return _c
7357}
7358
7359func (_c *MockLabelWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockLabelWidget_SetFocusable_Call {
7360	_c.Run(run)
7361	return _c
7362}
7363
7364// SetHalign provides a mock function for the type MockLabelWidget
7365func (_mock *MockLabelWidget) SetHalign(align gtk.Align) {
7366	_mock.Called(align)
7367	return
7368}
7369
7370// MockLabelWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
7371type MockLabelWidget_SetHalign_Call struct {
7372	*mock.Call
7373}
7374
7375// SetHalign is a helper method to define mock.On call
7376//   - align gtk.Align
7377func (_e *MockLabelWidget_Expecter) SetHalign(align interface{}) *MockLabelWidget_SetHalign_Call {
7378	return &MockLabelWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
7379}
7380
7381func (_c *MockLabelWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockLabelWidget_SetHalign_Call {
7382	_c.Call.Run(func(args mock.Arguments) {
7383		var arg0 gtk.Align
7384		if args[0] != nil {
7385			arg0 = args[0].(gtk.Align)
7386		}
7387		run(
7388			arg0,
7389		)
7390	})
7391	return _c
7392}
7393
7394func (_c *MockLabelWidget_SetHalign_Call) Return() *MockLabelWidget_SetHalign_Call {
7395	_c.Call.Return()
7396	return _c
7397}
7398
7399func (_c *MockLabelWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockLabelWidget_SetHalign_Call {
7400	_c.Run(run)
7401	return _c
7402}
7403
7404// SetHexpand provides a mock function for the type MockLabelWidget
7405func (_mock *MockLabelWidget) SetHexpand(expand bool) {
7406	_mock.Called(expand)
7407	return
7408}
7409
7410// MockLabelWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
7411type MockLabelWidget_SetHexpand_Call struct {
7412	*mock.Call
7413}
7414
7415// SetHexpand is a helper method to define mock.On call
7416//   - expand bool
7417func (_e *MockLabelWidget_Expecter) SetHexpand(expand interface{}) *MockLabelWidget_SetHexpand_Call {
7418	return &MockLabelWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
7419}
7420
7421func (_c *MockLabelWidget_SetHexpand_Call) Run(run func(expand bool)) *MockLabelWidget_SetHexpand_Call {
7422	_c.Call.Run(func(args mock.Arguments) {
7423		var arg0 bool
7424		if args[0] != nil {
7425			arg0 = args[0].(bool)
7426		}
7427		run(
7428			arg0,
7429		)
7430	})
7431	return _c
7432}
7433
7434func (_c *MockLabelWidget_SetHexpand_Call) Return() *MockLabelWidget_SetHexpand_Call {
7435	_c.Call.Return()
7436	return _c
7437}
7438
7439func (_c *MockLabelWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockLabelWidget_SetHexpand_Call {
7440	_c.Run(run)
7441	return _c
7442}
7443
7444// SetMarkup provides a mock function for the type MockLabelWidget
7445func (_mock *MockLabelWidget) SetMarkup(markup string) {
7446	_mock.Called(markup)
7447	return
7448}
7449
7450// MockLabelWidget_SetMarkup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMarkup'
7451type MockLabelWidget_SetMarkup_Call struct {
7452	*mock.Call
7453}
7454
7455// SetMarkup is a helper method to define mock.On call
7456//   - markup string
7457func (_e *MockLabelWidget_Expecter) SetMarkup(markup interface{}) *MockLabelWidget_SetMarkup_Call {
7458	return &MockLabelWidget_SetMarkup_Call{Call: _e.mock.On("SetMarkup", markup)}
7459}
7460
7461func (_c *MockLabelWidget_SetMarkup_Call) Run(run func(markup string)) *MockLabelWidget_SetMarkup_Call {
7462	_c.Call.Run(func(args mock.Arguments) {
7463		var arg0 string
7464		if args[0] != nil {
7465			arg0 = args[0].(string)
7466		}
7467		run(
7468			arg0,
7469		)
7470	})
7471	return _c
7472}
7473
7474func (_c *MockLabelWidget_SetMarkup_Call) Return() *MockLabelWidget_SetMarkup_Call {
7475	_c.Call.Return()
7476	return _c
7477}
7478
7479func (_c *MockLabelWidget_SetMarkup_Call) RunAndReturn(run func(markup string)) *MockLabelWidget_SetMarkup_Call {
7480	_c.Run(run)
7481	return _c
7482}
7483
7484// SetMaxWidthChars provides a mock function for the type MockLabelWidget
7485func (_mock *MockLabelWidget) SetMaxWidthChars(nChars int) {
7486	_mock.Called(nChars)
7487	return
7488}
7489
7490// MockLabelWidget_SetMaxWidthChars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMaxWidthChars'
7491type MockLabelWidget_SetMaxWidthChars_Call struct {
7492	*mock.Call
7493}
7494
7495// SetMaxWidthChars is a helper method to define mock.On call
7496//   - nChars int
7497func (_e *MockLabelWidget_Expecter) SetMaxWidthChars(nChars interface{}) *MockLabelWidget_SetMaxWidthChars_Call {
7498	return &MockLabelWidget_SetMaxWidthChars_Call{Call: _e.mock.On("SetMaxWidthChars", nChars)}
7499}
7500
7501func (_c *MockLabelWidget_SetMaxWidthChars_Call) Run(run func(nChars int)) *MockLabelWidget_SetMaxWidthChars_Call {
7502	_c.Call.Run(func(args mock.Arguments) {
7503		var arg0 int
7504		if args[0] != nil {
7505			arg0 = args[0].(int)
7506		}
7507		run(
7508			arg0,
7509		)
7510	})
7511	return _c
7512}
7513
7514func (_c *MockLabelWidget_SetMaxWidthChars_Call) Return() *MockLabelWidget_SetMaxWidthChars_Call {
7515	_c.Call.Return()
7516	return _c
7517}
7518
7519func (_c *MockLabelWidget_SetMaxWidthChars_Call) RunAndReturn(run func(nChars int)) *MockLabelWidget_SetMaxWidthChars_Call {
7520	_c.Run(run)
7521	return _c
7522}
7523
7524// SetSizeRequest provides a mock function for the type MockLabelWidget
7525func (_mock *MockLabelWidget) SetSizeRequest(width int, height int) {
7526	_mock.Called(width, height)
7527	return
7528}
7529
7530// MockLabelWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
7531type MockLabelWidget_SetSizeRequest_Call struct {
7532	*mock.Call
7533}
7534
7535// SetSizeRequest is a helper method to define mock.On call
7536//   - width int
7537//   - height int
7538func (_e *MockLabelWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockLabelWidget_SetSizeRequest_Call {
7539	return &MockLabelWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
7540}
7541
7542func (_c *MockLabelWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockLabelWidget_SetSizeRequest_Call {
7543	_c.Call.Run(func(args mock.Arguments) {
7544		var arg0 int
7545		if args[0] != nil {
7546			arg0 = args[0].(int)
7547		}
7548		var arg1 int
7549		if args[1] != nil {
7550			arg1 = args[1].(int)
7551		}
7552		run(
7553			arg0,
7554			arg1,
7555		)
7556	})
7557	return _c
7558}
7559
7560func (_c *MockLabelWidget_SetSizeRequest_Call) Return() *MockLabelWidget_SetSizeRequest_Call {
7561	_c.Call.Return()
7562	return _c
7563}
7564
7565func (_c *MockLabelWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockLabelWidget_SetSizeRequest_Call {
7566	_c.Run(run)
7567	return _c
7568}
7569
7570// SetText provides a mock function for the type MockLabelWidget
7571func (_mock *MockLabelWidget) SetText(text string) {
7572	_mock.Called(text)
7573	return
7574}
7575
7576// MockLabelWidget_SetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetText'
7577type MockLabelWidget_SetText_Call struct {
7578	*mock.Call
7579}
7580
7581// SetText is a helper method to define mock.On call
7582//   - text string
7583func (_e *MockLabelWidget_Expecter) SetText(text interface{}) *MockLabelWidget_SetText_Call {
7584	return &MockLabelWidget_SetText_Call{Call: _e.mock.On("SetText", text)}
7585}
7586
7587func (_c *MockLabelWidget_SetText_Call) Run(run func(text string)) *MockLabelWidget_SetText_Call {
7588	_c.Call.Run(func(args mock.Arguments) {
7589		var arg0 string
7590		if args[0] != nil {
7591			arg0 = args[0].(string)
7592		}
7593		run(
7594			arg0,
7595		)
7596	})
7597	return _c
7598}
7599
7600func (_c *MockLabelWidget_SetText_Call) Return() *MockLabelWidget_SetText_Call {
7601	_c.Call.Return()
7602	return _c
7603}
7604
7605func (_c *MockLabelWidget_SetText_Call) RunAndReturn(run func(text string)) *MockLabelWidget_SetText_Call {
7606	_c.Run(run)
7607	return _c
7608}
7609
7610// SetValign provides a mock function for the type MockLabelWidget
7611func (_mock *MockLabelWidget) SetValign(align gtk.Align) {
7612	_mock.Called(align)
7613	return
7614}
7615
7616// MockLabelWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
7617type MockLabelWidget_SetValign_Call struct {
7618	*mock.Call
7619}
7620
7621// SetValign is a helper method to define mock.On call
7622//   - align gtk.Align
7623func (_e *MockLabelWidget_Expecter) SetValign(align interface{}) *MockLabelWidget_SetValign_Call {
7624	return &MockLabelWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
7625}
7626
7627func (_c *MockLabelWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockLabelWidget_SetValign_Call {
7628	_c.Call.Run(func(args mock.Arguments) {
7629		var arg0 gtk.Align
7630		if args[0] != nil {
7631			arg0 = args[0].(gtk.Align)
7632		}
7633		run(
7634			arg0,
7635		)
7636	})
7637	return _c
7638}
7639
7640func (_c *MockLabelWidget_SetValign_Call) Return() *MockLabelWidget_SetValign_Call {
7641	_c.Call.Return()
7642	return _c
7643}
7644
7645func (_c *MockLabelWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockLabelWidget_SetValign_Call {
7646	_c.Run(run)
7647	return _c
7648}
7649
7650// SetVexpand provides a mock function for the type MockLabelWidget
7651func (_mock *MockLabelWidget) SetVexpand(expand bool) {
7652	_mock.Called(expand)
7653	return
7654}
7655
7656// MockLabelWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
7657type MockLabelWidget_SetVexpand_Call struct {
7658	*mock.Call
7659}
7660
7661// SetVexpand is a helper method to define mock.On call
7662//   - expand bool
7663func (_e *MockLabelWidget_Expecter) SetVexpand(expand interface{}) *MockLabelWidget_SetVexpand_Call {
7664	return &MockLabelWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
7665}
7666
7667func (_c *MockLabelWidget_SetVexpand_Call) Run(run func(expand bool)) *MockLabelWidget_SetVexpand_Call {
7668	_c.Call.Run(func(args mock.Arguments) {
7669		var arg0 bool
7670		if args[0] != nil {
7671			arg0 = args[0].(bool)
7672		}
7673		run(
7674			arg0,
7675		)
7676	})
7677	return _c
7678}
7679
7680func (_c *MockLabelWidget_SetVexpand_Call) Return() *MockLabelWidget_SetVexpand_Call {
7681	_c.Call.Return()
7682	return _c
7683}
7684
7685func (_c *MockLabelWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockLabelWidget_SetVexpand_Call {
7686	_c.Run(run)
7687	return _c
7688}
7689
7690// SetVisible provides a mock function for the type MockLabelWidget
7691func (_mock *MockLabelWidget) SetVisible(visible bool) {
7692	_mock.Called(visible)
7693	return
7694}
7695
7696// MockLabelWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
7697type MockLabelWidget_SetVisible_Call struct {
7698	*mock.Call
7699}
7700
7701// SetVisible is a helper method to define mock.On call
7702//   - visible bool
7703func (_e *MockLabelWidget_Expecter) SetVisible(visible interface{}) *MockLabelWidget_SetVisible_Call {
7704	return &MockLabelWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
7705}
7706
7707func (_c *MockLabelWidget_SetVisible_Call) Run(run func(visible bool)) *MockLabelWidget_SetVisible_Call {
7708	_c.Call.Run(func(args mock.Arguments) {
7709		var arg0 bool
7710		if args[0] != nil {
7711			arg0 = args[0].(bool)
7712		}
7713		run(
7714			arg0,
7715		)
7716	})
7717	return _c
7718}
7719
7720func (_c *MockLabelWidget_SetVisible_Call) Return() *MockLabelWidget_SetVisible_Call {
7721	_c.Call.Return()
7722	return _c
7723}
7724
7725func (_c *MockLabelWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockLabelWidget_SetVisible_Call {
7726	_c.Run(run)
7727	return _c
7728}
7729
7730// SetXalign provides a mock function for the type MockLabelWidget
7731func (_mock *MockLabelWidget) SetXalign(xalign float32) {
7732	_mock.Called(xalign)
7733	return
7734}
7735
7736// MockLabelWidget_SetXalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXalign'
7737type MockLabelWidget_SetXalign_Call struct {
7738	*mock.Call
7739}
7740
7741// SetXalign is a helper method to define mock.On call
7742//   - xalign float32
7743func (_e *MockLabelWidget_Expecter) SetXalign(xalign interface{}) *MockLabelWidget_SetXalign_Call {
7744	return &MockLabelWidget_SetXalign_Call{Call: _e.mock.On("SetXalign", xalign)}
7745}
7746
7747func (_c *MockLabelWidget_SetXalign_Call) Run(run func(xalign float32)) *MockLabelWidget_SetXalign_Call {
7748	_c.Call.Run(func(args mock.Arguments) {
7749		var arg0 float32
7750		if args[0] != nil {
7751			arg0 = args[0].(float32)
7752		}
7753		run(
7754			arg0,
7755		)
7756	})
7757	return _c
7758}
7759
7760func (_c *MockLabelWidget_SetXalign_Call) Return() *MockLabelWidget_SetXalign_Call {
7761	_c.Call.Return()
7762	return _c
7763}
7764
7765func (_c *MockLabelWidget_SetXalign_Call) RunAndReturn(run func(xalign float32)) *MockLabelWidget_SetXalign_Call {
7766	_c.Run(run)
7767	return _c
7768}
7769
7770// Show provides a mock function for the type MockLabelWidget
7771func (_mock *MockLabelWidget) Show() {
7772	_mock.Called()
7773	return
7774}
7775
7776// MockLabelWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
7777type MockLabelWidget_Show_Call struct {
7778	*mock.Call
7779}
7780
7781// Show is a helper method to define mock.On call
7782func (_e *MockLabelWidget_Expecter) Show() *MockLabelWidget_Show_Call {
7783	return &MockLabelWidget_Show_Call{Call: _e.mock.On("Show")}
7784}
7785
7786func (_c *MockLabelWidget_Show_Call) Run(run func()) *MockLabelWidget_Show_Call {
7787	_c.Call.Run(func(args mock.Arguments) {
7788		run()
7789	})
7790	return _c
7791}
7792
7793func (_c *MockLabelWidget_Show_Call) Return() *MockLabelWidget_Show_Call {
7794	_c.Call.Return()
7795	return _c
7796}
7797
7798func (_c *MockLabelWidget_Show_Call) RunAndReturn(run func()) *MockLabelWidget_Show_Call {
7799	_c.Run(run)
7800	return _c
7801}
7802
7803// Unparent provides a mock function for the type MockLabelWidget
7804func (_mock *MockLabelWidget) Unparent() {
7805	_mock.Called()
7806	return
7807}
7808
7809// MockLabelWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
7810type MockLabelWidget_Unparent_Call struct {
7811	*mock.Call
7812}
7813
7814// Unparent is a helper method to define mock.On call
7815func (_e *MockLabelWidget_Expecter) Unparent() *MockLabelWidget_Unparent_Call {
7816	return &MockLabelWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
7817}
7818
7819func (_c *MockLabelWidget_Unparent_Call) Run(run func()) *MockLabelWidget_Unparent_Call {
7820	_c.Call.Run(func(args mock.Arguments) {
7821		run()
7822	})
7823	return _c
7824}
7825
7826func (_c *MockLabelWidget_Unparent_Call) Return() *MockLabelWidget_Unparent_Call {
7827	_c.Call.Return()
7828	return _c
7829}
7830
7831func (_c *MockLabelWidget_Unparent_Call) RunAndReturn(run func()) *MockLabelWidget_Unparent_Call {
7832	_c.Run(run)
7833	return _c
7834}
7835
7836// 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.
7837// The first argument is typically a *testing.T value.
7838func NewMockButtonWidget(t interface {
7839	mock.TestingT
7840	Cleanup(func())
7841}) *MockButtonWidget {
7842	mock := &MockButtonWidget{}
7843	mock.Mock.Test(t)
7844
7845	t.Cleanup(func() { mock.AssertExpectations(t) })
7846
7847	return mock
7848}
7849
7850// MockButtonWidget is an autogenerated mock type for the ButtonWidget type
7851type MockButtonWidget struct {
7852	mock.Mock
7853}
7854
7855type MockButtonWidget_Expecter struct {
7856	mock *mock.Mock
7857}
7858
7859func (_m *MockButtonWidget) EXPECT() *MockButtonWidget_Expecter {
7860	return &MockButtonWidget_Expecter{mock: &_m.Mock}
7861}
7862
7863// AddController provides a mock function for the type MockButtonWidget
7864func (_mock *MockButtonWidget) AddController(controller *gtk.EventController) {
7865	_mock.Called(controller)
7866	return
7867}
7868
7869// MockButtonWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
7870type MockButtonWidget_AddController_Call struct {
7871	*mock.Call
7872}
7873
7874// AddController is a helper method to define mock.On call
7875//   - controller *gtk.EventController
7876func (_e *MockButtonWidget_Expecter) AddController(controller interface{}) *MockButtonWidget_AddController_Call {
7877	return &MockButtonWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
7878}
7879
7880func (_c *MockButtonWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockButtonWidget_AddController_Call {
7881	_c.Call.Run(func(args mock.Arguments) {
7882		var arg0 *gtk.EventController
7883		if args[0] != nil {
7884			arg0 = args[0].(*gtk.EventController)
7885		}
7886		run(
7887			arg0,
7888		)
7889	})
7890	return _c
7891}
7892
7893func (_c *MockButtonWidget_AddController_Call) Return() *MockButtonWidget_AddController_Call {
7894	_c.Call.Return()
7895	return _c
7896}
7897
7898func (_c *MockButtonWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockButtonWidget_AddController_Call {
7899	_c.Run(run)
7900	return _c
7901}
7902
7903// AddCssClass provides a mock function for the type MockButtonWidget
7904func (_mock *MockButtonWidget) AddCssClass(cssClass string) {
7905	_mock.Called(cssClass)
7906	return
7907}
7908
7909// MockButtonWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
7910type MockButtonWidget_AddCssClass_Call struct {
7911	*mock.Call
7912}
7913
7914// AddCssClass is a helper method to define mock.On call
7915//   - cssClass string
7916func (_e *MockButtonWidget_Expecter) AddCssClass(cssClass interface{}) *MockButtonWidget_AddCssClass_Call {
7917	return &MockButtonWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
7918}
7919
7920func (_c *MockButtonWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_AddCssClass_Call {
7921	_c.Call.Run(func(args mock.Arguments) {
7922		var arg0 string
7923		if args[0] != nil {
7924			arg0 = args[0].(string)
7925		}
7926		run(
7927			arg0,
7928		)
7929	})
7930	return _c
7931}
7932
7933func (_c *MockButtonWidget_AddCssClass_Call) Return() *MockButtonWidget_AddCssClass_Call {
7934	_c.Call.Return()
7935	return _c
7936}
7937
7938func (_c *MockButtonWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockButtonWidget_AddCssClass_Call {
7939	_c.Run(run)
7940	return _c
7941}
7942
7943// ComputePoint provides a mock function for the type MockButtonWidget
7944func (_mock *MockButtonWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
7945	ret := _mock.Called(target)
7946
7947	if len(ret) == 0 {
7948		panic("no return value specified for ComputePoint")
7949	}
7950
7951	var r0 float64
7952	var r1 float64
7953	var r2 bool
7954	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
7955		return returnFunc(target)
7956	}
7957	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
7958		r0 = returnFunc(target)
7959	} else {
7960		r0 = ret.Get(0).(float64)
7961	}
7962	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
7963		r1 = returnFunc(target)
7964	} else {
7965		r1 = ret.Get(1).(float64)
7966	}
7967	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
7968		r2 = returnFunc(target)
7969	} else {
7970		r2 = ret.Get(2).(bool)
7971	}
7972	return r0, r1, r2
7973}
7974
7975// MockButtonWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
7976type MockButtonWidget_ComputePoint_Call struct {
7977	*mock.Call
7978}
7979
7980// ComputePoint is a helper method to define mock.On call
7981//   - target layout.Widget
7982func (_e *MockButtonWidget_Expecter) ComputePoint(target interface{}) *MockButtonWidget_ComputePoint_Call {
7983	return &MockButtonWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
7984}
7985
7986func (_c *MockButtonWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockButtonWidget_ComputePoint_Call {
7987	_c.Call.Run(func(args mock.Arguments) {
7988		var arg0 layout.Widget
7989		if args[0] != nil {
7990			arg0 = args[0].(layout.Widget)
7991		}
7992		run(
7993			arg0,
7994		)
7995	})
7996	return _c
7997}
7998
7999func (_c *MockButtonWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockButtonWidget_ComputePoint_Call {
8000	_c.Call.Return(x, y, ok)
8001	return _c
8002}
8003
8004func (_c *MockButtonWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockButtonWidget_ComputePoint_Call {
8005	_c.Call.Return(run)
8006	return _c
8007}
8008
8009// ConnectClicked provides a mock function for the type MockButtonWidget
8010func (_mock *MockButtonWidget) ConnectClicked(callback func()) uint32 {
8011	ret := _mock.Called(callback)
8012
8013	if len(ret) == 0 {
8014		panic("no return value specified for ConnectClicked")
8015	}
8016
8017	var r0 uint32
8018	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
8019		r0 = returnFunc(callback)
8020	} else {
8021		r0 = ret.Get(0).(uint32)
8022	}
8023	return r0
8024}
8025
8026// MockButtonWidget_ConnectClicked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectClicked'
8027type MockButtonWidget_ConnectClicked_Call struct {
8028	*mock.Call
8029}
8030
8031// ConnectClicked is a helper method to define mock.On call
8032//   - callback func()
8033func (_e *MockButtonWidget_Expecter) ConnectClicked(callback interface{}) *MockButtonWidget_ConnectClicked_Call {
8034	return &MockButtonWidget_ConnectClicked_Call{Call: _e.mock.On("ConnectClicked", callback)}
8035}
8036
8037func (_c *MockButtonWidget_ConnectClicked_Call) Run(run func(callback func())) *MockButtonWidget_ConnectClicked_Call {
8038	_c.Call.Run(func(args mock.Arguments) {
8039		var arg0 func()
8040		if args[0] != nil {
8041			arg0 = args[0].(func())
8042		}
8043		run(
8044			arg0,
8045		)
8046	})
8047	return _c
8048}
8049
8050func (_c *MockButtonWidget_ConnectClicked_Call) Return(v uint32) *MockButtonWidget_ConnectClicked_Call {
8051	_c.Call.Return(v)
8052	return _c
8053}
8054
8055func (_c *MockButtonWidget_ConnectClicked_Call) RunAndReturn(run func(callback func()) uint32) *MockButtonWidget_ConnectClicked_Call {
8056	_c.Call.Return(run)
8057	return _c
8058}
8059
8060// GetAllocatedHeight provides a mock function for the type MockButtonWidget
8061func (_mock *MockButtonWidget) GetAllocatedHeight() int {
8062	ret := _mock.Called()
8063
8064	if len(ret) == 0 {
8065		panic("no return value specified for GetAllocatedHeight")
8066	}
8067
8068	var r0 int
8069	if returnFunc, ok := ret.Get(0).(func() int); ok {
8070		r0 = returnFunc()
8071	} else {
8072		r0 = ret.Get(0).(int)
8073	}
8074	return r0
8075}
8076
8077// MockButtonWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
8078type MockButtonWidget_GetAllocatedHeight_Call struct {
8079	*mock.Call
8080}
8081
8082// GetAllocatedHeight is a helper method to define mock.On call
8083func (_e *MockButtonWidget_Expecter) GetAllocatedHeight() *MockButtonWidget_GetAllocatedHeight_Call {
8084	return &MockButtonWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
8085}
8086
8087func (_c *MockButtonWidget_GetAllocatedHeight_Call) Run(run func()) *MockButtonWidget_GetAllocatedHeight_Call {
8088	_c.Call.Run(func(args mock.Arguments) {
8089		run()
8090	})
8091	return _c
8092}
8093
8094func (_c *MockButtonWidget_GetAllocatedHeight_Call) Return(n int) *MockButtonWidget_GetAllocatedHeight_Call {
8095	_c.Call.Return(n)
8096	return _c
8097}
8098
8099func (_c *MockButtonWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockButtonWidget_GetAllocatedHeight_Call {
8100	_c.Call.Return(run)
8101	return _c
8102}
8103
8104// GetAllocatedWidth provides a mock function for the type MockButtonWidget
8105func (_mock *MockButtonWidget) GetAllocatedWidth() int {
8106	ret := _mock.Called()
8107
8108	if len(ret) == 0 {
8109		panic("no return value specified for GetAllocatedWidth")
8110	}
8111
8112	var r0 int
8113	if returnFunc, ok := ret.Get(0).(func() int); ok {
8114		r0 = returnFunc()
8115	} else {
8116		r0 = ret.Get(0).(int)
8117	}
8118	return r0
8119}
8120
8121// MockButtonWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
8122type MockButtonWidget_GetAllocatedWidth_Call struct {
8123	*mock.Call
8124}
8125
8126// GetAllocatedWidth is a helper method to define mock.On call
8127func (_e *MockButtonWidget_Expecter) GetAllocatedWidth() *MockButtonWidget_GetAllocatedWidth_Call {
8128	return &MockButtonWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
8129}
8130
8131func (_c *MockButtonWidget_GetAllocatedWidth_Call) Run(run func()) *MockButtonWidget_GetAllocatedWidth_Call {
8132	_c.Call.Run(func(args mock.Arguments) {
8133		run()
8134	})
8135	return _c
8136}
8137
8138func (_c *MockButtonWidget_GetAllocatedWidth_Call) Return(n int) *MockButtonWidget_GetAllocatedWidth_Call {
8139	_c.Call.Return(n)
8140	return _c
8141}
8142
8143func (_c *MockButtonWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockButtonWidget_GetAllocatedWidth_Call {
8144	_c.Call.Return(run)
8145	return _c
8146}
8147
8148// GetChild provides a mock function for the type MockButtonWidget
8149func (_mock *MockButtonWidget) GetChild() layout.Widget {
8150	ret := _mock.Called()
8151
8152	if len(ret) == 0 {
8153		panic("no return value specified for GetChild")
8154	}
8155
8156	var r0 layout.Widget
8157	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
8158		r0 = returnFunc()
8159	} else {
8160		if ret.Get(0) != nil {
8161			r0 = ret.Get(0).(layout.Widget)
8162		}
8163	}
8164	return r0
8165}
8166
8167// MockButtonWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
8168type MockButtonWidget_GetChild_Call struct {
8169	*mock.Call
8170}
8171
8172// GetChild is a helper method to define mock.On call
8173func (_e *MockButtonWidget_Expecter) GetChild() *MockButtonWidget_GetChild_Call {
8174	return &MockButtonWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
8175}
8176
8177func (_c *MockButtonWidget_GetChild_Call) Run(run func()) *MockButtonWidget_GetChild_Call {
8178	_c.Call.Run(func(args mock.Arguments) {
8179		run()
8180	})
8181	return _c
8182}
8183
8184func (_c *MockButtonWidget_GetChild_Call) Return(widget layout.Widget) *MockButtonWidget_GetChild_Call {
8185	_c.Call.Return(widget)
8186	return _c
8187}
8188
8189func (_c *MockButtonWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) *MockButtonWidget_GetChild_Call {
8190	_c.Call.Return(run)
8191	return _c
8192}
8193
8194// GetHexpand provides a mock function for the type MockButtonWidget
8195func (_mock *MockButtonWidget) GetHexpand() bool {
8196	ret := _mock.Called()
8197
8198	if len(ret) == 0 {
8199		panic("no return value specified for GetHexpand")
8200	}
8201
8202	var r0 bool
8203	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8204		r0 = returnFunc()
8205	} else {
8206		r0 = ret.Get(0).(bool)
8207	}
8208	return r0
8209}
8210
8211// MockButtonWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
8212type MockButtonWidget_GetHexpand_Call struct {
8213	*mock.Call
8214}
8215
8216// GetHexpand is a helper method to define mock.On call
8217func (_e *MockButtonWidget_Expecter) GetHexpand() *MockButtonWidget_GetHexpand_Call {
8218	return &MockButtonWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
8219}
8220
8221func (_c *MockButtonWidget_GetHexpand_Call) Run(run func()) *MockButtonWidget_GetHexpand_Call {
8222	_c.Call.Run(func(args mock.Arguments) {
8223		run()
8224	})
8225	return _c
8226}
8227
8228func (_c *MockButtonWidget_GetHexpand_Call) Return(b bool) *MockButtonWidget_GetHexpand_Call {
8229	_c.Call.Return(b)
8230	return _c
8231}
8232
8233func (_c *MockButtonWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockButtonWidget_GetHexpand_Call {
8234	_c.Call.Return(run)
8235	return _c
8236}
8237
8238// GetLabel provides a mock function for the type MockButtonWidget
8239func (_mock *MockButtonWidget) GetLabel() string {
8240	ret := _mock.Called()
8241
8242	if len(ret) == 0 {
8243		panic("no return value specified for GetLabel")
8244	}
8245
8246	var r0 string
8247	if returnFunc, ok := ret.Get(0).(func() string); ok {
8248		r0 = returnFunc()
8249	} else {
8250		r0 = ret.Get(0).(string)
8251	}
8252	return r0
8253}
8254
8255// MockButtonWidget_GetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabel'
8256type MockButtonWidget_GetLabel_Call struct {
8257	*mock.Call
8258}
8259
8260// GetLabel is a helper method to define mock.On call
8261func (_e *MockButtonWidget_Expecter) GetLabel() *MockButtonWidget_GetLabel_Call {
8262	return &MockButtonWidget_GetLabel_Call{Call: _e.mock.On("GetLabel")}
8263}
8264
8265func (_c *MockButtonWidget_GetLabel_Call) Run(run func()) *MockButtonWidget_GetLabel_Call {
8266	_c.Call.Run(func(args mock.Arguments) {
8267		run()
8268	})
8269	return _c
8270}
8271
8272func (_c *MockButtonWidget_GetLabel_Call) Return(s string) *MockButtonWidget_GetLabel_Call {
8273	_c.Call.Return(s)
8274	return _c
8275}
8276
8277func (_c *MockButtonWidget_GetLabel_Call) RunAndReturn(run func() string) *MockButtonWidget_GetLabel_Call {
8278	_c.Call.Return(run)
8279	return _c
8280}
8281
8282// GetParent provides a mock function for the type MockButtonWidget
8283func (_mock *MockButtonWidget) GetParent() layout.Widget {
8284	ret := _mock.Called()
8285
8286	if len(ret) == 0 {
8287		panic("no return value specified for GetParent")
8288	}
8289
8290	var r0 layout.Widget
8291	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
8292		r0 = returnFunc()
8293	} else {
8294		if ret.Get(0) != nil {
8295			r0 = ret.Get(0).(layout.Widget)
8296		}
8297	}
8298	return r0
8299}
8300
8301// MockButtonWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
8302type MockButtonWidget_GetParent_Call struct {
8303	*mock.Call
8304}
8305
8306// GetParent is a helper method to define mock.On call
8307func (_e *MockButtonWidget_Expecter) GetParent() *MockButtonWidget_GetParent_Call {
8308	return &MockButtonWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
8309}
8310
8311func (_c *MockButtonWidget_GetParent_Call) Run(run func()) *MockButtonWidget_GetParent_Call {
8312	_c.Call.Run(func(args mock.Arguments) {
8313		run()
8314	})
8315	return _c
8316}
8317
8318func (_c *MockButtonWidget_GetParent_Call) Return(widget layout.Widget) *MockButtonWidget_GetParent_Call {
8319	_c.Call.Return(widget)
8320	return _c
8321}
8322
8323func (_c *MockButtonWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockButtonWidget_GetParent_Call {
8324	_c.Call.Return(run)
8325	return _c
8326}
8327
8328// GetVexpand provides a mock function for the type MockButtonWidget
8329func (_mock *MockButtonWidget) GetVexpand() bool {
8330	ret := _mock.Called()
8331
8332	if len(ret) == 0 {
8333		panic("no return value specified for GetVexpand")
8334	}
8335
8336	var r0 bool
8337	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8338		r0 = returnFunc()
8339	} else {
8340		r0 = ret.Get(0).(bool)
8341	}
8342	return r0
8343}
8344
8345// MockButtonWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
8346type MockButtonWidget_GetVexpand_Call struct {
8347	*mock.Call
8348}
8349
8350// GetVexpand is a helper method to define mock.On call
8351func (_e *MockButtonWidget_Expecter) GetVexpand() *MockButtonWidget_GetVexpand_Call {
8352	return &MockButtonWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
8353}
8354
8355func (_c *MockButtonWidget_GetVexpand_Call) Run(run func()) *MockButtonWidget_GetVexpand_Call {
8356	_c.Call.Run(func(args mock.Arguments) {
8357		run()
8358	})
8359	return _c
8360}
8361
8362func (_c *MockButtonWidget_GetVexpand_Call) Return(b bool) *MockButtonWidget_GetVexpand_Call {
8363	_c.Call.Return(b)
8364	return _c
8365}
8366
8367func (_c *MockButtonWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockButtonWidget_GetVexpand_Call {
8368	_c.Call.Return(run)
8369	return _c
8370}
8371
8372// GrabFocus provides a mock function for the type MockButtonWidget
8373func (_mock *MockButtonWidget) GrabFocus() bool {
8374	ret := _mock.Called()
8375
8376	if len(ret) == 0 {
8377		panic("no return value specified for GrabFocus")
8378	}
8379
8380	var r0 bool
8381	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8382		r0 = returnFunc()
8383	} else {
8384		r0 = ret.Get(0).(bool)
8385	}
8386	return r0
8387}
8388
8389// MockButtonWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
8390type MockButtonWidget_GrabFocus_Call struct {
8391	*mock.Call
8392}
8393
8394// GrabFocus is a helper method to define mock.On call
8395func (_e *MockButtonWidget_Expecter) GrabFocus() *MockButtonWidget_GrabFocus_Call {
8396	return &MockButtonWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
8397}
8398
8399func (_c *MockButtonWidget_GrabFocus_Call) Run(run func()) *MockButtonWidget_GrabFocus_Call {
8400	_c.Call.Run(func(args mock.Arguments) {
8401		run()
8402	})
8403	return _c
8404}
8405
8406func (_c *MockButtonWidget_GrabFocus_Call) Return(b bool) *MockButtonWidget_GrabFocus_Call {
8407	_c.Call.Return(b)
8408	return _c
8409}
8410
8411func (_c *MockButtonWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockButtonWidget_GrabFocus_Call {
8412	_c.Call.Return(run)
8413	return _c
8414}
8415
8416// GtkWidget provides a mock function for the type MockButtonWidget
8417func (_mock *MockButtonWidget) GtkWidget() *gtk.Widget {
8418	ret := _mock.Called()
8419
8420	if len(ret) == 0 {
8421		panic("no return value specified for GtkWidget")
8422	}
8423
8424	var r0 *gtk.Widget
8425	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
8426		r0 = returnFunc()
8427	} else {
8428		if ret.Get(0) != nil {
8429			r0 = ret.Get(0).(*gtk.Widget)
8430		}
8431	}
8432	return r0
8433}
8434
8435// MockButtonWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
8436type MockButtonWidget_GtkWidget_Call struct {
8437	*mock.Call
8438}
8439
8440// GtkWidget is a helper method to define mock.On call
8441func (_e *MockButtonWidget_Expecter) GtkWidget() *MockButtonWidget_GtkWidget_Call {
8442	return &MockButtonWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
8443}
8444
8445func (_c *MockButtonWidget_GtkWidget_Call) Run(run func()) *MockButtonWidget_GtkWidget_Call {
8446	_c.Call.Run(func(args mock.Arguments) {
8447		run()
8448	})
8449	return _c
8450}
8451
8452func (_c *MockButtonWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockButtonWidget_GtkWidget_Call {
8453	_c.Call.Return(widget)
8454	return _c
8455}
8456
8457func (_c *MockButtonWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockButtonWidget_GtkWidget_Call {
8458	_c.Call.Return(run)
8459	return _c
8460}
8461
8462// HasCssClass provides a mock function for the type MockButtonWidget
8463func (_mock *MockButtonWidget) HasCssClass(cssClass string) bool {
8464	ret := _mock.Called(cssClass)
8465
8466	if len(ret) == 0 {
8467		panic("no return value specified for HasCssClass")
8468	}
8469
8470	var r0 bool
8471	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
8472		r0 = returnFunc(cssClass)
8473	} else {
8474		r0 = ret.Get(0).(bool)
8475	}
8476	return r0
8477}
8478
8479// MockButtonWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
8480type MockButtonWidget_HasCssClass_Call struct {
8481	*mock.Call
8482}
8483
8484// HasCssClass is a helper method to define mock.On call
8485//   - cssClass string
8486func (_e *MockButtonWidget_Expecter) HasCssClass(cssClass interface{}) *MockButtonWidget_HasCssClass_Call {
8487	return &MockButtonWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
8488}
8489
8490func (_c *MockButtonWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_HasCssClass_Call {
8491	_c.Call.Run(func(args mock.Arguments) {
8492		var arg0 string
8493		if args[0] != nil {
8494			arg0 = args[0].(string)
8495		}
8496		run(
8497			arg0,
8498		)
8499	})
8500	return _c
8501}
8502
8503func (_c *MockButtonWidget_HasCssClass_Call) Return(b bool) *MockButtonWidget_HasCssClass_Call {
8504	_c.Call.Return(b)
8505	return _c
8506}
8507
8508func (_c *MockButtonWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockButtonWidget_HasCssClass_Call {
8509	_c.Call.Return(run)
8510	return _c
8511}
8512
8513// HasFocus provides a mock function for the type MockButtonWidget
8514func (_mock *MockButtonWidget) HasFocus() bool {
8515	ret := _mock.Called()
8516
8517	if len(ret) == 0 {
8518		panic("no return value specified for HasFocus")
8519	}
8520
8521	var r0 bool
8522	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8523		r0 = returnFunc()
8524	} else {
8525		r0 = ret.Get(0).(bool)
8526	}
8527	return r0
8528}
8529
8530// MockButtonWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
8531type MockButtonWidget_HasFocus_Call struct {
8532	*mock.Call
8533}
8534
8535// HasFocus is a helper method to define mock.On call
8536func (_e *MockButtonWidget_Expecter) HasFocus() *MockButtonWidget_HasFocus_Call {
8537	return &MockButtonWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
8538}
8539
8540func (_c *MockButtonWidget_HasFocus_Call) Run(run func()) *MockButtonWidget_HasFocus_Call {
8541	_c.Call.Run(func(args mock.Arguments) {
8542		run()
8543	})
8544	return _c
8545}
8546
8547func (_c *MockButtonWidget_HasFocus_Call) Return(b bool) *MockButtonWidget_HasFocus_Call {
8548	_c.Call.Return(b)
8549	return _c
8550}
8551
8552func (_c *MockButtonWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockButtonWidget_HasFocus_Call {
8553	_c.Call.Return(run)
8554	return _c
8555}
8556
8557// Hide provides a mock function for the type MockButtonWidget
8558func (_mock *MockButtonWidget) Hide() {
8559	_mock.Called()
8560	return
8561}
8562
8563// MockButtonWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
8564type MockButtonWidget_Hide_Call struct {
8565	*mock.Call
8566}
8567
8568// Hide is a helper method to define mock.On call
8569func (_e *MockButtonWidget_Expecter) Hide() *MockButtonWidget_Hide_Call {
8570	return &MockButtonWidget_Hide_Call{Call: _e.mock.On("Hide")}
8571}
8572
8573func (_c *MockButtonWidget_Hide_Call) Run(run func()) *MockButtonWidget_Hide_Call {
8574	_c.Call.Run(func(args mock.Arguments) {
8575		run()
8576	})
8577	return _c
8578}
8579
8580func (_c *MockButtonWidget_Hide_Call) Return() *MockButtonWidget_Hide_Call {
8581	_c.Call.Return()
8582	return _c
8583}
8584
8585func (_c *MockButtonWidget_Hide_Call) RunAndReturn(run func()) *MockButtonWidget_Hide_Call {
8586	_c.Run(run)
8587	return _c
8588}
8589
8590// IsVisible provides a mock function for the type MockButtonWidget
8591func (_mock *MockButtonWidget) IsVisible() bool {
8592	ret := _mock.Called()
8593
8594	if len(ret) == 0 {
8595		panic("no return value specified for IsVisible")
8596	}
8597
8598	var r0 bool
8599	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8600		r0 = returnFunc()
8601	} else {
8602		r0 = ret.Get(0).(bool)
8603	}
8604	return r0
8605}
8606
8607// MockButtonWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
8608type MockButtonWidget_IsVisible_Call struct {
8609	*mock.Call
8610}
8611
8612// IsVisible is a helper method to define mock.On call
8613func (_e *MockButtonWidget_Expecter) IsVisible() *MockButtonWidget_IsVisible_Call {
8614	return &MockButtonWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
8615}
8616
8617func (_c *MockButtonWidget_IsVisible_Call) Run(run func()) *MockButtonWidget_IsVisible_Call {
8618	_c.Call.Run(func(args mock.Arguments) {
8619		run()
8620	})
8621	return _c
8622}
8623
8624func (_c *MockButtonWidget_IsVisible_Call) Return(b bool) *MockButtonWidget_IsVisible_Call {
8625	_c.Call.Return(b)
8626	return _c
8627}
8628
8629func (_c *MockButtonWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockButtonWidget_IsVisible_Call {
8630	_c.Call.Return(run)
8631	return _c
8632}
8633
8634// RemoveCssClass provides a mock function for the type MockButtonWidget
8635func (_mock *MockButtonWidget) RemoveCssClass(cssClass string) {
8636	_mock.Called(cssClass)
8637	return
8638}
8639
8640// MockButtonWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
8641type MockButtonWidget_RemoveCssClass_Call struct {
8642	*mock.Call
8643}
8644
8645// RemoveCssClass is a helper method to define mock.On call
8646//   - cssClass string
8647func (_e *MockButtonWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockButtonWidget_RemoveCssClass_Call {
8648	return &MockButtonWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
8649}
8650
8651func (_c *MockButtonWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_RemoveCssClass_Call {
8652	_c.Call.Run(func(args mock.Arguments) {
8653		var arg0 string
8654		if args[0] != nil {
8655			arg0 = args[0].(string)
8656		}
8657		run(
8658			arg0,
8659		)
8660	})
8661	return _c
8662}
8663
8664func (_c *MockButtonWidget_RemoveCssClass_Call) Return() *MockButtonWidget_RemoveCssClass_Call {
8665	_c.Call.Return()
8666	return _c
8667}
8668
8669func (_c *MockButtonWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockButtonWidget_RemoveCssClass_Call {
8670	_c.Run(run)
8671	return _c
8672}
8673
8674// SetCanFocus provides a mock function for the type MockButtonWidget
8675func (_mock *MockButtonWidget) SetCanFocus(canFocus bool) {
8676	_mock.Called(canFocus)
8677	return
8678}
8679
8680// MockButtonWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
8681type MockButtonWidget_SetCanFocus_Call struct {
8682	*mock.Call
8683}
8684
8685// SetCanFocus is a helper method to define mock.On call
8686//   - canFocus bool
8687func (_e *MockButtonWidget_Expecter) SetCanFocus(canFocus interface{}) *MockButtonWidget_SetCanFocus_Call {
8688	return &MockButtonWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
8689}
8690
8691func (_c *MockButtonWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockButtonWidget_SetCanFocus_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_SetCanFocus_Call) Return() *MockButtonWidget_SetCanFocus_Call {
8705	_c.Call.Return()
8706	return _c
8707}
8708
8709func (_c *MockButtonWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockButtonWidget_SetCanFocus_Call {
8710	_c.Run(run)
8711	return _c
8712}
8713
8714// SetCanTarget provides a mock function for the type MockButtonWidget
8715func (_mock *MockButtonWidget) SetCanTarget(canTarget bool) {
8716	_mock.Called(canTarget)
8717	return
8718}
8719
8720// MockButtonWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
8721type MockButtonWidget_SetCanTarget_Call struct {
8722	*mock.Call
8723}
8724
8725// SetCanTarget is a helper method to define mock.On call
8726//   - canTarget bool
8727func (_e *MockButtonWidget_Expecter) SetCanTarget(canTarget interface{}) *MockButtonWidget_SetCanTarget_Call {
8728	return &MockButtonWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
8729}
8730
8731func (_c *MockButtonWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockButtonWidget_SetCanTarget_Call {
8732	_c.Call.Run(func(args mock.Arguments) {
8733		var arg0 bool
8734		if args[0] != nil {
8735			arg0 = args[0].(bool)
8736		}
8737		run(
8738			arg0,
8739		)
8740	})
8741	return _c
8742}
8743
8744func (_c *MockButtonWidget_SetCanTarget_Call) Return() *MockButtonWidget_SetCanTarget_Call {
8745	_c.Call.Return()
8746	return _c
8747}
8748
8749func (_c *MockButtonWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockButtonWidget_SetCanTarget_Call {
8750	_c.Run(run)
8751	return _c
8752}
8753
8754// SetChild provides a mock function for the type MockButtonWidget
8755func (_mock *MockButtonWidget) SetChild(child layout.Widget) {
8756	_mock.Called(child)
8757	return
8758}
8759
8760// MockButtonWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
8761type MockButtonWidget_SetChild_Call struct {
8762	*mock.Call
8763}
8764
8765// SetChild is a helper method to define mock.On call
8766//   - child layout.Widget
8767func (_e *MockButtonWidget_Expecter) SetChild(child interface{}) *MockButtonWidget_SetChild_Call {
8768	return &MockButtonWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
8769}
8770
8771func (_c *MockButtonWidget_SetChild_Call) Run(run func(child layout.Widget)) *MockButtonWidget_SetChild_Call {
8772	_c.Call.Run(func(args mock.Arguments) {
8773		var arg0 layout.Widget
8774		if args[0] != nil {
8775			arg0 = args[0].(layout.Widget)
8776		}
8777		run(
8778			arg0,
8779		)
8780	})
8781	return _c
8782}
8783
8784func (_c *MockButtonWidget_SetChild_Call) Return() *MockButtonWidget_SetChild_Call {
8785	_c.Call.Return()
8786	return _c
8787}
8788
8789func (_c *MockButtonWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) *MockButtonWidget_SetChild_Call {
8790	_c.Run(run)
8791	return _c
8792}
8793
8794// SetFocusOnClick provides a mock function for the type MockButtonWidget
8795func (_mock *MockButtonWidget) SetFocusOnClick(focusOnClick bool) {
8796	_mock.Called(focusOnClick)
8797	return
8798}
8799
8800// MockButtonWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
8801type MockButtonWidget_SetFocusOnClick_Call struct {
8802	*mock.Call
8803}
8804
8805// SetFocusOnClick is a helper method to define mock.On call
8806//   - focusOnClick bool
8807func (_e *MockButtonWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockButtonWidget_SetFocusOnClick_Call {
8808	return &MockButtonWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
8809}
8810
8811func (_c *MockButtonWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockButtonWidget_SetFocusOnClick_Call {
8812	_c.Call.Run(func(args mock.Arguments) {
8813		var arg0 bool
8814		if args[0] != nil {
8815			arg0 = args[0].(bool)
8816		}
8817		run(
8818			arg0,
8819		)
8820	})
8821	return _c
8822}
8823
8824func (_c *MockButtonWidget_SetFocusOnClick_Call) Return() *MockButtonWidget_SetFocusOnClick_Call {
8825	_c.Call.Return()
8826	return _c
8827}
8828
8829func (_c *MockButtonWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockButtonWidget_SetFocusOnClick_Call {
8830	_c.Run(run)
8831	return _c
8832}
8833
8834// SetFocusable provides a mock function for the type MockButtonWidget
8835func (_mock *MockButtonWidget) SetFocusable(focusable bool) {
8836	_mock.Called(focusable)
8837	return
8838}
8839
8840// MockButtonWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
8841type MockButtonWidget_SetFocusable_Call struct {
8842	*mock.Call
8843}
8844
8845// SetFocusable is a helper method to define mock.On call
8846//   - focusable bool
8847func (_e *MockButtonWidget_Expecter) SetFocusable(focusable interface{}) *MockButtonWidget_SetFocusable_Call {
8848	return &MockButtonWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
8849}
8850
8851func (_c *MockButtonWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockButtonWidget_SetFocusable_Call {
8852	_c.Call.Run(func(args mock.Arguments) {
8853		var arg0 bool
8854		if args[0] != nil {
8855			arg0 = args[0].(bool)
8856		}
8857		run(
8858			arg0,
8859		)
8860	})
8861	return _c
8862}
8863
8864func (_c *MockButtonWidget_SetFocusable_Call) Return() *MockButtonWidget_SetFocusable_Call {
8865	_c.Call.Return()
8866	return _c
8867}
8868
8869func (_c *MockButtonWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockButtonWidget_SetFocusable_Call {
8870	_c.Run(run)
8871	return _c
8872}
8873
8874// SetHalign provides a mock function for the type MockButtonWidget
8875func (_mock *MockButtonWidget) SetHalign(align gtk.Align) {
8876	_mock.Called(align)
8877	return
8878}
8879
8880// MockButtonWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
8881type MockButtonWidget_SetHalign_Call struct {
8882	*mock.Call
8883}
8884
8885// SetHalign is a helper method to define mock.On call
8886//   - align gtk.Align
8887func (_e *MockButtonWidget_Expecter) SetHalign(align interface{}) *MockButtonWidget_SetHalign_Call {
8888	return &MockButtonWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
8889}
8890
8891func (_c *MockButtonWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetHalign_Call {
8892	_c.Call.Run(func(args mock.Arguments) {
8893		var arg0 gtk.Align
8894		if args[0] != nil {
8895			arg0 = args[0].(gtk.Align)
8896		}
8897		run(
8898			arg0,
8899		)
8900	})
8901	return _c
8902}
8903
8904func (_c *MockButtonWidget_SetHalign_Call) Return() *MockButtonWidget_SetHalign_Call {
8905	_c.Call.Return()
8906	return _c
8907}
8908
8909func (_c *MockButtonWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetHalign_Call {
8910	_c.Run(run)
8911	return _c
8912}
8913
8914// SetHexpand provides a mock function for the type MockButtonWidget
8915func (_mock *MockButtonWidget) SetHexpand(expand bool) {
8916	_mock.Called(expand)
8917	return
8918}
8919
8920// MockButtonWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
8921type MockButtonWidget_SetHexpand_Call struct {
8922	*mock.Call
8923}
8924
8925// SetHexpand is a helper method to define mock.On call
8926//   - expand bool
8927func (_e *MockButtonWidget_Expecter) SetHexpand(expand interface{}) *MockButtonWidget_SetHexpand_Call {
8928	return &MockButtonWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
8929}
8930
8931func (_c *MockButtonWidget_SetHexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetHexpand_Call {
8932	_c.Call.Run(func(args mock.Arguments) {
8933		var arg0 bool
8934		if args[0] != nil {
8935			arg0 = args[0].(bool)
8936		}
8937		run(
8938			arg0,
8939		)
8940	})
8941	return _c
8942}
8943
8944func (_c *MockButtonWidget_SetHexpand_Call) Return() *MockButtonWidget_SetHexpand_Call {
8945	_c.Call.Return()
8946	return _c
8947}
8948
8949func (_c *MockButtonWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetHexpand_Call {
8950	_c.Run(run)
8951	return _c
8952}
8953
8954// SetLabel provides a mock function for the type MockButtonWidget
8955func (_mock *MockButtonWidget) SetLabel(label string) {
8956	_mock.Called(label)
8957	return
8958}
8959
8960// MockButtonWidget_SetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabel'
8961type MockButtonWidget_SetLabel_Call struct {
8962	*mock.Call
8963}
8964
8965// SetLabel is a helper method to define mock.On call
8966//   - label string
8967func (_e *MockButtonWidget_Expecter) SetLabel(label interface{}) *MockButtonWidget_SetLabel_Call {
8968	return &MockButtonWidget_SetLabel_Call{Call: _e.mock.On("SetLabel", label)}
8969}
8970
8971func (_c *MockButtonWidget_SetLabel_Call) Run(run func(label string)) *MockButtonWidget_SetLabel_Call {
8972	_c.Call.Run(func(args mock.Arguments) {
8973		var arg0 string
8974		if args[0] != nil {
8975			arg0 = args[0].(string)
8976		}
8977		run(
8978			arg0,
8979		)
8980	})
8981	return _c
8982}
8983
8984func (_c *MockButtonWidget_SetLabel_Call) Return() *MockButtonWidget_SetLabel_Call {
8985	_c.Call.Return()
8986	return _c
8987}
8988
8989func (_c *MockButtonWidget_SetLabel_Call) RunAndReturn(run func(label string)) *MockButtonWidget_SetLabel_Call {
8990	_c.Run(run)
8991	return _c
8992}
8993
8994// SetSizeRequest provides a mock function for the type MockButtonWidget
8995func (_mock *MockButtonWidget) SetSizeRequest(width int, height int) {
8996	_mock.Called(width, height)
8997	return
8998}
8999
9000// MockButtonWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
9001type MockButtonWidget_SetSizeRequest_Call struct {
9002	*mock.Call
9003}
9004
9005// SetSizeRequest is a helper method to define mock.On call
9006//   - width int
9007//   - height int
9008func (_e *MockButtonWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockButtonWidget_SetSizeRequest_Call {
9009	return &MockButtonWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
9010}
9011
9012func (_c *MockButtonWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
9013	_c.Call.Run(func(args mock.Arguments) {
9014		var arg0 int
9015		if args[0] != nil {
9016			arg0 = args[0].(int)
9017		}
9018		var arg1 int
9019		if args[1] != nil {
9020			arg1 = args[1].(int)
9021		}
9022		run(
9023			arg0,
9024			arg1,
9025		)
9026	})
9027	return _c
9028}
9029
9030func (_c *MockButtonWidget_SetSizeRequest_Call) Return() *MockButtonWidget_SetSizeRequest_Call {
9031	_c.Call.Return()
9032	return _c
9033}
9034
9035func (_c *MockButtonWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
9036	_c.Run(run)
9037	return _c
9038}
9039
9040// SetValign provides a mock function for the type MockButtonWidget
9041func (_mock *MockButtonWidget) SetValign(align gtk.Align) {
9042	_mock.Called(align)
9043	return
9044}
9045
9046// MockButtonWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
9047type MockButtonWidget_SetValign_Call struct {
9048	*mock.Call
9049}
9050
9051// SetValign is a helper method to define mock.On call
9052//   - align gtk.Align
9053func (_e *MockButtonWidget_Expecter) SetValign(align interface{}) *MockButtonWidget_SetValign_Call {
9054	return &MockButtonWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
9055}
9056
9057func (_c *MockButtonWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
9058	_c.Call.Run(func(args mock.Arguments) {
9059		var arg0 gtk.Align
9060		if args[0] != nil {
9061			arg0 = args[0].(gtk.Align)
9062		}
9063		run(
9064			arg0,
9065		)
9066	})
9067	return _c
9068}
9069
9070func (_c *MockButtonWidget_SetValign_Call) Return() *MockButtonWidget_SetValign_Call {
9071	_c.Call.Return()
9072	return _c
9073}
9074
9075func (_c *MockButtonWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
9076	_c.Run(run)
9077	return _c
9078}
9079
9080// SetVexpand provides a mock function for the type MockButtonWidget
9081func (_mock *MockButtonWidget) SetVexpand(expand bool) {
9082	_mock.Called(expand)
9083	return
9084}
9085
9086// MockButtonWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
9087type MockButtonWidget_SetVexpand_Call struct {
9088	*mock.Call
9089}
9090
9091// SetVexpand is a helper method to define mock.On call
9092//   - expand bool
9093func (_e *MockButtonWidget_Expecter) SetVexpand(expand interface{}) *MockButtonWidget_SetVexpand_Call {
9094	return &MockButtonWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
9095}
9096
9097func (_c *MockButtonWidget_SetVexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
9098	_c.Call.Run(func(args mock.Arguments) {
9099		var arg0 bool
9100		if args[0] != nil {
9101			arg0 = args[0].(bool)
9102		}
9103		run(
9104			arg0,
9105		)
9106	})
9107	return _c
9108}
9109
9110func (_c *MockButtonWidget_SetVexpand_Call) Return() *MockButtonWidget_SetVexpand_Call {
9111	_c.Call.Return()
9112	return _c
9113}
9114
9115func (_c *MockButtonWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
9116	_c.Run(run)
9117	return _c
9118}
9119
9120// SetVisible provides a mock function for the type MockButtonWidget
9121func (_mock *MockButtonWidget) SetVisible(visible bool) {
9122	_mock.Called(visible)
9123	return
9124}
9125
9126// MockButtonWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
9127type MockButtonWidget_SetVisible_Call struct {
9128	*mock.Call
9129}
9130
9131// SetVisible is a helper method to define mock.On call
9132//   - visible bool
9133func (_e *MockButtonWidget_Expecter) SetVisible(visible interface{}) *MockButtonWidget_SetVisible_Call {
9134	return &MockButtonWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
9135}
9136
9137func (_c *MockButtonWidget_SetVisible_Call) Run(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
9138	_c.Call.Run(func(args mock.Arguments) {
9139		var arg0 bool
9140		if args[0] != nil {
9141			arg0 = args[0].(bool)
9142		}
9143		run(
9144			arg0,
9145		)
9146	})
9147	return _c
9148}
9149
9150func (_c *MockButtonWidget_SetVisible_Call) Return() *MockButtonWidget_SetVisible_Call {
9151	_c.Call.Return()
9152	return _c
9153}
9154
9155func (_c *MockButtonWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
9156	_c.Run(run)
9157	return _c
9158}
9159
9160// Show provides a mock function for the type MockButtonWidget
9161func (_mock *MockButtonWidget) Show() {
9162	_mock.Called()
9163	return
9164}
9165
9166// MockButtonWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
9167type MockButtonWidget_Show_Call struct {
9168	*mock.Call
9169}
9170
9171// Show is a helper method to define mock.On call
9172func (_e *MockButtonWidget_Expecter) Show() *MockButtonWidget_Show_Call {
9173	return &MockButtonWidget_Show_Call{Call: _e.mock.On("Show")}
9174}
9175
9176func (_c *MockButtonWidget_Show_Call) Run(run func()) *MockButtonWidget_Show_Call {
9177	_c.Call.Run(func(args mock.Arguments) {
9178		run()
9179	})
9180	return _c
9181}
9182
9183func (_c *MockButtonWidget_Show_Call) Return() *MockButtonWidget_Show_Call {
9184	_c.Call.Return()
9185	return _c
9186}
9187
9188func (_c *MockButtonWidget_Show_Call) RunAndReturn(run func()) *MockButtonWidget_Show_Call {
9189	_c.Run(run)
9190	return _c
9191}
9192
9193// Unparent provides a mock function for the type MockButtonWidget
9194func (_mock *MockButtonWidget) Unparent() {
9195	_mock.Called()
9196	return
9197}
9198
9199// MockButtonWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
9200type MockButtonWidget_Unparent_Call struct {
9201	*mock.Call
9202}
9203
9204// Unparent is a helper method to define mock.On call
9205func (_e *MockButtonWidget_Expecter) Unparent() *MockButtonWidget_Unparent_Call {
9206	return &MockButtonWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
9207}
9208
9209func (_c *MockButtonWidget_Unparent_Call) Run(run func()) *MockButtonWidget_Unparent_Call {
9210	_c.Call.Run(func(args mock.Arguments) {
9211		run()
9212	})
9213	return _c
9214}
9215
9216func (_c *MockButtonWidget_Unparent_Call) Return() *MockButtonWidget_Unparent_Call {
9217	_c.Call.Return()
9218	return _c
9219}
9220
9221func (_c *MockButtonWidget_Unparent_Call) RunAndReturn(run func()) *MockButtonWidget_Unparent_Call {
9222	_c.Run(run)
9223	return _c
9224}
9225
9226// 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.
9227// The first argument is typically a *testing.T value.
9228func NewMockImageWidget(t interface {
9229	mock.TestingT
9230	Cleanup(func())
9231}) *MockImageWidget {
9232	mock := &MockImageWidget{}
9233	mock.Mock.Test(t)
9234
9235	t.Cleanup(func() { mock.AssertExpectations(t) })
9236
9237	return mock
9238}
9239
9240// MockImageWidget is an autogenerated mock type for the ImageWidget type
9241type MockImageWidget struct {
9242	mock.Mock
9243}
9244
9245type MockImageWidget_Expecter struct {
9246	mock *mock.Mock
9247}
9248
9249func (_m *MockImageWidget) EXPECT() *MockImageWidget_Expecter {
9250	return &MockImageWidget_Expecter{mock: &_m.Mock}
9251}
9252
9253// AddController provides a mock function for the type MockImageWidget
9254func (_mock *MockImageWidget) AddController(controller *gtk.EventController) {
9255	_mock.Called(controller)
9256	return
9257}
9258
9259// MockImageWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
9260type MockImageWidget_AddController_Call struct {
9261	*mock.Call
9262}
9263
9264// AddController is a helper method to define mock.On call
9265//   - controller *gtk.EventController
9266func (_e *MockImageWidget_Expecter) AddController(controller interface{}) *MockImageWidget_AddController_Call {
9267	return &MockImageWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
9268}
9269
9270func (_c *MockImageWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
9271	_c.Call.Run(func(args mock.Arguments) {
9272		var arg0 *gtk.EventController
9273		if args[0] != nil {
9274			arg0 = args[0].(*gtk.EventController)
9275		}
9276		run(
9277			arg0,
9278		)
9279	})
9280	return _c
9281}
9282
9283func (_c *MockImageWidget_AddController_Call) Return() *MockImageWidget_AddController_Call {
9284	_c.Call.Return()
9285	return _c
9286}
9287
9288func (_c *MockImageWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
9289	_c.Run(run)
9290	return _c
9291}
9292
9293// AddCssClass provides a mock function for the type MockImageWidget
9294func (_mock *MockImageWidget) AddCssClass(cssClass string) {
9295	_mock.Called(cssClass)
9296	return
9297}
9298
9299// MockImageWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
9300type MockImageWidget_AddCssClass_Call struct {
9301	*mock.Call
9302}
9303
9304// AddCssClass is a helper method to define mock.On call
9305//   - cssClass string
9306func (_e *MockImageWidget_Expecter) AddCssClass(cssClass interface{}) *MockImageWidget_AddCssClass_Call {
9307	return &MockImageWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
9308}
9309
9310func (_c *MockImageWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
9311	_c.Call.Run(func(args mock.Arguments) {
9312		var arg0 string
9313		if args[0] != nil {
9314			arg0 = args[0].(string)
9315		}
9316		run(
9317			arg0,
9318		)
9319	})
9320	return _c
9321}
9322
9323func (_c *MockImageWidget_AddCssClass_Call) Return() *MockImageWidget_AddCssClass_Call {
9324	_c.Call.Return()
9325	return _c
9326}
9327
9328func (_c *MockImageWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
9329	_c.Run(run)
9330	return _c
9331}
9332
9333// Clear provides a mock function for the type MockImageWidget
9334func (_mock *MockImageWidget) Clear() {
9335	_mock.Called()
9336	return
9337}
9338
9339// MockImageWidget_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
9340type MockImageWidget_Clear_Call struct {
9341	*mock.Call
9342}
9343
9344// Clear is a helper method to define mock.On call
9345func (_e *MockImageWidget_Expecter) Clear() *MockImageWidget_Clear_Call {
9346	return &MockImageWidget_Clear_Call{Call: _e.mock.On("Clear")}
9347}
9348
9349func (_c *MockImageWidget_Clear_Call) Run(run func()) *MockImageWidget_Clear_Call {
9350	_c.Call.Run(func(args mock.Arguments) {
9351		run()
9352	})
9353	return _c
9354}
9355
9356func (_c *MockImageWidget_Clear_Call) Return() *MockImageWidget_Clear_Call {
9357	_c.Call.Return()
9358	return _c
9359}
9360
9361func (_c *MockImageWidget_Clear_Call) RunAndReturn(run func()) *MockImageWidget_Clear_Call {
9362	_c.Run(run)
9363	return _c
9364}
9365
9366// ComputePoint provides a mock function for the type MockImageWidget
9367func (_mock *MockImageWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
9368	ret := _mock.Called(target)
9369
9370	if len(ret) == 0 {
9371		panic("no return value specified for ComputePoint")
9372	}
9373
9374	var r0 float64
9375	var r1 float64
9376	var r2 bool
9377	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
9378		return returnFunc(target)
9379	}
9380	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
9381		r0 = returnFunc(target)
9382	} else {
9383		r0 = ret.Get(0).(float64)
9384	}
9385	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
9386		r1 = returnFunc(target)
9387	} else {
9388		r1 = ret.Get(1).(float64)
9389	}
9390	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
9391		r2 = returnFunc(target)
9392	} else {
9393		r2 = ret.Get(2).(bool)
9394	}
9395	return r0, r1, r2
9396}
9397
9398// MockImageWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
9399type MockImageWidget_ComputePoint_Call struct {
9400	*mock.Call
9401}
9402
9403// ComputePoint is a helper method to define mock.On call
9404//   - target layout.Widget
9405func (_e *MockImageWidget_Expecter) ComputePoint(target interface{}) *MockImageWidget_ComputePoint_Call {
9406	return &MockImageWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
9407}
9408
9409func (_c *MockImageWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockImageWidget_ComputePoint_Call {
9410	_c.Call.Run(func(args mock.Arguments) {
9411		var arg0 layout.Widget
9412		if args[0] != nil {
9413			arg0 = args[0].(layout.Widget)
9414		}
9415		run(
9416			arg0,
9417		)
9418	})
9419	return _c
9420}
9421
9422func (_c *MockImageWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockImageWidget_ComputePoint_Call {
9423	_c.Call.Return(x, y, ok)
9424	return _c
9425}
9426
9427func (_c *MockImageWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockImageWidget_ComputePoint_Call {
9428	_c.Call.Return(run)
9429	return _c
9430}
9431
9432// GetAllocatedHeight provides a mock function for the type MockImageWidget
9433func (_mock *MockImageWidget) GetAllocatedHeight() int {
9434	ret := _mock.Called()
9435
9436	if len(ret) == 0 {
9437		panic("no return value specified for GetAllocatedHeight")
9438	}
9439
9440	var r0 int
9441	if returnFunc, ok := ret.Get(0).(func() int); ok {
9442		r0 = returnFunc()
9443	} else {
9444		r0 = ret.Get(0).(int)
9445	}
9446	return r0
9447}
9448
9449// MockImageWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
9450type MockImageWidget_GetAllocatedHeight_Call struct {
9451	*mock.Call
9452}
9453
9454// GetAllocatedHeight is a helper method to define mock.On call
9455func (_e *MockImageWidget_Expecter) GetAllocatedHeight() *MockImageWidget_GetAllocatedHeight_Call {
9456	return &MockImageWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
9457}
9458
9459func (_c *MockImageWidget_GetAllocatedHeight_Call) Run(run func()) *MockImageWidget_GetAllocatedHeight_Call {
9460	_c.Call.Run(func(args mock.Arguments) {
9461		run()
9462	})
9463	return _c
9464}
9465
9466func (_c *MockImageWidget_GetAllocatedHeight_Call) Return(n int) *MockImageWidget_GetAllocatedHeight_Call {
9467	_c.Call.Return(n)
9468	return _c
9469}
9470
9471func (_c *MockImageWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedHeight_Call {
9472	_c.Call.Return(run)
9473	return _c
9474}
9475
9476// GetAllocatedWidth provides a mock function for the type MockImageWidget
9477func (_mock *MockImageWidget) GetAllocatedWidth() int {
9478	ret := _mock.Called()
9479
9480	if len(ret) == 0 {
9481		panic("no return value specified for GetAllocatedWidth")
9482	}
9483
9484	var r0 int
9485	if returnFunc, ok := ret.Get(0).(func() int); ok {
9486		r0 = returnFunc()
9487	} else {
9488		r0 = ret.Get(0).(int)
9489	}
9490	return r0
9491}
9492
9493// MockImageWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
9494type MockImageWidget_GetAllocatedWidth_Call struct {
9495	*mock.Call
9496}
9497
9498// GetAllocatedWidth is a helper method to define mock.On call
9499func (_e *MockImageWidget_Expecter) GetAllocatedWidth() *MockImageWidget_GetAllocatedWidth_Call {
9500	return &MockImageWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
9501}
9502
9503func (_c *MockImageWidget_GetAllocatedWidth_Call) Run(run func()) *MockImageWidget_GetAllocatedWidth_Call {
9504	_c.Call.Run(func(args mock.Arguments) {
9505		run()
9506	})
9507	return _c
9508}
9509
9510func (_c *MockImageWidget_GetAllocatedWidth_Call) Return(n int) *MockImageWidget_GetAllocatedWidth_Call {
9511	_c.Call.Return(n)
9512	return _c
9513}
9514
9515func (_c *MockImageWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedWidth_Call {
9516	_c.Call.Return(run)
9517	return _c
9518}
9519
9520// GetHexpand provides a mock function for the type MockImageWidget
9521func (_mock *MockImageWidget) GetHexpand() bool {
9522	ret := _mock.Called()
9523
9524	if len(ret) == 0 {
9525		panic("no return value specified for GetHexpand")
9526	}
9527
9528	var r0 bool
9529	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9530		r0 = returnFunc()
9531	} else {
9532		r0 = ret.Get(0).(bool)
9533	}
9534	return r0
9535}
9536
9537// MockImageWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
9538type MockImageWidget_GetHexpand_Call struct {
9539	*mock.Call
9540}
9541
9542// GetHexpand is a helper method to define mock.On call
9543func (_e *MockImageWidget_Expecter) GetHexpand() *MockImageWidget_GetHexpand_Call {
9544	return &MockImageWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
9545}
9546
9547func (_c *MockImageWidget_GetHexpand_Call) Run(run func()) *MockImageWidget_GetHexpand_Call {
9548	_c.Call.Run(func(args mock.Arguments) {
9549		run()
9550	})
9551	return _c
9552}
9553
9554func (_c *MockImageWidget_GetHexpand_Call) Return(b bool) *MockImageWidget_GetHexpand_Call {
9555	_c.Call.Return(b)
9556	return _c
9557}
9558
9559func (_c *MockImageWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetHexpand_Call {
9560	_c.Call.Return(run)
9561	return _c
9562}
9563
9564// GetParent provides a mock function for the type MockImageWidget
9565func (_mock *MockImageWidget) GetParent() layout.Widget {
9566	ret := _mock.Called()
9567
9568	if len(ret) == 0 {
9569		panic("no return value specified for GetParent")
9570	}
9571
9572	var r0 layout.Widget
9573	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
9574		r0 = returnFunc()
9575	} else {
9576		if ret.Get(0) != nil {
9577			r0 = ret.Get(0).(layout.Widget)
9578		}
9579	}
9580	return r0
9581}
9582
9583// MockImageWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
9584type MockImageWidget_GetParent_Call struct {
9585	*mock.Call
9586}
9587
9588// GetParent is a helper method to define mock.On call
9589func (_e *MockImageWidget_Expecter) GetParent() *MockImageWidget_GetParent_Call {
9590	return &MockImageWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
9591}
9592
9593func (_c *MockImageWidget_GetParent_Call) Run(run func()) *MockImageWidget_GetParent_Call {
9594	_c.Call.Run(func(args mock.Arguments) {
9595		run()
9596	})
9597	return _c
9598}
9599
9600func (_c *MockImageWidget_GetParent_Call) Return(widget layout.Widget) *MockImageWidget_GetParent_Call {
9601	_c.Call.Return(widget)
9602	return _c
9603}
9604
9605func (_c *MockImageWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockImageWidget_GetParent_Call {
9606	_c.Call.Return(run)
9607	return _c
9608}
9609
9610// GetVexpand provides a mock function for the type MockImageWidget
9611func (_mock *MockImageWidget) GetVexpand() bool {
9612	ret := _mock.Called()
9613
9614	if len(ret) == 0 {
9615		panic("no return value specified for GetVexpand")
9616	}
9617
9618	var r0 bool
9619	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9620		r0 = returnFunc()
9621	} else {
9622		r0 = ret.Get(0).(bool)
9623	}
9624	return r0
9625}
9626
9627// MockImageWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
9628type MockImageWidget_GetVexpand_Call struct {
9629	*mock.Call
9630}
9631
9632// GetVexpand is a helper method to define mock.On call
9633func (_e *MockImageWidget_Expecter) GetVexpand() *MockImageWidget_GetVexpand_Call {
9634	return &MockImageWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
9635}
9636
9637func (_c *MockImageWidget_GetVexpand_Call) Run(run func()) *MockImageWidget_GetVexpand_Call {
9638	_c.Call.Run(func(args mock.Arguments) {
9639		run()
9640	})
9641	return _c
9642}
9643
9644func (_c *MockImageWidget_GetVexpand_Call) Return(b bool) *MockImageWidget_GetVexpand_Call {
9645	_c.Call.Return(b)
9646	return _c
9647}
9648
9649func (_c *MockImageWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetVexpand_Call {
9650	_c.Call.Return(run)
9651	return _c
9652}
9653
9654// GrabFocus provides a mock function for the type MockImageWidget
9655func (_mock *MockImageWidget) GrabFocus() bool {
9656	ret := _mock.Called()
9657
9658	if len(ret) == 0 {
9659		panic("no return value specified for GrabFocus")
9660	}
9661
9662	var r0 bool
9663	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9664		r0 = returnFunc()
9665	} else {
9666		r0 = ret.Get(0).(bool)
9667	}
9668	return r0
9669}
9670
9671// MockImageWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
9672type MockImageWidget_GrabFocus_Call struct {
9673	*mock.Call
9674}
9675
9676// GrabFocus is a helper method to define mock.On call
9677func (_e *MockImageWidget_Expecter) GrabFocus() *MockImageWidget_GrabFocus_Call {
9678	return &MockImageWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
9679}
9680
9681func (_c *MockImageWidget_GrabFocus_Call) Run(run func()) *MockImageWidget_GrabFocus_Call {
9682	_c.Call.Run(func(args mock.Arguments) {
9683		run()
9684	})
9685	return _c
9686}
9687
9688func (_c *MockImageWidget_GrabFocus_Call) Return(b bool) *MockImageWidget_GrabFocus_Call {
9689	_c.Call.Return(b)
9690	return _c
9691}
9692
9693func (_c *MockImageWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_GrabFocus_Call {
9694	_c.Call.Return(run)
9695	return _c
9696}
9697
9698// GtkWidget provides a mock function for the type MockImageWidget
9699func (_mock *MockImageWidget) GtkWidget() *gtk.Widget {
9700	ret := _mock.Called()
9701
9702	if len(ret) == 0 {
9703		panic("no return value specified for GtkWidget")
9704	}
9705
9706	var r0 *gtk.Widget
9707	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
9708		r0 = returnFunc()
9709	} else {
9710		if ret.Get(0) != nil {
9711			r0 = ret.Get(0).(*gtk.Widget)
9712		}
9713	}
9714	return r0
9715}
9716
9717// MockImageWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
9718type MockImageWidget_GtkWidget_Call struct {
9719	*mock.Call
9720}
9721
9722// GtkWidget is a helper method to define mock.On call
9723func (_e *MockImageWidget_Expecter) GtkWidget() *MockImageWidget_GtkWidget_Call {
9724	return &MockImageWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
9725}
9726
9727func (_c *MockImageWidget_GtkWidget_Call) Run(run func()) *MockImageWidget_GtkWidget_Call {
9728	_c.Call.Run(func(args mock.Arguments) {
9729		run()
9730	})
9731	return _c
9732}
9733
9734func (_c *MockImageWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockImageWidget_GtkWidget_Call {
9735	_c.Call.Return(widget)
9736	return _c
9737}
9738
9739func (_c *MockImageWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockImageWidget_GtkWidget_Call {
9740	_c.Call.Return(run)
9741	return _c
9742}
9743
9744// HasCssClass provides a mock function for the type MockImageWidget
9745func (_mock *MockImageWidget) HasCssClass(cssClass string) bool {
9746	ret := _mock.Called(cssClass)
9747
9748	if len(ret) == 0 {
9749		panic("no return value specified for HasCssClass")
9750	}
9751
9752	var r0 bool
9753	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
9754		r0 = returnFunc(cssClass)
9755	} else {
9756		r0 = ret.Get(0).(bool)
9757	}
9758	return r0
9759}
9760
9761// MockImageWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
9762type MockImageWidget_HasCssClass_Call struct {
9763	*mock.Call
9764}
9765
9766// HasCssClass is a helper method to define mock.On call
9767//   - cssClass string
9768func (_e *MockImageWidget_Expecter) HasCssClass(cssClass interface{}) *MockImageWidget_HasCssClass_Call {
9769	return &MockImageWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
9770}
9771
9772func (_c *MockImageWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_HasCssClass_Call {
9773	_c.Call.Run(func(args mock.Arguments) {
9774		var arg0 string
9775		if args[0] != nil {
9776			arg0 = args[0].(string)
9777		}
9778		run(
9779			arg0,
9780		)
9781	})
9782	return _c
9783}
9784
9785func (_c *MockImageWidget_HasCssClass_Call) Return(b bool) *MockImageWidget_HasCssClass_Call {
9786	_c.Call.Return(b)
9787	return _c
9788}
9789
9790func (_c *MockImageWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockImageWidget_HasCssClass_Call {
9791	_c.Call.Return(run)
9792	return _c
9793}
9794
9795// HasFocus provides a mock function for the type MockImageWidget
9796func (_mock *MockImageWidget) HasFocus() bool {
9797	ret := _mock.Called()
9798
9799	if len(ret) == 0 {
9800		panic("no return value specified for HasFocus")
9801	}
9802
9803	var r0 bool
9804	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9805		r0 = returnFunc()
9806	} else {
9807		r0 = ret.Get(0).(bool)
9808	}
9809	return r0
9810}
9811
9812// MockImageWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
9813type MockImageWidget_HasFocus_Call struct {
9814	*mock.Call
9815}
9816
9817// HasFocus is a helper method to define mock.On call
9818func (_e *MockImageWidget_Expecter) HasFocus() *MockImageWidget_HasFocus_Call {
9819	return &MockImageWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
9820}
9821
9822func (_c *MockImageWidget_HasFocus_Call) Run(run func()) *MockImageWidget_HasFocus_Call {
9823	_c.Call.Run(func(args mock.Arguments) {
9824		run()
9825	})
9826	return _c
9827}
9828
9829func (_c *MockImageWidget_HasFocus_Call) Return(b bool) *MockImageWidget_HasFocus_Call {
9830	_c.Call.Return(b)
9831	return _c
9832}
9833
9834func (_c *MockImageWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_HasFocus_Call {
9835	_c.Call.Return(run)
9836	return _c
9837}
9838
9839// Hide provides a mock function for the type MockImageWidget
9840func (_mock *MockImageWidget) Hide() {
9841	_mock.Called()
9842	return
9843}
9844
9845// MockImageWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
9846type MockImageWidget_Hide_Call struct {
9847	*mock.Call
9848}
9849
9850// Hide is a helper method to define mock.On call
9851func (_e *MockImageWidget_Expecter) Hide() *MockImageWidget_Hide_Call {
9852	return &MockImageWidget_Hide_Call{Call: _e.mock.On("Hide")}
9853}
9854
9855func (_c *MockImageWidget_Hide_Call) Run(run func()) *MockImageWidget_Hide_Call {
9856	_c.Call.Run(func(args mock.Arguments) {
9857		run()
9858	})
9859	return _c
9860}
9861
9862func (_c *MockImageWidget_Hide_Call) Return() *MockImageWidget_Hide_Call {
9863	_c.Call.Return()
9864	return _c
9865}
9866
9867func (_c *MockImageWidget_Hide_Call) RunAndReturn(run func()) *MockImageWidget_Hide_Call {
9868	_c.Run(run)
9869	return _c
9870}
9871
9872// IsVisible provides a mock function for the type MockImageWidget
9873func (_mock *MockImageWidget) IsVisible() bool {
9874	ret := _mock.Called()
9875
9876	if len(ret) == 0 {
9877		panic("no return value specified for IsVisible")
9878	}
9879
9880	var r0 bool
9881	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9882		r0 = returnFunc()
9883	} else {
9884		r0 = ret.Get(0).(bool)
9885	}
9886	return r0
9887}
9888
9889// MockImageWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
9890type MockImageWidget_IsVisible_Call struct {
9891	*mock.Call
9892}
9893
9894// IsVisible is a helper method to define mock.On call
9895func (_e *MockImageWidget_Expecter) IsVisible() *MockImageWidget_IsVisible_Call {
9896	return &MockImageWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
9897}
9898
9899func (_c *MockImageWidget_IsVisible_Call) Run(run func()) *MockImageWidget_IsVisible_Call {
9900	_c.Call.Run(func(args mock.Arguments) {
9901		run()
9902	})
9903	return _c
9904}
9905
9906func (_c *MockImageWidget_IsVisible_Call) Return(b bool) *MockImageWidget_IsVisible_Call {
9907	_c.Call.Return(b)
9908	return _c
9909}
9910
9911func (_c *MockImageWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockImageWidget_IsVisible_Call {
9912	_c.Call.Return(run)
9913	return _c
9914}
9915
9916// RemoveCssClass provides a mock function for the type MockImageWidget
9917func (_mock *MockImageWidget) RemoveCssClass(cssClass string) {
9918	_mock.Called(cssClass)
9919	return
9920}
9921
9922// MockImageWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
9923type MockImageWidget_RemoveCssClass_Call struct {
9924	*mock.Call
9925}
9926
9927// RemoveCssClass is a helper method to define mock.On call
9928//   - cssClass string
9929func (_e *MockImageWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockImageWidget_RemoveCssClass_Call {
9930	return &MockImageWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
9931}
9932
9933func (_c *MockImageWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
9934	_c.Call.Run(func(args mock.Arguments) {
9935		var arg0 string
9936		if args[0] != nil {
9937			arg0 = args[0].(string)
9938		}
9939		run(
9940			arg0,
9941		)
9942	})
9943	return _c
9944}
9945
9946func (_c *MockImageWidget_RemoveCssClass_Call) Return() *MockImageWidget_RemoveCssClass_Call {
9947	_c.Call.Return()
9948	return _c
9949}
9950
9951func (_c *MockImageWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
9952	_c.Run(run)
9953	return _c
9954}
9955
9956// SetCanFocus provides a mock function for the type MockImageWidget
9957func (_mock *MockImageWidget) SetCanFocus(canFocus bool) {
9958	_mock.Called(canFocus)
9959	return
9960}
9961
9962// MockImageWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
9963type MockImageWidget_SetCanFocus_Call struct {
9964	*mock.Call
9965}
9966
9967// SetCanFocus is a helper method to define mock.On call
9968//   - canFocus bool
9969func (_e *MockImageWidget_Expecter) SetCanFocus(canFocus interface{}) *MockImageWidget_SetCanFocus_Call {
9970	return &MockImageWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
9971}
9972
9973func (_c *MockImageWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
9974	_c.Call.Run(func(args mock.Arguments) {
9975		var arg0 bool
9976		if args[0] != nil {
9977			arg0 = args[0].(bool)
9978		}
9979		run(
9980			arg0,
9981		)
9982	})
9983	return _c
9984}
9985
9986func (_c *MockImageWidget_SetCanFocus_Call) Return() *MockImageWidget_SetCanFocus_Call {
9987	_c.Call.Return()
9988	return _c
9989}
9990
9991func (_c *MockImageWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
9992	_c.Run(run)
9993	return _c
9994}
9995
9996// SetCanTarget provides a mock function for the type MockImageWidget
9997func (_mock *MockImageWidget) SetCanTarget(canTarget bool) {
9998	_mock.Called(canTarget)
9999	return
10000}
10001
10002// MockImageWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
10003type MockImageWidget_SetCanTarget_Call struct {
10004	*mock.Call
10005}
10006
10007// SetCanTarget is a helper method to define mock.On call
10008//   - canTarget bool
10009func (_e *MockImageWidget_Expecter) SetCanTarget(canTarget interface{}) *MockImageWidget_SetCanTarget_Call {
10010	return &MockImageWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
10011}
10012
10013func (_c *MockImageWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockImageWidget_SetCanTarget_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_SetCanTarget_Call) Return() *MockImageWidget_SetCanTarget_Call {
10027	_c.Call.Return()
10028	return _c
10029}
10030
10031func (_c *MockImageWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockImageWidget_SetCanTarget_Call {
10032	_c.Run(run)
10033	return _c
10034}
10035
10036// SetFocusOnClick provides a mock function for the type MockImageWidget
10037func (_mock *MockImageWidget) SetFocusOnClick(focusOnClick bool) {
10038	_mock.Called(focusOnClick)
10039	return
10040}
10041
10042// MockImageWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
10043type MockImageWidget_SetFocusOnClick_Call struct {
10044	*mock.Call
10045}
10046
10047// SetFocusOnClick is a helper method to define mock.On call
10048//   - focusOnClick bool
10049func (_e *MockImageWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockImageWidget_SetFocusOnClick_Call {
10050	return &MockImageWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
10051}
10052
10053func (_c *MockImageWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
10054	_c.Call.Run(func(args mock.Arguments) {
10055		var arg0 bool
10056		if args[0] != nil {
10057			arg0 = args[0].(bool)
10058		}
10059		run(
10060			arg0,
10061		)
10062	})
10063	return _c
10064}
10065
10066func (_c *MockImageWidget_SetFocusOnClick_Call) Return() *MockImageWidget_SetFocusOnClick_Call {
10067	_c.Call.Return()
10068	return _c
10069}
10070
10071func (_c *MockImageWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
10072	_c.Run(run)
10073	return _c
10074}
10075
10076// SetFocusable provides a mock function for the type MockImageWidget
10077func (_mock *MockImageWidget) SetFocusable(focusable bool) {
10078	_mock.Called(focusable)
10079	return
10080}
10081
10082// MockImageWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
10083type MockImageWidget_SetFocusable_Call struct {
10084	*mock.Call
10085}
10086
10087// SetFocusable is a helper method to define mock.On call
10088//   - focusable bool
10089func (_e *MockImageWidget_Expecter) SetFocusable(focusable interface{}) *MockImageWidget_SetFocusable_Call {
10090	return &MockImageWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
10091}
10092
10093func (_c *MockImageWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockImageWidget_SetFocusable_Call {
10094	_c.Call.Run(func(args mock.Arguments) {
10095		var arg0 bool
10096		if args[0] != nil {
10097			arg0 = args[0].(bool)
10098		}
10099		run(
10100			arg0,
10101		)
10102	})
10103	return _c
10104}
10105
10106func (_c *MockImageWidget_SetFocusable_Call) Return() *MockImageWidget_SetFocusable_Call {
10107	_c.Call.Return()
10108	return _c
10109}
10110
10111func (_c *MockImageWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockImageWidget_SetFocusable_Call {
10112	_c.Run(run)
10113	return _c
10114}
10115
10116// SetFromFile provides a mock function for the type MockImageWidget
10117func (_mock *MockImageWidget) SetFromFile(filename string) {
10118	_mock.Called(filename)
10119	return
10120}
10121
10122// MockImageWidget_SetFromFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromFile'
10123type MockImageWidget_SetFromFile_Call struct {
10124	*mock.Call
10125}
10126
10127// SetFromFile is a helper method to define mock.On call
10128//   - filename string
10129func (_e *MockImageWidget_Expecter) SetFromFile(filename interface{}) *MockImageWidget_SetFromFile_Call {
10130	return &MockImageWidget_SetFromFile_Call{Call: _e.mock.On("SetFromFile", filename)}
10131}
10132
10133func (_c *MockImageWidget_SetFromFile_Call) Run(run func(filename string)) *MockImageWidget_SetFromFile_Call {
10134	_c.Call.Run(func(args mock.Arguments) {
10135		var arg0 string
10136		if args[0] != nil {
10137			arg0 = args[0].(string)
10138		}
10139		run(
10140			arg0,
10141		)
10142	})
10143	return _c
10144}
10145
10146func (_c *MockImageWidget_SetFromFile_Call) Return() *MockImageWidget_SetFromFile_Call {
10147	_c.Call.Return()
10148	return _c
10149}
10150
10151func (_c *MockImageWidget_SetFromFile_Call) RunAndReturn(run func(filename string)) *MockImageWidget_SetFromFile_Call {
10152	_c.Run(run)
10153	return _c
10154}
10155
10156// SetFromIconName provides a mock function for the type MockImageWidget
10157func (_mock *MockImageWidget) SetFromIconName(iconName string) {
10158	_mock.Called(iconName)
10159	return
10160}
10161
10162// MockImageWidget_SetFromIconName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromIconName'
10163type MockImageWidget_SetFromIconName_Call struct {
10164	*mock.Call
10165}
10166
10167// SetFromIconName is a helper method to define mock.On call
10168//   - iconName string
10169func (_e *MockImageWidget_Expecter) SetFromIconName(iconName interface{}) *MockImageWidget_SetFromIconName_Call {
10170	return &MockImageWidget_SetFromIconName_Call{Call: _e.mock.On("SetFromIconName", iconName)}
10171}
10172
10173func (_c *MockImageWidget_SetFromIconName_Call) Run(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
10174	_c.Call.Run(func(args mock.Arguments) {
10175		var arg0 string
10176		if args[0] != nil {
10177			arg0 = args[0].(string)
10178		}
10179		run(
10180			arg0,
10181		)
10182	})
10183	return _c
10184}
10185
10186func (_c *MockImageWidget_SetFromIconName_Call) Return() *MockImageWidget_SetFromIconName_Call {
10187	_c.Call.Return()
10188	return _c
10189}
10190
10191func (_c *MockImageWidget_SetFromIconName_Call) RunAndReturn(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
10192	_c.Run(run)
10193	return _c
10194}
10195
10196// SetFromPaintable provides a mock function for the type MockImageWidget
10197func (_mock *MockImageWidget) SetFromPaintable(paintable layout.Paintable) {
10198	_mock.Called(paintable)
10199	return
10200}
10201
10202// MockImageWidget_SetFromPaintable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromPaintable'
10203type MockImageWidget_SetFromPaintable_Call struct {
10204	*mock.Call
10205}
10206
10207// SetFromPaintable is a helper method to define mock.On call
10208//   - paintable layout.Paintable
10209func (_e *MockImageWidget_Expecter) SetFromPaintable(paintable interface{}) *MockImageWidget_SetFromPaintable_Call {
10210	return &MockImageWidget_SetFromPaintable_Call{Call: _e.mock.On("SetFromPaintable", paintable)}
10211}
10212
10213func (_c *MockImageWidget_SetFromPaintable_Call) Run(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
10214	_c.Call.Run(func(args mock.Arguments) {
10215		var arg0 layout.Paintable
10216		if args[0] != nil {
10217			arg0 = args[0].(layout.Paintable)
10218		}
10219		run(
10220			arg0,
10221		)
10222	})
10223	return _c
10224}
10225
10226func (_c *MockImageWidget_SetFromPaintable_Call) Return() *MockImageWidget_SetFromPaintable_Call {
10227	_c.Call.Return()
10228	return _c
10229}
10230
10231func (_c *MockImageWidget_SetFromPaintable_Call) RunAndReturn(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
10232	_c.Run(run)
10233	return _c
10234}
10235
10236// SetHalign provides a mock function for the type MockImageWidget
10237func (_mock *MockImageWidget) SetHalign(align gtk.Align) {
10238	_mock.Called(align)
10239	return
10240}
10241
10242// MockImageWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
10243type MockImageWidget_SetHalign_Call struct {
10244	*mock.Call
10245}
10246
10247// SetHalign is a helper method to define mock.On call
10248//   - align gtk.Align
10249func (_e *MockImageWidget_Expecter) SetHalign(align interface{}) *MockImageWidget_SetHalign_Call {
10250	return &MockImageWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
10251}
10252
10253func (_c *MockImageWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
10254	_c.Call.Run(func(args mock.Arguments) {
10255		var arg0 gtk.Align
10256		if args[0] != nil {
10257			arg0 = args[0].(gtk.Align)
10258		}
10259		run(
10260			arg0,
10261		)
10262	})
10263	return _c
10264}
10265
10266func (_c *MockImageWidget_SetHalign_Call) Return() *MockImageWidget_SetHalign_Call {
10267	_c.Call.Return()
10268	return _c
10269}
10270
10271func (_c *MockImageWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
10272	_c.Run(run)
10273	return _c
10274}
10275
10276// SetHexpand provides a mock function for the type MockImageWidget
10277func (_mock *MockImageWidget) SetHexpand(expand bool) {
10278	_mock.Called(expand)
10279	return
10280}
10281
10282// MockImageWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
10283type MockImageWidget_SetHexpand_Call struct {
10284	*mock.Call
10285}
10286
10287// SetHexpand is a helper method to define mock.On call
10288//   - expand bool
10289func (_e *MockImageWidget_Expecter) SetHexpand(expand interface{}) *MockImageWidget_SetHexpand_Call {
10290	return &MockImageWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
10291}
10292
10293func (_c *MockImageWidget_SetHexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
10294	_c.Call.Run(func(args mock.Arguments) {
10295		var arg0 bool
10296		if args[0] != nil {
10297			arg0 = args[0].(bool)
10298		}
10299		run(
10300			arg0,
10301		)
10302	})
10303	return _c
10304}
10305
10306func (_c *MockImageWidget_SetHexpand_Call) Return() *MockImageWidget_SetHexpand_Call {
10307	_c.Call.Return()
10308	return _c
10309}
10310
10311func (_c *MockImageWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
10312	_c.Run(run)
10313	return _c
10314}
10315
10316// SetPixelSize provides a mock function for the type MockImageWidget
10317func (_mock *MockImageWidget) SetPixelSize(pixelSize int) {
10318	_mock.Called(pixelSize)
10319	return
10320}
10321
10322// MockImageWidget_SetPixelSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPixelSize'
10323type MockImageWidget_SetPixelSize_Call struct {
10324	*mock.Call
10325}
10326
10327// SetPixelSize is a helper method to define mock.On call
10328//   - pixelSize int
10329func (_e *MockImageWidget_Expecter) SetPixelSize(pixelSize interface{}) *MockImageWidget_SetPixelSize_Call {
10330	return &MockImageWidget_SetPixelSize_Call{Call: _e.mock.On("SetPixelSize", pixelSize)}
10331}
10332
10333func (_c *MockImageWidget_SetPixelSize_Call) Run(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
10334	_c.Call.Run(func(args mock.Arguments) {
10335		var arg0 int
10336		if args[0] != nil {
10337			arg0 = args[0].(int)
10338		}
10339		run(
10340			arg0,
10341		)
10342	})
10343	return _c
10344}
10345
10346func (_c *MockImageWidget_SetPixelSize_Call) Return() *MockImageWidget_SetPixelSize_Call {
10347	_c.Call.Return()
10348	return _c
10349}
10350
10351func (_c *MockImageWidget_SetPixelSize_Call) RunAndReturn(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
10352	_c.Run(run)
10353	return _c
10354}
10355
10356// SetSizeRequest provides a mock function for the type MockImageWidget
10357func (_mock *MockImageWidget) SetSizeRequest(width int, height int) {
10358	_mock.Called(width, height)
10359	return
10360}
10361
10362// MockImageWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
10363type MockImageWidget_SetSizeRequest_Call struct {
10364	*mock.Call
10365}
10366
10367// SetSizeRequest is a helper method to define mock.On call
10368//   - width int
10369//   - height int
10370func (_e *MockImageWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockImageWidget_SetSizeRequest_Call {
10371	return &MockImageWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
10372}
10373
10374func (_c *MockImageWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
10375	_c.Call.Run(func(args mock.Arguments) {
10376		var arg0 int
10377		if args[0] != nil {
10378			arg0 = args[0].(int)
10379		}
10380		var arg1 int
10381		if args[1] != nil {
10382			arg1 = args[1].(int)
10383		}
10384		run(
10385			arg0,
10386			arg1,
10387		)
10388	})
10389	return _c
10390}
10391
10392func (_c *MockImageWidget_SetSizeRequest_Call) Return() *MockImageWidget_SetSizeRequest_Call {
10393	_c.Call.Return()
10394	return _c
10395}
10396
10397func (_c *MockImageWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
10398	_c.Run(run)
10399	return _c
10400}
10401
10402// SetValign provides a mock function for the type MockImageWidget
10403func (_mock *MockImageWidget) SetValign(align gtk.Align) {
10404	_mock.Called(align)
10405	return
10406}
10407
10408// MockImageWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
10409type MockImageWidget_SetValign_Call struct {
10410	*mock.Call
10411}
10412
10413// SetValign is a helper method to define mock.On call
10414//   - align gtk.Align
10415func (_e *MockImageWidget_Expecter) SetValign(align interface{}) *MockImageWidget_SetValign_Call {
10416	return &MockImageWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
10417}
10418
10419func (_c *MockImageWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
10420	_c.Call.Run(func(args mock.Arguments) {
10421		var arg0 gtk.Align
10422		if args[0] != nil {
10423			arg0 = args[0].(gtk.Align)
10424		}
10425		run(
10426			arg0,
10427		)
10428	})
10429	return _c
10430}
10431
10432func (_c *MockImageWidget_SetValign_Call) Return() *MockImageWidget_SetValign_Call {
10433	_c.Call.Return()
10434	return _c
10435}
10436
10437func (_c *MockImageWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
10438	_c.Run(run)
10439	return _c
10440}
10441
10442// SetVexpand provides a mock function for the type MockImageWidget
10443func (_mock *MockImageWidget) SetVexpand(expand bool) {
10444	_mock.Called(expand)
10445	return
10446}
10447
10448// MockImageWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
10449type MockImageWidget_SetVexpand_Call struct {
10450	*mock.Call
10451}
10452
10453// SetVexpand is a helper method to define mock.On call
10454//   - expand bool
10455func (_e *MockImageWidget_Expecter) SetVexpand(expand interface{}) *MockImageWidget_SetVexpand_Call {
10456	return &MockImageWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
10457}
10458
10459func (_c *MockImageWidget_SetVexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
10460	_c.Call.Run(func(args mock.Arguments) {
10461		var arg0 bool
10462		if args[0] != nil {
10463			arg0 = args[0].(bool)
10464		}
10465		run(
10466			arg0,
10467		)
10468	})
10469	return _c
10470}
10471
10472func (_c *MockImageWidget_SetVexpand_Call) Return() *MockImageWidget_SetVexpand_Call {
10473	_c.Call.Return()
10474	return _c
10475}
10476
10477func (_c *MockImageWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
10478	_c.Run(run)
10479	return _c
10480}
10481
10482// SetVisible provides a mock function for the type MockImageWidget
10483func (_mock *MockImageWidget) SetVisible(visible bool) {
10484	_mock.Called(visible)
10485	return
10486}
10487
10488// MockImageWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
10489type MockImageWidget_SetVisible_Call struct {
10490	*mock.Call
10491}
10492
10493// SetVisible is a helper method to define mock.On call
10494//   - visible bool
10495func (_e *MockImageWidget_Expecter) SetVisible(visible interface{}) *MockImageWidget_SetVisible_Call {
10496	return &MockImageWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
10497}
10498
10499func (_c *MockImageWidget_SetVisible_Call) Run(run func(visible bool)) *MockImageWidget_SetVisible_Call {
10500	_c.Call.Run(func(args mock.Arguments) {
10501		var arg0 bool
10502		if args[0] != nil {
10503			arg0 = args[0].(bool)
10504		}
10505		run(
10506			arg0,
10507		)
10508	})
10509	return _c
10510}
10511
10512func (_c *MockImageWidget_SetVisible_Call) Return() *MockImageWidget_SetVisible_Call {
10513	_c.Call.Return()
10514	return _c
10515}
10516
10517func (_c *MockImageWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockImageWidget_SetVisible_Call {
10518	_c.Run(run)
10519	return _c
10520}
10521
10522// Show provides a mock function for the type MockImageWidget
10523func (_mock *MockImageWidget) Show() {
10524	_mock.Called()
10525	return
10526}
10527
10528// MockImageWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
10529type MockImageWidget_Show_Call struct {
10530	*mock.Call
10531}
10532
10533// Show is a helper method to define mock.On call
10534func (_e *MockImageWidget_Expecter) Show() *MockImageWidget_Show_Call {
10535	return &MockImageWidget_Show_Call{Call: _e.mock.On("Show")}
10536}
10537
10538func (_c *MockImageWidget_Show_Call) Run(run func()) *MockImageWidget_Show_Call {
10539	_c.Call.Run(func(args mock.Arguments) {
10540		run()
10541	})
10542	return _c
10543}
10544
10545func (_c *MockImageWidget_Show_Call) Return() *MockImageWidget_Show_Call {
10546	_c.Call.Return()
10547	return _c
10548}
10549
10550func (_c *MockImageWidget_Show_Call) RunAndReturn(run func()) *MockImageWidget_Show_Call {
10551	_c.Run(run)
10552	return _c
10553}
10554
10555// Unparent provides a mock function for the type MockImageWidget
10556func (_mock *MockImageWidget) Unparent() {
10557	_mock.Called()
10558	return
10559}
10560
10561// MockImageWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
10562type MockImageWidget_Unparent_Call struct {
10563	*mock.Call
10564}
10565
10566// Unparent is a helper method to define mock.On call
10567func (_e *MockImageWidget_Expecter) Unparent() *MockImageWidget_Unparent_Call {
10568	return &MockImageWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
10569}
10570
10571func (_c *MockImageWidget_Unparent_Call) Run(run func()) *MockImageWidget_Unparent_Call {
10572	_c.Call.Run(func(args mock.Arguments) {
10573		run()
10574	})
10575	return _c
10576}
10577
10578func (_c *MockImageWidget_Unparent_Call) Return() *MockImageWidget_Unparent_Call {
10579	_c.Call.Return()
10580	return _c
10581}
10582
10583func (_c *MockImageWidget_Unparent_Call) RunAndReturn(run func()) *MockImageWidget_Unparent_Call {
10584	_c.Run(run)
10585	return _c
10586}
10587
10588// 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.
10589// The first argument is typically a *testing.T value.
10590func NewMockProgressBarWidget(t interface {
10591	mock.TestingT
10592	Cleanup(func())
10593}) *MockProgressBarWidget {
10594	mock := &MockProgressBarWidget{}
10595	mock.Mock.Test(t)
10596
10597	t.Cleanup(func() { mock.AssertExpectations(t) })
10598
10599	return mock
10600}
10601
10602// MockProgressBarWidget is an autogenerated mock type for the ProgressBarWidget type
10603type MockProgressBarWidget struct {
10604	mock.Mock
10605}
10606
10607type MockProgressBarWidget_Expecter struct {
10608	mock *mock.Mock
10609}
10610
10611func (_m *MockProgressBarWidget) EXPECT() *MockProgressBarWidget_Expecter {
10612	return &MockProgressBarWidget_Expecter{mock: &_m.Mock}
10613}
10614
10615// AddController provides a mock function for the type MockProgressBarWidget
10616func (_mock *MockProgressBarWidget) AddController(controller *gtk.EventController) {
10617	_mock.Called(controller)
10618	return
10619}
10620
10621// MockProgressBarWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
10622type MockProgressBarWidget_AddController_Call struct {
10623	*mock.Call
10624}
10625
10626// AddController is a helper method to define mock.On call
10627//   - controller *gtk.EventController
10628func (_e *MockProgressBarWidget_Expecter) AddController(controller interface{}) *MockProgressBarWidget_AddController_Call {
10629	return &MockProgressBarWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
10630}
10631
10632func (_c *MockProgressBarWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
10633	_c.Call.Run(func(args mock.Arguments) {
10634		var arg0 *gtk.EventController
10635		if args[0] != nil {
10636			arg0 = args[0].(*gtk.EventController)
10637		}
10638		run(
10639			arg0,
10640		)
10641	})
10642	return _c
10643}
10644
10645func (_c *MockProgressBarWidget_AddController_Call) Return() *MockProgressBarWidget_AddController_Call {
10646	_c.Call.Return()
10647	return _c
10648}
10649
10650func (_c *MockProgressBarWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
10651	_c.Run(run)
10652	return _c
10653}
10654
10655// AddCssClass provides a mock function for the type MockProgressBarWidget
10656func (_mock *MockProgressBarWidget) AddCssClass(cssClass string) {
10657	_mock.Called(cssClass)
10658	return
10659}
10660
10661// MockProgressBarWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
10662type MockProgressBarWidget_AddCssClass_Call struct {
10663	*mock.Call
10664}
10665
10666// AddCssClass is a helper method to define mock.On call
10667//   - cssClass string
10668func (_e *MockProgressBarWidget_Expecter) AddCssClass(cssClass interface{}) *MockProgressBarWidget_AddCssClass_Call {
10669	return &MockProgressBarWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
10670}
10671
10672func (_c *MockProgressBarWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
10673	_c.Call.Run(func(args mock.Arguments) {
10674		var arg0 string
10675		if args[0] != nil {
10676			arg0 = args[0].(string)
10677		}
10678		run(
10679			arg0,
10680		)
10681	})
10682	return _c
10683}
10684
10685func (_c *MockProgressBarWidget_AddCssClass_Call) Return() *MockProgressBarWidget_AddCssClass_Call {
10686	_c.Call.Return()
10687	return _c
10688}
10689
10690func (_c *MockProgressBarWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
10691	_c.Run(run)
10692	return _c
10693}
10694
10695// ComputePoint provides a mock function for the type MockProgressBarWidget
10696func (_mock *MockProgressBarWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
10697	ret := _mock.Called(target)
10698
10699	if len(ret) == 0 {
10700		panic("no return value specified for ComputePoint")
10701	}
10702
10703	var r0 float64
10704	var r1 float64
10705	var r2 bool
10706	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
10707		return returnFunc(target)
10708	}
10709	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
10710		r0 = returnFunc(target)
10711	} else {
10712		r0 = ret.Get(0).(float64)
10713	}
10714	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
10715		r1 = returnFunc(target)
10716	} else {
10717		r1 = ret.Get(1).(float64)
10718	}
10719	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
10720		r2 = returnFunc(target)
10721	} else {
10722		r2 = ret.Get(2).(bool)
10723	}
10724	return r0, r1, r2
10725}
10726
10727// MockProgressBarWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
10728type MockProgressBarWidget_ComputePoint_Call struct {
10729	*mock.Call
10730}
10731
10732// ComputePoint is a helper method to define mock.On call
10733//   - target layout.Widget
10734func (_e *MockProgressBarWidget_Expecter) ComputePoint(target interface{}) *MockProgressBarWidget_ComputePoint_Call {
10735	return &MockProgressBarWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
10736}
10737
10738func (_c *MockProgressBarWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockProgressBarWidget_ComputePoint_Call {
10739	_c.Call.Run(func(args mock.Arguments) {
10740		var arg0 layout.Widget
10741		if args[0] != nil {
10742			arg0 = args[0].(layout.Widget)
10743		}
10744		run(
10745			arg0,
10746		)
10747	})
10748	return _c
10749}
10750
10751func (_c *MockProgressBarWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockProgressBarWidget_ComputePoint_Call {
10752	_c.Call.Return(x, y, ok)
10753	return _c
10754}
10755
10756func (_c *MockProgressBarWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockProgressBarWidget_ComputePoint_Call {
10757	_c.Call.Return(run)
10758	return _c
10759}
10760
10761// GetAllocatedHeight provides a mock function for the type MockProgressBarWidget
10762func (_mock *MockProgressBarWidget) GetAllocatedHeight() int {
10763	ret := _mock.Called()
10764
10765	if len(ret) == 0 {
10766		panic("no return value specified for GetAllocatedHeight")
10767	}
10768
10769	var r0 int
10770	if returnFunc, ok := ret.Get(0).(func() int); ok {
10771		r0 = returnFunc()
10772	} else {
10773		r0 = ret.Get(0).(int)
10774	}
10775	return r0
10776}
10777
10778// MockProgressBarWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
10779type MockProgressBarWidget_GetAllocatedHeight_Call struct {
10780	*mock.Call
10781}
10782
10783// GetAllocatedHeight is a helper method to define mock.On call
10784func (_e *MockProgressBarWidget_Expecter) GetAllocatedHeight() *MockProgressBarWidget_GetAllocatedHeight_Call {
10785	return &MockProgressBarWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
10786}
10787
10788func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedHeight_Call {
10789	_c.Call.Run(func(args mock.Arguments) {
10790		run()
10791	})
10792	return _c
10793}
10794
10795func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Return(n int) *MockProgressBarWidget_GetAllocatedHeight_Call {
10796	_c.Call.Return(n)
10797	return _c
10798}
10799
10800func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedHeight_Call {
10801	_c.Call.Return(run)
10802	return _c
10803}
10804
10805// GetAllocatedWidth provides a mock function for the type MockProgressBarWidget
10806func (_mock *MockProgressBarWidget) GetAllocatedWidth() int {
10807	ret := _mock.Called()
10808
10809	if len(ret) == 0 {
10810		panic("no return value specified for GetAllocatedWidth")
10811	}
10812
10813	var r0 int
10814	if returnFunc, ok := ret.Get(0).(func() int); ok {
10815		r0 = returnFunc()
10816	} else {
10817		r0 = ret.Get(0).(int)
10818	}
10819	return r0
10820}
10821
10822// MockProgressBarWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
10823type MockProgressBarWidget_GetAllocatedWidth_Call struct {
10824	*mock.Call
10825}
10826
10827// GetAllocatedWidth is a helper method to define mock.On call
10828func (_e *MockProgressBarWidget_Expecter) GetAllocatedWidth() *MockProgressBarWidget_GetAllocatedWidth_Call {
10829	return &MockProgressBarWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
10830}
10831
10832func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedWidth_Call {
10833	_c.Call.Run(func(args mock.Arguments) {
10834		run()
10835	})
10836	return _c
10837}
10838
10839func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Return(n int) *MockProgressBarWidget_GetAllocatedWidth_Call {
10840	_c.Call.Return(n)
10841	return _c
10842}
10843
10844func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedWidth_Call {
10845	_c.Call.Return(run)
10846	return _c
10847}
10848
10849// GetFraction provides a mock function for the type MockProgressBarWidget
10850func (_mock *MockProgressBarWidget) GetFraction() float64 {
10851	ret := _mock.Called()
10852
10853	if len(ret) == 0 {
10854		panic("no return value specified for GetFraction")
10855	}
10856
10857	var r0 float64
10858	if returnFunc, ok := ret.Get(0).(func() float64); ok {
10859		r0 = returnFunc()
10860	} else {
10861		r0 = ret.Get(0).(float64)
10862	}
10863	return r0
10864}
10865
10866// MockProgressBarWidget_GetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFraction'
10867type MockProgressBarWidget_GetFraction_Call struct {
10868	*mock.Call
10869}
10870
10871// GetFraction is a helper method to define mock.On call
10872func (_e *MockProgressBarWidget_Expecter) GetFraction() *MockProgressBarWidget_GetFraction_Call {
10873	return &MockProgressBarWidget_GetFraction_Call{Call: _e.mock.On("GetFraction")}
10874}
10875
10876func (_c *MockProgressBarWidget_GetFraction_Call) Run(run func()) *MockProgressBarWidget_GetFraction_Call {
10877	_c.Call.Run(func(args mock.Arguments) {
10878		run()
10879	})
10880	return _c
10881}
10882
10883func (_c *MockProgressBarWidget_GetFraction_Call) Return(f float64) *MockProgressBarWidget_GetFraction_Call {
10884	_c.Call.Return(f)
10885	return _c
10886}
10887
10888func (_c *MockProgressBarWidget_GetFraction_Call) RunAndReturn(run func() float64) *MockProgressBarWidget_GetFraction_Call {
10889	_c.Call.Return(run)
10890	return _c
10891}
10892
10893// GetHexpand provides a mock function for the type MockProgressBarWidget
10894func (_mock *MockProgressBarWidget) GetHexpand() bool {
10895	ret := _mock.Called()
10896
10897	if len(ret) == 0 {
10898		panic("no return value specified for GetHexpand")
10899	}
10900
10901	var r0 bool
10902	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10903		r0 = returnFunc()
10904	} else {
10905		r0 = ret.Get(0).(bool)
10906	}
10907	return r0
10908}
10909
10910// MockProgressBarWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
10911type MockProgressBarWidget_GetHexpand_Call struct {
10912	*mock.Call
10913}
10914
10915// GetHexpand is a helper method to define mock.On call
10916func (_e *MockProgressBarWidget_Expecter) GetHexpand() *MockProgressBarWidget_GetHexpand_Call {
10917	return &MockProgressBarWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
10918}
10919
10920func (_c *MockProgressBarWidget_GetHexpand_Call) Run(run func()) *MockProgressBarWidget_GetHexpand_Call {
10921	_c.Call.Run(func(args mock.Arguments) {
10922		run()
10923	})
10924	return _c
10925}
10926
10927func (_c *MockProgressBarWidget_GetHexpand_Call) Return(b bool) *MockProgressBarWidget_GetHexpand_Call {
10928	_c.Call.Return(b)
10929	return _c
10930}
10931
10932func (_c *MockProgressBarWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetHexpand_Call {
10933	_c.Call.Return(run)
10934	return _c
10935}
10936
10937// GetParent provides a mock function for the type MockProgressBarWidget
10938func (_mock *MockProgressBarWidget) GetParent() layout.Widget {
10939	ret := _mock.Called()
10940
10941	if len(ret) == 0 {
10942		panic("no return value specified for GetParent")
10943	}
10944
10945	var r0 layout.Widget
10946	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
10947		r0 = returnFunc()
10948	} else {
10949		if ret.Get(0) != nil {
10950			r0 = ret.Get(0).(layout.Widget)
10951		}
10952	}
10953	return r0
10954}
10955
10956// MockProgressBarWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
10957type MockProgressBarWidget_GetParent_Call struct {
10958	*mock.Call
10959}
10960
10961// GetParent is a helper method to define mock.On call
10962func (_e *MockProgressBarWidget_Expecter) GetParent() *MockProgressBarWidget_GetParent_Call {
10963	return &MockProgressBarWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
10964}
10965
10966func (_c *MockProgressBarWidget_GetParent_Call) Run(run func()) *MockProgressBarWidget_GetParent_Call {
10967	_c.Call.Run(func(args mock.Arguments) {
10968		run()
10969	})
10970	return _c
10971}
10972
10973func (_c *MockProgressBarWidget_GetParent_Call) Return(widget layout.Widget) *MockProgressBarWidget_GetParent_Call {
10974	_c.Call.Return(widget)
10975	return _c
10976}
10977
10978func (_c *MockProgressBarWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockProgressBarWidget_GetParent_Call {
10979	_c.Call.Return(run)
10980	return _c
10981}
10982
10983// GetVexpand provides a mock function for the type MockProgressBarWidget
10984func (_mock *MockProgressBarWidget) GetVexpand() bool {
10985	ret := _mock.Called()
10986
10987	if len(ret) == 0 {
10988		panic("no return value specified for GetVexpand")
10989	}
10990
10991	var r0 bool
10992	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10993		r0 = returnFunc()
10994	} else {
10995		r0 = ret.Get(0).(bool)
10996	}
10997	return r0
10998}
10999
11000// MockProgressBarWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
11001type MockProgressBarWidget_GetVexpand_Call struct {
11002	*mock.Call
11003}
11004
11005// GetVexpand is a helper method to define mock.On call
11006func (_e *MockProgressBarWidget_Expecter) GetVexpand() *MockProgressBarWidget_GetVexpand_Call {
11007	return &MockProgressBarWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
11008}
11009
11010func (_c *MockProgressBarWidget_GetVexpand_Call) Run(run func()) *MockProgressBarWidget_GetVexpand_Call {
11011	_c.Call.Run(func(args mock.Arguments) {
11012		run()
11013	})
11014	return _c
11015}
11016
11017func (_c *MockProgressBarWidget_GetVexpand_Call) Return(b bool) *MockProgressBarWidget_GetVexpand_Call {
11018	_c.Call.Return(b)
11019	return _c
11020}
11021
11022func (_c *MockProgressBarWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetVexpand_Call {
11023	_c.Call.Return(run)
11024	return _c
11025}
11026
11027// GrabFocus provides a mock function for the type MockProgressBarWidget
11028func (_mock *MockProgressBarWidget) GrabFocus() bool {
11029	ret := _mock.Called()
11030
11031	if len(ret) == 0 {
11032		panic("no return value specified for GrabFocus")
11033	}
11034
11035	var r0 bool
11036	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11037		r0 = returnFunc()
11038	} else {
11039		r0 = ret.Get(0).(bool)
11040	}
11041	return r0
11042}
11043
11044// MockProgressBarWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
11045type MockProgressBarWidget_GrabFocus_Call struct {
11046	*mock.Call
11047}
11048
11049// GrabFocus is a helper method to define mock.On call
11050func (_e *MockProgressBarWidget_Expecter) GrabFocus() *MockProgressBarWidget_GrabFocus_Call {
11051	return &MockProgressBarWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
11052}
11053
11054func (_c *MockProgressBarWidget_GrabFocus_Call) Run(run func()) *MockProgressBarWidget_GrabFocus_Call {
11055	_c.Call.Run(func(args mock.Arguments) {
11056		run()
11057	})
11058	return _c
11059}
11060
11061func (_c *MockProgressBarWidget_GrabFocus_Call) Return(b bool) *MockProgressBarWidget_GrabFocus_Call {
11062	_c.Call.Return(b)
11063	return _c
11064}
11065
11066func (_c *MockProgressBarWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GrabFocus_Call {
11067	_c.Call.Return(run)
11068	return _c
11069}
11070
11071// GtkWidget provides a mock function for the type MockProgressBarWidget
11072func (_mock *MockProgressBarWidget) GtkWidget() *gtk.Widget {
11073	ret := _mock.Called()
11074
11075	if len(ret) == 0 {
11076		panic("no return value specified for GtkWidget")
11077	}
11078
11079	var r0 *gtk.Widget
11080	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
11081		r0 = returnFunc()
11082	} else {
11083		if ret.Get(0) != nil {
11084			r0 = ret.Get(0).(*gtk.Widget)
11085		}
11086	}
11087	return r0
11088}
11089
11090// MockProgressBarWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
11091type MockProgressBarWidget_GtkWidget_Call struct {
11092	*mock.Call
11093}
11094
11095// GtkWidget is a helper method to define mock.On call
11096func (_e *MockProgressBarWidget_Expecter) GtkWidget() *MockProgressBarWidget_GtkWidget_Call {
11097	return &MockProgressBarWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
11098}
11099
11100func (_c *MockProgressBarWidget_GtkWidget_Call) Run(run func()) *MockProgressBarWidget_GtkWidget_Call {
11101	_c.Call.Run(func(args mock.Arguments) {
11102		run()
11103	})
11104	return _c
11105}
11106
11107func (_c *MockProgressBarWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
11108	_c.Call.Return(widget)
11109	return _c
11110}
11111
11112func (_c *MockProgressBarWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
11113	_c.Call.Return(run)
11114	return _c
11115}
11116
11117// HasCssClass provides a mock function for the type MockProgressBarWidget
11118func (_mock *MockProgressBarWidget) HasCssClass(cssClass string) bool {
11119	ret := _mock.Called(cssClass)
11120
11121	if len(ret) == 0 {
11122		panic("no return value specified for HasCssClass")
11123	}
11124
11125	var r0 bool
11126	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
11127		r0 = returnFunc(cssClass)
11128	} else {
11129		r0 = ret.Get(0).(bool)
11130	}
11131	return r0
11132}
11133
11134// MockProgressBarWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
11135type MockProgressBarWidget_HasCssClass_Call struct {
11136	*mock.Call
11137}
11138
11139// HasCssClass is a helper method to define mock.On call
11140//   - cssClass string
11141func (_e *MockProgressBarWidget_Expecter) HasCssClass(cssClass interface{}) *MockProgressBarWidget_HasCssClass_Call {
11142	return &MockProgressBarWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
11143}
11144
11145func (_c *MockProgressBarWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_HasCssClass_Call {
11146	_c.Call.Run(func(args mock.Arguments) {
11147		var arg0 string
11148		if args[0] != nil {
11149			arg0 = args[0].(string)
11150		}
11151		run(
11152			arg0,
11153		)
11154	})
11155	return _c
11156}
11157
11158func (_c *MockProgressBarWidget_HasCssClass_Call) Return(b bool) *MockProgressBarWidget_HasCssClass_Call {
11159	_c.Call.Return(b)
11160	return _c
11161}
11162
11163func (_c *MockProgressBarWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockProgressBarWidget_HasCssClass_Call {
11164	_c.Call.Return(run)
11165	return _c
11166}
11167
11168// HasFocus provides a mock function for the type MockProgressBarWidget
11169func (_mock *MockProgressBarWidget) HasFocus() bool {
11170	ret := _mock.Called()
11171
11172	if len(ret) == 0 {
11173		panic("no return value specified for HasFocus")
11174	}
11175
11176	var r0 bool
11177	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11178		r0 = returnFunc()
11179	} else {
11180		r0 = ret.Get(0).(bool)
11181	}
11182	return r0
11183}
11184
11185// MockProgressBarWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
11186type MockProgressBarWidget_HasFocus_Call struct {
11187	*mock.Call
11188}
11189
11190// HasFocus is a helper method to define mock.On call
11191func (_e *MockProgressBarWidget_Expecter) HasFocus() *MockProgressBarWidget_HasFocus_Call {
11192	return &MockProgressBarWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
11193}
11194
11195func (_c *MockProgressBarWidget_HasFocus_Call) Run(run func()) *MockProgressBarWidget_HasFocus_Call {
11196	_c.Call.Run(func(args mock.Arguments) {
11197		run()
11198	})
11199	return _c
11200}
11201
11202func (_c *MockProgressBarWidget_HasFocus_Call) Return(b bool) *MockProgressBarWidget_HasFocus_Call {
11203	_c.Call.Return(b)
11204	return _c
11205}
11206
11207func (_c *MockProgressBarWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_HasFocus_Call {
11208	_c.Call.Return(run)
11209	return _c
11210}
11211
11212// Hide provides a mock function for the type MockProgressBarWidget
11213func (_mock *MockProgressBarWidget) Hide() {
11214	_mock.Called()
11215	return
11216}
11217
11218// MockProgressBarWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
11219type MockProgressBarWidget_Hide_Call struct {
11220	*mock.Call
11221}
11222
11223// Hide is a helper method to define mock.On call
11224func (_e *MockProgressBarWidget_Expecter) Hide() *MockProgressBarWidget_Hide_Call {
11225	return &MockProgressBarWidget_Hide_Call{Call: _e.mock.On("Hide")}
11226}
11227
11228func (_c *MockProgressBarWidget_Hide_Call) Run(run func()) *MockProgressBarWidget_Hide_Call {
11229	_c.Call.Run(func(args mock.Arguments) {
11230		run()
11231	})
11232	return _c
11233}
11234
11235func (_c *MockProgressBarWidget_Hide_Call) Return() *MockProgressBarWidget_Hide_Call {
11236	_c.Call.Return()
11237	return _c
11238}
11239
11240func (_c *MockProgressBarWidget_Hide_Call) RunAndReturn(run func()) *MockProgressBarWidget_Hide_Call {
11241	_c.Run(run)
11242	return _c
11243}
11244
11245// IsVisible provides a mock function for the type MockProgressBarWidget
11246func (_mock *MockProgressBarWidget) IsVisible() bool {
11247	ret := _mock.Called()
11248
11249	if len(ret) == 0 {
11250		panic("no return value specified for IsVisible")
11251	}
11252
11253	var r0 bool
11254	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11255		r0 = returnFunc()
11256	} else {
11257		r0 = ret.Get(0).(bool)
11258	}
11259	return r0
11260}
11261
11262// MockProgressBarWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
11263type MockProgressBarWidget_IsVisible_Call struct {
11264	*mock.Call
11265}
11266
11267// IsVisible is a helper method to define mock.On call
11268func (_e *MockProgressBarWidget_Expecter) IsVisible() *MockProgressBarWidget_IsVisible_Call {
11269	return &MockProgressBarWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
11270}
11271
11272func (_c *MockProgressBarWidget_IsVisible_Call) Run(run func()) *MockProgressBarWidget_IsVisible_Call {
11273	_c.Call.Run(func(args mock.Arguments) {
11274		run()
11275	})
11276	return _c
11277}
11278
11279func (_c *MockProgressBarWidget_IsVisible_Call) Return(b bool) *MockProgressBarWidget_IsVisible_Call {
11280	_c.Call.Return(b)
11281	return _c
11282}
11283
11284func (_c *MockProgressBarWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_IsVisible_Call {
11285	_c.Call.Return(run)
11286	return _c
11287}
11288
11289// RemoveCssClass provides a mock function for the type MockProgressBarWidget
11290func (_mock *MockProgressBarWidget) RemoveCssClass(cssClass string) {
11291	_mock.Called(cssClass)
11292	return
11293}
11294
11295// MockProgressBarWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
11296type MockProgressBarWidget_RemoveCssClass_Call struct {
11297	*mock.Call
11298}
11299
11300// RemoveCssClass is a helper method to define mock.On call
11301//   - cssClass string
11302func (_e *MockProgressBarWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockProgressBarWidget_RemoveCssClass_Call {
11303	return &MockProgressBarWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
11304}
11305
11306func (_c *MockProgressBarWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
11307	_c.Call.Run(func(args mock.Arguments) {
11308		var arg0 string
11309		if args[0] != nil {
11310			arg0 = args[0].(string)
11311		}
11312		run(
11313			arg0,
11314		)
11315	})
11316	return _c
11317}
11318
11319func (_c *MockProgressBarWidget_RemoveCssClass_Call) Return() *MockProgressBarWidget_RemoveCssClass_Call {
11320	_c.Call.Return()
11321	return _c
11322}
11323
11324func (_c *MockProgressBarWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
11325	_c.Run(run)
11326	return _c
11327}
11328
11329// SetCanFocus provides a mock function for the type MockProgressBarWidget
11330func (_mock *MockProgressBarWidget) SetCanFocus(canFocus bool) {
11331	_mock.Called(canFocus)
11332	return
11333}
11334
11335// MockProgressBarWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
11336type MockProgressBarWidget_SetCanFocus_Call struct {
11337	*mock.Call
11338}
11339
11340// SetCanFocus is a helper method to define mock.On call
11341//   - canFocus bool
11342func (_e *MockProgressBarWidget_Expecter) SetCanFocus(canFocus interface{}) *MockProgressBarWidget_SetCanFocus_Call {
11343	return &MockProgressBarWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
11344}
11345
11346func (_c *MockProgressBarWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
11347	_c.Call.Run(func(args mock.Arguments) {
11348		var arg0 bool
11349		if args[0] != nil {
11350			arg0 = args[0].(bool)
11351		}
11352		run(
11353			arg0,
11354		)
11355	})
11356	return _c
11357}
11358
11359func (_c *MockProgressBarWidget_SetCanFocus_Call) Return() *MockProgressBarWidget_SetCanFocus_Call {
11360	_c.Call.Return()
11361	return _c
11362}
11363
11364func (_c *MockProgressBarWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
11365	_c.Run(run)
11366	return _c
11367}
11368
11369// SetCanTarget provides a mock function for the type MockProgressBarWidget
11370func (_mock *MockProgressBarWidget) SetCanTarget(canTarget bool) {
11371	_mock.Called(canTarget)
11372	return
11373}
11374
11375// MockProgressBarWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
11376type MockProgressBarWidget_SetCanTarget_Call struct {
11377	*mock.Call
11378}
11379
11380// SetCanTarget is a helper method to define mock.On call
11381//   - canTarget bool
11382func (_e *MockProgressBarWidget_Expecter) SetCanTarget(canTarget interface{}) *MockProgressBarWidget_SetCanTarget_Call {
11383	return &MockProgressBarWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
11384}
11385
11386func (_c *MockProgressBarWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
11387	_c.Call.Run(func(args mock.Arguments) {
11388		var arg0 bool
11389		if args[0] != nil {
11390			arg0 = args[0].(bool)
11391		}
11392		run(
11393			arg0,
11394		)
11395	})
11396	return _c
11397}
11398
11399func (_c *MockProgressBarWidget_SetCanTarget_Call) Return() *MockProgressBarWidget_SetCanTarget_Call {
11400	_c.Call.Return()
11401	return _c
11402}
11403
11404func (_c *MockProgressBarWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
11405	_c.Run(run)
11406	return _c
11407}
11408
11409// SetFocusOnClick provides a mock function for the type MockProgressBarWidget
11410func (_mock *MockProgressBarWidget) SetFocusOnClick(focusOnClick bool) {
11411	_mock.Called(focusOnClick)
11412	return
11413}
11414
11415// MockProgressBarWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
11416type MockProgressBarWidget_SetFocusOnClick_Call struct {
11417	*mock.Call
11418}
11419
11420// SetFocusOnClick is a helper method to define mock.On call
11421//   - focusOnClick bool
11422func (_e *MockProgressBarWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockProgressBarWidget_SetFocusOnClick_Call {
11423	return &MockProgressBarWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
11424}
11425
11426func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
11427	_c.Call.Run(func(args mock.Arguments) {
11428		var arg0 bool
11429		if args[0] != nil {
11430			arg0 = args[0].(bool)
11431		}
11432		run(
11433			arg0,
11434		)
11435	})
11436	return _c
11437}
11438
11439func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Return() *MockProgressBarWidget_SetFocusOnClick_Call {
11440	_c.Call.Return()
11441	return _c
11442}
11443
11444func (_c *MockProgressBarWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
11445	_c.Run(run)
11446	return _c
11447}
11448
11449// SetFocusable provides a mock function for the type MockProgressBarWidget
11450func (_mock *MockProgressBarWidget) SetFocusable(focusable bool) {
11451	_mock.Called(focusable)
11452	return
11453}
11454
11455// MockProgressBarWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
11456type MockProgressBarWidget_SetFocusable_Call struct {
11457	*mock.Call
11458}
11459
11460// SetFocusable is a helper method to define mock.On call
11461//   - focusable bool
11462func (_e *MockProgressBarWidget_Expecter) SetFocusable(focusable interface{}) *MockProgressBarWidget_SetFocusable_Call {
11463	return &MockProgressBarWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
11464}
11465
11466func (_c *MockProgressBarWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockProgressBarWidget_SetFocusable_Call {
11467	_c.Call.Run(func(args mock.Arguments) {
11468		var arg0 bool
11469		if args[0] != nil {
11470			arg0 = args[0].(bool)
11471		}
11472		run(
11473			arg0,
11474		)
11475	})
11476	return _c
11477}
11478
11479func (_c *MockProgressBarWidget_SetFocusable_Call) Return() *MockProgressBarWidget_SetFocusable_Call {
11480	_c.Call.Return()
11481	return _c
11482}
11483
11484func (_c *MockProgressBarWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockProgressBarWidget_SetFocusable_Call {
11485	_c.Run(run)
11486	return _c
11487}
11488
11489// SetFraction provides a mock function for the type MockProgressBarWidget
11490func (_mock *MockProgressBarWidget) SetFraction(fraction float64) {
11491	_mock.Called(fraction)
11492	return
11493}
11494
11495// MockProgressBarWidget_SetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFraction'
11496type MockProgressBarWidget_SetFraction_Call struct {
11497	*mock.Call
11498}
11499
11500// SetFraction is a helper method to define mock.On call
11501//   - fraction float64
11502func (_e *MockProgressBarWidget_Expecter) SetFraction(fraction interface{}) *MockProgressBarWidget_SetFraction_Call {
11503	return &MockProgressBarWidget_SetFraction_Call{Call: _e.mock.On("SetFraction", fraction)}
11504}
11505
11506func (_c *MockProgressBarWidget_SetFraction_Call) Run(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
11507	_c.Call.Run(func(args mock.Arguments) {
11508		var arg0 float64
11509		if args[0] != nil {
11510			arg0 = args[0].(float64)
11511		}
11512		run(
11513			arg0,
11514		)
11515	})
11516	return _c
11517}
11518
11519func (_c *MockProgressBarWidget_SetFraction_Call) Return() *MockProgressBarWidget_SetFraction_Call {
11520	_c.Call.Return()
11521	return _c
11522}
11523
11524func (_c *MockProgressBarWidget_SetFraction_Call) RunAndReturn(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
11525	_c.Run(run)
11526	return _c
11527}
11528
11529// SetHalign provides a mock function for the type MockProgressBarWidget
11530func (_mock *MockProgressBarWidget) SetHalign(align gtk.Align) {
11531	_mock.Called(align)
11532	return
11533}
11534
11535// MockProgressBarWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
11536type MockProgressBarWidget_SetHalign_Call struct {
11537	*mock.Call
11538}
11539
11540// SetHalign is a helper method to define mock.On call
11541//   - align gtk.Align
11542func (_e *MockProgressBarWidget_Expecter) SetHalign(align interface{}) *MockProgressBarWidget_SetHalign_Call {
11543	return &MockProgressBarWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
11544}
11545
11546func (_c *MockProgressBarWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
11547	_c.Call.Run(func(args mock.Arguments) {
11548		var arg0 gtk.Align
11549		if args[0] != nil {
11550			arg0 = args[0].(gtk.Align)
11551		}
11552		run(
11553			arg0,
11554		)
11555	})
11556	return _c
11557}
11558
11559func (_c *MockProgressBarWidget_SetHalign_Call) Return() *MockProgressBarWidget_SetHalign_Call {
11560	_c.Call.Return()
11561	return _c
11562}
11563
11564func (_c *MockProgressBarWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
11565	_c.Run(run)
11566	return _c
11567}
11568
11569// SetHexpand provides a mock function for the type MockProgressBarWidget
11570func (_mock *MockProgressBarWidget) SetHexpand(expand bool) {
11571	_mock.Called(expand)
11572	return
11573}
11574
11575// MockProgressBarWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
11576type MockProgressBarWidget_SetHexpand_Call struct {
11577	*mock.Call
11578}
11579
11580// SetHexpand is a helper method to define mock.On call
11581//   - expand bool
11582func (_e *MockProgressBarWidget_Expecter) SetHexpand(expand interface{}) *MockProgressBarWidget_SetHexpand_Call {
11583	return &MockProgressBarWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
11584}
11585
11586func (_c *MockProgressBarWidget_SetHexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
11587	_c.Call.Run(func(args mock.Arguments) {
11588		var arg0 bool
11589		if args[0] != nil {
11590			arg0 = args[0].(bool)
11591		}
11592		run(
11593			arg0,
11594		)
11595	})
11596	return _c
11597}
11598
11599func (_c *MockProgressBarWidget_SetHexpand_Call) Return() *MockProgressBarWidget_SetHexpand_Call {
11600	_c.Call.Return()
11601	return _c
11602}
11603
11604func (_c *MockProgressBarWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
11605	_c.Run(run)
11606	return _c
11607}
11608
11609// SetSizeRequest provides a mock function for the type MockProgressBarWidget
11610func (_mock *MockProgressBarWidget) SetSizeRequest(width int, height int) {
11611	_mock.Called(width, height)
11612	return
11613}
11614
11615// MockProgressBarWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
11616type MockProgressBarWidget_SetSizeRequest_Call struct {
11617	*mock.Call
11618}
11619
11620// SetSizeRequest is a helper method to define mock.On call
11621//   - width int
11622//   - height int
11623func (_e *MockProgressBarWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockProgressBarWidget_SetSizeRequest_Call {
11624	return &MockProgressBarWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
11625}
11626
11627func (_c *MockProgressBarWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
11628	_c.Call.Run(func(args mock.Arguments) {
11629		var arg0 int
11630		if args[0] != nil {
11631			arg0 = args[0].(int)
11632		}
11633		var arg1 int
11634		if args[1] != nil {
11635			arg1 = args[1].(int)
11636		}
11637		run(
11638			arg0,
11639			arg1,
11640		)
11641	})
11642	return _c
11643}
11644
11645func (_c *MockProgressBarWidget_SetSizeRequest_Call) Return() *MockProgressBarWidget_SetSizeRequest_Call {
11646	_c.Call.Return()
11647	return _c
11648}
11649
11650func (_c *MockProgressBarWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
11651	_c.Run(run)
11652	return _c
11653}
11654
11655// SetValign provides a mock function for the type MockProgressBarWidget
11656func (_mock *MockProgressBarWidget) SetValign(align gtk.Align) {
11657	_mock.Called(align)
11658	return
11659}
11660
11661// MockProgressBarWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
11662type MockProgressBarWidget_SetValign_Call struct {
11663	*mock.Call
11664}
11665
11666// SetValign is a helper method to define mock.On call
11667//   - align gtk.Align
11668func (_e *MockProgressBarWidget_Expecter) SetValign(align interface{}) *MockProgressBarWidget_SetValign_Call {
11669	return &MockProgressBarWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
11670}
11671
11672func (_c *MockProgressBarWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
11673	_c.Call.Run(func(args mock.Arguments) {
11674		var arg0 gtk.Align
11675		if args[0] != nil {
11676			arg0 = args[0].(gtk.Align)
11677		}
11678		run(
11679			arg0,
11680		)
11681	})
11682	return _c
11683}
11684
11685func (_c *MockProgressBarWidget_SetValign_Call) Return() *MockProgressBarWidget_SetValign_Call {
11686	_c.Call.Return()
11687	return _c
11688}
11689
11690func (_c *MockProgressBarWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
11691	_c.Run(run)
11692	return _c
11693}
11694
11695// SetVexpand provides a mock function for the type MockProgressBarWidget
11696func (_mock *MockProgressBarWidget) SetVexpand(expand bool) {
11697	_mock.Called(expand)
11698	return
11699}
11700
11701// MockProgressBarWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
11702type MockProgressBarWidget_SetVexpand_Call struct {
11703	*mock.Call
11704}
11705
11706// SetVexpand is a helper method to define mock.On call
11707//   - expand bool
11708func (_e *MockProgressBarWidget_Expecter) SetVexpand(expand interface{}) *MockProgressBarWidget_SetVexpand_Call {
11709	return &MockProgressBarWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
11710}
11711
11712func (_c *MockProgressBarWidget_SetVexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
11713	_c.Call.Run(func(args mock.Arguments) {
11714		var arg0 bool
11715		if args[0] != nil {
11716			arg0 = args[0].(bool)
11717		}
11718		run(
11719			arg0,
11720		)
11721	})
11722	return _c
11723}
11724
11725func (_c *MockProgressBarWidget_SetVexpand_Call) Return() *MockProgressBarWidget_SetVexpand_Call {
11726	_c.Call.Return()
11727	return _c
11728}
11729
11730func (_c *MockProgressBarWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
11731	_c.Run(run)
11732	return _c
11733}
11734
11735// SetVisible provides a mock function for the type MockProgressBarWidget
11736func (_mock *MockProgressBarWidget) SetVisible(visible bool) {
11737	_mock.Called(visible)
11738	return
11739}
11740
11741// MockProgressBarWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
11742type MockProgressBarWidget_SetVisible_Call struct {
11743	*mock.Call
11744}
11745
11746// SetVisible is a helper method to define mock.On call
11747//   - visible bool
11748func (_e *MockProgressBarWidget_Expecter) SetVisible(visible interface{}) *MockProgressBarWidget_SetVisible_Call {
11749	return &MockProgressBarWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
11750}
11751
11752func (_c *MockProgressBarWidget_SetVisible_Call) Run(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
11753	_c.Call.Run(func(args mock.Arguments) {
11754		var arg0 bool
11755		if args[0] != nil {
11756			arg0 = args[0].(bool)
11757		}
11758		run(
11759			arg0,
11760		)
11761	})
11762	return _c
11763}
11764
11765func (_c *MockProgressBarWidget_SetVisible_Call) Return() *MockProgressBarWidget_SetVisible_Call {
11766	_c.Call.Return()
11767	return _c
11768}
11769
11770func (_c *MockProgressBarWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
11771	_c.Run(run)
11772	return _c
11773}
11774
11775// Show provides a mock function for the type MockProgressBarWidget
11776func (_mock *MockProgressBarWidget) Show() {
11777	_mock.Called()
11778	return
11779}
11780
11781// MockProgressBarWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
11782type MockProgressBarWidget_Show_Call struct {
11783	*mock.Call
11784}
11785
11786// Show is a helper method to define mock.On call
11787func (_e *MockProgressBarWidget_Expecter) Show() *MockProgressBarWidget_Show_Call {
11788	return &MockProgressBarWidget_Show_Call{Call: _e.mock.On("Show")}
11789}
11790
11791func (_c *MockProgressBarWidget_Show_Call) Run(run func()) *MockProgressBarWidget_Show_Call {
11792	_c.Call.Run(func(args mock.Arguments) {
11793		run()
11794	})
11795	return _c
11796}
11797
11798func (_c *MockProgressBarWidget_Show_Call) Return() *MockProgressBarWidget_Show_Call {
11799	_c.Call.Return()
11800	return _c
11801}
11802
11803func (_c *MockProgressBarWidget_Show_Call) RunAndReturn(run func()) *MockProgressBarWidget_Show_Call {
11804	_c.Run(run)
11805	return _c
11806}
11807
11808// Unparent provides a mock function for the type MockProgressBarWidget
11809func (_mock *MockProgressBarWidget) Unparent() {
11810	_mock.Called()
11811	return
11812}
11813
11814// MockProgressBarWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
11815type MockProgressBarWidget_Unparent_Call struct {
11816	*mock.Call
11817}
11818
11819// Unparent is a helper method to define mock.On call
11820func (_e *MockProgressBarWidget_Expecter) Unparent() *MockProgressBarWidget_Unparent_Call {
11821	return &MockProgressBarWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
11822}
11823
11824func (_c *MockProgressBarWidget_Unparent_Call) Run(run func()) *MockProgressBarWidget_Unparent_Call {
11825	_c.Call.Run(func(args mock.Arguments) {
11826		run()
11827	})
11828	return _c
11829}
11830
11831func (_c *MockProgressBarWidget_Unparent_Call) Return() *MockProgressBarWidget_Unparent_Call {
11832	_c.Call.Return()
11833	return _c
11834}
11835
11836func (_c *MockProgressBarWidget_Unparent_Call) RunAndReturn(run func()) *MockProgressBarWidget_Unparent_Call {
11837	_c.Run(run)
11838	return _c
11839}
11840
11841// NewMockSpinnerWidget creates a new instance of MockSpinnerWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11842// The first argument is typically a *testing.T value.
11843func NewMockSpinnerWidget(t interface {
11844	mock.TestingT
11845	Cleanup(func())
11846}) *MockSpinnerWidget {
11847	mock := &MockSpinnerWidget{}
11848	mock.Mock.Test(t)
11849
11850	t.Cleanup(func() { mock.AssertExpectations(t) })
11851
11852	return mock
11853}
11854
11855// MockSpinnerWidget is an autogenerated mock type for the SpinnerWidget type
11856type MockSpinnerWidget struct {
11857	mock.Mock
11858}
11859
11860type MockSpinnerWidget_Expecter struct {
11861	mock *mock.Mock
11862}
11863
11864func (_m *MockSpinnerWidget) EXPECT() *MockSpinnerWidget_Expecter {
11865	return &MockSpinnerWidget_Expecter{mock: &_m.Mock}
11866}
11867
11868// AddController provides a mock function for the type MockSpinnerWidget
11869func (_mock *MockSpinnerWidget) AddController(controller *gtk.EventController) {
11870	_mock.Called(controller)
11871	return
11872}
11873
11874// MockSpinnerWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
11875type MockSpinnerWidget_AddController_Call struct {
11876	*mock.Call
11877}
11878
11879// AddController is a helper method to define mock.On call
11880//   - controller *gtk.EventController
11881func (_e *MockSpinnerWidget_Expecter) AddController(controller interface{}) *MockSpinnerWidget_AddController_Call {
11882	return &MockSpinnerWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
11883}
11884
11885func (_c *MockSpinnerWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockSpinnerWidget_AddController_Call {
11886	_c.Call.Run(func(args mock.Arguments) {
11887		var arg0 *gtk.EventController
11888		if args[0] != nil {
11889			arg0 = args[0].(*gtk.EventController)
11890		}
11891		run(
11892			arg0,
11893		)
11894	})
11895	return _c
11896}
11897
11898func (_c *MockSpinnerWidget_AddController_Call) Return() *MockSpinnerWidget_AddController_Call {
11899	_c.Call.Return()
11900	return _c
11901}
11902
11903func (_c *MockSpinnerWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockSpinnerWidget_AddController_Call {
11904	_c.Run(run)
11905	return _c
11906}
11907
11908// AddCssClass provides a mock function for the type MockSpinnerWidget
11909func (_mock *MockSpinnerWidget) AddCssClass(cssClass string) {
11910	_mock.Called(cssClass)
11911	return
11912}
11913
11914// MockSpinnerWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
11915type MockSpinnerWidget_AddCssClass_Call struct {
11916	*mock.Call
11917}
11918
11919// AddCssClass is a helper method to define mock.On call
11920//   - cssClass string
11921func (_e *MockSpinnerWidget_Expecter) AddCssClass(cssClass interface{}) *MockSpinnerWidget_AddCssClass_Call {
11922	return &MockSpinnerWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
11923}
11924
11925func (_c *MockSpinnerWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_AddCssClass_Call {
11926	_c.Call.Run(func(args mock.Arguments) {
11927		var arg0 string
11928		if args[0] != nil {
11929			arg0 = args[0].(string)
11930		}
11931		run(
11932			arg0,
11933		)
11934	})
11935	return _c
11936}
11937
11938func (_c *MockSpinnerWidget_AddCssClass_Call) Return() *MockSpinnerWidget_AddCssClass_Call {
11939	_c.Call.Return()
11940	return _c
11941}
11942
11943func (_c *MockSpinnerWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockSpinnerWidget_AddCssClass_Call {
11944	_c.Run(run)
11945	return _c
11946}
11947
11948// ComputePoint provides a mock function for the type MockSpinnerWidget
11949func (_mock *MockSpinnerWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
11950	ret := _mock.Called(target)
11951
11952	if len(ret) == 0 {
11953		panic("no return value specified for ComputePoint")
11954	}
11955
11956	var r0 float64
11957	var r1 float64
11958	var r2 bool
11959	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
11960		return returnFunc(target)
11961	}
11962	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
11963		r0 = returnFunc(target)
11964	} else {
11965		r0 = ret.Get(0).(float64)
11966	}
11967	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
11968		r1 = returnFunc(target)
11969	} else {
11970		r1 = ret.Get(1).(float64)
11971	}
11972	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
11973		r2 = returnFunc(target)
11974	} else {
11975		r2 = ret.Get(2).(bool)
11976	}
11977	return r0, r1, r2
11978}
11979
11980// MockSpinnerWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
11981type MockSpinnerWidget_ComputePoint_Call struct {
11982	*mock.Call
11983}
11984
11985// ComputePoint is a helper method to define mock.On call
11986//   - target layout.Widget
11987func (_e *MockSpinnerWidget_Expecter) ComputePoint(target interface{}) *MockSpinnerWidget_ComputePoint_Call {
11988	return &MockSpinnerWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
11989}
11990
11991func (_c *MockSpinnerWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockSpinnerWidget_ComputePoint_Call {
11992	_c.Call.Run(func(args mock.Arguments) {
11993		var arg0 layout.Widget
11994		if args[0] != nil {
11995			arg0 = args[0].(layout.Widget)
11996		}
11997		run(
11998			arg0,
11999		)
12000	})
12001	return _c
12002}
12003
12004func (_c *MockSpinnerWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockSpinnerWidget_ComputePoint_Call {
12005	_c.Call.Return(x, y, ok)
12006	return _c
12007}
12008
12009func (_c *MockSpinnerWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockSpinnerWidget_ComputePoint_Call {
12010	_c.Call.Return(run)
12011	return _c
12012}
12013
12014// GetAllocatedHeight provides a mock function for the type MockSpinnerWidget
12015func (_mock *MockSpinnerWidget) GetAllocatedHeight() int {
12016	ret := _mock.Called()
12017
12018	if len(ret) == 0 {
12019		panic("no return value specified for GetAllocatedHeight")
12020	}
12021
12022	var r0 int
12023	if returnFunc, ok := ret.Get(0).(func() int); ok {
12024		r0 = returnFunc()
12025	} else {
12026		r0 = ret.Get(0).(int)
12027	}
12028	return r0
12029}
12030
12031// MockSpinnerWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
12032type MockSpinnerWidget_GetAllocatedHeight_Call struct {
12033	*mock.Call
12034}
12035
12036// GetAllocatedHeight is a helper method to define mock.On call
12037func (_e *MockSpinnerWidget_Expecter) GetAllocatedHeight() *MockSpinnerWidget_GetAllocatedHeight_Call {
12038	return &MockSpinnerWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
12039}
12040
12041func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) Run(run func()) *MockSpinnerWidget_GetAllocatedHeight_Call {
12042	_c.Call.Run(func(args mock.Arguments) {
12043		run()
12044	})
12045	return _c
12046}
12047
12048func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) Return(n int) *MockSpinnerWidget_GetAllocatedHeight_Call {
12049	_c.Call.Return(n)
12050	return _c
12051}
12052
12053func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockSpinnerWidget_GetAllocatedHeight_Call {
12054	_c.Call.Return(run)
12055	return _c
12056}
12057
12058// GetAllocatedWidth provides a mock function for the type MockSpinnerWidget
12059func (_mock *MockSpinnerWidget) GetAllocatedWidth() int {
12060	ret := _mock.Called()
12061
12062	if len(ret) == 0 {
12063		panic("no return value specified for GetAllocatedWidth")
12064	}
12065
12066	var r0 int
12067	if returnFunc, ok := ret.Get(0).(func() int); ok {
12068		r0 = returnFunc()
12069	} else {
12070		r0 = ret.Get(0).(int)
12071	}
12072	return r0
12073}
12074
12075// MockSpinnerWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
12076type MockSpinnerWidget_GetAllocatedWidth_Call struct {
12077	*mock.Call
12078}
12079
12080// GetAllocatedWidth is a helper method to define mock.On call
12081func (_e *MockSpinnerWidget_Expecter) GetAllocatedWidth() *MockSpinnerWidget_GetAllocatedWidth_Call {
12082	return &MockSpinnerWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
12083}
12084
12085func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) Run(run func()) *MockSpinnerWidget_GetAllocatedWidth_Call {
12086	_c.Call.Run(func(args mock.Arguments) {
12087		run()
12088	})
12089	return _c
12090}
12091
12092func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) Return(n int) *MockSpinnerWidget_GetAllocatedWidth_Call {
12093	_c.Call.Return(n)
12094	return _c
12095}
12096
12097func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockSpinnerWidget_GetAllocatedWidth_Call {
12098	_c.Call.Return(run)
12099	return _c
12100}
12101
12102// GetHexpand provides a mock function for the type MockSpinnerWidget
12103func (_mock *MockSpinnerWidget) GetHexpand() bool {
12104	ret := _mock.Called()
12105
12106	if len(ret) == 0 {
12107		panic("no return value specified for GetHexpand")
12108	}
12109
12110	var r0 bool
12111	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12112		r0 = returnFunc()
12113	} else {
12114		r0 = ret.Get(0).(bool)
12115	}
12116	return r0
12117}
12118
12119// MockSpinnerWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
12120type MockSpinnerWidget_GetHexpand_Call struct {
12121	*mock.Call
12122}
12123
12124// GetHexpand is a helper method to define mock.On call
12125func (_e *MockSpinnerWidget_Expecter) GetHexpand() *MockSpinnerWidget_GetHexpand_Call {
12126	return &MockSpinnerWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
12127}
12128
12129func (_c *MockSpinnerWidget_GetHexpand_Call) Run(run func()) *MockSpinnerWidget_GetHexpand_Call {
12130	_c.Call.Run(func(args mock.Arguments) {
12131		run()
12132	})
12133	return _c
12134}
12135
12136func (_c *MockSpinnerWidget_GetHexpand_Call) Return(b bool) *MockSpinnerWidget_GetHexpand_Call {
12137	_c.Call.Return(b)
12138	return _c
12139}
12140
12141func (_c *MockSpinnerWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetHexpand_Call {
12142	_c.Call.Return(run)
12143	return _c
12144}
12145
12146// GetParent provides a mock function for the type MockSpinnerWidget
12147func (_mock *MockSpinnerWidget) GetParent() layout.Widget {
12148	ret := _mock.Called()
12149
12150	if len(ret) == 0 {
12151		panic("no return value specified for GetParent")
12152	}
12153
12154	var r0 layout.Widget
12155	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
12156		r0 = returnFunc()
12157	} else {
12158		if ret.Get(0) != nil {
12159			r0 = ret.Get(0).(layout.Widget)
12160		}
12161	}
12162	return r0
12163}
12164
12165// MockSpinnerWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
12166type MockSpinnerWidget_GetParent_Call struct {
12167	*mock.Call
12168}
12169
12170// GetParent is a helper method to define mock.On call
12171func (_e *MockSpinnerWidget_Expecter) GetParent() *MockSpinnerWidget_GetParent_Call {
12172	return &MockSpinnerWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
12173}
12174
12175func (_c *MockSpinnerWidget_GetParent_Call) Run(run func()) *MockSpinnerWidget_GetParent_Call {
12176	_c.Call.Run(func(args mock.Arguments) {
12177		run()
12178	})
12179	return _c
12180}
12181
12182func (_c *MockSpinnerWidget_GetParent_Call) Return(widget layout.Widget) *MockSpinnerWidget_GetParent_Call {
12183	_c.Call.Return(widget)
12184	return _c
12185}
12186
12187func (_c *MockSpinnerWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockSpinnerWidget_GetParent_Call {
12188	_c.Call.Return(run)
12189	return _c
12190}
12191
12192// GetSpinning provides a mock function for the type MockSpinnerWidget
12193func (_mock *MockSpinnerWidget) GetSpinning() bool {
12194	ret := _mock.Called()
12195
12196	if len(ret) == 0 {
12197		panic("no return value specified for GetSpinning")
12198	}
12199
12200	var r0 bool
12201	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12202		r0 = returnFunc()
12203	} else {
12204		r0 = ret.Get(0).(bool)
12205	}
12206	return r0
12207}
12208
12209// MockSpinnerWidget_GetSpinning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpinning'
12210type MockSpinnerWidget_GetSpinning_Call struct {
12211	*mock.Call
12212}
12213
12214// GetSpinning is a helper method to define mock.On call
12215func (_e *MockSpinnerWidget_Expecter) GetSpinning() *MockSpinnerWidget_GetSpinning_Call {
12216	return &MockSpinnerWidget_GetSpinning_Call{Call: _e.mock.On("GetSpinning")}
12217}
12218
12219func (_c *MockSpinnerWidget_GetSpinning_Call) Run(run func()) *MockSpinnerWidget_GetSpinning_Call {
12220	_c.Call.Run(func(args mock.Arguments) {
12221		run()
12222	})
12223	return _c
12224}
12225
12226func (_c *MockSpinnerWidget_GetSpinning_Call) Return(b bool) *MockSpinnerWidget_GetSpinning_Call {
12227	_c.Call.Return(b)
12228	return _c
12229}
12230
12231func (_c *MockSpinnerWidget_GetSpinning_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetSpinning_Call {
12232	_c.Call.Return(run)
12233	return _c
12234}
12235
12236// GetVexpand provides a mock function for the type MockSpinnerWidget
12237func (_mock *MockSpinnerWidget) GetVexpand() bool {
12238	ret := _mock.Called()
12239
12240	if len(ret) == 0 {
12241		panic("no return value specified for GetVexpand")
12242	}
12243
12244	var r0 bool
12245	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12246		r0 = returnFunc()
12247	} else {
12248		r0 = ret.Get(0).(bool)
12249	}
12250	return r0
12251}
12252
12253// MockSpinnerWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
12254type MockSpinnerWidget_GetVexpand_Call struct {
12255	*mock.Call
12256}
12257
12258// GetVexpand is a helper method to define mock.On call
12259func (_e *MockSpinnerWidget_Expecter) GetVexpand() *MockSpinnerWidget_GetVexpand_Call {
12260	return &MockSpinnerWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
12261}
12262
12263func (_c *MockSpinnerWidget_GetVexpand_Call) Run(run func()) *MockSpinnerWidget_GetVexpand_Call {
12264	_c.Call.Run(func(args mock.Arguments) {
12265		run()
12266	})
12267	return _c
12268}
12269
12270func (_c *MockSpinnerWidget_GetVexpand_Call) Return(b bool) *MockSpinnerWidget_GetVexpand_Call {
12271	_c.Call.Return(b)
12272	return _c
12273}
12274
12275func (_c *MockSpinnerWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetVexpand_Call {
12276	_c.Call.Return(run)
12277	return _c
12278}
12279
12280// GrabFocus provides a mock function for the type MockSpinnerWidget
12281func (_mock *MockSpinnerWidget) GrabFocus() bool {
12282	ret := _mock.Called()
12283
12284	if len(ret) == 0 {
12285		panic("no return value specified for GrabFocus")
12286	}
12287
12288	var r0 bool
12289	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12290		r0 = returnFunc()
12291	} else {
12292		r0 = ret.Get(0).(bool)
12293	}
12294	return r0
12295}
12296
12297// MockSpinnerWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
12298type MockSpinnerWidget_GrabFocus_Call struct {
12299	*mock.Call
12300}
12301
12302// GrabFocus is a helper method to define mock.On call
12303func (_e *MockSpinnerWidget_Expecter) GrabFocus() *MockSpinnerWidget_GrabFocus_Call {
12304	return &MockSpinnerWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
12305}
12306
12307func (_c *MockSpinnerWidget_GrabFocus_Call) Run(run func()) *MockSpinnerWidget_GrabFocus_Call {
12308	_c.Call.Run(func(args mock.Arguments) {
12309		run()
12310	})
12311	return _c
12312}
12313
12314func (_c *MockSpinnerWidget_GrabFocus_Call) Return(b bool) *MockSpinnerWidget_GrabFocus_Call {
12315	_c.Call.Return(b)
12316	return _c
12317}
12318
12319func (_c *MockSpinnerWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GrabFocus_Call {
12320	_c.Call.Return(run)
12321	return _c
12322}
12323
12324// GtkWidget provides a mock function for the type MockSpinnerWidget
12325func (_mock *MockSpinnerWidget) GtkWidget() *gtk.Widget {
12326	ret := _mock.Called()
12327
12328	if len(ret) == 0 {
12329		panic("no return value specified for GtkWidget")
12330	}
12331
12332	var r0 *gtk.Widget
12333	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
12334		r0 = returnFunc()
12335	} else {
12336		if ret.Get(0) != nil {
12337			r0 = ret.Get(0).(*gtk.Widget)
12338		}
12339	}
12340	return r0
12341}
12342
12343// MockSpinnerWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
12344type MockSpinnerWidget_GtkWidget_Call struct {
12345	*mock.Call
12346}
12347
12348// GtkWidget is a helper method to define mock.On call
12349func (_e *MockSpinnerWidget_Expecter) GtkWidget() *MockSpinnerWidget_GtkWidget_Call {
12350	return &MockSpinnerWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
12351}
12352
12353func (_c *MockSpinnerWidget_GtkWidget_Call) Run(run func()) *MockSpinnerWidget_GtkWidget_Call {
12354	_c.Call.Run(func(args mock.Arguments) {
12355		run()
12356	})
12357	return _c
12358}
12359
12360func (_c *MockSpinnerWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockSpinnerWidget_GtkWidget_Call {
12361	_c.Call.Return(widget)
12362	return _c
12363}
12364
12365func (_c *MockSpinnerWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockSpinnerWidget_GtkWidget_Call {
12366	_c.Call.Return(run)
12367	return _c
12368}
12369
12370// HasCssClass provides a mock function for the type MockSpinnerWidget
12371func (_mock *MockSpinnerWidget) HasCssClass(cssClass string) bool {
12372	ret := _mock.Called(cssClass)
12373
12374	if len(ret) == 0 {
12375		panic("no return value specified for HasCssClass")
12376	}
12377
12378	var r0 bool
12379	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
12380		r0 = returnFunc(cssClass)
12381	} else {
12382		r0 = ret.Get(0).(bool)
12383	}
12384	return r0
12385}
12386
12387// MockSpinnerWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
12388type MockSpinnerWidget_HasCssClass_Call struct {
12389	*mock.Call
12390}
12391
12392// HasCssClass is a helper method to define mock.On call
12393//   - cssClass string
12394func (_e *MockSpinnerWidget_Expecter) HasCssClass(cssClass interface{}) *MockSpinnerWidget_HasCssClass_Call {
12395	return &MockSpinnerWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
12396}
12397
12398func (_c *MockSpinnerWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_HasCssClass_Call {
12399	_c.Call.Run(func(args mock.Arguments) {
12400		var arg0 string
12401		if args[0] != nil {
12402			arg0 = args[0].(string)
12403		}
12404		run(
12405			arg0,
12406		)
12407	})
12408	return _c
12409}
12410
12411func (_c *MockSpinnerWidget_HasCssClass_Call) Return(b bool) *MockSpinnerWidget_HasCssClass_Call {
12412	_c.Call.Return(b)
12413	return _c
12414}
12415
12416func (_c *MockSpinnerWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockSpinnerWidget_HasCssClass_Call {
12417	_c.Call.Return(run)
12418	return _c
12419}
12420
12421// HasFocus provides a mock function for the type MockSpinnerWidget
12422func (_mock *MockSpinnerWidget) HasFocus() bool {
12423	ret := _mock.Called()
12424
12425	if len(ret) == 0 {
12426		panic("no return value specified for HasFocus")
12427	}
12428
12429	var r0 bool
12430	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12431		r0 = returnFunc()
12432	} else {
12433		r0 = ret.Get(0).(bool)
12434	}
12435	return r0
12436}
12437
12438// MockSpinnerWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
12439type MockSpinnerWidget_HasFocus_Call struct {
12440	*mock.Call
12441}
12442
12443// HasFocus is a helper method to define mock.On call
12444func (_e *MockSpinnerWidget_Expecter) HasFocus() *MockSpinnerWidget_HasFocus_Call {
12445	return &MockSpinnerWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
12446}
12447
12448func (_c *MockSpinnerWidget_HasFocus_Call) Run(run func()) *MockSpinnerWidget_HasFocus_Call {
12449	_c.Call.Run(func(args mock.Arguments) {
12450		run()
12451	})
12452	return _c
12453}
12454
12455func (_c *MockSpinnerWidget_HasFocus_Call) Return(b bool) *MockSpinnerWidget_HasFocus_Call {
12456	_c.Call.Return(b)
12457	return _c
12458}
12459
12460func (_c *MockSpinnerWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_HasFocus_Call {
12461	_c.Call.Return(run)
12462	return _c
12463}
12464
12465// Hide provides a mock function for the type MockSpinnerWidget
12466func (_mock *MockSpinnerWidget) Hide() {
12467	_mock.Called()
12468	return
12469}
12470
12471// MockSpinnerWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
12472type MockSpinnerWidget_Hide_Call struct {
12473	*mock.Call
12474}
12475
12476// Hide is a helper method to define mock.On call
12477func (_e *MockSpinnerWidget_Expecter) Hide() *MockSpinnerWidget_Hide_Call {
12478	return &MockSpinnerWidget_Hide_Call{Call: _e.mock.On("Hide")}
12479}
12480
12481func (_c *MockSpinnerWidget_Hide_Call) Run(run func()) *MockSpinnerWidget_Hide_Call {
12482	_c.Call.Run(func(args mock.Arguments) {
12483		run()
12484	})
12485	return _c
12486}
12487
12488func (_c *MockSpinnerWidget_Hide_Call) Return() *MockSpinnerWidget_Hide_Call {
12489	_c.Call.Return()
12490	return _c
12491}
12492
12493func (_c *MockSpinnerWidget_Hide_Call) RunAndReturn(run func()) *MockSpinnerWidget_Hide_Call {
12494	_c.Run(run)
12495	return _c
12496}
12497
12498// IsVisible provides a mock function for the type MockSpinnerWidget
12499func (_mock *MockSpinnerWidget) IsVisible() bool {
12500	ret := _mock.Called()
12501
12502	if len(ret) == 0 {
12503		panic("no return value specified for IsVisible")
12504	}
12505
12506	var r0 bool
12507	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12508		r0 = returnFunc()
12509	} else {
12510		r0 = ret.Get(0).(bool)
12511	}
12512	return r0
12513}
12514
12515// MockSpinnerWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
12516type MockSpinnerWidget_IsVisible_Call struct {
12517	*mock.Call
12518}
12519
12520// IsVisible is a helper method to define mock.On call
12521func (_e *MockSpinnerWidget_Expecter) IsVisible() *MockSpinnerWidget_IsVisible_Call {
12522	return &MockSpinnerWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
12523}
12524
12525func (_c *MockSpinnerWidget_IsVisible_Call) Run(run func()) *MockSpinnerWidget_IsVisible_Call {
12526	_c.Call.Run(func(args mock.Arguments) {
12527		run()
12528	})
12529	return _c
12530}
12531
12532func (_c *MockSpinnerWidget_IsVisible_Call) Return(b bool) *MockSpinnerWidget_IsVisible_Call {
12533	_c.Call.Return(b)
12534	return _c
12535}
12536
12537func (_c *MockSpinnerWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_IsVisible_Call {
12538	_c.Call.Return(run)
12539	return _c
12540}
12541
12542// RemoveCssClass provides a mock function for the type MockSpinnerWidget
12543func (_mock *MockSpinnerWidget) RemoveCssClass(cssClass string) {
12544	_mock.Called(cssClass)
12545	return
12546}
12547
12548// MockSpinnerWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
12549type MockSpinnerWidget_RemoveCssClass_Call struct {
12550	*mock.Call
12551}
12552
12553// RemoveCssClass is a helper method to define mock.On call
12554//   - cssClass string
12555func (_e *MockSpinnerWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockSpinnerWidget_RemoveCssClass_Call {
12556	return &MockSpinnerWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
12557}
12558
12559func (_c *MockSpinnerWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_RemoveCssClass_Call {
12560	_c.Call.Run(func(args mock.Arguments) {
12561		var arg0 string
12562		if args[0] != nil {
12563			arg0 = args[0].(string)
12564		}
12565		run(
12566			arg0,
12567		)
12568	})
12569	return _c
12570}
12571
12572func (_c *MockSpinnerWidget_RemoveCssClass_Call) Return() *MockSpinnerWidget_RemoveCssClass_Call {
12573	_c.Call.Return()
12574	return _c
12575}
12576
12577func (_c *MockSpinnerWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockSpinnerWidget_RemoveCssClass_Call {
12578	_c.Run(run)
12579	return _c
12580}
12581
12582// SetCanFocus provides a mock function for the type MockSpinnerWidget
12583func (_mock *MockSpinnerWidget) SetCanFocus(canFocus bool) {
12584	_mock.Called(canFocus)
12585	return
12586}
12587
12588// MockSpinnerWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
12589type MockSpinnerWidget_SetCanFocus_Call struct {
12590	*mock.Call
12591}
12592
12593// SetCanFocus is a helper method to define mock.On call
12594//   - canFocus bool
12595func (_e *MockSpinnerWidget_Expecter) SetCanFocus(canFocus interface{}) *MockSpinnerWidget_SetCanFocus_Call {
12596	return &MockSpinnerWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
12597}
12598
12599func (_c *MockSpinnerWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockSpinnerWidget_SetCanFocus_Call {
12600	_c.Call.Run(func(args mock.Arguments) {
12601		var arg0 bool
12602		if args[0] != nil {
12603			arg0 = args[0].(bool)
12604		}
12605		run(
12606			arg0,
12607		)
12608	})
12609	return _c
12610}
12611
12612func (_c *MockSpinnerWidget_SetCanFocus_Call) Return() *MockSpinnerWidget_SetCanFocus_Call {
12613	_c.Call.Return()
12614	return _c
12615}
12616
12617func (_c *MockSpinnerWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockSpinnerWidget_SetCanFocus_Call {
12618	_c.Run(run)
12619	return _c
12620}
12621
12622// SetCanTarget provides a mock function for the type MockSpinnerWidget
12623func (_mock *MockSpinnerWidget) SetCanTarget(canTarget bool) {
12624	_mock.Called(canTarget)
12625	return
12626}
12627
12628// MockSpinnerWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
12629type MockSpinnerWidget_SetCanTarget_Call struct {
12630	*mock.Call
12631}
12632
12633// SetCanTarget is a helper method to define mock.On call
12634//   - canTarget bool
12635func (_e *MockSpinnerWidget_Expecter) SetCanTarget(canTarget interface{}) *MockSpinnerWidget_SetCanTarget_Call {
12636	return &MockSpinnerWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
12637}
12638
12639func (_c *MockSpinnerWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockSpinnerWidget_SetCanTarget_Call {
12640	_c.Call.Run(func(args mock.Arguments) {
12641		var arg0 bool
12642		if args[0] != nil {
12643			arg0 = args[0].(bool)
12644		}
12645		run(
12646			arg0,
12647		)
12648	})
12649	return _c
12650}
12651
12652func (_c *MockSpinnerWidget_SetCanTarget_Call) Return() *MockSpinnerWidget_SetCanTarget_Call {
12653	_c.Call.Return()
12654	return _c
12655}
12656
12657func (_c *MockSpinnerWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockSpinnerWidget_SetCanTarget_Call {
12658	_c.Run(run)
12659	return _c
12660}
12661
12662// SetFocusOnClick provides a mock function for the type MockSpinnerWidget
12663func (_mock *MockSpinnerWidget) SetFocusOnClick(focusOnClick bool) {
12664	_mock.Called(focusOnClick)
12665	return
12666}
12667
12668// MockSpinnerWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
12669type MockSpinnerWidget_SetFocusOnClick_Call struct {
12670	*mock.Call
12671}
12672
12673// SetFocusOnClick is a helper method to define mock.On call
12674//   - focusOnClick bool
12675func (_e *MockSpinnerWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockSpinnerWidget_SetFocusOnClick_Call {
12676	return &MockSpinnerWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
12677}
12678
12679func (_c *MockSpinnerWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockSpinnerWidget_SetFocusOnClick_Call {
12680	_c.Call.Run(func(args mock.Arguments) {
12681		var arg0 bool
12682		if args[0] != nil {
12683			arg0 = args[0].(bool)
12684		}
12685		run(
12686			arg0,
12687		)
12688	})
12689	return _c
12690}
12691
12692func (_c *MockSpinnerWidget_SetFocusOnClick_Call) Return() *MockSpinnerWidget_SetFocusOnClick_Call {
12693	_c.Call.Return()
12694	return _c
12695}
12696
12697func (_c *MockSpinnerWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockSpinnerWidget_SetFocusOnClick_Call {
12698	_c.Run(run)
12699	return _c
12700}
12701
12702// SetFocusable provides a mock function for the type MockSpinnerWidget
12703func (_mock *MockSpinnerWidget) SetFocusable(focusable bool) {
12704	_mock.Called(focusable)
12705	return
12706}
12707
12708// MockSpinnerWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
12709type MockSpinnerWidget_SetFocusable_Call struct {
12710	*mock.Call
12711}
12712
12713// SetFocusable is a helper method to define mock.On call
12714//   - focusable bool
12715func (_e *MockSpinnerWidget_Expecter) SetFocusable(focusable interface{}) *MockSpinnerWidget_SetFocusable_Call {
12716	return &MockSpinnerWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
12717}
12718
12719func (_c *MockSpinnerWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockSpinnerWidget_SetFocusable_Call {
12720	_c.Call.Run(func(args mock.Arguments) {
12721		var arg0 bool
12722		if args[0] != nil {
12723			arg0 = args[0].(bool)
12724		}
12725		run(
12726			arg0,
12727		)
12728	})
12729	return _c
12730}
12731
12732func (_c *MockSpinnerWidget_SetFocusable_Call) Return() *MockSpinnerWidget_SetFocusable_Call {
12733	_c.Call.Return()
12734	return _c
12735}
12736
12737func (_c *MockSpinnerWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockSpinnerWidget_SetFocusable_Call {
12738	_c.Run(run)
12739	return _c
12740}
12741
12742// SetHalign provides a mock function for the type MockSpinnerWidget
12743func (_mock *MockSpinnerWidget) SetHalign(align gtk.Align) {
12744	_mock.Called(align)
12745	return
12746}
12747
12748// MockSpinnerWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
12749type MockSpinnerWidget_SetHalign_Call struct {
12750	*mock.Call
12751}
12752
12753// SetHalign is a helper method to define mock.On call
12754//   - align gtk.Align
12755func (_e *MockSpinnerWidget_Expecter) SetHalign(align interface{}) *MockSpinnerWidget_SetHalign_Call {
12756	return &MockSpinnerWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
12757}
12758
12759func (_c *MockSpinnerWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockSpinnerWidget_SetHalign_Call {
12760	_c.Call.Run(func(args mock.Arguments) {
12761		var arg0 gtk.Align
12762		if args[0] != nil {
12763			arg0 = args[0].(gtk.Align)
12764		}
12765		run(
12766			arg0,
12767		)
12768	})
12769	return _c
12770}
12771
12772func (_c *MockSpinnerWidget_SetHalign_Call) Return() *MockSpinnerWidget_SetHalign_Call {
12773	_c.Call.Return()
12774	return _c
12775}
12776
12777func (_c *MockSpinnerWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockSpinnerWidget_SetHalign_Call {
12778	_c.Run(run)
12779	return _c
12780}
12781
12782// SetHexpand provides a mock function for the type MockSpinnerWidget
12783func (_mock *MockSpinnerWidget) SetHexpand(expand bool) {
12784	_mock.Called(expand)
12785	return
12786}
12787
12788// MockSpinnerWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
12789type MockSpinnerWidget_SetHexpand_Call struct {
12790	*mock.Call
12791}
12792
12793// SetHexpand is a helper method to define mock.On call
12794//   - expand bool
12795func (_e *MockSpinnerWidget_Expecter) SetHexpand(expand interface{}) *MockSpinnerWidget_SetHexpand_Call {
12796	return &MockSpinnerWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
12797}
12798
12799func (_c *MockSpinnerWidget_SetHexpand_Call) Run(run func(expand bool)) *MockSpinnerWidget_SetHexpand_Call {
12800	_c.Call.Run(func(args mock.Arguments) {
12801		var arg0 bool
12802		if args[0] != nil {
12803			arg0 = args[0].(bool)
12804		}
12805		run(
12806			arg0,
12807		)
12808	})
12809	return _c
12810}
12811
12812func (_c *MockSpinnerWidget_SetHexpand_Call) Return() *MockSpinnerWidget_SetHexpand_Call {
12813	_c.Call.Return()
12814	return _c
12815}
12816
12817func (_c *MockSpinnerWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockSpinnerWidget_SetHexpand_Call {
12818	_c.Run(run)
12819	return _c
12820}
12821
12822// SetSizeRequest provides a mock function for the type MockSpinnerWidget
12823func (_mock *MockSpinnerWidget) SetSizeRequest(width int, height int) {
12824	_mock.Called(width, height)
12825	return
12826}
12827
12828// MockSpinnerWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
12829type MockSpinnerWidget_SetSizeRequest_Call struct {
12830	*mock.Call
12831}
12832
12833// SetSizeRequest is a helper method to define mock.On call
12834//   - width int
12835//   - height int
12836func (_e *MockSpinnerWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockSpinnerWidget_SetSizeRequest_Call {
12837	return &MockSpinnerWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
12838}
12839
12840func (_c *MockSpinnerWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockSpinnerWidget_SetSizeRequest_Call {
12841	_c.Call.Run(func(args mock.Arguments) {
12842		var arg0 int
12843		if args[0] != nil {
12844			arg0 = args[0].(int)
12845		}
12846		var arg1 int
12847		if args[1] != nil {
12848			arg1 = args[1].(int)
12849		}
12850		run(
12851			arg0,
12852			arg1,
12853		)
12854	})
12855	return _c
12856}
12857
12858func (_c *MockSpinnerWidget_SetSizeRequest_Call) Return() *MockSpinnerWidget_SetSizeRequest_Call {
12859	_c.Call.Return()
12860	return _c
12861}
12862
12863func (_c *MockSpinnerWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockSpinnerWidget_SetSizeRequest_Call {
12864	_c.Run(run)
12865	return _c
12866}
12867
12868// SetSpinning provides a mock function for the type MockSpinnerWidget
12869func (_mock *MockSpinnerWidget) SetSpinning(spinning bool) {
12870	_mock.Called(spinning)
12871	return
12872}
12873
12874// MockSpinnerWidget_SetSpinning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpinning'
12875type MockSpinnerWidget_SetSpinning_Call struct {
12876	*mock.Call
12877}
12878
12879// SetSpinning is a helper method to define mock.On call
12880//   - spinning bool
12881func (_e *MockSpinnerWidget_Expecter) SetSpinning(spinning interface{}) *MockSpinnerWidget_SetSpinning_Call {
12882	return &MockSpinnerWidget_SetSpinning_Call{Call: _e.mock.On("SetSpinning", spinning)}
12883}
12884
12885func (_c *MockSpinnerWidget_SetSpinning_Call) Run(run func(spinning bool)) *MockSpinnerWidget_SetSpinning_Call {
12886	_c.Call.Run(func(args mock.Arguments) {
12887		var arg0 bool
12888		if args[0] != nil {
12889			arg0 = args[0].(bool)
12890		}
12891		run(
12892			arg0,
12893		)
12894	})
12895	return _c
12896}
12897
12898func (_c *MockSpinnerWidget_SetSpinning_Call) Return() *MockSpinnerWidget_SetSpinning_Call {
12899	_c.Call.Return()
12900	return _c
12901}
12902
12903func (_c *MockSpinnerWidget_SetSpinning_Call) RunAndReturn(run func(spinning bool)) *MockSpinnerWidget_SetSpinning_Call {
12904	_c.Run(run)
12905	return _c
12906}
12907
12908// SetValign provides a mock function for the type MockSpinnerWidget
12909func (_mock *MockSpinnerWidget) SetValign(align gtk.Align) {
12910	_mock.Called(align)
12911	return
12912}
12913
12914// MockSpinnerWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
12915type MockSpinnerWidget_SetValign_Call struct {
12916	*mock.Call
12917}
12918
12919// SetValign is a helper method to define mock.On call
12920//   - align gtk.Align
12921func (_e *MockSpinnerWidget_Expecter) SetValign(align interface{}) *MockSpinnerWidget_SetValign_Call {
12922	return &MockSpinnerWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
12923}
12924
12925func (_c *MockSpinnerWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockSpinnerWidget_SetValign_Call {
12926	_c.Call.Run(func(args mock.Arguments) {
12927		var arg0 gtk.Align
12928		if args[0] != nil {
12929			arg0 = args[0].(gtk.Align)
12930		}
12931		run(
12932			arg0,
12933		)
12934	})
12935	return _c
12936}
12937
12938func (_c *MockSpinnerWidget_SetValign_Call) Return() *MockSpinnerWidget_SetValign_Call {
12939	_c.Call.Return()
12940	return _c
12941}
12942
12943func (_c *MockSpinnerWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockSpinnerWidget_SetValign_Call {
12944	_c.Run(run)
12945	return _c
12946}
12947
12948// SetVexpand provides a mock function for the type MockSpinnerWidget
12949func (_mock *MockSpinnerWidget) SetVexpand(expand bool) {
12950	_mock.Called(expand)
12951	return
12952}
12953
12954// MockSpinnerWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
12955type MockSpinnerWidget_SetVexpand_Call struct {
12956	*mock.Call
12957}
12958
12959// SetVexpand is a helper method to define mock.On call
12960//   - expand bool
12961func (_e *MockSpinnerWidget_Expecter) SetVexpand(expand interface{}) *MockSpinnerWidget_SetVexpand_Call {
12962	return &MockSpinnerWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
12963}
12964
12965func (_c *MockSpinnerWidget_SetVexpand_Call) Run(run func(expand bool)) *MockSpinnerWidget_SetVexpand_Call {
12966	_c.Call.Run(func(args mock.Arguments) {
12967		var arg0 bool
12968		if args[0] != nil {
12969			arg0 = args[0].(bool)
12970		}
12971		run(
12972			arg0,
12973		)
12974	})
12975	return _c
12976}
12977
12978func (_c *MockSpinnerWidget_SetVexpand_Call) Return() *MockSpinnerWidget_SetVexpand_Call {
12979	_c.Call.Return()
12980	return _c
12981}
12982
12983func (_c *MockSpinnerWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockSpinnerWidget_SetVexpand_Call {
12984	_c.Run(run)
12985	return _c
12986}
12987
12988// SetVisible provides a mock function for the type MockSpinnerWidget
12989func (_mock *MockSpinnerWidget) SetVisible(visible bool) {
12990	_mock.Called(visible)
12991	return
12992}
12993
12994// MockSpinnerWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
12995type MockSpinnerWidget_SetVisible_Call struct {
12996	*mock.Call
12997}
12998
12999// SetVisible is a helper method to define mock.On call
13000//   - visible bool
13001func (_e *MockSpinnerWidget_Expecter) SetVisible(visible interface{}) *MockSpinnerWidget_SetVisible_Call {
13002	return &MockSpinnerWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
13003}
13004
13005func (_c *MockSpinnerWidget_SetVisible_Call) Run(run func(visible bool)) *MockSpinnerWidget_SetVisible_Call {
13006	_c.Call.Run(func(args mock.Arguments) {
13007		var arg0 bool
13008		if args[0] != nil {
13009			arg0 = args[0].(bool)
13010		}
13011		run(
13012			arg0,
13013		)
13014	})
13015	return _c
13016}
13017
13018func (_c *MockSpinnerWidget_SetVisible_Call) Return() *MockSpinnerWidget_SetVisible_Call {
13019	_c.Call.Return()
13020	return _c
13021}
13022
13023func (_c *MockSpinnerWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockSpinnerWidget_SetVisible_Call {
13024	_c.Run(run)
13025	return _c
13026}
13027
13028// Show provides a mock function for the type MockSpinnerWidget
13029func (_mock *MockSpinnerWidget) Show() {
13030	_mock.Called()
13031	return
13032}
13033
13034// MockSpinnerWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
13035type MockSpinnerWidget_Show_Call struct {
13036	*mock.Call
13037}
13038
13039// Show is a helper method to define mock.On call
13040func (_e *MockSpinnerWidget_Expecter) Show() *MockSpinnerWidget_Show_Call {
13041	return &MockSpinnerWidget_Show_Call{Call: _e.mock.On("Show")}
13042}
13043
13044func (_c *MockSpinnerWidget_Show_Call) Run(run func()) *MockSpinnerWidget_Show_Call {
13045	_c.Call.Run(func(args mock.Arguments) {
13046		run()
13047	})
13048	return _c
13049}
13050
13051func (_c *MockSpinnerWidget_Show_Call) Return() *MockSpinnerWidget_Show_Call {
13052	_c.Call.Return()
13053	return _c
13054}
13055
13056func (_c *MockSpinnerWidget_Show_Call) RunAndReturn(run func()) *MockSpinnerWidget_Show_Call {
13057	_c.Run(run)
13058	return _c
13059}
13060
13061// Start provides a mock function for the type MockSpinnerWidget
13062func (_mock *MockSpinnerWidget) Start() {
13063	_mock.Called()
13064	return
13065}
13066
13067// MockSpinnerWidget_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
13068type MockSpinnerWidget_Start_Call struct {
13069	*mock.Call
13070}
13071
13072// Start is a helper method to define mock.On call
13073func (_e *MockSpinnerWidget_Expecter) Start() *MockSpinnerWidget_Start_Call {
13074	return &MockSpinnerWidget_Start_Call{Call: _e.mock.On("Start")}
13075}
13076
13077func (_c *MockSpinnerWidget_Start_Call) Run(run func()) *MockSpinnerWidget_Start_Call {
13078	_c.Call.Run(func(args mock.Arguments) {
13079		run()
13080	})
13081	return _c
13082}
13083
13084func (_c *MockSpinnerWidget_Start_Call) Return() *MockSpinnerWidget_Start_Call {
13085	_c.Call.Return()
13086	return _c
13087}
13088
13089func (_c *MockSpinnerWidget_Start_Call) RunAndReturn(run func()) *MockSpinnerWidget_Start_Call {
13090	_c.Run(run)
13091	return _c
13092}
13093
13094// Stop provides a mock function for the type MockSpinnerWidget
13095func (_mock *MockSpinnerWidget) Stop() {
13096	_mock.Called()
13097	return
13098}
13099
13100// MockSpinnerWidget_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
13101type MockSpinnerWidget_Stop_Call struct {
13102	*mock.Call
13103}
13104
13105// Stop is a helper method to define mock.On call
13106func (_e *MockSpinnerWidget_Expecter) Stop() *MockSpinnerWidget_Stop_Call {
13107	return &MockSpinnerWidget_Stop_Call{Call: _e.mock.On("Stop")}
13108}
13109
13110func (_c *MockSpinnerWidget_Stop_Call) Run(run func()) *MockSpinnerWidget_Stop_Call {
13111	_c.Call.Run(func(args mock.Arguments) {
13112		run()
13113	})
13114	return _c
13115}
13116
13117func (_c *MockSpinnerWidget_Stop_Call) Return() *MockSpinnerWidget_Stop_Call {
13118	_c.Call.Return()
13119	return _c
13120}
13121
13122func (_c *MockSpinnerWidget_Stop_Call) RunAndReturn(run func()) *MockSpinnerWidget_Stop_Call {
13123	_c.Run(run)
13124	return _c
13125}
13126
13127// Unparent provides a mock function for the type MockSpinnerWidget
13128func (_mock *MockSpinnerWidget) Unparent() {
13129	_mock.Called()
13130	return
13131}
13132
13133// MockSpinnerWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
13134type MockSpinnerWidget_Unparent_Call struct {
13135	*mock.Call
13136}
13137
13138// Unparent is a helper method to define mock.On call
13139func (_e *MockSpinnerWidget_Expecter) Unparent() *MockSpinnerWidget_Unparent_Call {
13140	return &MockSpinnerWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
13141}
13142
13143func (_c *MockSpinnerWidget_Unparent_Call) Run(run func()) *MockSpinnerWidget_Unparent_Call {
13144	_c.Call.Run(func(args mock.Arguments) {
13145		run()
13146	})
13147	return _c
13148}
13149
13150func (_c *MockSpinnerWidget_Unparent_Call) Return() *MockSpinnerWidget_Unparent_Call {
13151	_c.Call.Return()
13152	return _c
13153}
13154
13155func (_c *MockSpinnerWidget_Unparent_Call) RunAndReturn(run func()) *MockSpinnerWidget_Unparent_Call {
13156	_c.Run(run)
13157	return _c
13158}
13159
13160// 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.
13161// The first argument is typically a *testing.T value.
13162func NewMockWidgetFactory(t interface {
13163	mock.TestingT
13164	Cleanup(func())
13165}) *MockWidgetFactory {
13166	mock := &MockWidgetFactory{}
13167	mock.Mock.Test(t)
13168
13169	t.Cleanup(func() { mock.AssertExpectations(t) })
13170
13171	return mock
13172}
13173
13174// MockWidgetFactory is an autogenerated mock type for the WidgetFactory type
13175type MockWidgetFactory struct {
13176	mock.Mock
13177}
13178
13179type MockWidgetFactory_Expecter struct {
13180	mock *mock.Mock
13181}
13182
13183func (_m *MockWidgetFactory) EXPECT() *MockWidgetFactory_Expecter {
13184	return &MockWidgetFactory_Expecter{mock: &_m.Mock}
13185}
13186
13187// NewBox provides a mock function for the type MockWidgetFactory
13188func (_mock *MockWidgetFactory) NewBox(orientation layout.Orientation, spacing int) layout.BoxWidget {
13189	ret := _mock.Called(orientation, spacing)
13190
13191	if len(ret) == 0 {
13192		panic("no return value specified for NewBox")
13193	}
13194
13195	var r0 layout.BoxWidget
13196	if returnFunc, ok := ret.Get(0).(func(layout.Orientation, int) layout.BoxWidget); ok {
13197		r0 = returnFunc(orientation, spacing)
13198	} else {
13199		if ret.Get(0) != nil {
13200			r0 = ret.Get(0).(layout.BoxWidget)
13201		}
13202	}
13203	return r0
13204}
13205
13206// MockWidgetFactory_NewBox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBox'
13207type MockWidgetFactory_NewBox_Call struct {
13208	*mock.Call
13209}
13210
13211// NewBox is a helper method to define mock.On call
13212//   - orientation layout.Orientation
13213//   - spacing int
13214func (_e *MockWidgetFactory_Expecter) NewBox(orientation interface{}, spacing interface{}) *MockWidgetFactory_NewBox_Call {
13215	return &MockWidgetFactory_NewBox_Call{Call: _e.mock.On("NewBox", orientation, spacing)}
13216}
13217
13218func (_c *MockWidgetFactory_NewBox_Call) Run(run func(orientation layout.Orientation, spacing int)) *MockWidgetFactory_NewBox_Call {
13219	_c.Call.Run(func(args mock.Arguments) {
13220		var arg0 layout.Orientation
13221		if args[0] != nil {
13222			arg0 = args[0].(layout.Orientation)
13223		}
13224		var arg1 int
13225		if args[1] != nil {
13226			arg1 = args[1].(int)
13227		}
13228		run(
13229			arg0,
13230			arg1,
13231		)
13232	})
13233	return _c
13234}
13235
13236func (_c *MockWidgetFactory_NewBox_Call) Return(boxWidget layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
13237	_c.Call.Return(boxWidget)
13238	return _c
13239}
13240
13241func (_c *MockWidgetFactory_NewBox_Call) RunAndReturn(run func(orientation layout.Orientation, spacing int) layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
13242	_c.Call.Return(run)
13243	return _c
13244}
13245
13246// NewButton provides a mock function for the type MockWidgetFactory
13247func (_mock *MockWidgetFactory) NewButton() layout.ButtonWidget {
13248	ret := _mock.Called()
13249
13250	if len(ret) == 0 {
13251		panic("no return value specified for NewButton")
13252	}
13253
13254	var r0 layout.ButtonWidget
13255	if returnFunc, ok := ret.Get(0).(func() layout.ButtonWidget); ok {
13256		r0 = returnFunc()
13257	} else {
13258		if ret.Get(0) != nil {
13259			r0 = ret.Get(0).(layout.ButtonWidget)
13260		}
13261	}
13262	return r0
13263}
13264
13265// MockWidgetFactory_NewButton_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewButton'
13266type MockWidgetFactory_NewButton_Call struct {
13267	*mock.Call
13268}
13269
13270// NewButton is a helper method to define mock.On call
13271func (_e *MockWidgetFactory_Expecter) NewButton() *MockWidgetFactory_NewButton_Call {
13272	return &MockWidgetFactory_NewButton_Call{Call: _e.mock.On("NewButton")}
13273}
13274
13275func (_c *MockWidgetFactory_NewButton_Call) Run(run func()) *MockWidgetFactory_NewButton_Call {
13276	_c.Call.Run(func(args mock.Arguments) {
13277		run()
13278	})
13279	return _c
13280}
13281
13282func (_c *MockWidgetFactory_NewButton_Call) Return(buttonWidget layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
13283	_c.Call.Return(buttonWidget)
13284	return _c
13285}
13286
13287func (_c *MockWidgetFactory_NewButton_Call) RunAndReturn(run func() layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
13288	_c.Call.Return(run)
13289	return _c
13290}
13291
13292// NewImage provides a mock function for the type MockWidgetFactory
13293func (_mock *MockWidgetFactory) NewImage() layout.ImageWidget {
13294	ret := _mock.Called()
13295
13296	if len(ret) == 0 {
13297		panic("no return value specified for NewImage")
13298	}
13299
13300	var r0 layout.ImageWidget
13301	if returnFunc, ok := ret.Get(0).(func() layout.ImageWidget); ok {
13302		r0 = returnFunc()
13303	} else {
13304		if ret.Get(0) != nil {
13305			r0 = ret.Get(0).(layout.ImageWidget)
13306		}
13307	}
13308	return r0
13309}
13310
13311// MockWidgetFactory_NewImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewImage'
13312type MockWidgetFactory_NewImage_Call struct {
13313	*mock.Call
13314}
13315
13316// NewImage is a helper method to define mock.On call
13317func (_e *MockWidgetFactory_Expecter) NewImage() *MockWidgetFactory_NewImage_Call {
13318	return &MockWidgetFactory_NewImage_Call{Call: _e.mock.On("NewImage")}
13319}
13320
13321func (_c *MockWidgetFactory_NewImage_Call) Run(run func()) *MockWidgetFactory_NewImage_Call {
13322	_c.Call.Run(func(args mock.Arguments) {
13323		run()
13324	})
13325	return _c
13326}
13327
13328func (_c *MockWidgetFactory_NewImage_Call) Return(imageWidget layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
13329	_c.Call.Return(imageWidget)
13330	return _c
13331}
13332
13333func (_c *MockWidgetFactory_NewImage_Call) RunAndReturn(run func() layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
13334	_c.Call.Return(run)
13335	return _c
13336}
13337
13338// NewLabel provides a mock function for the type MockWidgetFactory
13339func (_mock *MockWidgetFactory) NewLabel(text string) layout.LabelWidget {
13340	ret := _mock.Called(text)
13341
13342	if len(ret) == 0 {
13343		panic("no return value specified for NewLabel")
13344	}
13345
13346	var r0 layout.LabelWidget
13347	if returnFunc, ok := ret.Get(0).(func(string) layout.LabelWidget); ok {
13348		r0 = returnFunc(text)
13349	} else {
13350		if ret.Get(0) != nil {
13351			r0 = ret.Get(0).(layout.LabelWidget)
13352		}
13353	}
13354	return r0
13355}
13356
13357// MockWidgetFactory_NewLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewLabel'
13358type MockWidgetFactory_NewLabel_Call struct {
13359	*mock.Call
13360}
13361
13362// NewLabel is a helper method to define mock.On call
13363//   - text string
13364func (_e *MockWidgetFactory_Expecter) NewLabel(text interface{}) *MockWidgetFactory_NewLabel_Call {
13365	return &MockWidgetFactory_NewLabel_Call{Call: _e.mock.On("NewLabel", text)}
13366}
13367
13368func (_c *MockWidgetFactory_NewLabel_Call) Run(run func(text string)) *MockWidgetFactory_NewLabel_Call {
13369	_c.Call.Run(func(args mock.Arguments) {
13370		var arg0 string
13371		if args[0] != nil {
13372			arg0 = args[0].(string)
13373		}
13374		run(
13375			arg0,
13376		)
13377	})
13378	return _c
13379}
13380
13381func (_c *MockWidgetFactory_NewLabel_Call) Return(labelWidget layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
13382	_c.Call.Return(labelWidget)
13383	return _c
13384}
13385
13386func (_c *MockWidgetFactory_NewLabel_Call) RunAndReturn(run func(text string) layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
13387	_c.Call.Return(run)
13388	return _c
13389}
13390
13391// NewOverlay provides a mock function for the type MockWidgetFactory
13392func (_mock *MockWidgetFactory) NewOverlay() layout.OverlayWidget {
13393	ret := _mock.Called()
13394
13395	if len(ret) == 0 {
13396		panic("no return value specified for NewOverlay")
13397	}
13398
13399	var r0 layout.OverlayWidget
13400	if returnFunc, ok := ret.Get(0).(func() layout.OverlayWidget); ok {
13401		r0 = returnFunc()
13402	} else {
13403		if ret.Get(0) != nil {
13404			r0 = ret.Get(0).(layout.OverlayWidget)
13405		}
13406	}
13407	return r0
13408}
13409
13410// MockWidgetFactory_NewOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewOverlay'
13411type MockWidgetFactory_NewOverlay_Call struct {
13412	*mock.Call
13413}
13414
13415// NewOverlay is a helper method to define mock.On call
13416func (_e *MockWidgetFactory_Expecter) NewOverlay() *MockWidgetFactory_NewOverlay_Call {
13417	return &MockWidgetFactory_NewOverlay_Call{Call: _e.mock.On("NewOverlay")}
13418}
13419
13420func (_c *MockWidgetFactory_NewOverlay_Call) Run(run func()) *MockWidgetFactory_NewOverlay_Call {
13421	_c.Call.Run(func(args mock.Arguments) {
13422		run()
13423	})
13424	return _c
13425}
13426
13427func (_c *MockWidgetFactory_NewOverlay_Call) Return(overlayWidget layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
13428	_c.Call.Return(overlayWidget)
13429	return _c
13430}
13431
13432func (_c *MockWidgetFactory_NewOverlay_Call) RunAndReturn(run func() layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
13433	_c.Call.Return(run)
13434	return _c
13435}
13436
13437// NewPaned provides a mock function for the type MockWidgetFactory
13438func (_mock *MockWidgetFactory) NewPaned(orientation layout.Orientation) layout.PanedWidget {
13439	ret := _mock.Called(orientation)
13440
13441	if len(ret) == 0 {
13442		panic("no return value specified for NewPaned")
13443	}
13444
13445	var r0 layout.PanedWidget
13446	if returnFunc, ok := ret.Get(0).(func(layout.Orientation) layout.PanedWidget); ok {
13447		r0 = returnFunc(orientation)
13448	} else {
13449		if ret.Get(0) != nil {
13450			r0 = ret.Get(0).(layout.PanedWidget)
13451		}
13452	}
13453	return r0
13454}
13455
13456// MockWidgetFactory_NewPaned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewPaned'
13457type MockWidgetFactory_NewPaned_Call struct {
13458	*mock.Call
13459}
13460
13461// NewPaned is a helper method to define mock.On call
13462//   - orientation layout.Orientation
13463func (_e *MockWidgetFactory_Expecter) NewPaned(orientation interface{}) *MockWidgetFactory_NewPaned_Call {
13464	return &MockWidgetFactory_NewPaned_Call{Call: _e.mock.On("NewPaned", orientation)}
13465}
13466
13467func (_c *MockWidgetFactory_NewPaned_Call) Run(run func(orientation layout.Orientation)) *MockWidgetFactory_NewPaned_Call {
13468	_c.Call.Run(func(args mock.Arguments) {
13469		var arg0 layout.Orientation
13470		if args[0] != nil {
13471			arg0 = args[0].(layout.Orientation)
13472		}
13473		run(
13474			arg0,
13475		)
13476	})
13477	return _c
13478}
13479
13480func (_c *MockWidgetFactory_NewPaned_Call) Return(panedWidget layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
13481	_c.Call.Return(panedWidget)
13482	return _c
13483}
13484
13485func (_c *MockWidgetFactory_NewPaned_Call) RunAndReturn(run func(orientation layout.Orientation) layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
13486	_c.Call.Return(run)
13487	return _c
13488}
13489
13490// NewProgressBar provides a mock function for the type MockWidgetFactory
13491func (_mock *MockWidgetFactory) NewProgressBar() layout.ProgressBarWidget {
13492	ret := _mock.Called()
13493
13494	if len(ret) == 0 {
13495		panic("no return value specified for NewProgressBar")
13496	}
13497
13498	var r0 layout.ProgressBarWidget
13499	if returnFunc, ok := ret.Get(0).(func() layout.ProgressBarWidget); ok {
13500		r0 = returnFunc()
13501	} else {
13502		if ret.Get(0) != nil {
13503			r0 = ret.Get(0).(layout.ProgressBarWidget)
13504		}
13505	}
13506	return r0
13507}
13508
13509// MockWidgetFactory_NewProgressBar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewProgressBar'
13510type MockWidgetFactory_NewProgressBar_Call struct {
13511	*mock.Call
13512}
13513
13514// NewProgressBar is a helper method to define mock.On call
13515func (_e *MockWidgetFactory_Expecter) NewProgressBar() *MockWidgetFactory_NewProgressBar_Call {
13516	return &MockWidgetFactory_NewProgressBar_Call{Call: _e.mock.On("NewProgressBar")}
13517}
13518
13519func (_c *MockWidgetFactory_NewProgressBar_Call) Run(run func()) *MockWidgetFactory_NewProgressBar_Call {
13520	_c.Call.Run(func(args mock.Arguments) {
13521		run()
13522	})
13523	return _c
13524}
13525
13526func (_c *MockWidgetFactory_NewProgressBar_Call) Return(progressBarWidget layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
13527	_c.Call.Return(progressBarWidget)
13528	return _c
13529}
13530
13531func (_c *MockWidgetFactory_NewProgressBar_Call) RunAndReturn(run func() layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
13532	_c.Call.Return(run)
13533	return _c
13534}
13535
13536// NewSpinner provides a mock function for the type MockWidgetFactory
13537func (_mock *MockWidgetFactory) NewSpinner() layout.SpinnerWidget {
13538	ret := _mock.Called()
13539
13540	if len(ret) == 0 {
13541		panic("no return value specified for NewSpinner")
13542	}
13543
13544	var r0 layout.SpinnerWidget
13545	if returnFunc, ok := ret.Get(0).(func() layout.SpinnerWidget); ok {
13546		r0 = returnFunc()
13547	} else {
13548		if ret.Get(0) != nil {
13549			r0 = ret.Get(0).(layout.SpinnerWidget)
13550		}
13551	}
13552	return r0
13553}
13554
13555// MockWidgetFactory_NewSpinner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSpinner'
13556type MockWidgetFactory_NewSpinner_Call struct {
13557	*mock.Call
13558}
13559
13560// NewSpinner is a helper method to define mock.On call
13561func (_e *MockWidgetFactory_Expecter) NewSpinner() *MockWidgetFactory_NewSpinner_Call {
13562	return &MockWidgetFactory_NewSpinner_Call{Call: _e.mock.On("NewSpinner")}
13563}
13564
13565func (_c *MockWidgetFactory_NewSpinner_Call) Run(run func()) *MockWidgetFactory_NewSpinner_Call {
13566	_c.Call.Run(func(args mock.Arguments) {
13567		run()
13568	})
13569	return _c
13570}
13571
13572func (_c *MockWidgetFactory_NewSpinner_Call) Return(spinnerWidget layout.SpinnerWidget) *MockWidgetFactory_NewSpinner_Call {
13573	_c.Call.Return(spinnerWidget)
13574	return _c
13575}
13576
13577func (_c *MockWidgetFactory_NewSpinner_Call) RunAndReturn(run func() layout.SpinnerWidget) *MockWidgetFactory_NewSpinner_Call {
13578	_c.Call.Return(run)
13579	return _c
13580}
13581
13582// WrapWidget provides a mock function for the type MockWidgetFactory
13583func (_mock *MockWidgetFactory) WrapWidget(w *gtk.Widget) layout.Widget {
13584	ret := _mock.Called(w)
13585
13586	if len(ret) == 0 {
13587		panic("no return value specified for WrapWidget")
13588	}
13589
13590	var r0 layout.Widget
13591	if returnFunc, ok := ret.Get(0).(func(*gtk.Widget) layout.Widget); ok {
13592		r0 = returnFunc(w)
13593	} else {
13594		if ret.Get(0) != nil {
13595			r0 = ret.Get(0).(layout.Widget)
13596		}
13597	}
13598	return r0
13599}
13600
13601// MockWidgetFactory_WrapWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WrapWidget'
13602type MockWidgetFactory_WrapWidget_Call struct {
13603	*mock.Call
13604}
13605
13606// WrapWidget is a helper method to define mock.On call
13607//   - w *gtk.Widget
13608func (_e *MockWidgetFactory_Expecter) WrapWidget(w interface{}) *MockWidgetFactory_WrapWidget_Call {
13609	return &MockWidgetFactory_WrapWidget_Call{Call: _e.mock.On("WrapWidget", w)}
13610}
13611
13612func (_c *MockWidgetFactory_WrapWidget_Call) Run(run func(w *gtk.Widget)) *MockWidgetFactory_WrapWidget_Call {
13613	_c.Call.Run(func(args mock.Arguments) {
13614		var arg0 *gtk.Widget
13615		if args[0] != nil {
13616			arg0 = args[0].(*gtk.Widget)
13617		}
13618		run(
13619			arg0,
13620		)
13621	})
13622	return _c
13623}
13624
13625func (_c *MockWidgetFactory_WrapWidget_Call) Return(widget layout.Widget) *MockWidgetFactory_WrapWidget_Call {
13626	_c.Call.Return(widget)
13627	return _c
13628}
13629
13630func (_c *MockWidgetFactory_WrapWidget_Call) RunAndReturn(run func(w *gtk.Widget) layout.Widget) *MockWidgetFactory_WrapWidget_Call {
13631	_c.Call.Return(run)
13632	return _c
13633}
13634
13635// 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.
13636// The first argument is typically a *testing.T value.
13637func NewMockPaneRenderer(t interface {
13638	mock.TestingT
13639	Cleanup(func())
13640}) *MockPaneRenderer {
13641	mock := &MockPaneRenderer{}
13642	mock.Mock.Test(t)
13643
13644	t.Cleanup(func() { mock.AssertExpectations(t) })
13645
13646	return mock
13647}
13648
13649// MockPaneRenderer is an autogenerated mock type for the PaneRenderer type
13650type MockPaneRenderer struct {
13651	mock.Mock
13652}
13653
13654type MockPaneRenderer_Expecter struct {
13655	mock *mock.Mock
13656}
13657
13658func (_m *MockPaneRenderer) EXPECT() *MockPaneRenderer_Expecter {
13659	return &MockPaneRenderer_Expecter{mock: &_m.Mock}
13660}
13661
13662// RenderPane provides a mock function for the type MockPaneRenderer
13663func (_mock *MockPaneRenderer) RenderPane(paneID string, webViewWidget layout.Widget) layout.Widget {
13664	ret := _mock.Called(paneID, webViewWidget)
13665
13666	if len(ret) == 0 {
13667		panic("no return value specified for RenderPane")
13668	}
13669
13670	var r0 layout.Widget
13671	if returnFunc, ok := ret.Get(0).(func(string, layout.Widget) layout.Widget); ok {
13672		r0 = returnFunc(paneID, webViewWidget)
13673	} else {
13674		if ret.Get(0) != nil {
13675			r0 = ret.Get(0).(layout.Widget)
13676		}
13677	}
13678	return r0
13679}
13680
13681// MockPaneRenderer_RenderPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenderPane'
13682type MockPaneRenderer_RenderPane_Call struct {
13683	*mock.Call
13684}
13685
13686// RenderPane is a helper method to define mock.On call
13687//   - paneID string
13688//   - webViewWidget layout.Widget
13689func (_e *MockPaneRenderer_Expecter) RenderPane(paneID interface{}, webViewWidget interface{}) *MockPaneRenderer_RenderPane_Call {
13690	return &MockPaneRenderer_RenderPane_Call{Call: _e.mock.On("RenderPane", paneID, webViewWidget)}
13691}
13692
13693func (_c *MockPaneRenderer_RenderPane_Call) Run(run func(paneID string, webViewWidget layout.Widget)) *MockPaneRenderer_RenderPane_Call {
13694	_c.Call.Run(func(args mock.Arguments) {
13695		var arg0 string
13696		if args[0] != nil {
13697			arg0 = args[0].(string)
13698		}
13699		var arg1 layout.Widget
13700		if args[1] != nil {
13701			arg1 = args[1].(layout.Widget)
13702		}
13703		run(
13704			arg0,
13705			arg1,
13706		)
13707	})
13708	return _c
13709}
13710
13711func (_c *MockPaneRenderer_RenderPane_Call) Return(widget layout.Widget) *MockPaneRenderer_RenderPane_Call {
13712	_c.Call.Return(widget)
13713	return _c
13714}
13715
13716func (_c *MockPaneRenderer_RenderPane_Call) RunAndReturn(run func(paneID string, webViewWidget layout.Widget) layout.Widget) *MockPaneRenderer_RenderPane_Call {
13717	_c.Call.Return(run)
13718	return _c
13719}