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