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