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// SetIconName provides a mock function for the type MockButtonWidget
8955func (_mock *MockButtonWidget) SetIconName(iconName string) {
8956	_mock.Called(iconName)
8957	return
8958}
8959
8960// MockButtonWidget_SetIconName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetIconName'
8961type MockButtonWidget_SetIconName_Call struct {
8962	*mock.Call
8963}
8964
8965// SetIconName is a helper method to define mock.On call
8966//   - iconName string
8967func (_e *MockButtonWidget_Expecter) SetIconName(iconName interface{}) *MockButtonWidget_SetIconName_Call {
8968	return &MockButtonWidget_SetIconName_Call{Call: _e.mock.On("SetIconName", iconName)}
8969}
8970
8971func (_c *MockButtonWidget_SetIconName_Call) Run(run func(iconName string)) *MockButtonWidget_SetIconName_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_SetIconName_Call) Return() *MockButtonWidget_SetIconName_Call {
8985	_c.Call.Return()
8986	return _c
8987}
8988
8989func (_c *MockButtonWidget_SetIconName_Call) RunAndReturn(run func(iconName string)) *MockButtonWidget_SetIconName_Call {
8990	_c.Run(run)
8991	return _c
8992}
8993
8994// SetLabel provides a mock function for the type MockButtonWidget
8995func (_mock *MockButtonWidget) SetLabel(label string) {
8996	_mock.Called(label)
8997	return
8998}
8999
9000// MockButtonWidget_SetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabel'
9001type MockButtonWidget_SetLabel_Call struct {
9002	*mock.Call
9003}
9004
9005// SetLabel is a helper method to define mock.On call
9006//   - label string
9007func (_e *MockButtonWidget_Expecter) SetLabel(label interface{}) *MockButtonWidget_SetLabel_Call {
9008	return &MockButtonWidget_SetLabel_Call{Call: _e.mock.On("SetLabel", label)}
9009}
9010
9011func (_c *MockButtonWidget_SetLabel_Call) Run(run func(label string)) *MockButtonWidget_SetLabel_Call {
9012	_c.Call.Run(func(args mock.Arguments) {
9013		var arg0 string
9014		if args[0] != nil {
9015			arg0 = args[0].(string)
9016		}
9017		run(
9018			arg0,
9019		)
9020	})
9021	return _c
9022}
9023
9024func (_c *MockButtonWidget_SetLabel_Call) Return() *MockButtonWidget_SetLabel_Call {
9025	_c.Call.Return()
9026	return _c
9027}
9028
9029func (_c *MockButtonWidget_SetLabel_Call) RunAndReturn(run func(label string)) *MockButtonWidget_SetLabel_Call {
9030	_c.Run(run)
9031	return _c
9032}
9033
9034// SetSizeRequest provides a mock function for the type MockButtonWidget
9035func (_mock *MockButtonWidget) SetSizeRequest(width int, height int) {
9036	_mock.Called(width, height)
9037	return
9038}
9039
9040// MockButtonWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
9041type MockButtonWidget_SetSizeRequest_Call struct {
9042	*mock.Call
9043}
9044
9045// SetSizeRequest is a helper method to define mock.On call
9046//   - width int
9047//   - height int
9048func (_e *MockButtonWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockButtonWidget_SetSizeRequest_Call {
9049	return &MockButtonWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
9050}
9051
9052func (_c *MockButtonWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
9053	_c.Call.Run(func(args mock.Arguments) {
9054		var arg0 int
9055		if args[0] != nil {
9056			arg0 = args[0].(int)
9057		}
9058		var arg1 int
9059		if args[1] != nil {
9060			arg1 = args[1].(int)
9061		}
9062		run(
9063			arg0,
9064			arg1,
9065		)
9066	})
9067	return _c
9068}
9069
9070func (_c *MockButtonWidget_SetSizeRequest_Call) Return() *MockButtonWidget_SetSizeRequest_Call {
9071	_c.Call.Return()
9072	return _c
9073}
9074
9075func (_c *MockButtonWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
9076	_c.Run(run)
9077	return _c
9078}
9079
9080// SetValign provides a mock function for the type MockButtonWidget
9081func (_mock *MockButtonWidget) SetValign(align gtk.Align) {
9082	_mock.Called(align)
9083	return
9084}
9085
9086// MockButtonWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
9087type MockButtonWidget_SetValign_Call struct {
9088	*mock.Call
9089}
9090
9091// SetValign is a helper method to define mock.On call
9092//   - align gtk.Align
9093func (_e *MockButtonWidget_Expecter) SetValign(align interface{}) *MockButtonWidget_SetValign_Call {
9094	return &MockButtonWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
9095}
9096
9097func (_c *MockButtonWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
9098	_c.Call.Run(func(args mock.Arguments) {
9099		var arg0 gtk.Align
9100		if args[0] != nil {
9101			arg0 = args[0].(gtk.Align)
9102		}
9103		run(
9104			arg0,
9105		)
9106	})
9107	return _c
9108}
9109
9110func (_c *MockButtonWidget_SetValign_Call) Return() *MockButtonWidget_SetValign_Call {
9111	_c.Call.Return()
9112	return _c
9113}
9114
9115func (_c *MockButtonWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
9116	_c.Run(run)
9117	return _c
9118}
9119
9120// SetVexpand provides a mock function for the type MockButtonWidget
9121func (_mock *MockButtonWidget) SetVexpand(expand bool) {
9122	_mock.Called(expand)
9123	return
9124}
9125
9126// MockButtonWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
9127type MockButtonWidget_SetVexpand_Call struct {
9128	*mock.Call
9129}
9130
9131// SetVexpand is a helper method to define mock.On call
9132//   - expand bool
9133func (_e *MockButtonWidget_Expecter) SetVexpand(expand interface{}) *MockButtonWidget_SetVexpand_Call {
9134	return &MockButtonWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
9135}
9136
9137func (_c *MockButtonWidget_SetVexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetVexpand_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_SetVexpand_Call) Return() *MockButtonWidget_SetVexpand_Call {
9151	_c.Call.Return()
9152	return _c
9153}
9154
9155func (_c *MockButtonWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
9156	_c.Run(run)
9157	return _c
9158}
9159
9160// SetVisible provides a mock function for the type MockButtonWidget
9161func (_mock *MockButtonWidget) SetVisible(visible bool) {
9162	_mock.Called(visible)
9163	return
9164}
9165
9166// MockButtonWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
9167type MockButtonWidget_SetVisible_Call struct {
9168	*mock.Call
9169}
9170
9171// SetVisible is a helper method to define mock.On call
9172//   - visible bool
9173func (_e *MockButtonWidget_Expecter) SetVisible(visible interface{}) *MockButtonWidget_SetVisible_Call {
9174	return &MockButtonWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
9175}
9176
9177func (_c *MockButtonWidget_SetVisible_Call) Run(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
9178	_c.Call.Run(func(args mock.Arguments) {
9179		var arg0 bool
9180		if args[0] != nil {
9181			arg0 = args[0].(bool)
9182		}
9183		run(
9184			arg0,
9185		)
9186	})
9187	return _c
9188}
9189
9190func (_c *MockButtonWidget_SetVisible_Call) Return() *MockButtonWidget_SetVisible_Call {
9191	_c.Call.Return()
9192	return _c
9193}
9194
9195func (_c *MockButtonWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
9196	_c.Run(run)
9197	return _c
9198}
9199
9200// Show provides a mock function for the type MockButtonWidget
9201func (_mock *MockButtonWidget) Show() {
9202	_mock.Called()
9203	return
9204}
9205
9206// MockButtonWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
9207type MockButtonWidget_Show_Call struct {
9208	*mock.Call
9209}
9210
9211// Show is a helper method to define mock.On call
9212func (_e *MockButtonWidget_Expecter) Show() *MockButtonWidget_Show_Call {
9213	return &MockButtonWidget_Show_Call{Call: _e.mock.On("Show")}
9214}
9215
9216func (_c *MockButtonWidget_Show_Call) Run(run func()) *MockButtonWidget_Show_Call {
9217	_c.Call.Run(func(args mock.Arguments) {
9218		run()
9219	})
9220	return _c
9221}
9222
9223func (_c *MockButtonWidget_Show_Call) Return() *MockButtonWidget_Show_Call {
9224	_c.Call.Return()
9225	return _c
9226}
9227
9228func (_c *MockButtonWidget_Show_Call) RunAndReturn(run func()) *MockButtonWidget_Show_Call {
9229	_c.Run(run)
9230	return _c
9231}
9232
9233// Unparent provides a mock function for the type MockButtonWidget
9234func (_mock *MockButtonWidget) Unparent() {
9235	_mock.Called()
9236	return
9237}
9238
9239// MockButtonWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
9240type MockButtonWidget_Unparent_Call struct {
9241	*mock.Call
9242}
9243
9244// Unparent is a helper method to define mock.On call
9245func (_e *MockButtonWidget_Expecter) Unparent() *MockButtonWidget_Unparent_Call {
9246	return &MockButtonWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
9247}
9248
9249func (_c *MockButtonWidget_Unparent_Call) Run(run func()) *MockButtonWidget_Unparent_Call {
9250	_c.Call.Run(func(args mock.Arguments) {
9251		run()
9252	})
9253	return _c
9254}
9255
9256func (_c *MockButtonWidget_Unparent_Call) Return() *MockButtonWidget_Unparent_Call {
9257	_c.Call.Return()
9258	return _c
9259}
9260
9261func (_c *MockButtonWidget_Unparent_Call) RunAndReturn(run func()) *MockButtonWidget_Unparent_Call {
9262	_c.Run(run)
9263	return _c
9264}
9265
9266// 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.
9267// The first argument is typically a *testing.T value.
9268func NewMockImageWidget(t interface {
9269	mock.TestingT
9270	Cleanup(func())
9271}) *MockImageWidget {
9272	mock := &MockImageWidget{}
9273	mock.Mock.Test(t)
9274
9275	t.Cleanup(func() { mock.AssertExpectations(t) })
9276
9277	return mock
9278}
9279
9280// MockImageWidget is an autogenerated mock type for the ImageWidget type
9281type MockImageWidget struct {
9282	mock.Mock
9283}
9284
9285type MockImageWidget_Expecter struct {
9286	mock *mock.Mock
9287}
9288
9289func (_m *MockImageWidget) EXPECT() *MockImageWidget_Expecter {
9290	return &MockImageWidget_Expecter{mock: &_m.Mock}
9291}
9292
9293// AddController provides a mock function for the type MockImageWidget
9294func (_mock *MockImageWidget) AddController(controller *gtk.EventController) {
9295	_mock.Called(controller)
9296	return
9297}
9298
9299// MockImageWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
9300type MockImageWidget_AddController_Call struct {
9301	*mock.Call
9302}
9303
9304// AddController is a helper method to define mock.On call
9305//   - controller *gtk.EventController
9306func (_e *MockImageWidget_Expecter) AddController(controller interface{}) *MockImageWidget_AddController_Call {
9307	return &MockImageWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
9308}
9309
9310func (_c *MockImageWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
9311	_c.Call.Run(func(args mock.Arguments) {
9312		var arg0 *gtk.EventController
9313		if args[0] != nil {
9314			arg0 = args[0].(*gtk.EventController)
9315		}
9316		run(
9317			arg0,
9318		)
9319	})
9320	return _c
9321}
9322
9323func (_c *MockImageWidget_AddController_Call) Return() *MockImageWidget_AddController_Call {
9324	_c.Call.Return()
9325	return _c
9326}
9327
9328func (_c *MockImageWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
9329	_c.Run(run)
9330	return _c
9331}
9332
9333// AddCssClass provides a mock function for the type MockImageWidget
9334func (_mock *MockImageWidget) AddCssClass(cssClass string) {
9335	_mock.Called(cssClass)
9336	return
9337}
9338
9339// MockImageWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
9340type MockImageWidget_AddCssClass_Call struct {
9341	*mock.Call
9342}
9343
9344// AddCssClass is a helper method to define mock.On call
9345//   - cssClass string
9346func (_e *MockImageWidget_Expecter) AddCssClass(cssClass interface{}) *MockImageWidget_AddCssClass_Call {
9347	return &MockImageWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
9348}
9349
9350func (_c *MockImageWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
9351	_c.Call.Run(func(args mock.Arguments) {
9352		var arg0 string
9353		if args[0] != nil {
9354			arg0 = args[0].(string)
9355		}
9356		run(
9357			arg0,
9358		)
9359	})
9360	return _c
9361}
9362
9363func (_c *MockImageWidget_AddCssClass_Call) Return() *MockImageWidget_AddCssClass_Call {
9364	_c.Call.Return()
9365	return _c
9366}
9367
9368func (_c *MockImageWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
9369	_c.Run(run)
9370	return _c
9371}
9372
9373// Clear provides a mock function for the type MockImageWidget
9374func (_mock *MockImageWidget) Clear() {
9375	_mock.Called()
9376	return
9377}
9378
9379// MockImageWidget_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
9380type MockImageWidget_Clear_Call struct {
9381	*mock.Call
9382}
9383
9384// Clear is a helper method to define mock.On call
9385func (_e *MockImageWidget_Expecter) Clear() *MockImageWidget_Clear_Call {
9386	return &MockImageWidget_Clear_Call{Call: _e.mock.On("Clear")}
9387}
9388
9389func (_c *MockImageWidget_Clear_Call) Run(run func()) *MockImageWidget_Clear_Call {
9390	_c.Call.Run(func(args mock.Arguments) {
9391		run()
9392	})
9393	return _c
9394}
9395
9396func (_c *MockImageWidget_Clear_Call) Return() *MockImageWidget_Clear_Call {
9397	_c.Call.Return()
9398	return _c
9399}
9400
9401func (_c *MockImageWidget_Clear_Call) RunAndReturn(run func()) *MockImageWidget_Clear_Call {
9402	_c.Run(run)
9403	return _c
9404}
9405
9406// ComputePoint provides a mock function for the type MockImageWidget
9407func (_mock *MockImageWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
9408	ret := _mock.Called(target)
9409
9410	if len(ret) == 0 {
9411		panic("no return value specified for ComputePoint")
9412	}
9413
9414	var r0 float64
9415	var r1 float64
9416	var r2 bool
9417	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
9418		return returnFunc(target)
9419	}
9420	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
9421		r0 = returnFunc(target)
9422	} else {
9423		r0 = ret.Get(0).(float64)
9424	}
9425	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
9426		r1 = returnFunc(target)
9427	} else {
9428		r1 = ret.Get(1).(float64)
9429	}
9430	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
9431		r2 = returnFunc(target)
9432	} else {
9433		r2 = ret.Get(2).(bool)
9434	}
9435	return r0, r1, r2
9436}
9437
9438// MockImageWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
9439type MockImageWidget_ComputePoint_Call struct {
9440	*mock.Call
9441}
9442
9443// ComputePoint is a helper method to define mock.On call
9444//   - target layout.Widget
9445func (_e *MockImageWidget_Expecter) ComputePoint(target interface{}) *MockImageWidget_ComputePoint_Call {
9446	return &MockImageWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
9447}
9448
9449func (_c *MockImageWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockImageWidget_ComputePoint_Call {
9450	_c.Call.Run(func(args mock.Arguments) {
9451		var arg0 layout.Widget
9452		if args[0] != nil {
9453			arg0 = args[0].(layout.Widget)
9454		}
9455		run(
9456			arg0,
9457		)
9458	})
9459	return _c
9460}
9461
9462func (_c *MockImageWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockImageWidget_ComputePoint_Call {
9463	_c.Call.Return(x, y, ok)
9464	return _c
9465}
9466
9467func (_c *MockImageWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockImageWidget_ComputePoint_Call {
9468	_c.Call.Return(run)
9469	return _c
9470}
9471
9472// GetAllocatedHeight provides a mock function for the type MockImageWidget
9473func (_mock *MockImageWidget) GetAllocatedHeight() int {
9474	ret := _mock.Called()
9475
9476	if len(ret) == 0 {
9477		panic("no return value specified for GetAllocatedHeight")
9478	}
9479
9480	var r0 int
9481	if returnFunc, ok := ret.Get(0).(func() int); ok {
9482		r0 = returnFunc()
9483	} else {
9484		r0 = ret.Get(0).(int)
9485	}
9486	return r0
9487}
9488
9489// MockImageWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
9490type MockImageWidget_GetAllocatedHeight_Call struct {
9491	*mock.Call
9492}
9493
9494// GetAllocatedHeight is a helper method to define mock.On call
9495func (_e *MockImageWidget_Expecter) GetAllocatedHeight() *MockImageWidget_GetAllocatedHeight_Call {
9496	return &MockImageWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
9497}
9498
9499func (_c *MockImageWidget_GetAllocatedHeight_Call) Run(run func()) *MockImageWidget_GetAllocatedHeight_Call {
9500	_c.Call.Run(func(args mock.Arguments) {
9501		run()
9502	})
9503	return _c
9504}
9505
9506func (_c *MockImageWidget_GetAllocatedHeight_Call) Return(n int) *MockImageWidget_GetAllocatedHeight_Call {
9507	_c.Call.Return(n)
9508	return _c
9509}
9510
9511func (_c *MockImageWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedHeight_Call {
9512	_c.Call.Return(run)
9513	return _c
9514}
9515
9516// GetAllocatedWidth provides a mock function for the type MockImageWidget
9517func (_mock *MockImageWidget) GetAllocatedWidth() int {
9518	ret := _mock.Called()
9519
9520	if len(ret) == 0 {
9521		panic("no return value specified for GetAllocatedWidth")
9522	}
9523
9524	var r0 int
9525	if returnFunc, ok := ret.Get(0).(func() int); ok {
9526		r0 = returnFunc()
9527	} else {
9528		r0 = ret.Get(0).(int)
9529	}
9530	return r0
9531}
9532
9533// MockImageWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
9534type MockImageWidget_GetAllocatedWidth_Call struct {
9535	*mock.Call
9536}
9537
9538// GetAllocatedWidth is a helper method to define mock.On call
9539func (_e *MockImageWidget_Expecter) GetAllocatedWidth() *MockImageWidget_GetAllocatedWidth_Call {
9540	return &MockImageWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
9541}
9542
9543func (_c *MockImageWidget_GetAllocatedWidth_Call) Run(run func()) *MockImageWidget_GetAllocatedWidth_Call {
9544	_c.Call.Run(func(args mock.Arguments) {
9545		run()
9546	})
9547	return _c
9548}
9549
9550func (_c *MockImageWidget_GetAllocatedWidth_Call) Return(n int) *MockImageWidget_GetAllocatedWidth_Call {
9551	_c.Call.Return(n)
9552	return _c
9553}
9554
9555func (_c *MockImageWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedWidth_Call {
9556	_c.Call.Return(run)
9557	return _c
9558}
9559
9560// GetHexpand provides a mock function for the type MockImageWidget
9561func (_mock *MockImageWidget) GetHexpand() bool {
9562	ret := _mock.Called()
9563
9564	if len(ret) == 0 {
9565		panic("no return value specified for GetHexpand")
9566	}
9567
9568	var r0 bool
9569	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9570		r0 = returnFunc()
9571	} else {
9572		r0 = ret.Get(0).(bool)
9573	}
9574	return r0
9575}
9576
9577// MockImageWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
9578type MockImageWidget_GetHexpand_Call struct {
9579	*mock.Call
9580}
9581
9582// GetHexpand is a helper method to define mock.On call
9583func (_e *MockImageWidget_Expecter) GetHexpand() *MockImageWidget_GetHexpand_Call {
9584	return &MockImageWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
9585}
9586
9587func (_c *MockImageWidget_GetHexpand_Call) Run(run func()) *MockImageWidget_GetHexpand_Call {
9588	_c.Call.Run(func(args mock.Arguments) {
9589		run()
9590	})
9591	return _c
9592}
9593
9594func (_c *MockImageWidget_GetHexpand_Call) Return(b bool) *MockImageWidget_GetHexpand_Call {
9595	_c.Call.Return(b)
9596	return _c
9597}
9598
9599func (_c *MockImageWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetHexpand_Call {
9600	_c.Call.Return(run)
9601	return _c
9602}
9603
9604// GetParent provides a mock function for the type MockImageWidget
9605func (_mock *MockImageWidget) GetParent() layout.Widget {
9606	ret := _mock.Called()
9607
9608	if len(ret) == 0 {
9609		panic("no return value specified for GetParent")
9610	}
9611
9612	var r0 layout.Widget
9613	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
9614		r0 = returnFunc()
9615	} else {
9616		if ret.Get(0) != nil {
9617			r0 = ret.Get(0).(layout.Widget)
9618		}
9619	}
9620	return r0
9621}
9622
9623// MockImageWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
9624type MockImageWidget_GetParent_Call struct {
9625	*mock.Call
9626}
9627
9628// GetParent is a helper method to define mock.On call
9629func (_e *MockImageWidget_Expecter) GetParent() *MockImageWidget_GetParent_Call {
9630	return &MockImageWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
9631}
9632
9633func (_c *MockImageWidget_GetParent_Call) Run(run func()) *MockImageWidget_GetParent_Call {
9634	_c.Call.Run(func(args mock.Arguments) {
9635		run()
9636	})
9637	return _c
9638}
9639
9640func (_c *MockImageWidget_GetParent_Call) Return(widget layout.Widget) *MockImageWidget_GetParent_Call {
9641	_c.Call.Return(widget)
9642	return _c
9643}
9644
9645func (_c *MockImageWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockImageWidget_GetParent_Call {
9646	_c.Call.Return(run)
9647	return _c
9648}
9649
9650// GetVexpand provides a mock function for the type MockImageWidget
9651func (_mock *MockImageWidget) GetVexpand() bool {
9652	ret := _mock.Called()
9653
9654	if len(ret) == 0 {
9655		panic("no return value specified for GetVexpand")
9656	}
9657
9658	var r0 bool
9659	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9660		r0 = returnFunc()
9661	} else {
9662		r0 = ret.Get(0).(bool)
9663	}
9664	return r0
9665}
9666
9667// MockImageWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
9668type MockImageWidget_GetVexpand_Call struct {
9669	*mock.Call
9670}
9671
9672// GetVexpand is a helper method to define mock.On call
9673func (_e *MockImageWidget_Expecter) GetVexpand() *MockImageWidget_GetVexpand_Call {
9674	return &MockImageWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
9675}
9676
9677func (_c *MockImageWidget_GetVexpand_Call) Run(run func()) *MockImageWidget_GetVexpand_Call {
9678	_c.Call.Run(func(args mock.Arguments) {
9679		run()
9680	})
9681	return _c
9682}
9683
9684func (_c *MockImageWidget_GetVexpand_Call) Return(b bool) *MockImageWidget_GetVexpand_Call {
9685	_c.Call.Return(b)
9686	return _c
9687}
9688
9689func (_c *MockImageWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetVexpand_Call {
9690	_c.Call.Return(run)
9691	return _c
9692}
9693
9694// GrabFocus provides a mock function for the type MockImageWidget
9695func (_mock *MockImageWidget) GrabFocus() bool {
9696	ret := _mock.Called()
9697
9698	if len(ret) == 0 {
9699		panic("no return value specified for GrabFocus")
9700	}
9701
9702	var r0 bool
9703	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9704		r0 = returnFunc()
9705	} else {
9706		r0 = ret.Get(0).(bool)
9707	}
9708	return r0
9709}
9710
9711// MockImageWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
9712type MockImageWidget_GrabFocus_Call struct {
9713	*mock.Call
9714}
9715
9716// GrabFocus is a helper method to define mock.On call
9717func (_e *MockImageWidget_Expecter) GrabFocus() *MockImageWidget_GrabFocus_Call {
9718	return &MockImageWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
9719}
9720
9721func (_c *MockImageWidget_GrabFocus_Call) Run(run func()) *MockImageWidget_GrabFocus_Call {
9722	_c.Call.Run(func(args mock.Arguments) {
9723		run()
9724	})
9725	return _c
9726}
9727
9728func (_c *MockImageWidget_GrabFocus_Call) Return(b bool) *MockImageWidget_GrabFocus_Call {
9729	_c.Call.Return(b)
9730	return _c
9731}
9732
9733func (_c *MockImageWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_GrabFocus_Call {
9734	_c.Call.Return(run)
9735	return _c
9736}
9737
9738// GtkWidget provides a mock function for the type MockImageWidget
9739func (_mock *MockImageWidget) GtkWidget() *gtk.Widget {
9740	ret := _mock.Called()
9741
9742	if len(ret) == 0 {
9743		panic("no return value specified for GtkWidget")
9744	}
9745
9746	var r0 *gtk.Widget
9747	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
9748		r0 = returnFunc()
9749	} else {
9750		if ret.Get(0) != nil {
9751			r0 = ret.Get(0).(*gtk.Widget)
9752		}
9753	}
9754	return r0
9755}
9756
9757// MockImageWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
9758type MockImageWidget_GtkWidget_Call struct {
9759	*mock.Call
9760}
9761
9762// GtkWidget is a helper method to define mock.On call
9763func (_e *MockImageWidget_Expecter) GtkWidget() *MockImageWidget_GtkWidget_Call {
9764	return &MockImageWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
9765}
9766
9767func (_c *MockImageWidget_GtkWidget_Call) Run(run func()) *MockImageWidget_GtkWidget_Call {
9768	_c.Call.Run(func(args mock.Arguments) {
9769		run()
9770	})
9771	return _c
9772}
9773
9774func (_c *MockImageWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockImageWidget_GtkWidget_Call {
9775	_c.Call.Return(widget)
9776	return _c
9777}
9778
9779func (_c *MockImageWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockImageWidget_GtkWidget_Call {
9780	_c.Call.Return(run)
9781	return _c
9782}
9783
9784// HasCssClass provides a mock function for the type MockImageWidget
9785func (_mock *MockImageWidget) HasCssClass(cssClass string) bool {
9786	ret := _mock.Called(cssClass)
9787
9788	if len(ret) == 0 {
9789		panic("no return value specified for HasCssClass")
9790	}
9791
9792	var r0 bool
9793	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
9794		r0 = returnFunc(cssClass)
9795	} else {
9796		r0 = ret.Get(0).(bool)
9797	}
9798	return r0
9799}
9800
9801// MockImageWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
9802type MockImageWidget_HasCssClass_Call struct {
9803	*mock.Call
9804}
9805
9806// HasCssClass is a helper method to define mock.On call
9807//   - cssClass string
9808func (_e *MockImageWidget_Expecter) HasCssClass(cssClass interface{}) *MockImageWidget_HasCssClass_Call {
9809	return &MockImageWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
9810}
9811
9812func (_c *MockImageWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_HasCssClass_Call {
9813	_c.Call.Run(func(args mock.Arguments) {
9814		var arg0 string
9815		if args[0] != nil {
9816			arg0 = args[0].(string)
9817		}
9818		run(
9819			arg0,
9820		)
9821	})
9822	return _c
9823}
9824
9825func (_c *MockImageWidget_HasCssClass_Call) Return(b bool) *MockImageWidget_HasCssClass_Call {
9826	_c.Call.Return(b)
9827	return _c
9828}
9829
9830func (_c *MockImageWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockImageWidget_HasCssClass_Call {
9831	_c.Call.Return(run)
9832	return _c
9833}
9834
9835// HasFocus provides a mock function for the type MockImageWidget
9836func (_mock *MockImageWidget) HasFocus() bool {
9837	ret := _mock.Called()
9838
9839	if len(ret) == 0 {
9840		panic("no return value specified for HasFocus")
9841	}
9842
9843	var r0 bool
9844	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9845		r0 = returnFunc()
9846	} else {
9847		r0 = ret.Get(0).(bool)
9848	}
9849	return r0
9850}
9851
9852// MockImageWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
9853type MockImageWidget_HasFocus_Call struct {
9854	*mock.Call
9855}
9856
9857// HasFocus is a helper method to define mock.On call
9858func (_e *MockImageWidget_Expecter) HasFocus() *MockImageWidget_HasFocus_Call {
9859	return &MockImageWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
9860}
9861
9862func (_c *MockImageWidget_HasFocus_Call) Run(run func()) *MockImageWidget_HasFocus_Call {
9863	_c.Call.Run(func(args mock.Arguments) {
9864		run()
9865	})
9866	return _c
9867}
9868
9869func (_c *MockImageWidget_HasFocus_Call) Return(b bool) *MockImageWidget_HasFocus_Call {
9870	_c.Call.Return(b)
9871	return _c
9872}
9873
9874func (_c *MockImageWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_HasFocus_Call {
9875	_c.Call.Return(run)
9876	return _c
9877}
9878
9879// Hide provides a mock function for the type MockImageWidget
9880func (_mock *MockImageWidget) Hide() {
9881	_mock.Called()
9882	return
9883}
9884
9885// MockImageWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
9886type MockImageWidget_Hide_Call struct {
9887	*mock.Call
9888}
9889
9890// Hide is a helper method to define mock.On call
9891func (_e *MockImageWidget_Expecter) Hide() *MockImageWidget_Hide_Call {
9892	return &MockImageWidget_Hide_Call{Call: _e.mock.On("Hide")}
9893}
9894
9895func (_c *MockImageWidget_Hide_Call) Run(run func()) *MockImageWidget_Hide_Call {
9896	_c.Call.Run(func(args mock.Arguments) {
9897		run()
9898	})
9899	return _c
9900}
9901
9902func (_c *MockImageWidget_Hide_Call) Return() *MockImageWidget_Hide_Call {
9903	_c.Call.Return()
9904	return _c
9905}
9906
9907func (_c *MockImageWidget_Hide_Call) RunAndReturn(run func()) *MockImageWidget_Hide_Call {
9908	_c.Run(run)
9909	return _c
9910}
9911
9912// IsVisible provides a mock function for the type MockImageWidget
9913func (_mock *MockImageWidget) IsVisible() bool {
9914	ret := _mock.Called()
9915
9916	if len(ret) == 0 {
9917		panic("no return value specified for IsVisible")
9918	}
9919
9920	var r0 bool
9921	if returnFunc, ok := ret.Get(0).(func() bool); ok {
9922		r0 = returnFunc()
9923	} else {
9924		r0 = ret.Get(0).(bool)
9925	}
9926	return r0
9927}
9928
9929// MockImageWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
9930type MockImageWidget_IsVisible_Call struct {
9931	*mock.Call
9932}
9933
9934// IsVisible is a helper method to define mock.On call
9935func (_e *MockImageWidget_Expecter) IsVisible() *MockImageWidget_IsVisible_Call {
9936	return &MockImageWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
9937}
9938
9939func (_c *MockImageWidget_IsVisible_Call) Run(run func()) *MockImageWidget_IsVisible_Call {
9940	_c.Call.Run(func(args mock.Arguments) {
9941		run()
9942	})
9943	return _c
9944}
9945
9946func (_c *MockImageWidget_IsVisible_Call) Return(b bool) *MockImageWidget_IsVisible_Call {
9947	_c.Call.Return(b)
9948	return _c
9949}
9950
9951func (_c *MockImageWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockImageWidget_IsVisible_Call {
9952	_c.Call.Return(run)
9953	return _c
9954}
9955
9956// RemoveCssClass provides a mock function for the type MockImageWidget
9957func (_mock *MockImageWidget) RemoveCssClass(cssClass string) {
9958	_mock.Called(cssClass)
9959	return
9960}
9961
9962// MockImageWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
9963type MockImageWidget_RemoveCssClass_Call struct {
9964	*mock.Call
9965}
9966
9967// RemoveCssClass is a helper method to define mock.On call
9968//   - cssClass string
9969func (_e *MockImageWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockImageWidget_RemoveCssClass_Call {
9970	return &MockImageWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
9971}
9972
9973func (_c *MockImageWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
9974	_c.Call.Run(func(args mock.Arguments) {
9975		var arg0 string
9976		if args[0] != nil {
9977			arg0 = args[0].(string)
9978		}
9979		run(
9980			arg0,
9981		)
9982	})
9983	return _c
9984}
9985
9986func (_c *MockImageWidget_RemoveCssClass_Call) Return() *MockImageWidget_RemoveCssClass_Call {
9987	_c.Call.Return()
9988	return _c
9989}
9990
9991func (_c *MockImageWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
9992	_c.Run(run)
9993	return _c
9994}
9995
9996// SetCanFocus provides a mock function for the type MockImageWidget
9997func (_mock *MockImageWidget) SetCanFocus(canFocus bool) {
9998	_mock.Called(canFocus)
9999	return
10000}
10001
10002// MockImageWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
10003type MockImageWidget_SetCanFocus_Call struct {
10004	*mock.Call
10005}
10006
10007// SetCanFocus is a helper method to define mock.On call
10008//   - canFocus bool
10009func (_e *MockImageWidget_Expecter) SetCanFocus(canFocus interface{}) *MockImageWidget_SetCanFocus_Call {
10010	return &MockImageWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
10011}
10012
10013func (_c *MockImageWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockImageWidget_SetCanFocus_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_SetCanFocus_Call) Return() *MockImageWidget_SetCanFocus_Call {
10027	_c.Call.Return()
10028	return _c
10029}
10030
10031func (_c *MockImageWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
10032	_c.Run(run)
10033	return _c
10034}
10035
10036// SetCanTarget provides a mock function for the type MockImageWidget
10037func (_mock *MockImageWidget) SetCanTarget(canTarget bool) {
10038	_mock.Called(canTarget)
10039	return
10040}
10041
10042// MockImageWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
10043type MockImageWidget_SetCanTarget_Call struct {
10044	*mock.Call
10045}
10046
10047// SetCanTarget is a helper method to define mock.On call
10048//   - canTarget bool
10049func (_e *MockImageWidget_Expecter) SetCanTarget(canTarget interface{}) *MockImageWidget_SetCanTarget_Call {
10050	return &MockImageWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
10051}
10052
10053func (_c *MockImageWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockImageWidget_SetCanTarget_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_SetCanTarget_Call) Return() *MockImageWidget_SetCanTarget_Call {
10067	_c.Call.Return()
10068	return _c
10069}
10070
10071func (_c *MockImageWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockImageWidget_SetCanTarget_Call {
10072	_c.Run(run)
10073	return _c
10074}
10075
10076// SetFocusOnClick provides a mock function for the type MockImageWidget
10077func (_mock *MockImageWidget) SetFocusOnClick(focusOnClick bool) {
10078	_mock.Called(focusOnClick)
10079	return
10080}
10081
10082// MockImageWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
10083type MockImageWidget_SetFocusOnClick_Call struct {
10084	*mock.Call
10085}
10086
10087// SetFocusOnClick is a helper method to define mock.On call
10088//   - focusOnClick bool
10089func (_e *MockImageWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockImageWidget_SetFocusOnClick_Call {
10090	return &MockImageWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
10091}
10092
10093func (_c *MockImageWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_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_SetFocusOnClick_Call) Return() *MockImageWidget_SetFocusOnClick_Call {
10107	_c.Call.Return()
10108	return _c
10109}
10110
10111func (_c *MockImageWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
10112	_c.Run(run)
10113	return _c
10114}
10115
10116// SetFocusable provides a mock function for the type MockImageWidget
10117func (_mock *MockImageWidget) SetFocusable(focusable bool) {
10118	_mock.Called(focusable)
10119	return
10120}
10121
10122// MockImageWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
10123type MockImageWidget_SetFocusable_Call struct {
10124	*mock.Call
10125}
10126
10127// SetFocusable is a helper method to define mock.On call
10128//   - focusable bool
10129func (_e *MockImageWidget_Expecter) SetFocusable(focusable interface{}) *MockImageWidget_SetFocusable_Call {
10130	return &MockImageWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
10131}
10132
10133func (_c *MockImageWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockImageWidget_SetFocusable_Call {
10134	_c.Call.Run(func(args mock.Arguments) {
10135		var arg0 bool
10136		if args[0] != nil {
10137			arg0 = args[0].(bool)
10138		}
10139		run(
10140			arg0,
10141		)
10142	})
10143	return _c
10144}
10145
10146func (_c *MockImageWidget_SetFocusable_Call) Return() *MockImageWidget_SetFocusable_Call {
10147	_c.Call.Return()
10148	return _c
10149}
10150
10151func (_c *MockImageWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockImageWidget_SetFocusable_Call {
10152	_c.Run(run)
10153	return _c
10154}
10155
10156// SetFromFile provides a mock function for the type MockImageWidget
10157func (_mock *MockImageWidget) SetFromFile(filename string) {
10158	_mock.Called(filename)
10159	return
10160}
10161
10162// MockImageWidget_SetFromFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromFile'
10163type MockImageWidget_SetFromFile_Call struct {
10164	*mock.Call
10165}
10166
10167// SetFromFile is a helper method to define mock.On call
10168//   - filename string
10169func (_e *MockImageWidget_Expecter) SetFromFile(filename interface{}) *MockImageWidget_SetFromFile_Call {
10170	return &MockImageWidget_SetFromFile_Call{Call: _e.mock.On("SetFromFile", filename)}
10171}
10172
10173func (_c *MockImageWidget_SetFromFile_Call) Run(run func(filename string)) *MockImageWidget_SetFromFile_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_SetFromFile_Call) Return() *MockImageWidget_SetFromFile_Call {
10187	_c.Call.Return()
10188	return _c
10189}
10190
10191func (_c *MockImageWidget_SetFromFile_Call) RunAndReturn(run func(filename string)) *MockImageWidget_SetFromFile_Call {
10192	_c.Run(run)
10193	return _c
10194}
10195
10196// SetFromIconName provides a mock function for the type MockImageWidget
10197func (_mock *MockImageWidget) SetFromIconName(iconName string) {
10198	_mock.Called(iconName)
10199	return
10200}
10201
10202// MockImageWidget_SetFromIconName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromIconName'
10203type MockImageWidget_SetFromIconName_Call struct {
10204	*mock.Call
10205}
10206
10207// SetFromIconName is a helper method to define mock.On call
10208//   - iconName string
10209func (_e *MockImageWidget_Expecter) SetFromIconName(iconName interface{}) *MockImageWidget_SetFromIconName_Call {
10210	return &MockImageWidget_SetFromIconName_Call{Call: _e.mock.On("SetFromIconName", iconName)}
10211}
10212
10213func (_c *MockImageWidget_SetFromIconName_Call) Run(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
10214	_c.Call.Run(func(args mock.Arguments) {
10215		var arg0 string
10216		if args[0] != nil {
10217			arg0 = args[0].(string)
10218		}
10219		run(
10220			arg0,
10221		)
10222	})
10223	return _c
10224}
10225
10226func (_c *MockImageWidget_SetFromIconName_Call) Return() *MockImageWidget_SetFromIconName_Call {
10227	_c.Call.Return()
10228	return _c
10229}
10230
10231func (_c *MockImageWidget_SetFromIconName_Call) RunAndReturn(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
10232	_c.Run(run)
10233	return _c
10234}
10235
10236// SetFromPaintable provides a mock function for the type MockImageWidget
10237func (_mock *MockImageWidget) SetFromPaintable(paintable layout.Paintable) {
10238	_mock.Called(paintable)
10239	return
10240}
10241
10242// MockImageWidget_SetFromPaintable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromPaintable'
10243type MockImageWidget_SetFromPaintable_Call struct {
10244	*mock.Call
10245}
10246
10247// SetFromPaintable is a helper method to define mock.On call
10248//   - paintable layout.Paintable
10249func (_e *MockImageWidget_Expecter) SetFromPaintable(paintable interface{}) *MockImageWidget_SetFromPaintable_Call {
10250	return &MockImageWidget_SetFromPaintable_Call{Call: _e.mock.On("SetFromPaintable", paintable)}
10251}
10252
10253func (_c *MockImageWidget_SetFromPaintable_Call) Run(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
10254	_c.Call.Run(func(args mock.Arguments) {
10255		var arg0 layout.Paintable
10256		if args[0] != nil {
10257			arg0 = args[0].(layout.Paintable)
10258		}
10259		run(
10260			arg0,
10261		)
10262	})
10263	return _c
10264}
10265
10266func (_c *MockImageWidget_SetFromPaintable_Call) Return() *MockImageWidget_SetFromPaintable_Call {
10267	_c.Call.Return()
10268	return _c
10269}
10270
10271func (_c *MockImageWidget_SetFromPaintable_Call) RunAndReturn(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
10272	_c.Run(run)
10273	return _c
10274}
10275
10276// SetHalign provides a mock function for the type MockImageWidget
10277func (_mock *MockImageWidget) SetHalign(align gtk.Align) {
10278	_mock.Called(align)
10279	return
10280}
10281
10282// MockImageWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
10283type MockImageWidget_SetHalign_Call struct {
10284	*mock.Call
10285}
10286
10287// SetHalign is a helper method to define mock.On call
10288//   - align gtk.Align
10289func (_e *MockImageWidget_Expecter) SetHalign(align interface{}) *MockImageWidget_SetHalign_Call {
10290	return &MockImageWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
10291}
10292
10293func (_c *MockImageWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
10294	_c.Call.Run(func(args mock.Arguments) {
10295		var arg0 gtk.Align
10296		if args[0] != nil {
10297			arg0 = args[0].(gtk.Align)
10298		}
10299		run(
10300			arg0,
10301		)
10302	})
10303	return _c
10304}
10305
10306func (_c *MockImageWidget_SetHalign_Call) Return() *MockImageWidget_SetHalign_Call {
10307	_c.Call.Return()
10308	return _c
10309}
10310
10311func (_c *MockImageWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
10312	_c.Run(run)
10313	return _c
10314}
10315
10316// SetHexpand provides a mock function for the type MockImageWidget
10317func (_mock *MockImageWidget) SetHexpand(expand bool) {
10318	_mock.Called(expand)
10319	return
10320}
10321
10322// MockImageWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
10323type MockImageWidget_SetHexpand_Call struct {
10324	*mock.Call
10325}
10326
10327// SetHexpand is a helper method to define mock.On call
10328//   - expand bool
10329func (_e *MockImageWidget_Expecter) SetHexpand(expand interface{}) *MockImageWidget_SetHexpand_Call {
10330	return &MockImageWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
10331}
10332
10333func (_c *MockImageWidget_SetHexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
10334	_c.Call.Run(func(args mock.Arguments) {
10335		var arg0 bool
10336		if args[0] != nil {
10337			arg0 = args[0].(bool)
10338		}
10339		run(
10340			arg0,
10341		)
10342	})
10343	return _c
10344}
10345
10346func (_c *MockImageWidget_SetHexpand_Call) Return() *MockImageWidget_SetHexpand_Call {
10347	_c.Call.Return()
10348	return _c
10349}
10350
10351func (_c *MockImageWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
10352	_c.Run(run)
10353	return _c
10354}
10355
10356// SetPixelSize provides a mock function for the type MockImageWidget
10357func (_mock *MockImageWidget) SetPixelSize(pixelSize int) {
10358	_mock.Called(pixelSize)
10359	return
10360}
10361
10362// MockImageWidget_SetPixelSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPixelSize'
10363type MockImageWidget_SetPixelSize_Call struct {
10364	*mock.Call
10365}
10366
10367// SetPixelSize is a helper method to define mock.On call
10368//   - pixelSize int
10369func (_e *MockImageWidget_Expecter) SetPixelSize(pixelSize interface{}) *MockImageWidget_SetPixelSize_Call {
10370	return &MockImageWidget_SetPixelSize_Call{Call: _e.mock.On("SetPixelSize", pixelSize)}
10371}
10372
10373func (_c *MockImageWidget_SetPixelSize_Call) Run(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
10374	_c.Call.Run(func(args mock.Arguments) {
10375		var arg0 int
10376		if args[0] != nil {
10377			arg0 = args[0].(int)
10378		}
10379		run(
10380			arg0,
10381		)
10382	})
10383	return _c
10384}
10385
10386func (_c *MockImageWidget_SetPixelSize_Call) Return() *MockImageWidget_SetPixelSize_Call {
10387	_c.Call.Return()
10388	return _c
10389}
10390
10391func (_c *MockImageWidget_SetPixelSize_Call) RunAndReturn(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
10392	_c.Run(run)
10393	return _c
10394}
10395
10396// SetSizeRequest provides a mock function for the type MockImageWidget
10397func (_mock *MockImageWidget) SetSizeRequest(width int, height int) {
10398	_mock.Called(width, height)
10399	return
10400}
10401
10402// MockImageWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
10403type MockImageWidget_SetSizeRequest_Call struct {
10404	*mock.Call
10405}
10406
10407// SetSizeRequest is a helper method to define mock.On call
10408//   - width int
10409//   - height int
10410func (_e *MockImageWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockImageWidget_SetSizeRequest_Call {
10411	return &MockImageWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
10412}
10413
10414func (_c *MockImageWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
10415	_c.Call.Run(func(args mock.Arguments) {
10416		var arg0 int
10417		if args[0] != nil {
10418			arg0 = args[0].(int)
10419		}
10420		var arg1 int
10421		if args[1] != nil {
10422			arg1 = args[1].(int)
10423		}
10424		run(
10425			arg0,
10426			arg1,
10427		)
10428	})
10429	return _c
10430}
10431
10432func (_c *MockImageWidget_SetSizeRequest_Call) Return() *MockImageWidget_SetSizeRequest_Call {
10433	_c.Call.Return()
10434	return _c
10435}
10436
10437func (_c *MockImageWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
10438	_c.Run(run)
10439	return _c
10440}
10441
10442// SetValign provides a mock function for the type MockImageWidget
10443func (_mock *MockImageWidget) SetValign(align gtk.Align) {
10444	_mock.Called(align)
10445	return
10446}
10447
10448// MockImageWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
10449type MockImageWidget_SetValign_Call struct {
10450	*mock.Call
10451}
10452
10453// SetValign is a helper method to define mock.On call
10454//   - align gtk.Align
10455func (_e *MockImageWidget_Expecter) SetValign(align interface{}) *MockImageWidget_SetValign_Call {
10456	return &MockImageWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
10457}
10458
10459func (_c *MockImageWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
10460	_c.Call.Run(func(args mock.Arguments) {
10461		var arg0 gtk.Align
10462		if args[0] != nil {
10463			arg0 = args[0].(gtk.Align)
10464		}
10465		run(
10466			arg0,
10467		)
10468	})
10469	return _c
10470}
10471
10472func (_c *MockImageWidget_SetValign_Call) Return() *MockImageWidget_SetValign_Call {
10473	_c.Call.Return()
10474	return _c
10475}
10476
10477func (_c *MockImageWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
10478	_c.Run(run)
10479	return _c
10480}
10481
10482// SetVexpand provides a mock function for the type MockImageWidget
10483func (_mock *MockImageWidget) SetVexpand(expand bool) {
10484	_mock.Called(expand)
10485	return
10486}
10487
10488// MockImageWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
10489type MockImageWidget_SetVexpand_Call struct {
10490	*mock.Call
10491}
10492
10493// SetVexpand is a helper method to define mock.On call
10494//   - expand bool
10495func (_e *MockImageWidget_Expecter) SetVexpand(expand interface{}) *MockImageWidget_SetVexpand_Call {
10496	return &MockImageWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
10497}
10498
10499func (_c *MockImageWidget_SetVexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetVexpand_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_SetVexpand_Call) Return() *MockImageWidget_SetVexpand_Call {
10513	_c.Call.Return()
10514	return _c
10515}
10516
10517func (_c *MockImageWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
10518	_c.Run(run)
10519	return _c
10520}
10521
10522// SetVisible provides a mock function for the type MockImageWidget
10523func (_mock *MockImageWidget) SetVisible(visible bool) {
10524	_mock.Called(visible)
10525	return
10526}
10527
10528// MockImageWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
10529type MockImageWidget_SetVisible_Call struct {
10530	*mock.Call
10531}
10532
10533// SetVisible is a helper method to define mock.On call
10534//   - visible bool
10535func (_e *MockImageWidget_Expecter) SetVisible(visible interface{}) *MockImageWidget_SetVisible_Call {
10536	return &MockImageWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
10537}
10538
10539func (_c *MockImageWidget_SetVisible_Call) Run(run func(visible bool)) *MockImageWidget_SetVisible_Call {
10540	_c.Call.Run(func(args mock.Arguments) {
10541		var arg0 bool
10542		if args[0] != nil {
10543			arg0 = args[0].(bool)
10544		}
10545		run(
10546			arg0,
10547		)
10548	})
10549	return _c
10550}
10551
10552func (_c *MockImageWidget_SetVisible_Call) Return() *MockImageWidget_SetVisible_Call {
10553	_c.Call.Return()
10554	return _c
10555}
10556
10557func (_c *MockImageWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockImageWidget_SetVisible_Call {
10558	_c.Run(run)
10559	return _c
10560}
10561
10562// Show provides a mock function for the type MockImageWidget
10563func (_mock *MockImageWidget) Show() {
10564	_mock.Called()
10565	return
10566}
10567
10568// MockImageWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
10569type MockImageWidget_Show_Call struct {
10570	*mock.Call
10571}
10572
10573// Show is a helper method to define mock.On call
10574func (_e *MockImageWidget_Expecter) Show() *MockImageWidget_Show_Call {
10575	return &MockImageWidget_Show_Call{Call: _e.mock.On("Show")}
10576}
10577
10578func (_c *MockImageWidget_Show_Call) Run(run func()) *MockImageWidget_Show_Call {
10579	_c.Call.Run(func(args mock.Arguments) {
10580		run()
10581	})
10582	return _c
10583}
10584
10585func (_c *MockImageWidget_Show_Call) Return() *MockImageWidget_Show_Call {
10586	_c.Call.Return()
10587	return _c
10588}
10589
10590func (_c *MockImageWidget_Show_Call) RunAndReturn(run func()) *MockImageWidget_Show_Call {
10591	_c.Run(run)
10592	return _c
10593}
10594
10595// Unparent provides a mock function for the type MockImageWidget
10596func (_mock *MockImageWidget) Unparent() {
10597	_mock.Called()
10598	return
10599}
10600
10601// MockImageWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
10602type MockImageWidget_Unparent_Call struct {
10603	*mock.Call
10604}
10605
10606// Unparent is a helper method to define mock.On call
10607func (_e *MockImageWidget_Expecter) Unparent() *MockImageWidget_Unparent_Call {
10608	return &MockImageWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
10609}
10610
10611func (_c *MockImageWidget_Unparent_Call) Run(run func()) *MockImageWidget_Unparent_Call {
10612	_c.Call.Run(func(args mock.Arguments) {
10613		run()
10614	})
10615	return _c
10616}
10617
10618func (_c *MockImageWidget_Unparent_Call) Return() *MockImageWidget_Unparent_Call {
10619	_c.Call.Return()
10620	return _c
10621}
10622
10623func (_c *MockImageWidget_Unparent_Call) RunAndReturn(run func()) *MockImageWidget_Unparent_Call {
10624	_c.Run(run)
10625	return _c
10626}
10627
10628// 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.
10629// The first argument is typically a *testing.T value.
10630func NewMockProgressBarWidget(t interface {
10631	mock.TestingT
10632	Cleanup(func())
10633}) *MockProgressBarWidget {
10634	mock := &MockProgressBarWidget{}
10635	mock.Mock.Test(t)
10636
10637	t.Cleanup(func() { mock.AssertExpectations(t) })
10638
10639	return mock
10640}
10641
10642// MockProgressBarWidget is an autogenerated mock type for the ProgressBarWidget type
10643type MockProgressBarWidget struct {
10644	mock.Mock
10645}
10646
10647type MockProgressBarWidget_Expecter struct {
10648	mock *mock.Mock
10649}
10650
10651func (_m *MockProgressBarWidget) EXPECT() *MockProgressBarWidget_Expecter {
10652	return &MockProgressBarWidget_Expecter{mock: &_m.Mock}
10653}
10654
10655// AddController provides a mock function for the type MockProgressBarWidget
10656func (_mock *MockProgressBarWidget) AddController(controller *gtk.EventController) {
10657	_mock.Called(controller)
10658	return
10659}
10660
10661// MockProgressBarWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
10662type MockProgressBarWidget_AddController_Call struct {
10663	*mock.Call
10664}
10665
10666// AddController is a helper method to define mock.On call
10667//   - controller *gtk.EventController
10668func (_e *MockProgressBarWidget_Expecter) AddController(controller interface{}) *MockProgressBarWidget_AddController_Call {
10669	return &MockProgressBarWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
10670}
10671
10672func (_c *MockProgressBarWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
10673	_c.Call.Run(func(args mock.Arguments) {
10674		var arg0 *gtk.EventController
10675		if args[0] != nil {
10676			arg0 = args[0].(*gtk.EventController)
10677		}
10678		run(
10679			arg0,
10680		)
10681	})
10682	return _c
10683}
10684
10685func (_c *MockProgressBarWidget_AddController_Call) Return() *MockProgressBarWidget_AddController_Call {
10686	_c.Call.Return()
10687	return _c
10688}
10689
10690func (_c *MockProgressBarWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
10691	_c.Run(run)
10692	return _c
10693}
10694
10695// AddCssClass provides a mock function for the type MockProgressBarWidget
10696func (_mock *MockProgressBarWidget) AddCssClass(cssClass string) {
10697	_mock.Called(cssClass)
10698	return
10699}
10700
10701// MockProgressBarWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
10702type MockProgressBarWidget_AddCssClass_Call struct {
10703	*mock.Call
10704}
10705
10706// AddCssClass is a helper method to define mock.On call
10707//   - cssClass string
10708func (_e *MockProgressBarWidget_Expecter) AddCssClass(cssClass interface{}) *MockProgressBarWidget_AddCssClass_Call {
10709	return &MockProgressBarWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
10710}
10711
10712func (_c *MockProgressBarWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
10713	_c.Call.Run(func(args mock.Arguments) {
10714		var arg0 string
10715		if args[0] != nil {
10716			arg0 = args[0].(string)
10717		}
10718		run(
10719			arg0,
10720		)
10721	})
10722	return _c
10723}
10724
10725func (_c *MockProgressBarWidget_AddCssClass_Call) Return() *MockProgressBarWidget_AddCssClass_Call {
10726	_c.Call.Return()
10727	return _c
10728}
10729
10730func (_c *MockProgressBarWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
10731	_c.Run(run)
10732	return _c
10733}
10734
10735// ComputePoint provides a mock function for the type MockProgressBarWidget
10736func (_mock *MockProgressBarWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
10737	ret := _mock.Called(target)
10738
10739	if len(ret) == 0 {
10740		panic("no return value specified for ComputePoint")
10741	}
10742
10743	var r0 float64
10744	var r1 float64
10745	var r2 bool
10746	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
10747		return returnFunc(target)
10748	}
10749	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
10750		r0 = returnFunc(target)
10751	} else {
10752		r0 = ret.Get(0).(float64)
10753	}
10754	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
10755		r1 = returnFunc(target)
10756	} else {
10757		r1 = ret.Get(1).(float64)
10758	}
10759	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
10760		r2 = returnFunc(target)
10761	} else {
10762		r2 = ret.Get(2).(bool)
10763	}
10764	return r0, r1, r2
10765}
10766
10767// MockProgressBarWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
10768type MockProgressBarWidget_ComputePoint_Call struct {
10769	*mock.Call
10770}
10771
10772// ComputePoint is a helper method to define mock.On call
10773//   - target layout.Widget
10774func (_e *MockProgressBarWidget_Expecter) ComputePoint(target interface{}) *MockProgressBarWidget_ComputePoint_Call {
10775	return &MockProgressBarWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
10776}
10777
10778func (_c *MockProgressBarWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockProgressBarWidget_ComputePoint_Call {
10779	_c.Call.Run(func(args mock.Arguments) {
10780		var arg0 layout.Widget
10781		if args[0] != nil {
10782			arg0 = args[0].(layout.Widget)
10783		}
10784		run(
10785			arg0,
10786		)
10787	})
10788	return _c
10789}
10790
10791func (_c *MockProgressBarWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockProgressBarWidget_ComputePoint_Call {
10792	_c.Call.Return(x, y, ok)
10793	return _c
10794}
10795
10796func (_c *MockProgressBarWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockProgressBarWidget_ComputePoint_Call {
10797	_c.Call.Return(run)
10798	return _c
10799}
10800
10801// GetAllocatedHeight provides a mock function for the type MockProgressBarWidget
10802func (_mock *MockProgressBarWidget) GetAllocatedHeight() int {
10803	ret := _mock.Called()
10804
10805	if len(ret) == 0 {
10806		panic("no return value specified for GetAllocatedHeight")
10807	}
10808
10809	var r0 int
10810	if returnFunc, ok := ret.Get(0).(func() int); ok {
10811		r0 = returnFunc()
10812	} else {
10813		r0 = ret.Get(0).(int)
10814	}
10815	return r0
10816}
10817
10818// MockProgressBarWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
10819type MockProgressBarWidget_GetAllocatedHeight_Call struct {
10820	*mock.Call
10821}
10822
10823// GetAllocatedHeight is a helper method to define mock.On call
10824func (_e *MockProgressBarWidget_Expecter) GetAllocatedHeight() *MockProgressBarWidget_GetAllocatedHeight_Call {
10825	return &MockProgressBarWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
10826}
10827
10828func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedHeight_Call {
10829	_c.Call.Run(func(args mock.Arguments) {
10830		run()
10831	})
10832	return _c
10833}
10834
10835func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Return(n int) *MockProgressBarWidget_GetAllocatedHeight_Call {
10836	_c.Call.Return(n)
10837	return _c
10838}
10839
10840func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedHeight_Call {
10841	_c.Call.Return(run)
10842	return _c
10843}
10844
10845// GetAllocatedWidth provides a mock function for the type MockProgressBarWidget
10846func (_mock *MockProgressBarWidget) GetAllocatedWidth() int {
10847	ret := _mock.Called()
10848
10849	if len(ret) == 0 {
10850		panic("no return value specified for GetAllocatedWidth")
10851	}
10852
10853	var r0 int
10854	if returnFunc, ok := ret.Get(0).(func() int); ok {
10855		r0 = returnFunc()
10856	} else {
10857		r0 = ret.Get(0).(int)
10858	}
10859	return r0
10860}
10861
10862// MockProgressBarWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
10863type MockProgressBarWidget_GetAllocatedWidth_Call struct {
10864	*mock.Call
10865}
10866
10867// GetAllocatedWidth is a helper method to define mock.On call
10868func (_e *MockProgressBarWidget_Expecter) GetAllocatedWidth() *MockProgressBarWidget_GetAllocatedWidth_Call {
10869	return &MockProgressBarWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
10870}
10871
10872func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedWidth_Call {
10873	_c.Call.Run(func(args mock.Arguments) {
10874		run()
10875	})
10876	return _c
10877}
10878
10879func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Return(n int) *MockProgressBarWidget_GetAllocatedWidth_Call {
10880	_c.Call.Return(n)
10881	return _c
10882}
10883
10884func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedWidth_Call {
10885	_c.Call.Return(run)
10886	return _c
10887}
10888
10889// GetFraction provides a mock function for the type MockProgressBarWidget
10890func (_mock *MockProgressBarWidget) GetFraction() float64 {
10891	ret := _mock.Called()
10892
10893	if len(ret) == 0 {
10894		panic("no return value specified for GetFraction")
10895	}
10896
10897	var r0 float64
10898	if returnFunc, ok := ret.Get(0).(func() float64); ok {
10899		r0 = returnFunc()
10900	} else {
10901		r0 = ret.Get(0).(float64)
10902	}
10903	return r0
10904}
10905
10906// MockProgressBarWidget_GetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFraction'
10907type MockProgressBarWidget_GetFraction_Call struct {
10908	*mock.Call
10909}
10910
10911// GetFraction is a helper method to define mock.On call
10912func (_e *MockProgressBarWidget_Expecter) GetFraction() *MockProgressBarWidget_GetFraction_Call {
10913	return &MockProgressBarWidget_GetFraction_Call{Call: _e.mock.On("GetFraction")}
10914}
10915
10916func (_c *MockProgressBarWidget_GetFraction_Call) Run(run func()) *MockProgressBarWidget_GetFraction_Call {
10917	_c.Call.Run(func(args mock.Arguments) {
10918		run()
10919	})
10920	return _c
10921}
10922
10923func (_c *MockProgressBarWidget_GetFraction_Call) Return(f float64) *MockProgressBarWidget_GetFraction_Call {
10924	_c.Call.Return(f)
10925	return _c
10926}
10927
10928func (_c *MockProgressBarWidget_GetFraction_Call) RunAndReturn(run func() float64) *MockProgressBarWidget_GetFraction_Call {
10929	_c.Call.Return(run)
10930	return _c
10931}
10932
10933// GetHexpand provides a mock function for the type MockProgressBarWidget
10934func (_mock *MockProgressBarWidget) GetHexpand() bool {
10935	ret := _mock.Called()
10936
10937	if len(ret) == 0 {
10938		panic("no return value specified for GetHexpand")
10939	}
10940
10941	var r0 bool
10942	if returnFunc, ok := ret.Get(0).(func() bool); ok {
10943		r0 = returnFunc()
10944	} else {
10945		r0 = ret.Get(0).(bool)
10946	}
10947	return r0
10948}
10949
10950// MockProgressBarWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
10951type MockProgressBarWidget_GetHexpand_Call struct {
10952	*mock.Call
10953}
10954
10955// GetHexpand is a helper method to define mock.On call
10956func (_e *MockProgressBarWidget_Expecter) GetHexpand() *MockProgressBarWidget_GetHexpand_Call {
10957	return &MockProgressBarWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
10958}
10959
10960func (_c *MockProgressBarWidget_GetHexpand_Call) Run(run func()) *MockProgressBarWidget_GetHexpand_Call {
10961	_c.Call.Run(func(args mock.Arguments) {
10962		run()
10963	})
10964	return _c
10965}
10966
10967func (_c *MockProgressBarWidget_GetHexpand_Call) Return(b bool) *MockProgressBarWidget_GetHexpand_Call {
10968	_c.Call.Return(b)
10969	return _c
10970}
10971
10972func (_c *MockProgressBarWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetHexpand_Call {
10973	_c.Call.Return(run)
10974	return _c
10975}
10976
10977// GetParent provides a mock function for the type MockProgressBarWidget
10978func (_mock *MockProgressBarWidget) GetParent() layout.Widget {
10979	ret := _mock.Called()
10980
10981	if len(ret) == 0 {
10982		panic("no return value specified for GetParent")
10983	}
10984
10985	var r0 layout.Widget
10986	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
10987		r0 = returnFunc()
10988	} else {
10989		if ret.Get(0) != nil {
10990			r0 = ret.Get(0).(layout.Widget)
10991		}
10992	}
10993	return r0
10994}
10995
10996// MockProgressBarWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
10997type MockProgressBarWidget_GetParent_Call struct {
10998	*mock.Call
10999}
11000
11001// GetParent is a helper method to define mock.On call
11002func (_e *MockProgressBarWidget_Expecter) GetParent() *MockProgressBarWidget_GetParent_Call {
11003	return &MockProgressBarWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
11004}
11005
11006func (_c *MockProgressBarWidget_GetParent_Call) Run(run func()) *MockProgressBarWidget_GetParent_Call {
11007	_c.Call.Run(func(args mock.Arguments) {
11008		run()
11009	})
11010	return _c
11011}
11012
11013func (_c *MockProgressBarWidget_GetParent_Call) Return(widget layout.Widget) *MockProgressBarWidget_GetParent_Call {
11014	_c.Call.Return(widget)
11015	return _c
11016}
11017
11018func (_c *MockProgressBarWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockProgressBarWidget_GetParent_Call {
11019	_c.Call.Return(run)
11020	return _c
11021}
11022
11023// GetVexpand provides a mock function for the type MockProgressBarWidget
11024func (_mock *MockProgressBarWidget) GetVexpand() bool {
11025	ret := _mock.Called()
11026
11027	if len(ret) == 0 {
11028		panic("no return value specified for GetVexpand")
11029	}
11030
11031	var r0 bool
11032	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11033		r0 = returnFunc()
11034	} else {
11035		r0 = ret.Get(0).(bool)
11036	}
11037	return r0
11038}
11039
11040// MockProgressBarWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
11041type MockProgressBarWidget_GetVexpand_Call struct {
11042	*mock.Call
11043}
11044
11045// GetVexpand is a helper method to define mock.On call
11046func (_e *MockProgressBarWidget_Expecter) GetVexpand() *MockProgressBarWidget_GetVexpand_Call {
11047	return &MockProgressBarWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
11048}
11049
11050func (_c *MockProgressBarWidget_GetVexpand_Call) Run(run func()) *MockProgressBarWidget_GetVexpand_Call {
11051	_c.Call.Run(func(args mock.Arguments) {
11052		run()
11053	})
11054	return _c
11055}
11056
11057func (_c *MockProgressBarWidget_GetVexpand_Call) Return(b bool) *MockProgressBarWidget_GetVexpand_Call {
11058	_c.Call.Return(b)
11059	return _c
11060}
11061
11062func (_c *MockProgressBarWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetVexpand_Call {
11063	_c.Call.Return(run)
11064	return _c
11065}
11066
11067// GrabFocus provides a mock function for the type MockProgressBarWidget
11068func (_mock *MockProgressBarWidget) GrabFocus() bool {
11069	ret := _mock.Called()
11070
11071	if len(ret) == 0 {
11072		panic("no return value specified for GrabFocus")
11073	}
11074
11075	var r0 bool
11076	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11077		r0 = returnFunc()
11078	} else {
11079		r0 = ret.Get(0).(bool)
11080	}
11081	return r0
11082}
11083
11084// MockProgressBarWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
11085type MockProgressBarWidget_GrabFocus_Call struct {
11086	*mock.Call
11087}
11088
11089// GrabFocus is a helper method to define mock.On call
11090func (_e *MockProgressBarWidget_Expecter) GrabFocus() *MockProgressBarWidget_GrabFocus_Call {
11091	return &MockProgressBarWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
11092}
11093
11094func (_c *MockProgressBarWidget_GrabFocus_Call) Run(run func()) *MockProgressBarWidget_GrabFocus_Call {
11095	_c.Call.Run(func(args mock.Arguments) {
11096		run()
11097	})
11098	return _c
11099}
11100
11101func (_c *MockProgressBarWidget_GrabFocus_Call) Return(b bool) *MockProgressBarWidget_GrabFocus_Call {
11102	_c.Call.Return(b)
11103	return _c
11104}
11105
11106func (_c *MockProgressBarWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GrabFocus_Call {
11107	_c.Call.Return(run)
11108	return _c
11109}
11110
11111// GtkWidget provides a mock function for the type MockProgressBarWidget
11112func (_mock *MockProgressBarWidget) GtkWidget() *gtk.Widget {
11113	ret := _mock.Called()
11114
11115	if len(ret) == 0 {
11116		panic("no return value specified for GtkWidget")
11117	}
11118
11119	var r0 *gtk.Widget
11120	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
11121		r0 = returnFunc()
11122	} else {
11123		if ret.Get(0) != nil {
11124			r0 = ret.Get(0).(*gtk.Widget)
11125		}
11126	}
11127	return r0
11128}
11129
11130// MockProgressBarWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
11131type MockProgressBarWidget_GtkWidget_Call struct {
11132	*mock.Call
11133}
11134
11135// GtkWidget is a helper method to define mock.On call
11136func (_e *MockProgressBarWidget_Expecter) GtkWidget() *MockProgressBarWidget_GtkWidget_Call {
11137	return &MockProgressBarWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
11138}
11139
11140func (_c *MockProgressBarWidget_GtkWidget_Call) Run(run func()) *MockProgressBarWidget_GtkWidget_Call {
11141	_c.Call.Run(func(args mock.Arguments) {
11142		run()
11143	})
11144	return _c
11145}
11146
11147func (_c *MockProgressBarWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
11148	_c.Call.Return(widget)
11149	return _c
11150}
11151
11152func (_c *MockProgressBarWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
11153	_c.Call.Return(run)
11154	return _c
11155}
11156
11157// HasCssClass provides a mock function for the type MockProgressBarWidget
11158func (_mock *MockProgressBarWidget) HasCssClass(cssClass string) bool {
11159	ret := _mock.Called(cssClass)
11160
11161	if len(ret) == 0 {
11162		panic("no return value specified for HasCssClass")
11163	}
11164
11165	var r0 bool
11166	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
11167		r0 = returnFunc(cssClass)
11168	} else {
11169		r0 = ret.Get(0).(bool)
11170	}
11171	return r0
11172}
11173
11174// MockProgressBarWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
11175type MockProgressBarWidget_HasCssClass_Call struct {
11176	*mock.Call
11177}
11178
11179// HasCssClass is a helper method to define mock.On call
11180//   - cssClass string
11181func (_e *MockProgressBarWidget_Expecter) HasCssClass(cssClass interface{}) *MockProgressBarWidget_HasCssClass_Call {
11182	return &MockProgressBarWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
11183}
11184
11185func (_c *MockProgressBarWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_HasCssClass_Call {
11186	_c.Call.Run(func(args mock.Arguments) {
11187		var arg0 string
11188		if args[0] != nil {
11189			arg0 = args[0].(string)
11190		}
11191		run(
11192			arg0,
11193		)
11194	})
11195	return _c
11196}
11197
11198func (_c *MockProgressBarWidget_HasCssClass_Call) Return(b bool) *MockProgressBarWidget_HasCssClass_Call {
11199	_c.Call.Return(b)
11200	return _c
11201}
11202
11203func (_c *MockProgressBarWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockProgressBarWidget_HasCssClass_Call {
11204	_c.Call.Return(run)
11205	return _c
11206}
11207
11208// HasFocus provides a mock function for the type MockProgressBarWidget
11209func (_mock *MockProgressBarWidget) HasFocus() bool {
11210	ret := _mock.Called()
11211
11212	if len(ret) == 0 {
11213		panic("no return value specified for HasFocus")
11214	}
11215
11216	var r0 bool
11217	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11218		r0 = returnFunc()
11219	} else {
11220		r0 = ret.Get(0).(bool)
11221	}
11222	return r0
11223}
11224
11225// MockProgressBarWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
11226type MockProgressBarWidget_HasFocus_Call struct {
11227	*mock.Call
11228}
11229
11230// HasFocus is a helper method to define mock.On call
11231func (_e *MockProgressBarWidget_Expecter) HasFocus() *MockProgressBarWidget_HasFocus_Call {
11232	return &MockProgressBarWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
11233}
11234
11235func (_c *MockProgressBarWidget_HasFocus_Call) Run(run func()) *MockProgressBarWidget_HasFocus_Call {
11236	_c.Call.Run(func(args mock.Arguments) {
11237		run()
11238	})
11239	return _c
11240}
11241
11242func (_c *MockProgressBarWidget_HasFocus_Call) Return(b bool) *MockProgressBarWidget_HasFocus_Call {
11243	_c.Call.Return(b)
11244	return _c
11245}
11246
11247func (_c *MockProgressBarWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_HasFocus_Call {
11248	_c.Call.Return(run)
11249	return _c
11250}
11251
11252// Hide provides a mock function for the type MockProgressBarWidget
11253func (_mock *MockProgressBarWidget) Hide() {
11254	_mock.Called()
11255	return
11256}
11257
11258// MockProgressBarWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
11259type MockProgressBarWidget_Hide_Call struct {
11260	*mock.Call
11261}
11262
11263// Hide is a helper method to define mock.On call
11264func (_e *MockProgressBarWidget_Expecter) Hide() *MockProgressBarWidget_Hide_Call {
11265	return &MockProgressBarWidget_Hide_Call{Call: _e.mock.On("Hide")}
11266}
11267
11268func (_c *MockProgressBarWidget_Hide_Call) Run(run func()) *MockProgressBarWidget_Hide_Call {
11269	_c.Call.Run(func(args mock.Arguments) {
11270		run()
11271	})
11272	return _c
11273}
11274
11275func (_c *MockProgressBarWidget_Hide_Call) Return() *MockProgressBarWidget_Hide_Call {
11276	_c.Call.Return()
11277	return _c
11278}
11279
11280func (_c *MockProgressBarWidget_Hide_Call) RunAndReturn(run func()) *MockProgressBarWidget_Hide_Call {
11281	_c.Run(run)
11282	return _c
11283}
11284
11285// IsVisible provides a mock function for the type MockProgressBarWidget
11286func (_mock *MockProgressBarWidget) IsVisible() bool {
11287	ret := _mock.Called()
11288
11289	if len(ret) == 0 {
11290		panic("no return value specified for IsVisible")
11291	}
11292
11293	var r0 bool
11294	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11295		r0 = returnFunc()
11296	} else {
11297		r0 = ret.Get(0).(bool)
11298	}
11299	return r0
11300}
11301
11302// MockProgressBarWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
11303type MockProgressBarWidget_IsVisible_Call struct {
11304	*mock.Call
11305}
11306
11307// IsVisible is a helper method to define mock.On call
11308func (_e *MockProgressBarWidget_Expecter) IsVisible() *MockProgressBarWidget_IsVisible_Call {
11309	return &MockProgressBarWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
11310}
11311
11312func (_c *MockProgressBarWidget_IsVisible_Call) Run(run func()) *MockProgressBarWidget_IsVisible_Call {
11313	_c.Call.Run(func(args mock.Arguments) {
11314		run()
11315	})
11316	return _c
11317}
11318
11319func (_c *MockProgressBarWidget_IsVisible_Call) Return(b bool) *MockProgressBarWidget_IsVisible_Call {
11320	_c.Call.Return(b)
11321	return _c
11322}
11323
11324func (_c *MockProgressBarWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_IsVisible_Call {
11325	_c.Call.Return(run)
11326	return _c
11327}
11328
11329// RemoveCssClass provides a mock function for the type MockProgressBarWidget
11330func (_mock *MockProgressBarWidget) RemoveCssClass(cssClass string) {
11331	_mock.Called(cssClass)
11332	return
11333}
11334
11335// MockProgressBarWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
11336type MockProgressBarWidget_RemoveCssClass_Call struct {
11337	*mock.Call
11338}
11339
11340// RemoveCssClass is a helper method to define mock.On call
11341//   - cssClass string
11342func (_e *MockProgressBarWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockProgressBarWidget_RemoveCssClass_Call {
11343	return &MockProgressBarWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
11344}
11345
11346func (_c *MockProgressBarWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
11347	_c.Call.Run(func(args mock.Arguments) {
11348		var arg0 string
11349		if args[0] != nil {
11350			arg0 = args[0].(string)
11351		}
11352		run(
11353			arg0,
11354		)
11355	})
11356	return _c
11357}
11358
11359func (_c *MockProgressBarWidget_RemoveCssClass_Call) Return() *MockProgressBarWidget_RemoveCssClass_Call {
11360	_c.Call.Return()
11361	return _c
11362}
11363
11364func (_c *MockProgressBarWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
11365	_c.Run(run)
11366	return _c
11367}
11368
11369// SetCanFocus provides a mock function for the type MockProgressBarWidget
11370func (_mock *MockProgressBarWidget) SetCanFocus(canFocus bool) {
11371	_mock.Called(canFocus)
11372	return
11373}
11374
11375// MockProgressBarWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
11376type MockProgressBarWidget_SetCanFocus_Call struct {
11377	*mock.Call
11378}
11379
11380// SetCanFocus is a helper method to define mock.On call
11381//   - canFocus bool
11382func (_e *MockProgressBarWidget_Expecter) SetCanFocus(canFocus interface{}) *MockProgressBarWidget_SetCanFocus_Call {
11383	return &MockProgressBarWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
11384}
11385
11386func (_c *MockProgressBarWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_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_SetCanFocus_Call) Return() *MockProgressBarWidget_SetCanFocus_Call {
11400	_c.Call.Return()
11401	return _c
11402}
11403
11404func (_c *MockProgressBarWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
11405	_c.Run(run)
11406	return _c
11407}
11408
11409// SetCanTarget provides a mock function for the type MockProgressBarWidget
11410func (_mock *MockProgressBarWidget) SetCanTarget(canTarget bool) {
11411	_mock.Called(canTarget)
11412	return
11413}
11414
11415// MockProgressBarWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
11416type MockProgressBarWidget_SetCanTarget_Call struct {
11417	*mock.Call
11418}
11419
11420// SetCanTarget is a helper method to define mock.On call
11421//   - canTarget bool
11422func (_e *MockProgressBarWidget_Expecter) SetCanTarget(canTarget interface{}) *MockProgressBarWidget_SetCanTarget_Call {
11423	return &MockProgressBarWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
11424}
11425
11426func (_c *MockProgressBarWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_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_SetCanTarget_Call) Return() *MockProgressBarWidget_SetCanTarget_Call {
11440	_c.Call.Return()
11441	return _c
11442}
11443
11444func (_c *MockProgressBarWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
11445	_c.Run(run)
11446	return _c
11447}
11448
11449// SetFocusOnClick provides a mock function for the type MockProgressBarWidget
11450func (_mock *MockProgressBarWidget) SetFocusOnClick(focusOnClick bool) {
11451	_mock.Called(focusOnClick)
11452	return
11453}
11454
11455// MockProgressBarWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
11456type MockProgressBarWidget_SetFocusOnClick_Call struct {
11457	*mock.Call
11458}
11459
11460// SetFocusOnClick is a helper method to define mock.On call
11461//   - focusOnClick bool
11462func (_e *MockProgressBarWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockProgressBarWidget_SetFocusOnClick_Call {
11463	return &MockProgressBarWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
11464}
11465
11466func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_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_SetFocusOnClick_Call) Return() *MockProgressBarWidget_SetFocusOnClick_Call {
11480	_c.Call.Return()
11481	return _c
11482}
11483
11484func (_c *MockProgressBarWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
11485	_c.Run(run)
11486	return _c
11487}
11488
11489// SetFocusable provides a mock function for the type MockProgressBarWidget
11490func (_mock *MockProgressBarWidget) SetFocusable(focusable bool) {
11491	_mock.Called(focusable)
11492	return
11493}
11494
11495// MockProgressBarWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
11496type MockProgressBarWidget_SetFocusable_Call struct {
11497	*mock.Call
11498}
11499
11500// SetFocusable is a helper method to define mock.On call
11501//   - focusable bool
11502func (_e *MockProgressBarWidget_Expecter) SetFocusable(focusable interface{}) *MockProgressBarWidget_SetFocusable_Call {
11503	return &MockProgressBarWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
11504}
11505
11506func (_c *MockProgressBarWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockProgressBarWidget_SetFocusable_Call {
11507	_c.Call.Run(func(args mock.Arguments) {
11508		var arg0 bool
11509		if args[0] != nil {
11510			arg0 = args[0].(bool)
11511		}
11512		run(
11513			arg0,
11514		)
11515	})
11516	return _c
11517}
11518
11519func (_c *MockProgressBarWidget_SetFocusable_Call) Return() *MockProgressBarWidget_SetFocusable_Call {
11520	_c.Call.Return()
11521	return _c
11522}
11523
11524func (_c *MockProgressBarWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockProgressBarWidget_SetFocusable_Call {
11525	_c.Run(run)
11526	return _c
11527}
11528
11529// SetFraction provides a mock function for the type MockProgressBarWidget
11530func (_mock *MockProgressBarWidget) SetFraction(fraction float64) {
11531	_mock.Called(fraction)
11532	return
11533}
11534
11535// MockProgressBarWidget_SetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFraction'
11536type MockProgressBarWidget_SetFraction_Call struct {
11537	*mock.Call
11538}
11539
11540// SetFraction is a helper method to define mock.On call
11541//   - fraction float64
11542func (_e *MockProgressBarWidget_Expecter) SetFraction(fraction interface{}) *MockProgressBarWidget_SetFraction_Call {
11543	return &MockProgressBarWidget_SetFraction_Call{Call: _e.mock.On("SetFraction", fraction)}
11544}
11545
11546func (_c *MockProgressBarWidget_SetFraction_Call) Run(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
11547	_c.Call.Run(func(args mock.Arguments) {
11548		var arg0 float64
11549		if args[0] != nil {
11550			arg0 = args[0].(float64)
11551		}
11552		run(
11553			arg0,
11554		)
11555	})
11556	return _c
11557}
11558
11559func (_c *MockProgressBarWidget_SetFraction_Call) Return() *MockProgressBarWidget_SetFraction_Call {
11560	_c.Call.Return()
11561	return _c
11562}
11563
11564func (_c *MockProgressBarWidget_SetFraction_Call) RunAndReturn(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
11565	_c.Run(run)
11566	return _c
11567}
11568
11569// SetHalign provides a mock function for the type MockProgressBarWidget
11570func (_mock *MockProgressBarWidget) SetHalign(align gtk.Align) {
11571	_mock.Called(align)
11572	return
11573}
11574
11575// MockProgressBarWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
11576type MockProgressBarWidget_SetHalign_Call struct {
11577	*mock.Call
11578}
11579
11580// SetHalign is a helper method to define mock.On call
11581//   - align gtk.Align
11582func (_e *MockProgressBarWidget_Expecter) SetHalign(align interface{}) *MockProgressBarWidget_SetHalign_Call {
11583	return &MockProgressBarWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
11584}
11585
11586func (_c *MockProgressBarWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
11587	_c.Call.Run(func(args mock.Arguments) {
11588		var arg0 gtk.Align
11589		if args[0] != nil {
11590			arg0 = args[0].(gtk.Align)
11591		}
11592		run(
11593			arg0,
11594		)
11595	})
11596	return _c
11597}
11598
11599func (_c *MockProgressBarWidget_SetHalign_Call) Return() *MockProgressBarWidget_SetHalign_Call {
11600	_c.Call.Return()
11601	return _c
11602}
11603
11604func (_c *MockProgressBarWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
11605	_c.Run(run)
11606	return _c
11607}
11608
11609// SetHexpand provides a mock function for the type MockProgressBarWidget
11610func (_mock *MockProgressBarWidget) SetHexpand(expand bool) {
11611	_mock.Called(expand)
11612	return
11613}
11614
11615// MockProgressBarWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
11616type MockProgressBarWidget_SetHexpand_Call struct {
11617	*mock.Call
11618}
11619
11620// SetHexpand is a helper method to define mock.On call
11621//   - expand bool
11622func (_e *MockProgressBarWidget_Expecter) SetHexpand(expand interface{}) *MockProgressBarWidget_SetHexpand_Call {
11623	return &MockProgressBarWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
11624}
11625
11626func (_c *MockProgressBarWidget_SetHexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
11627	_c.Call.Run(func(args mock.Arguments) {
11628		var arg0 bool
11629		if args[0] != nil {
11630			arg0 = args[0].(bool)
11631		}
11632		run(
11633			arg0,
11634		)
11635	})
11636	return _c
11637}
11638
11639func (_c *MockProgressBarWidget_SetHexpand_Call) Return() *MockProgressBarWidget_SetHexpand_Call {
11640	_c.Call.Return()
11641	return _c
11642}
11643
11644func (_c *MockProgressBarWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
11645	_c.Run(run)
11646	return _c
11647}
11648
11649// SetSizeRequest provides a mock function for the type MockProgressBarWidget
11650func (_mock *MockProgressBarWidget) SetSizeRequest(width int, height int) {
11651	_mock.Called(width, height)
11652	return
11653}
11654
11655// MockProgressBarWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
11656type MockProgressBarWidget_SetSizeRequest_Call struct {
11657	*mock.Call
11658}
11659
11660// SetSizeRequest is a helper method to define mock.On call
11661//   - width int
11662//   - height int
11663func (_e *MockProgressBarWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockProgressBarWidget_SetSizeRequest_Call {
11664	return &MockProgressBarWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
11665}
11666
11667func (_c *MockProgressBarWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
11668	_c.Call.Run(func(args mock.Arguments) {
11669		var arg0 int
11670		if args[0] != nil {
11671			arg0 = args[0].(int)
11672		}
11673		var arg1 int
11674		if args[1] != nil {
11675			arg1 = args[1].(int)
11676		}
11677		run(
11678			arg0,
11679			arg1,
11680		)
11681	})
11682	return _c
11683}
11684
11685func (_c *MockProgressBarWidget_SetSizeRequest_Call) Return() *MockProgressBarWidget_SetSizeRequest_Call {
11686	_c.Call.Return()
11687	return _c
11688}
11689
11690func (_c *MockProgressBarWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
11691	_c.Run(run)
11692	return _c
11693}
11694
11695// SetValign provides a mock function for the type MockProgressBarWidget
11696func (_mock *MockProgressBarWidget) SetValign(align gtk.Align) {
11697	_mock.Called(align)
11698	return
11699}
11700
11701// MockProgressBarWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
11702type MockProgressBarWidget_SetValign_Call struct {
11703	*mock.Call
11704}
11705
11706// SetValign is a helper method to define mock.On call
11707//   - align gtk.Align
11708func (_e *MockProgressBarWidget_Expecter) SetValign(align interface{}) *MockProgressBarWidget_SetValign_Call {
11709	return &MockProgressBarWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
11710}
11711
11712func (_c *MockProgressBarWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
11713	_c.Call.Run(func(args mock.Arguments) {
11714		var arg0 gtk.Align
11715		if args[0] != nil {
11716			arg0 = args[0].(gtk.Align)
11717		}
11718		run(
11719			arg0,
11720		)
11721	})
11722	return _c
11723}
11724
11725func (_c *MockProgressBarWidget_SetValign_Call) Return() *MockProgressBarWidget_SetValign_Call {
11726	_c.Call.Return()
11727	return _c
11728}
11729
11730func (_c *MockProgressBarWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
11731	_c.Run(run)
11732	return _c
11733}
11734
11735// SetVexpand provides a mock function for the type MockProgressBarWidget
11736func (_mock *MockProgressBarWidget) SetVexpand(expand bool) {
11737	_mock.Called(expand)
11738	return
11739}
11740
11741// MockProgressBarWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
11742type MockProgressBarWidget_SetVexpand_Call struct {
11743	*mock.Call
11744}
11745
11746// SetVexpand is a helper method to define mock.On call
11747//   - expand bool
11748func (_e *MockProgressBarWidget_Expecter) SetVexpand(expand interface{}) *MockProgressBarWidget_SetVexpand_Call {
11749	return &MockProgressBarWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
11750}
11751
11752func (_c *MockProgressBarWidget_SetVexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetVexpand_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_SetVexpand_Call) Return() *MockProgressBarWidget_SetVexpand_Call {
11766	_c.Call.Return()
11767	return _c
11768}
11769
11770func (_c *MockProgressBarWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
11771	_c.Run(run)
11772	return _c
11773}
11774
11775// SetVisible provides a mock function for the type MockProgressBarWidget
11776func (_mock *MockProgressBarWidget) SetVisible(visible bool) {
11777	_mock.Called(visible)
11778	return
11779}
11780
11781// MockProgressBarWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
11782type MockProgressBarWidget_SetVisible_Call struct {
11783	*mock.Call
11784}
11785
11786// SetVisible is a helper method to define mock.On call
11787//   - visible bool
11788func (_e *MockProgressBarWidget_Expecter) SetVisible(visible interface{}) *MockProgressBarWidget_SetVisible_Call {
11789	return &MockProgressBarWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
11790}
11791
11792func (_c *MockProgressBarWidget_SetVisible_Call) Run(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
11793	_c.Call.Run(func(args mock.Arguments) {
11794		var arg0 bool
11795		if args[0] != nil {
11796			arg0 = args[0].(bool)
11797		}
11798		run(
11799			arg0,
11800		)
11801	})
11802	return _c
11803}
11804
11805func (_c *MockProgressBarWidget_SetVisible_Call) Return() *MockProgressBarWidget_SetVisible_Call {
11806	_c.Call.Return()
11807	return _c
11808}
11809
11810func (_c *MockProgressBarWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
11811	_c.Run(run)
11812	return _c
11813}
11814
11815// Show provides a mock function for the type MockProgressBarWidget
11816func (_mock *MockProgressBarWidget) Show() {
11817	_mock.Called()
11818	return
11819}
11820
11821// MockProgressBarWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
11822type MockProgressBarWidget_Show_Call struct {
11823	*mock.Call
11824}
11825
11826// Show is a helper method to define mock.On call
11827func (_e *MockProgressBarWidget_Expecter) Show() *MockProgressBarWidget_Show_Call {
11828	return &MockProgressBarWidget_Show_Call{Call: _e.mock.On("Show")}
11829}
11830
11831func (_c *MockProgressBarWidget_Show_Call) Run(run func()) *MockProgressBarWidget_Show_Call {
11832	_c.Call.Run(func(args mock.Arguments) {
11833		run()
11834	})
11835	return _c
11836}
11837
11838func (_c *MockProgressBarWidget_Show_Call) Return() *MockProgressBarWidget_Show_Call {
11839	_c.Call.Return()
11840	return _c
11841}
11842
11843func (_c *MockProgressBarWidget_Show_Call) RunAndReturn(run func()) *MockProgressBarWidget_Show_Call {
11844	_c.Run(run)
11845	return _c
11846}
11847
11848// Unparent provides a mock function for the type MockProgressBarWidget
11849func (_mock *MockProgressBarWidget) Unparent() {
11850	_mock.Called()
11851	return
11852}
11853
11854// MockProgressBarWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
11855type MockProgressBarWidget_Unparent_Call struct {
11856	*mock.Call
11857}
11858
11859// Unparent is a helper method to define mock.On call
11860func (_e *MockProgressBarWidget_Expecter) Unparent() *MockProgressBarWidget_Unparent_Call {
11861	return &MockProgressBarWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
11862}
11863
11864func (_c *MockProgressBarWidget_Unparent_Call) Run(run func()) *MockProgressBarWidget_Unparent_Call {
11865	_c.Call.Run(func(args mock.Arguments) {
11866		run()
11867	})
11868	return _c
11869}
11870
11871func (_c *MockProgressBarWidget_Unparent_Call) Return() *MockProgressBarWidget_Unparent_Call {
11872	_c.Call.Return()
11873	return _c
11874}
11875
11876func (_c *MockProgressBarWidget_Unparent_Call) RunAndReturn(run func()) *MockProgressBarWidget_Unparent_Call {
11877	_c.Run(run)
11878	return _c
11879}
11880
11881// 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.
11882// The first argument is typically a *testing.T value.
11883func NewMockSpinnerWidget(t interface {
11884	mock.TestingT
11885	Cleanup(func())
11886}) *MockSpinnerWidget {
11887	mock := &MockSpinnerWidget{}
11888	mock.Mock.Test(t)
11889
11890	t.Cleanup(func() { mock.AssertExpectations(t) })
11891
11892	return mock
11893}
11894
11895// MockSpinnerWidget is an autogenerated mock type for the SpinnerWidget type
11896type MockSpinnerWidget struct {
11897	mock.Mock
11898}
11899
11900type MockSpinnerWidget_Expecter struct {
11901	mock *mock.Mock
11902}
11903
11904func (_m *MockSpinnerWidget) EXPECT() *MockSpinnerWidget_Expecter {
11905	return &MockSpinnerWidget_Expecter{mock: &_m.Mock}
11906}
11907
11908// AddController provides a mock function for the type MockSpinnerWidget
11909func (_mock *MockSpinnerWidget) AddController(controller *gtk.EventController) {
11910	_mock.Called(controller)
11911	return
11912}
11913
11914// MockSpinnerWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
11915type MockSpinnerWidget_AddController_Call struct {
11916	*mock.Call
11917}
11918
11919// AddController is a helper method to define mock.On call
11920//   - controller *gtk.EventController
11921func (_e *MockSpinnerWidget_Expecter) AddController(controller interface{}) *MockSpinnerWidget_AddController_Call {
11922	return &MockSpinnerWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
11923}
11924
11925func (_c *MockSpinnerWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockSpinnerWidget_AddController_Call {
11926	_c.Call.Run(func(args mock.Arguments) {
11927		var arg0 *gtk.EventController
11928		if args[0] != nil {
11929			arg0 = args[0].(*gtk.EventController)
11930		}
11931		run(
11932			arg0,
11933		)
11934	})
11935	return _c
11936}
11937
11938func (_c *MockSpinnerWidget_AddController_Call) Return() *MockSpinnerWidget_AddController_Call {
11939	_c.Call.Return()
11940	return _c
11941}
11942
11943func (_c *MockSpinnerWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockSpinnerWidget_AddController_Call {
11944	_c.Run(run)
11945	return _c
11946}
11947
11948// AddCssClass provides a mock function for the type MockSpinnerWidget
11949func (_mock *MockSpinnerWidget) AddCssClass(cssClass string) {
11950	_mock.Called(cssClass)
11951	return
11952}
11953
11954// MockSpinnerWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
11955type MockSpinnerWidget_AddCssClass_Call struct {
11956	*mock.Call
11957}
11958
11959// AddCssClass is a helper method to define mock.On call
11960//   - cssClass string
11961func (_e *MockSpinnerWidget_Expecter) AddCssClass(cssClass interface{}) *MockSpinnerWidget_AddCssClass_Call {
11962	return &MockSpinnerWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
11963}
11964
11965func (_c *MockSpinnerWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_AddCssClass_Call {
11966	_c.Call.Run(func(args mock.Arguments) {
11967		var arg0 string
11968		if args[0] != nil {
11969			arg0 = args[0].(string)
11970		}
11971		run(
11972			arg0,
11973		)
11974	})
11975	return _c
11976}
11977
11978func (_c *MockSpinnerWidget_AddCssClass_Call) Return() *MockSpinnerWidget_AddCssClass_Call {
11979	_c.Call.Return()
11980	return _c
11981}
11982
11983func (_c *MockSpinnerWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockSpinnerWidget_AddCssClass_Call {
11984	_c.Run(run)
11985	return _c
11986}
11987
11988// ComputePoint provides a mock function for the type MockSpinnerWidget
11989func (_mock *MockSpinnerWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
11990	ret := _mock.Called(target)
11991
11992	if len(ret) == 0 {
11993		panic("no return value specified for ComputePoint")
11994	}
11995
11996	var r0 float64
11997	var r1 float64
11998	var r2 bool
11999	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
12000		return returnFunc(target)
12001	}
12002	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
12003		r0 = returnFunc(target)
12004	} else {
12005		r0 = ret.Get(0).(float64)
12006	}
12007	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
12008		r1 = returnFunc(target)
12009	} else {
12010		r1 = ret.Get(1).(float64)
12011	}
12012	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
12013		r2 = returnFunc(target)
12014	} else {
12015		r2 = ret.Get(2).(bool)
12016	}
12017	return r0, r1, r2
12018}
12019
12020// MockSpinnerWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
12021type MockSpinnerWidget_ComputePoint_Call struct {
12022	*mock.Call
12023}
12024
12025// ComputePoint is a helper method to define mock.On call
12026//   - target layout.Widget
12027func (_e *MockSpinnerWidget_Expecter) ComputePoint(target interface{}) *MockSpinnerWidget_ComputePoint_Call {
12028	return &MockSpinnerWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
12029}
12030
12031func (_c *MockSpinnerWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockSpinnerWidget_ComputePoint_Call {
12032	_c.Call.Run(func(args mock.Arguments) {
12033		var arg0 layout.Widget
12034		if args[0] != nil {
12035			arg0 = args[0].(layout.Widget)
12036		}
12037		run(
12038			arg0,
12039		)
12040	})
12041	return _c
12042}
12043
12044func (_c *MockSpinnerWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockSpinnerWidget_ComputePoint_Call {
12045	_c.Call.Return(x, y, ok)
12046	return _c
12047}
12048
12049func (_c *MockSpinnerWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockSpinnerWidget_ComputePoint_Call {
12050	_c.Call.Return(run)
12051	return _c
12052}
12053
12054// GetAllocatedHeight provides a mock function for the type MockSpinnerWidget
12055func (_mock *MockSpinnerWidget) GetAllocatedHeight() int {
12056	ret := _mock.Called()
12057
12058	if len(ret) == 0 {
12059		panic("no return value specified for GetAllocatedHeight")
12060	}
12061
12062	var r0 int
12063	if returnFunc, ok := ret.Get(0).(func() int); ok {
12064		r0 = returnFunc()
12065	} else {
12066		r0 = ret.Get(0).(int)
12067	}
12068	return r0
12069}
12070
12071// MockSpinnerWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
12072type MockSpinnerWidget_GetAllocatedHeight_Call struct {
12073	*mock.Call
12074}
12075
12076// GetAllocatedHeight is a helper method to define mock.On call
12077func (_e *MockSpinnerWidget_Expecter) GetAllocatedHeight() *MockSpinnerWidget_GetAllocatedHeight_Call {
12078	return &MockSpinnerWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
12079}
12080
12081func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) Run(run func()) *MockSpinnerWidget_GetAllocatedHeight_Call {
12082	_c.Call.Run(func(args mock.Arguments) {
12083		run()
12084	})
12085	return _c
12086}
12087
12088func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) Return(n int) *MockSpinnerWidget_GetAllocatedHeight_Call {
12089	_c.Call.Return(n)
12090	return _c
12091}
12092
12093func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockSpinnerWidget_GetAllocatedHeight_Call {
12094	_c.Call.Return(run)
12095	return _c
12096}
12097
12098// GetAllocatedWidth provides a mock function for the type MockSpinnerWidget
12099func (_mock *MockSpinnerWidget) GetAllocatedWidth() int {
12100	ret := _mock.Called()
12101
12102	if len(ret) == 0 {
12103		panic("no return value specified for GetAllocatedWidth")
12104	}
12105
12106	var r0 int
12107	if returnFunc, ok := ret.Get(0).(func() int); ok {
12108		r0 = returnFunc()
12109	} else {
12110		r0 = ret.Get(0).(int)
12111	}
12112	return r0
12113}
12114
12115// MockSpinnerWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
12116type MockSpinnerWidget_GetAllocatedWidth_Call struct {
12117	*mock.Call
12118}
12119
12120// GetAllocatedWidth is a helper method to define mock.On call
12121func (_e *MockSpinnerWidget_Expecter) GetAllocatedWidth() *MockSpinnerWidget_GetAllocatedWidth_Call {
12122	return &MockSpinnerWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
12123}
12124
12125func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) Run(run func()) *MockSpinnerWidget_GetAllocatedWidth_Call {
12126	_c.Call.Run(func(args mock.Arguments) {
12127		run()
12128	})
12129	return _c
12130}
12131
12132func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) Return(n int) *MockSpinnerWidget_GetAllocatedWidth_Call {
12133	_c.Call.Return(n)
12134	return _c
12135}
12136
12137func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockSpinnerWidget_GetAllocatedWidth_Call {
12138	_c.Call.Return(run)
12139	return _c
12140}
12141
12142// GetHexpand provides a mock function for the type MockSpinnerWidget
12143func (_mock *MockSpinnerWidget) GetHexpand() bool {
12144	ret := _mock.Called()
12145
12146	if len(ret) == 0 {
12147		panic("no return value specified for GetHexpand")
12148	}
12149
12150	var r0 bool
12151	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12152		r0 = returnFunc()
12153	} else {
12154		r0 = ret.Get(0).(bool)
12155	}
12156	return r0
12157}
12158
12159// MockSpinnerWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
12160type MockSpinnerWidget_GetHexpand_Call struct {
12161	*mock.Call
12162}
12163
12164// GetHexpand is a helper method to define mock.On call
12165func (_e *MockSpinnerWidget_Expecter) GetHexpand() *MockSpinnerWidget_GetHexpand_Call {
12166	return &MockSpinnerWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
12167}
12168
12169func (_c *MockSpinnerWidget_GetHexpand_Call) Run(run func()) *MockSpinnerWidget_GetHexpand_Call {
12170	_c.Call.Run(func(args mock.Arguments) {
12171		run()
12172	})
12173	return _c
12174}
12175
12176func (_c *MockSpinnerWidget_GetHexpand_Call) Return(b bool) *MockSpinnerWidget_GetHexpand_Call {
12177	_c.Call.Return(b)
12178	return _c
12179}
12180
12181func (_c *MockSpinnerWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetHexpand_Call {
12182	_c.Call.Return(run)
12183	return _c
12184}
12185
12186// GetParent provides a mock function for the type MockSpinnerWidget
12187func (_mock *MockSpinnerWidget) GetParent() layout.Widget {
12188	ret := _mock.Called()
12189
12190	if len(ret) == 0 {
12191		panic("no return value specified for GetParent")
12192	}
12193
12194	var r0 layout.Widget
12195	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
12196		r0 = returnFunc()
12197	} else {
12198		if ret.Get(0) != nil {
12199			r0 = ret.Get(0).(layout.Widget)
12200		}
12201	}
12202	return r0
12203}
12204
12205// MockSpinnerWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
12206type MockSpinnerWidget_GetParent_Call struct {
12207	*mock.Call
12208}
12209
12210// GetParent is a helper method to define mock.On call
12211func (_e *MockSpinnerWidget_Expecter) GetParent() *MockSpinnerWidget_GetParent_Call {
12212	return &MockSpinnerWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
12213}
12214
12215func (_c *MockSpinnerWidget_GetParent_Call) Run(run func()) *MockSpinnerWidget_GetParent_Call {
12216	_c.Call.Run(func(args mock.Arguments) {
12217		run()
12218	})
12219	return _c
12220}
12221
12222func (_c *MockSpinnerWidget_GetParent_Call) Return(widget layout.Widget) *MockSpinnerWidget_GetParent_Call {
12223	_c.Call.Return(widget)
12224	return _c
12225}
12226
12227func (_c *MockSpinnerWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockSpinnerWidget_GetParent_Call {
12228	_c.Call.Return(run)
12229	return _c
12230}
12231
12232// GetSpinning provides a mock function for the type MockSpinnerWidget
12233func (_mock *MockSpinnerWidget) GetSpinning() bool {
12234	ret := _mock.Called()
12235
12236	if len(ret) == 0 {
12237		panic("no return value specified for GetSpinning")
12238	}
12239
12240	var r0 bool
12241	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12242		r0 = returnFunc()
12243	} else {
12244		r0 = ret.Get(0).(bool)
12245	}
12246	return r0
12247}
12248
12249// MockSpinnerWidget_GetSpinning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpinning'
12250type MockSpinnerWidget_GetSpinning_Call struct {
12251	*mock.Call
12252}
12253
12254// GetSpinning is a helper method to define mock.On call
12255func (_e *MockSpinnerWidget_Expecter) GetSpinning() *MockSpinnerWidget_GetSpinning_Call {
12256	return &MockSpinnerWidget_GetSpinning_Call{Call: _e.mock.On("GetSpinning")}
12257}
12258
12259func (_c *MockSpinnerWidget_GetSpinning_Call) Run(run func()) *MockSpinnerWidget_GetSpinning_Call {
12260	_c.Call.Run(func(args mock.Arguments) {
12261		run()
12262	})
12263	return _c
12264}
12265
12266func (_c *MockSpinnerWidget_GetSpinning_Call) Return(b bool) *MockSpinnerWidget_GetSpinning_Call {
12267	_c.Call.Return(b)
12268	return _c
12269}
12270
12271func (_c *MockSpinnerWidget_GetSpinning_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetSpinning_Call {
12272	_c.Call.Return(run)
12273	return _c
12274}
12275
12276// GetVexpand provides a mock function for the type MockSpinnerWidget
12277func (_mock *MockSpinnerWidget) GetVexpand() bool {
12278	ret := _mock.Called()
12279
12280	if len(ret) == 0 {
12281		panic("no return value specified for GetVexpand")
12282	}
12283
12284	var r0 bool
12285	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12286		r0 = returnFunc()
12287	} else {
12288		r0 = ret.Get(0).(bool)
12289	}
12290	return r0
12291}
12292
12293// MockSpinnerWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
12294type MockSpinnerWidget_GetVexpand_Call struct {
12295	*mock.Call
12296}
12297
12298// GetVexpand is a helper method to define mock.On call
12299func (_e *MockSpinnerWidget_Expecter) GetVexpand() *MockSpinnerWidget_GetVexpand_Call {
12300	return &MockSpinnerWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
12301}
12302
12303func (_c *MockSpinnerWidget_GetVexpand_Call) Run(run func()) *MockSpinnerWidget_GetVexpand_Call {
12304	_c.Call.Run(func(args mock.Arguments) {
12305		run()
12306	})
12307	return _c
12308}
12309
12310func (_c *MockSpinnerWidget_GetVexpand_Call) Return(b bool) *MockSpinnerWidget_GetVexpand_Call {
12311	_c.Call.Return(b)
12312	return _c
12313}
12314
12315func (_c *MockSpinnerWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetVexpand_Call {
12316	_c.Call.Return(run)
12317	return _c
12318}
12319
12320// GrabFocus provides a mock function for the type MockSpinnerWidget
12321func (_mock *MockSpinnerWidget) GrabFocus() bool {
12322	ret := _mock.Called()
12323
12324	if len(ret) == 0 {
12325		panic("no return value specified for GrabFocus")
12326	}
12327
12328	var r0 bool
12329	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12330		r0 = returnFunc()
12331	} else {
12332		r0 = ret.Get(0).(bool)
12333	}
12334	return r0
12335}
12336
12337// MockSpinnerWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
12338type MockSpinnerWidget_GrabFocus_Call struct {
12339	*mock.Call
12340}
12341
12342// GrabFocus is a helper method to define mock.On call
12343func (_e *MockSpinnerWidget_Expecter) GrabFocus() *MockSpinnerWidget_GrabFocus_Call {
12344	return &MockSpinnerWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
12345}
12346
12347func (_c *MockSpinnerWidget_GrabFocus_Call) Run(run func()) *MockSpinnerWidget_GrabFocus_Call {
12348	_c.Call.Run(func(args mock.Arguments) {
12349		run()
12350	})
12351	return _c
12352}
12353
12354func (_c *MockSpinnerWidget_GrabFocus_Call) Return(b bool) *MockSpinnerWidget_GrabFocus_Call {
12355	_c.Call.Return(b)
12356	return _c
12357}
12358
12359func (_c *MockSpinnerWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GrabFocus_Call {
12360	_c.Call.Return(run)
12361	return _c
12362}
12363
12364// GtkWidget provides a mock function for the type MockSpinnerWidget
12365func (_mock *MockSpinnerWidget) GtkWidget() *gtk.Widget {
12366	ret := _mock.Called()
12367
12368	if len(ret) == 0 {
12369		panic("no return value specified for GtkWidget")
12370	}
12371
12372	var r0 *gtk.Widget
12373	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
12374		r0 = returnFunc()
12375	} else {
12376		if ret.Get(0) != nil {
12377			r0 = ret.Get(0).(*gtk.Widget)
12378		}
12379	}
12380	return r0
12381}
12382
12383// MockSpinnerWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
12384type MockSpinnerWidget_GtkWidget_Call struct {
12385	*mock.Call
12386}
12387
12388// GtkWidget is a helper method to define mock.On call
12389func (_e *MockSpinnerWidget_Expecter) GtkWidget() *MockSpinnerWidget_GtkWidget_Call {
12390	return &MockSpinnerWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
12391}
12392
12393func (_c *MockSpinnerWidget_GtkWidget_Call) Run(run func()) *MockSpinnerWidget_GtkWidget_Call {
12394	_c.Call.Run(func(args mock.Arguments) {
12395		run()
12396	})
12397	return _c
12398}
12399
12400func (_c *MockSpinnerWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockSpinnerWidget_GtkWidget_Call {
12401	_c.Call.Return(widget)
12402	return _c
12403}
12404
12405func (_c *MockSpinnerWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockSpinnerWidget_GtkWidget_Call {
12406	_c.Call.Return(run)
12407	return _c
12408}
12409
12410// HasCssClass provides a mock function for the type MockSpinnerWidget
12411func (_mock *MockSpinnerWidget) HasCssClass(cssClass string) bool {
12412	ret := _mock.Called(cssClass)
12413
12414	if len(ret) == 0 {
12415		panic("no return value specified for HasCssClass")
12416	}
12417
12418	var r0 bool
12419	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
12420		r0 = returnFunc(cssClass)
12421	} else {
12422		r0 = ret.Get(0).(bool)
12423	}
12424	return r0
12425}
12426
12427// MockSpinnerWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
12428type MockSpinnerWidget_HasCssClass_Call struct {
12429	*mock.Call
12430}
12431
12432// HasCssClass is a helper method to define mock.On call
12433//   - cssClass string
12434func (_e *MockSpinnerWidget_Expecter) HasCssClass(cssClass interface{}) *MockSpinnerWidget_HasCssClass_Call {
12435	return &MockSpinnerWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
12436}
12437
12438func (_c *MockSpinnerWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_HasCssClass_Call {
12439	_c.Call.Run(func(args mock.Arguments) {
12440		var arg0 string
12441		if args[0] != nil {
12442			arg0 = args[0].(string)
12443		}
12444		run(
12445			arg0,
12446		)
12447	})
12448	return _c
12449}
12450
12451func (_c *MockSpinnerWidget_HasCssClass_Call) Return(b bool) *MockSpinnerWidget_HasCssClass_Call {
12452	_c.Call.Return(b)
12453	return _c
12454}
12455
12456func (_c *MockSpinnerWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockSpinnerWidget_HasCssClass_Call {
12457	_c.Call.Return(run)
12458	return _c
12459}
12460
12461// HasFocus provides a mock function for the type MockSpinnerWidget
12462func (_mock *MockSpinnerWidget) HasFocus() bool {
12463	ret := _mock.Called()
12464
12465	if len(ret) == 0 {
12466		panic("no return value specified for HasFocus")
12467	}
12468
12469	var r0 bool
12470	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12471		r0 = returnFunc()
12472	} else {
12473		r0 = ret.Get(0).(bool)
12474	}
12475	return r0
12476}
12477
12478// MockSpinnerWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
12479type MockSpinnerWidget_HasFocus_Call struct {
12480	*mock.Call
12481}
12482
12483// HasFocus is a helper method to define mock.On call
12484func (_e *MockSpinnerWidget_Expecter) HasFocus() *MockSpinnerWidget_HasFocus_Call {
12485	return &MockSpinnerWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
12486}
12487
12488func (_c *MockSpinnerWidget_HasFocus_Call) Run(run func()) *MockSpinnerWidget_HasFocus_Call {
12489	_c.Call.Run(func(args mock.Arguments) {
12490		run()
12491	})
12492	return _c
12493}
12494
12495func (_c *MockSpinnerWidget_HasFocus_Call) Return(b bool) *MockSpinnerWidget_HasFocus_Call {
12496	_c.Call.Return(b)
12497	return _c
12498}
12499
12500func (_c *MockSpinnerWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_HasFocus_Call {
12501	_c.Call.Return(run)
12502	return _c
12503}
12504
12505// Hide provides a mock function for the type MockSpinnerWidget
12506func (_mock *MockSpinnerWidget) Hide() {
12507	_mock.Called()
12508	return
12509}
12510
12511// MockSpinnerWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
12512type MockSpinnerWidget_Hide_Call struct {
12513	*mock.Call
12514}
12515
12516// Hide is a helper method to define mock.On call
12517func (_e *MockSpinnerWidget_Expecter) Hide() *MockSpinnerWidget_Hide_Call {
12518	return &MockSpinnerWidget_Hide_Call{Call: _e.mock.On("Hide")}
12519}
12520
12521func (_c *MockSpinnerWidget_Hide_Call) Run(run func()) *MockSpinnerWidget_Hide_Call {
12522	_c.Call.Run(func(args mock.Arguments) {
12523		run()
12524	})
12525	return _c
12526}
12527
12528func (_c *MockSpinnerWidget_Hide_Call) Return() *MockSpinnerWidget_Hide_Call {
12529	_c.Call.Return()
12530	return _c
12531}
12532
12533func (_c *MockSpinnerWidget_Hide_Call) RunAndReturn(run func()) *MockSpinnerWidget_Hide_Call {
12534	_c.Run(run)
12535	return _c
12536}
12537
12538// IsVisible provides a mock function for the type MockSpinnerWidget
12539func (_mock *MockSpinnerWidget) IsVisible() bool {
12540	ret := _mock.Called()
12541
12542	if len(ret) == 0 {
12543		panic("no return value specified for IsVisible")
12544	}
12545
12546	var r0 bool
12547	if returnFunc, ok := ret.Get(0).(func() bool); ok {
12548		r0 = returnFunc()
12549	} else {
12550		r0 = ret.Get(0).(bool)
12551	}
12552	return r0
12553}
12554
12555// MockSpinnerWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
12556type MockSpinnerWidget_IsVisible_Call struct {
12557	*mock.Call
12558}
12559
12560// IsVisible is a helper method to define mock.On call
12561func (_e *MockSpinnerWidget_Expecter) IsVisible() *MockSpinnerWidget_IsVisible_Call {
12562	return &MockSpinnerWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
12563}
12564
12565func (_c *MockSpinnerWidget_IsVisible_Call) Run(run func()) *MockSpinnerWidget_IsVisible_Call {
12566	_c.Call.Run(func(args mock.Arguments) {
12567		run()
12568	})
12569	return _c
12570}
12571
12572func (_c *MockSpinnerWidget_IsVisible_Call) Return(b bool) *MockSpinnerWidget_IsVisible_Call {
12573	_c.Call.Return(b)
12574	return _c
12575}
12576
12577func (_c *MockSpinnerWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_IsVisible_Call {
12578	_c.Call.Return(run)
12579	return _c
12580}
12581
12582// RemoveCssClass provides a mock function for the type MockSpinnerWidget
12583func (_mock *MockSpinnerWidget) RemoveCssClass(cssClass string) {
12584	_mock.Called(cssClass)
12585	return
12586}
12587
12588// MockSpinnerWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
12589type MockSpinnerWidget_RemoveCssClass_Call struct {
12590	*mock.Call
12591}
12592
12593// RemoveCssClass is a helper method to define mock.On call
12594//   - cssClass string
12595func (_e *MockSpinnerWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockSpinnerWidget_RemoveCssClass_Call {
12596	return &MockSpinnerWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
12597}
12598
12599func (_c *MockSpinnerWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_RemoveCssClass_Call {
12600	_c.Call.Run(func(args mock.Arguments) {
12601		var arg0 string
12602		if args[0] != nil {
12603			arg0 = args[0].(string)
12604		}
12605		run(
12606			arg0,
12607		)
12608	})
12609	return _c
12610}
12611
12612func (_c *MockSpinnerWidget_RemoveCssClass_Call) Return() *MockSpinnerWidget_RemoveCssClass_Call {
12613	_c.Call.Return()
12614	return _c
12615}
12616
12617func (_c *MockSpinnerWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockSpinnerWidget_RemoveCssClass_Call {
12618	_c.Run(run)
12619	return _c
12620}
12621
12622// SetCanFocus provides a mock function for the type MockSpinnerWidget
12623func (_mock *MockSpinnerWidget) SetCanFocus(canFocus bool) {
12624	_mock.Called(canFocus)
12625	return
12626}
12627
12628// MockSpinnerWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
12629type MockSpinnerWidget_SetCanFocus_Call struct {
12630	*mock.Call
12631}
12632
12633// SetCanFocus is a helper method to define mock.On call
12634//   - canFocus bool
12635func (_e *MockSpinnerWidget_Expecter) SetCanFocus(canFocus interface{}) *MockSpinnerWidget_SetCanFocus_Call {
12636	return &MockSpinnerWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
12637}
12638
12639func (_c *MockSpinnerWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockSpinnerWidget_SetCanFocus_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_SetCanFocus_Call) Return() *MockSpinnerWidget_SetCanFocus_Call {
12653	_c.Call.Return()
12654	return _c
12655}
12656
12657func (_c *MockSpinnerWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockSpinnerWidget_SetCanFocus_Call {
12658	_c.Run(run)
12659	return _c
12660}
12661
12662// SetCanTarget provides a mock function for the type MockSpinnerWidget
12663func (_mock *MockSpinnerWidget) SetCanTarget(canTarget bool) {
12664	_mock.Called(canTarget)
12665	return
12666}
12667
12668// MockSpinnerWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
12669type MockSpinnerWidget_SetCanTarget_Call struct {
12670	*mock.Call
12671}
12672
12673// SetCanTarget is a helper method to define mock.On call
12674//   - canTarget bool
12675func (_e *MockSpinnerWidget_Expecter) SetCanTarget(canTarget interface{}) *MockSpinnerWidget_SetCanTarget_Call {
12676	return &MockSpinnerWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
12677}
12678
12679func (_c *MockSpinnerWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockSpinnerWidget_SetCanTarget_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_SetCanTarget_Call) Return() *MockSpinnerWidget_SetCanTarget_Call {
12693	_c.Call.Return()
12694	return _c
12695}
12696
12697func (_c *MockSpinnerWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockSpinnerWidget_SetCanTarget_Call {
12698	_c.Run(run)
12699	return _c
12700}
12701
12702// SetFocusOnClick provides a mock function for the type MockSpinnerWidget
12703func (_mock *MockSpinnerWidget) SetFocusOnClick(focusOnClick bool) {
12704	_mock.Called(focusOnClick)
12705	return
12706}
12707
12708// MockSpinnerWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
12709type MockSpinnerWidget_SetFocusOnClick_Call struct {
12710	*mock.Call
12711}
12712
12713// SetFocusOnClick is a helper method to define mock.On call
12714//   - focusOnClick bool
12715func (_e *MockSpinnerWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockSpinnerWidget_SetFocusOnClick_Call {
12716	return &MockSpinnerWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
12717}
12718
12719func (_c *MockSpinnerWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockSpinnerWidget_SetFocusOnClick_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_SetFocusOnClick_Call) Return() *MockSpinnerWidget_SetFocusOnClick_Call {
12733	_c.Call.Return()
12734	return _c
12735}
12736
12737func (_c *MockSpinnerWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockSpinnerWidget_SetFocusOnClick_Call {
12738	_c.Run(run)
12739	return _c
12740}
12741
12742// SetFocusable provides a mock function for the type MockSpinnerWidget
12743func (_mock *MockSpinnerWidget) SetFocusable(focusable bool) {
12744	_mock.Called(focusable)
12745	return
12746}
12747
12748// MockSpinnerWidget_SetFocusable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusable'
12749type MockSpinnerWidget_SetFocusable_Call struct {
12750	*mock.Call
12751}
12752
12753// SetFocusable is a helper method to define mock.On call
12754//   - focusable bool
12755func (_e *MockSpinnerWidget_Expecter) SetFocusable(focusable interface{}) *MockSpinnerWidget_SetFocusable_Call {
12756	return &MockSpinnerWidget_SetFocusable_Call{Call: _e.mock.On("SetFocusable", focusable)}
12757}
12758
12759func (_c *MockSpinnerWidget_SetFocusable_Call) Run(run func(focusable bool)) *MockSpinnerWidget_SetFocusable_Call {
12760	_c.Call.Run(func(args mock.Arguments) {
12761		var arg0 bool
12762		if args[0] != nil {
12763			arg0 = args[0].(bool)
12764		}
12765		run(
12766			arg0,
12767		)
12768	})
12769	return _c
12770}
12771
12772func (_c *MockSpinnerWidget_SetFocusable_Call) Return() *MockSpinnerWidget_SetFocusable_Call {
12773	_c.Call.Return()
12774	return _c
12775}
12776
12777func (_c *MockSpinnerWidget_SetFocusable_Call) RunAndReturn(run func(focusable bool)) *MockSpinnerWidget_SetFocusable_Call {
12778	_c.Run(run)
12779	return _c
12780}
12781
12782// SetHalign provides a mock function for the type MockSpinnerWidget
12783func (_mock *MockSpinnerWidget) SetHalign(align gtk.Align) {
12784	_mock.Called(align)
12785	return
12786}
12787
12788// MockSpinnerWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
12789type MockSpinnerWidget_SetHalign_Call struct {
12790	*mock.Call
12791}
12792
12793// SetHalign is a helper method to define mock.On call
12794//   - align gtk.Align
12795func (_e *MockSpinnerWidget_Expecter) SetHalign(align interface{}) *MockSpinnerWidget_SetHalign_Call {
12796	return &MockSpinnerWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
12797}
12798
12799func (_c *MockSpinnerWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockSpinnerWidget_SetHalign_Call {
12800	_c.Call.Run(func(args mock.Arguments) {
12801		var arg0 gtk.Align
12802		if args[0] != nil {
12803			arg0 = args[0].(gtk.Align)
12804		}
12805		run(
12806			arg0,
12807		)
12808	})
12809	return _c
12810}
12811
12812func (_c *MockSpinnerWidget_SetHalign_Call) Return() *MockSpinnerWidget_SetHalign_Call {
12813	_c.Call.Return()
12814	return _c
12815}
12816
12817func (_c *MockSpinnerWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockSpinnerWidget_SetHalign_Call {
12818	_c.Run(run)
12819	return _c
12820}
12821
12822// SetHexpand provides a mock function for the type MockSpinnerWidget
12823func (_mock *MockSpinnerWidget) SetHexpand(expand bool) {
12824	_mock.Called(expand)
12825	return
12826}
12827
12828// MockSpinnerWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
12829type MockSpinnerWidget_SetHexpand_Call struct {
12830	*mock.Call
12831}
12832
12833// SetHexpand is a helper method to define mock.On call
12834//   - expand bool
12835func (_e *MockSpinnerWidget_Expecter) SetHexpand(expand interface{}) *MockSpinnerWidget_SetHexpand_Call {
12836	return &MockSpinnerWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
12837}
12838
12839func (_c *MockSpinnerWidget_SetHexpand_Call) Run(run func(expand bool)) *MockSpinnerWidget_SetHexpand_Call {
12840	_c.Call.Run(func(args mock.Arguments) {
12841		var arg0 bool
12842		if args[0] != nil {
12843			arg0 = args[0].(bool)
12844		}
12845		run(
12846			arg0,
12847		)
12848	})
12849	return _c
12850}
12851
12852func (_c *MockSpinnerWidget_SetHexpand_Call) Return() *MockSpinnerWidget_SetHexpand_Call {
12853	_c.Call.Return()
12854	return _c
12855}
12856
12857func (_c *MockSpinnerWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockSpinnerWidget_SetHexpand_Call {
12858	_c.Run(run)
12859	return _c
12860}
12861
12862// SetSizeRequest provides a mock function for the type MockSpinnerWidget
12863func (_mock *MockSpinnerWidget) SetSizeRequest(width int, height int) {
12864	_mock.Called(width, height)
12865	return
12866}
12867
12868// MockSpinnerWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
12869type MockSpinnerWidget_SetSizeRequest_Call struct {
12870	*mock.Call
12871}
12872
12873// SetSizeRequest is a helper method to define mock.On call
12874//   - width int
12875//   - height int
12876func (_e *MockSpinnerWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockSpinnerWidget_SetSizeRequest_Call {
12877	return &MockSpinnerWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
12878}
12879
12880func (_c *MockSpinnerWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockSpinnerWidget_SetSizeRequest_Call {
12881	_c.Call.Run(func(args mock.Arguments) {
12882		var arg0 int
12883		if args[0] != nil {
12884			arg0 = args[0].(int)
12885		}
12886		var arg1 int
12887		if args[1] != nil {
12888			arg1 = args[1].(int)
12889		}
12890		run(
12891			arg0,
12892			arg1,
12893		)
12894	})
12895	return _c
12896}
12897
12898func (_c *MockSpinnerWidget_SetSizeRequest_Call) Return() *MockSpinnerWidget_SetSizeRequest_Call {
12899	_c.Call.Return()
12900	return _c
12901}
12902
12903func (_c *MockSpinnerWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockSpinnerWidget_SetSizeRequest_Call {
12904	_c.Run(run)
12905	return _c
12906}
12907
12908// SetSpinning provides a mock function for the type MockSpinnerWidget
12909func (_mock *MockSpinnerWidget) SetSpinning(spinning bool) {
12910	_mock.Called(spinning)
12911	return
12912}
12913
12914// MockSpinnerWidget_SetSpinning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpinning'
12915type MockSpinnerWidget_SetSpinning_Call struct {
12916	*mock.Call
12917}
12918
12919// SetSpinning is a helper method to define mock.On call
12920//   - spinning bool
12921func (_e *MockSpinnerWidget_Expecter) SetSpinning(spinning interface{}) *MockSpinnerWidget_SetSpinning_Call {
12922	return &MockSpinnerWidget_SetSpinning_Call{Call: _e.mock.On("SetSpinning", spinning)}
12923}
12924
12925func (_c *MockSpinnerWidget_SetSpinning_Call) Run(run func(spinning bool)) *MockSpinnerWidget_SetSpinning_Call {
12926	_c.Call.Run(func(args mock.Arguments) {
12927		var arg0 bool
12928		if args[0] != nil {
12929			arg0 = args[0].(bool)
12930		}
12931		run(
12932			arg0,
12933		)
12934	})
12935	return _c
12936}
12937
12938func (_c *MockSpinnerWidget_SetSpinning_Call) Return() *MockSpinnerWidget_SetSpinning_Call {
12939	_c.Call.Return()
12940	return _c
12941}
12942
12943func (_c *MockSpinnerWidget_SetSpinning_Call) RunAndReturn(run func(spinning bool)) *MockSpinnerWidget_SetSpinning_Call {
12944	_c.Run(run)
12945	return _c
12946}
12947
12948// SetValign provides a mock function for the type MockSpinnerWidget
12949func (_mock *MockSpinnerWidget) SetValign(align gtk.Align) {
12950	_mock.Called(align)
12951	return
12952}
12953
12954// MockSpinnerWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
12955type MockSpinnerWidget_SetValign_Call struct {
12956	*mock.Call
12957}
12958
12959// SetValign is a helper method to define mock.On call
12960//   - align gtk.Align
12961func (_e *MockSpinnerWidget_Expecter) SetValign(align interface{}) *MockSpinnerWidget_SetValign_Call {
12962	return &MockSpinnerWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
12963}
12964
12965func (_c *MockSpinnerWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockSpinnerWidget_SetValign_Call {
12966	_c.Call.Run(func(args mock.Arguments) {
12967		var arg0 gtk.Align
12968		if args[0] != nil {
12969			arg0 = args[0].(gtk.Align)
12970		}
12971		run(
12972			arg0,
12973		)
12974	})
12975	return _c
12976}
12977
12978func (_c *MockSpinnerWidget_SetValign_Call) Return() *MockSpinnerWidget_SetValign_Call {
12979	_c.Call.Return()
12980	return _c
12981}
12982
12983func (_c *MockSpinnerWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockSpinnerWidget_SetValign_Call {
12984	_c.Run(run)
12985	return _c
12986}
12987
12988// SetVexpand provides a mock function for the type MockSpinnerWidget
12989func (_mock *MockSpinnerWidget) SetVexpand(expand bool) {
12990	_mock.Called(expand)
12991	return
12992}
12993
12994// MockSpinnerWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
12995type MockSpinnerWidget_SetVexpand_Call struct {
12996	*mock.Call
12997}
12998
12999// SetVexpand is a helper method to define mock.On call
13000//   - expand bool
13001func (_e *MockSpinnerWidget_Expecter) SetVexpand(expand interface{}) *MockSpinnerWidget_SetVexpand_Call {
13002	return &MockSpinnerWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
13003}
13004
13005func (_c *MockSpinnerWidget_SetVexpand_Call) Run(run func(expand bool)) *MockSpinnerWidget_SetVexpand_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_SetVexpand_Call) Return() *MockSpinnerWidget_SetVexpand_Call {
13019	_c.Call.Return()
13020	return _c
13021}
13022
13023func (_c *MockSpinnerWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockSpinnerWidget_SetVexpand_Call {
13024	_c.Run(run)
13025	return _c
13026}
13027
13028// SetVisible provides a mock function for the type MockSpinnerWidget
13029func (_mock *MockSpinnerWidget) SetVisible(visible bool) {
13030	_mock.Called(visible)
13031	return
13032}
13033
13034// MockSpinnerWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
13035type MockSpinnerWidget_SetVisible_Call struct {
13036	*mock.Call
13037}
13038
13039// SetVisible is a helper method to define mock.On call
13040//   - visible bool
13041func (_e *MockSpinnerWidget_Expecter) SetVisible(visible interface{}) *MockSpinnerWidget_SetVisible_Call {
13042	return &MockSpinnerWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
13043}
13044
13045func (_c *MockSpinnerWidget_SetVisible_Call) Run(run func(visible bool)) *MockSpinnerWidget_SetVisible_Call {
13046	_c.Call.Run(func(args mock.Arguments) {
13047		var arg0 bool
13048		if args[0] != nil {
13049			arg0 = args[0].(bool)
13050		}
13051		run(
13052			arg0,
13053		)
13054	})
13055	return _c
13056}
13057
13058func (_c *MockSpinnerWidget_SetVisible_Call) Return() *MockSpinnerWidget_SetVisible_Call {
13059	_c.Call.Return()
13060	return _c
13061}
13062
13063func (_c *MockSpinnerWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockSpinnerWidget_SetVisible_Call {
13064	_c.Run(run)
13065	return _c
13066}
13067
13068// Show provides a mock function for the type MockSpinnerWidget
13069func (_mock *MockSpinnerWidget) Show() {
13070	_mock.Called()
13071	return
13072}
13073
13074// MockSpinnerWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
13075type MockSpinnerWidget_Show_Call struct {
13076	*mock.Call
13077}
13078
13079// Show is a helper method to define mock.On call
13080func (_e *MockSpinnerWidget_Expecter) Show() *MockSpinnerWidget_Show_Call {
13081	return &MockSpinnerWidget_Show_Call{Call: _e.mock.On("Show")}
13082}
13083
13084func (_c *MockSpinnerWidget_Show_Call) Run(run func()) *MockSpinnerWidget_Show_Call {
13085	_c.Call.Run(func(args mock.Arguments) {
13086		run()
13087	})
13088	return _c
13089}
13090
13091func (_c *MockSpinnerWidget_Show_Call) Return() *MockSpinnerWidget_Show_Call {
13092	_c.Call.Return()
13093	return _c
13094}
13095
13096func (_c *MockSpinnerWidget_Show_Call) RunAndReturn(run func()) *MockSpinnerWidget_Show_Call {
13097	_c.Run(run)
13098	return _c
13099}
13100
13101// Start provides a mock function for the type MockSpinnerWidget
13102func (_mock *MockSpinnerWidget) Start() {
13103	_mock.Called()
13104	return
13105}
13106
13107// MockSpinnerWidget_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
13108type MockSpinnerWidget_Start_Call struct {
13109	*mock.Call
13110}
13111
13112// Start is a helper method to define mock.On call
13113func (_e *MockSpinnerWidget_Expecter) Start() *MockSpinnerWidget_Start_Call {
13114	return &MockSpinnerWidget_Start_Call{Call: _e.mock.On("Start")}
13115}
13116
13117func (_c *MockSpinnerWidget_Start_Call) Run(run func()) *MockSpinnerWidget_Start_Call {
13118	_c.Call.Run(func(args mock.Arguments) {
13119		run()
13120	})
13121	return _c
13122}
13123
13124func (_c *MockSpinnerWidget_Start_Call) Return() *MockSpinnerWidget_Start_Call {
13125	_c.Call.Return()
13126	return _c
13127}
13128
13129func (_c *MockSpinnerWidget_Start_Call) RunAndReturn(run func()) *MockSpinnerWidget_Start_Call {
13130	_c.Run(run)
13131	return _c
13132}
13133
13134// Stop provides a mock function for the type MockSpinnerWidget
13135func (_mock *MockSpinnerWidget) Stop() {
13136	_mock.Called()
13137	return
13138}
13139
13140// MockSpinnerWidget_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
13141type MockSpinnerWidget_Stop_Call struct {
13142	*mock.Call
13143}
13144
13145// Stop is a helper method to define mock.On call
13146func (_e *MockSpinnerWidget_Expecter) Stop() *MockSpinnerWidget_Stop_Call {
13147	return &MockSpinnerWidget_Stop_Call{Call: _e.mock.On("Stop")}
13148}
13149
13150func (_c *MockSpinnerWidget_Stop_Call) Run(run func()) *MockSpinnerWidget_Stop_Call {
13151	_c.Call.Run(func(args mock.Arguments) {
13152		run()
13153	})
13154	return _c
13155}
13156
13157func (_c *MockSpinnerWidget_Stop_Call) Return() *MockSpinnerWidget_Stop_Call {
13158	_c.Call.Return()
13159	return _c
13160}
13161
13162func (_c *MockSpinnerWidget_Stop_Call) RunAndReturn(run func()) *MockSpinnerWidget_Stop_Call {
13163	_c.Run(run)
13164	return _c
13165}
13166
13167// Unparent provides a mock function for the type MockSpinnerWidget
13168func (_mock *MockSpinnerWidget) Unparent() {
13169	_mock.Called()
13170	return
13171}
13172
13173// MockSpinnerWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
13174type MockSpinnerWidget_Unparent_Call struct {
13175	*mock.Call
13176}
13177
13178// Unparent is a helper method to define mock.On call
13179func (_e *MockSpinnerWidget_Expecter) Unparent() *MockSpinnerWidget_Unparent_Call {
13180	return &MockSpinnerWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
13181}
13182
13183func (_c *MockSpinnerWidget_Unparent_Call) Run(run func()) *MockSpinnerWidget_Unparent_Call {
13184	_c.Call.Run(func(args mock.Arguments) {
13185		run()
13186	})
13187	return _c
13188}
13189
13190func (_c *MockSpinnerWidget_Unparent_Call) Return() *MockSpinnerWidget_Unparent_Call {
13191	_c.Call.Return()
13192	return _c
13193}
13194
13195func (_c *MockSpinnerWidget_Unparent_Call) RunAndReturn(run func()) *MockSpinnerWidget_Unparent_Call {
13196	_c.Run(run)
13197	return _c
13198}
13199
13200// 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.
13201// The first argument is typically a *testing.T value.
13202func NewMockWidgetFactory(t interface {
13203	mock.TestingT
13204	Cleanup(func())
13205}) *MockWidgetFactory {
13206	mock := &MockWidgetFactory{}
13207	mock.Mock.Test(t)
13208
13209	t.Cleanup(func() { mock.AssertExpectations(t) })
13210
13211	return mock
13212}
13213
13214// MockWidgetFactory is an autogenerated mock type for the WidgetFactory type
13215type MockWidgetFactory struct {
13216	mock.Mock
13217}
13218
13219type MockWidgetFactory_Expecter struct {
13220	mock *mock.Mock
13221}
13222
13223func (_m *MockWidgetFactory) EXPECT() *MockWidgetFactory_Expecter {
13224	return &MockWidgetFactory_Expecter{mock: &_m.Mock}
13225}
13226
13227// NewBox provides a mock function for the type MockWidgetFactory
13228func (_mock *MockWidgetFactory) NewBox(orientation layout.Orientation, spacing int) layout.BoxWidget {
13229	ret := _mock.Called(orientation, spacing)
13230
13231	if len(ret) == 0 {
13232		panic("no return value specified for NewBox")
13233	}
13234
13235	var r0 layout.BoxWidget
13236	if returnFunc, ok := ret.Get(0).(func(layout.Orientation, int) layout.BoxWidget); ok {
13237		r0 = returnFunc(orientation, spacing)
13238	} else {
13239		if ret.Get(0) != nil {
13240			r0 = ret.Get(0).(layout.BoxWidget)
13241		}
13242	}
13243	return r0
13244}
13245
13246// MockWidgetFactory_NewBox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBox'
13247type MockWidgetFactory_NewBox_Call struct {
13248	*mock.Call
13249}
13250
13251// NewBox is a helper method to define mock.On call
13252//   - orientation layout.Orientation
13253//   - spacing int
13254func (_e *MockWidgetFactory_Expecter) NewBox(orientation interface{}, spacing interface{}) *MockWidgetFactory_NewBox_Call {
13255	return &MockWidgetFactory_NewBox_Call{Call: _e.mock.On("NewBox", orientation, spacing)}
13256}
13257
13258func (_c *MockWidgetFactory_NewBox_Call) Run(run func(orientation layout.Orientation, spacing int)) *MockWidgetFactory_NewBox_Call {
13259	_c.Call.Run(func(args mock.Arguments) {
13260		var arg0 layout.Orientation
13261		if args[0] != nil {
13262			arg0 = args[0].(layout.Orientation)
13263		}
13264		var arg1 int
13265		if args[1] != nil {
13266			arg1 = args[1].(int)
13267		}
13268		run(
13269			arg0,
13270			arg1,
13271		)
13272	})
13273	return _c
13274}
13275
13276func (_c *MockWidgetFactory_NewBox_Call) Return(boxWidget layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
13277	_c.Call.Return(boxWidget)
13278	return _c
13279}
13280
13281func (_c *MockWidgetFactory_NewBox_Call) RunAndReturn(run func(orientation layout.Orientation, spacing int) layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
13282	_c.Call.Return(run)
13283	return _c
13284}
13285
13286// NewButton provides a mock function for the type MockWidgetFactory
13287func (_mock *MockWidgetFactory) NewButton() layout.ButtonWidget {
13288	ret := _mock.Called()
13289
13290	if len(ret) == 0 {
13291		panic("no return value specified for NewButton")
13292	}
13293
13294	var r0 layout.ButtonWidget
13295	if returnFunc, ok := ret.Get(0).(func() layout.ButtonWidget); ok {
13296		r0 = returnFunc()
13297	} else {
13298		if ret.Get(0) != nil {
13299			r0 = ret.Get(0).(layout.ButtonWidget)
13300		}
13301	}
13302	return r0
13303}
13304
13305// MockWidgetFactory_NewButton_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewButton'
13306type MockWidgetFactory_NewButton_Call struct {
13307	*mock.Call
13308}
13309
13310// NewButton is a helper method to define mock.On call
13311func (_e *MockWidgetFactory_Expecter) NewButton() *MockWidgetFactory_NewButton_Call {
13312	return &MockWidgetFactory_NewButton_Call{Call: _e.mock.On("NewButton")}
13313}
13314
13315func (_c *MockWidgetFactory_NewButton_Call) Run(run func()) *MockWidgetFactory_NewButton_Call {
13316	_c.Call.Run(func(args mock.Arguments) {
13317		run()
13318	})
13319	return _c
13320}
13321
13322func (_c *MockWidgetFactory_NewButton_Call) Return(buttonWidget layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
13323	_c.Call.Return(buttonWidget)
13324	return _c
13325}
13326
13327func (_c *MockWidgetFactory_NewButton_Call) RunAndReturn(run func() layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
13328	_c.Call.Return(run)
13329	return _c
13330}
13331
13332// NewImage provides a mock function for the type MockWidgetFactory
13333func (_mock *MockWidgetFactory) NewImage() layout.ImageWidget {
13334	ret := _mock.Called()
13335
13336	if len(ret) == 0 {
13337		panic("no return value specified for NewImage")
13338	}
13339
13340	var r0 layout.ImageWidget
13341	if returnFunc, ok := ret.Get(0).(func() layout.ImageWidget); ok {
13342		r0 = returnFunc()
13343	} else {
13344		if ret.Get(0) != nil {
13345			r0 = ret.Get(0).(layout.ImageWidget)
13346		}
13347	}
13348	return r0
13349}
13350
13351// MockWidgetFactory_NewImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewImage'
13352type MockWidgetFactory_NewImage_Call struct {
13353	*mock.Call
13354}
13355
13356// NewImage is a helper method to define mock.On call
13357func (_e *MockWidgetFactory_Expecter) NewImage() *MockWidgetFactory_NewImage_Call {
13358	return &MockWidgetFactory_NewImage_Call{Call: _e.mock.On("NewImage")}
13359}
13360
13361func (_c *MockWidgetFactory_NewImage_Call) Run(run func()) *MockWidgetFactory_NewImage_Call {
13362	_c.Call.Run(func(args mock.Arguments) {
13363		run()
13364	})
13365	return _c
13366}
13367
13368func (_c *MockWidgetFactory_NewImage_Call) Return(imageWidget layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
13369	_c.Call.Return(imageWidget)
13370	return _c
13371}
13372
13373func (_c *MockWidgetFactory_NewImage_Call) RunAndReturn(run func() layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
13374	_c.Call.Return(run)
13375	return _c
13376}
13377
13378// NewLabel provides a mock function for the type MockWidgetFactory
13379func (_mock *MockWidgetFactory) NewLabel(text string) layout.LabelWidget {
13380	ret := _mock.Called(text)
13381
13382	if len(ret) == 0 {
13383		panic("no return value specified for NewLabel")
13384	}
13385
13386	var r0 layout.LabelWidget
13387	if returnFunc, ok := ret.Get(0).(func(string) layout.LabelWidget); ok {
13388		r0 = returnFunc(text)
13389	} else {
13390		if ret.Get(0) != nil {
13391			r0 = ret.Get(0).(layout.LabelWidget)
13392		}
13393	}
13394	return r0
13395}
13396
13397// MockWidgetFactory_NewLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewLabel'
13398type MockWidgetFactory_NewLabel_Call struct {
13399	*mock.Call
13400}
13401
13402// NewLabel is a helper method to define mock.On call
13403//   - text string
13404func (_e *MockWidgetFactory_Expecter) NewLabel(text interface{}) *MockWidgetFactory_NewLabel_Call {
13405	return &MockWidgetFactory_NewLabel_Call{Call: _e.mock.On("NewLabel", text)}
13406}
13407
13408func (_c *MockWidgetFactory_NewLabel_Call) Run(run func(text string)) *MockWidgetFactory_NewLabel_Call {
13409	_c.Call.Run(func(args mock.Arguments) {
13410		var arg0 string
13411		if args[0] != nil {
13412			arg0 = args[0].(string)
13413		}
13414		run(
13415			arg0,
13416		)
13417	})
13418	return _c
13419}
13420
13421func (_c *MockWidgetFactory_NewLabel_Call) Return(labelWidget layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
13422	_c.Call.Return(labelWidget)
13423	return _c
13424}
13425
13426func (_c *MockWidgetFactory_NewLabel_Call) RunAndReturn(run func(text string) layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
13427	_c.Call.Return(run)
13428	return _c
13429}
13430
13431// NewOverlay provides a mock function for the type MockWidgetFactory
13432func (_mock *MockWidgetFactory) NewOverlay() layout.OverlayWidget {
13433	ret := _mock.Called()
13434
13435	if len(ret) == 0 {
13436		panic("no return value specified for NewOverlay")
13437	}
13438
13439	var r0 layout.OverlayWidget
13440	if returnFunc, ok := ret.Get(0).(func() layout.OverlayWidget); ok {
13441		r0 = returnFunc()
13442	} else {
13443		if ret.Get(0) != nil {
13444			r0 = ret.Get(0).(layout.OverlayWidget)
13445		}
13446	}
13447	return r0
13448}
13449
13450// MockWidgetFactory_NewOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewOverlay'
13451type MockWidgetFactory_NewOverlay_Call struct {
13452	*mock.Call
13453}
13454
13455// NewOverlay is a helper method to define mock.On call
13456func (_e *MockWidgetFactory_Expecter) NewOverlay() *MockWidgetFactory_NewOverlay_Call {
13457	return &MockWidgetFactory_NewOverlay_Call{Call: _e.mock.On("NewOverlay")}
13458}
13459
13460func (_c *MockWidgetFactory_NewOverlay_Call) Run(run func()) *MockWidgetFactory_NewOverlay_Call {
13461	_c.Call.Run(func(args mock.Arguments) {
13462		run()
13463	})
13464	return _c
13465}
13466
13467func (_c *MockWidgetFactory_NewOverlay_Call) Return(overlayWidget layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
13468	_c.Call.Return(overlayWidget)
13469	return _c
13470}
13471
13472func (_c *MockWidgetFactory_NewOverlay_Call) RunAndReturn(run func() layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
13473	_c.Call.Return(run)
13474	return _c
13475}
13476
13477// NewPaned provides a mock function for the type MockWidgetFactory
13478func (_mock *MockWidgetFactory) NewPaned(orientation layout.Orientation) layout.PanedWidget {
13479	ret := _mock.Called(orientation)
13480
13481	if len(ret) == 0 {
13482		panic("no return value specified for NewPaned")
13483	}
13484
13485	var r0 layout.PanedWidget
13486	if returnFunc, ok := ret.Get(0).(func(layout.Orientation) layout.PanedWidget); ok {
13487		r0 = returnFunc(orientation)
13488	} else {
13489		if ret.Get(0) != nil {
13490			r0 = ret.Get(0).(layout.PanedWidget)
13491		}
13492	}
13493	return r0
13494}
13495
13496// MockWidgetFactory_NewPaned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewPaned'
13497type MockWidgetFactory_NewPaned_Call struct {
13498	*mock.Call
13499}
13500
13501// NewPaned is a helper method to define mock.On call
13502//   - orientation layout.Orientation
13503func (_e *MockWidgetFactory_Expecter) NewPaned(orientation interface{}) *MockWidgetFactory_NewPaned_Call {
13504	return &MockWidgetFactory_NewPaned_Call{Call: _e.mock.On("NewPaned", orientation)}
13505}
13506
13507func (_c *MockWidgetFactory_NewPaned_Call) Run(run func(orientation layout.Orientation)) *MockWidgetFactory_NewPaned_Call {
13508	_c.Call.Run(func(args mock.Arguments) {
13509		var arg0 layout.Orientation
13510		if args[0] != nil {
13511			arg0 = args[0].(layout.Orientation)
13512		}
13513		run(
13514			arg0,
13515		)
13516	})
13517	return _c
13518}
13519
13520func (_c *MockWidgetFactory_NewPaned_Call) Return(panedWidget layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
13521	_c.Call.Return(panedWidget)
13522	return _c
13523}
13524
13525func (_c *MockWidgetFactory_NewPaned_Call) RunAndReturn(run func(orientation layout.Orientation) layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
13526	_c.Call.Return(run)
13527	return _c
13528}
13529
13530// NewProgressBar provides a mock function for the type MockWidgetFactory
13531func (_mock *MockWidgetFactory) NewProgressBar() layout.ProgressBarWidget {
13532	ret := _mock.Called()
13533
13534	if len(ret) == 0 {
13535		panic("no return value specified for NewProgressBar")
13536	}
13537
13538	var r0 layout.ProgressBarWidget
13539	if returnFunc, ok := ret.Get(0).(func() layout.ProgressBarWidget); ok {
13540		r0 = returnFunc()
13541	} else {
13542		if ret.Get(0) != nil {
13543			r0 = ret.Get(0).(layout.ProgressBarWidget)
13544		}
13545	}
13546	return r0
13547}
13548
13549// MockWidgetFactory_NewProgressBar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewProgressBar'
13550type MockWidgetFactory_NewProgressBar_Call struct {
13551	*mock.Call
13552}
13553
13554// NewProgressBar is a helper method to define mock.On call
13555func (_e *MockWidgetFactory_Expecter) NewProgressBar() *MockWidgetFactory_NewProgressBar_Call {
13556	return &MockWidgetFactory_NewProgressBar_Call{Call: _e.mock.On("NewProgressBar")}
13557}
13558
13559func (_c *MockWidgetFactory_NewProgressBar_Call) Run(run func()) *MockWidgetFactory_NewProgressBar_Call {
13560	_c.Call.Run(func(args mock.Arguments) {
13561		run()
13562	})
13563	return _c
13564}
13565
13566func (_c *MockWidgetFactory_NewProgressBar_Call) Return(progressBarWidget layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
13567	_c.Call.Return(progressBarWidget)
13568	return _c
13569}
13570
13571func (_c *MockWidgetFactory_NewProgressBar_Call) RunAndReturn(run func() layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
13572	_c.Call.Return(run)
13573	return _c
13574}
13575
13576// NewSpinner provides a mock function for the type MockWidgetFactory
13577func (_mock *MockWidgetFactory) NewSpinner() layout.SpinnerWidget {
13578	ret := _mock.Called()
13579
13580	if len(ret) == 0 {
13581		panic("no return value specified for NewSpinner")
13582	}
13583
13584	var r0 layout.SpinnerWidget
13585	if returnFunc, ok := ret.Get(0).(func() layout.SpinnerWidget); ok {
13586		r0 = returnFunc()
13587	} else {
13588		if ret.Get(0) != nil {
13589			r0 = ret.Get(0).(layout.SpinnerWidget)
13590		}
13591	}
13592	return r0
13593}
13594
13595// MockWidgetFactory_NewSpinner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSpinner'
13596type MockWidgetFactory_NewSpinner_Call struct {
13597	*mock.Call
13598}
13599
13600// NewSpinner is a helper method to define mock.On call
13601func (_e *MockWidgetFactory_Expecter) NewSpinner() *MockWidgetFactory_NewSpinner_Call {
13602	return &MockWidgetFactory_NewSpinner_Call{Call: _e.mock.On("NewSpinner")}
13603}
13604
13605func (_c *MockWidgetFactory_NewSpinner_Call) Run(run func()) *MockWidgetFactory_NewSpinner_Call {
13606	_c.Call.Run(func(args mock.Arguments) {
13607		run()
13608	})
13609	return _c
13610}
13611
13612func (_c *MockWidgetFactory_NewSpinner_Call) Return(spinnerWidget layout.SpinnerWidget) *MockWidgetFactory_NewSpinner_Call {
13613	_c.Call.Return(spinnerWidget)
13614	return _c
13615}
13616
13617func (_c *MockWidgetFactory_NewSpinner_Call) RunAndReturn(run func() layout.SpinnerWidget) *MockWidgetFactory_NewSpinner_Call {
13618	_c.Call.Return(run)
13619	return _c
13620}
13621
13622// WrapWidget provides a mock function for the type MockWidgetFactory
13623func (_mock *MockWidgetFactory) WrapWidget(w *gtk.Widget) layout.Widget {
13624	ret := _mock.Called(w)
13625
13626	if len(ret) == 0 {
13627		panic("no return value specified for WrapWidget")
13628	}
13629
13630	var r0 layout.Widget
13631	if returnFunc, ok := ret.Get(0).(func(*gtk.Widget) layout.Widget); ok {
13632		r0 = returnFunc(w)
13633	} else {
13634		if ret.Get(0) != nil {
13635			r0 = ret.Get(0).(layout.Widget)
13636		}
13637	}
13638	return r0
13639}
13640
13641// MockWidgetFactory_WrapWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WrapWidget'
13642type MockWidgetFactory_WrapWidget_Call struct {
13643	*mock.Call
13644}
13645
13646// WrapWidget is a helper method to define mock.On call
13647//   - w *gtk.Widget
13648func (_e *MockWidgetFactory_Expecter) WrapWidget(w interface{}) *MockWidgetFactory_WrapWidget_Call {
13649	return &MockWidgetFactory_WrapWidget_Call{Call: _e.mock.On("WrapWidget", w)}
13650}
13651
13652func (_c *MockWidgetFactory_WrapWidget_Call) Run(run func(w *gtk.Widget)) *MockWidgetFactory_WrapWidget_Call {
13653	_c.Call.Run(func(args mock.Arguments) {
13654		var arg0 *gtk.Widget
13655		if args[0] != nil {
13656			arg0 = args[0].(*gtk.Widget)
13657		}
13658		run(
13659			arg0,
13660		)
13661	})
13662	return _c
13663}
13664
13665func (_c *MockWidgetFactory_WrapWidget_Call) Return(widget layout.Widget) *MockWidgetFactory_WrapWidget_Call {
13666	_c.Call.Return(widget)
13667	return _c
13668}
13669
13670func (_c *MockWidgetFactory_WrapWidget_Call) RunAndReturn(run func(w *gtk.Widget) layout.Widget) *MockWidgetFactory_WrapWidget_Call {
13671	_c.Call.Return(run)
13672	return _c
13673}
13674
13675// 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.
13676// The first argument is typically a *testing.T value.
13677func NewMockPaneRenderer(t interface {
13678	mock.TestingT
13679	Cleanup(func())
13680}) *MockPaneRenderer {
13681	mock := &MockPaneRenderer{}
13682	mock.Mock.Test(t)
13683
13684	t.Cleanup(func() { mock.AssertExpectations(t) })
13685
13686	return mock
13687}
13688
13689// MockPaneRenderer is an autogenerated mock type for the PaneRenderer type
13690type MockPaneRenderer struct {
13691	mock.Mock
13692}
13693
13694type MockPaneRenderer_Expecter struct {
13695	mock *mock.Mock
13696}
13697
13698func (_m *MockPaneRenderer) EXPECT() *MockPaneRenderer_Expecter {
13699	return &MockPaneRenderer_Expecter{mock: &_m.Mock}
13700}
13701
13702// RenderPane provides a mock function for the type MockPaneRenderer
13703func (_mock *MockPaneRenderer) RenderPane(paneID string, webViewWidget layout.Widget) layout.Widget {
13704	ret := _mock.Called(paneID, webViewWidget)
13705
13706	if len(ret) == 0 {
13707		panic("no return value specified for RenderPane")
13708	}
13709
13710	var r0 layout.Widget
13711	if returnFunc, ok := ret.Get(0).(func(string, layout.Widget) layout.Widget); ok {
13712		r0 = returnFunc(paneID, webViewWidget)
13713	} else {
13714		if ret.Get(0) != nil {
13715			r0 = ret.Get(0).(layout.Widget)
13716		}
13717	}
13718	return r0
13719}
13720
13721// MockPaneRenderer_RenderPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenderPane'
13722type MockPaneRenderer_RenderPane_Call struct {
13723	*mock.Call
13724}
13725
13726// RenderPane is a helper method to define mock.On call
13727//   - paneID string
13728//   - webViewWidget layout.Widget
13729func (_e *MockPaneRenderer_Expecter) RenderPane(paneID interface{}, webViewWidget interface{}) *MockPaneRenderer_RenderPane_Call {
13730	return &MockPaneRenderer_RenderPane_Call{Call: _e.mock.On("RenderPane", paneID, webViewWidget)}
13731}
13732
13733func (_c *MockPaneRenderer_RenderPane_Call) Run(run func(paneID string, webViewWidget layout.Widget)) *MockPaneRenderer_RenderPane_Call {
13734	_c.Call.Run(func(args mock.Arguments) {
13735		var arg0 string
13736		if args[0] != nil {
13737			arg0 = args[0].(string)
13738		}
13739		var arg1 layout.Widget
13740		if args[1] != nil {
13741			arg1 = args[1].(layout.Widget)
13742		}
13743		run(
13744			arg0,
13745			arg1,
13746		)
13747	})
13748	return _c
13749}
13750
13751func (_c *MockPaneRenderer_RenderPane_Call) Return(widget layout.Widget) *MockPaneRenderer_RenderPane_Call {
13752	_c.Call.Return(widget)
13753	return _c
13754}
13755
13756func (_c *MockPaneRenderer_RenderPane_Call) RunAndReturn(run func(paneID string, webViewWidget layout.Widget) layout.Widget) *MockPaneRenderer_RenderPane_Call {
13757	_c.Call.Return(run)
13758	return _c
13759}