mocks.go RawHistoryFolder

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