summaryrefslogtreecommitdiff
path: root/src/lib/ecore/efl_timer.eo
blob: f44052e10b750eddcb559d2a5d80938d65738b28 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import ecore_types;

class Efl.Timer (Efl.Loop_User)
{
   [[Timers are objects that will call a given callback at some point
     in the future.

     They may also optionally repeat themselves if the timer callback returns
     true. If it does not they will be automatically deleted and never called
     again. Timers require the ecore main loop to be running and functioning
     properly. They do not guarantee exact timing, but try to work on a "best
     effort" basis.
   ]]
   legacy_prefix: ecore_timer;
   methods {
      @property interval {
         [[Interval the timer ticks on.]]
         set {
            [[If set during a timer call, this will affect the next interval.]]
         }
         get {
         }
         values {
            in: double(-1); [[The new interval in seconds]]
         }
      }
      @property pending {
         [[Pending time regarding a timer.]]
         get {
            return: double;
         }
      }
      reset {
         /* FIXME-doc:
          * @note This is equivalent to (but faster than)
          * @code
          * ecore_timer_delay(timer, ecore_timer_interval_get(timer) - ecore_timer_pending_get(timer));
          * @endcode
          */
          [[Reset a timer to its full interval. This effectively makes the
            timer start ticking off from zero now.

            @since 1.2
          ]]
      }
      loop_reset {
         [[This effectively reset a timer, but based on the time when this iteration of the main loop started.
           @since 1.18
	 ]]
      }
      delay {
         [[Add some delay for the next occurrence of a timer.
           This doesn't affect the interval of a timer.
         ]]
         params {
            @in add: double; [[The amount of time to delay the timer by in seconds]]
         }
      }
   }
   events {
      tick; [[Event triggered when the specified time as passed.]]
   }
   implements {
      Eo.Base.constructor;
      Eo.Base.destructor;
      Eo.Base.finalize;
      Eo.Base.event_freeze;
      /* XXX: can't document overridden methods
       * Pauses a running timer.
       *
       * @param timer The timer to be paused.
       *
       * The timer callback won't be called while the timer is paused. The remaining
       * time until the timer expires will be saved, so the timer can be resumed with
       * that same remaining time to expire, instead of expiring instantly. Use
       * ecore_timer_thaw() to resume it.
       *
       * @note Nothing happens if the timer was already paused.
       *
       * @see ecore_timer_thaw()
       */
      Eo.Base.event_freeze_count.get;
      Eo.Base.event_thaw;
      /* XXX: can't document overridden methods
       * Resumes a frozen (paused) timer.
       *
       * @param timer The timer to be resumed.
       *
       * The timer will be resumed from its previous relative position in time. That
       * means, if it had X seconds remaining until expire when it was paused, it will
       * be started now with those same X seconds remaining to expire again. But
       * notice that the interval time won't be touched by this call or by
       * ecore_timer_freeze().
       *
       * @see ecore_timer_freeze()
       */
   }
}