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