efl/src/lib/ecore/efl_loop.eo

132 lines
5.3 KiB
Plaintext

struct Efl.Loop_Arguments {
[[EFL loop arguments data structure
@since 1.22
]]
argv: const(array<stringshare>); [[Array with loop arguments]]
initialization: bool; [[Set to $true when the program should initialize its internal state.
This happens once per process instance.]]
}
abstract Efl.Loop extends Efl.Task
{
[[The Efl Main Loop
The Efl main loop provides a clean and tiny event loop library with many modules to
do lots of convenient things for a programmer, saving time and effort. It's
lean and designed to work on anything from embedded systems all the way up to large
and powerful multi-cpu workstations. The main loop has a number of primitives you can use.
It serializes these and allows for
greater responsiveness without the need for threads (or any other concurrency). However
you can provide these if you need to.
@since 1.22
]]
methods {
iterate {
[[Runs a single iteration of the main loop to process everything on the
queue.]]
}
iterate_may_block {
[[Runs a single iteration of the main loop to process everything on the
queue with block/non-blocking status.]]
return: int; [[Return from single iteration run]]
params {
may_block: int; [[A flag if the main loop has a possibility of blocking.]]
}
}
begin {
[[Runs the application main loop.]]
return: any_value_ref; [[Value set by quit()]]
}
quit {
[[Quits the main loop once all the events currently on the queue have
been processed.]]
params {
@in exit_code: any_value; [[Returned value by begin()]]
}
}
job {
[[A future promise that will be resolved from a clean main
loop context as soon as possible.
This has higher priority, for low priority use
@.idle
]]
return: future<void> @move; [[The future handle.]]
}
@property throttle {
[[Slow down the loop execution by forcing sleep for a small
period of time every time the loop iterates/loops.]]
set {}
get {}
values {
amount : double; [[Time to sleep for each "loop iteration"]]
}
}
@property time {
[[Retrieves the time at which the last loop stopped waiting for timeouts or events.]]
set @protected {
[[You should never need/call this, unless you are implementing a custom
tick source for an animator.
Note: The time point must match whatever zero time you get from ecore_time_get() and @.time.get()
(same 0 point).
What this point is is undefined, so unless your source uses the same 0 time, then you may have to adjust
and do some guessing.
]]
}
get {
[[This gets the time that the main loop ceased waiting for timouts and/or
events to come in or for signals or any other interrupt source. This should
be considered a reference point for all time based activity that should
calculate its timepoint from the return of ecore_loop_time_get(). Note that this
time is meant to be used as relative to other times obtained on this run.
If you need absolute time references, use a unix timestamp instead.
]]
}
values {
timepoint: double; [[Time in seconds]]
}
}
idle {
[[A future promise that will be resolved from a clean main
loop context as soon as the main loop is idle.
This is a low priority version of @.job
]]
return: future<void> @move; [[The future handle.]]
}
timeout {
[[A future promise that will be resolved from a clean main
loop context after $time seconds.]]
params {
@in time: double; [[The time from now in second that the main loop will wait before triggering it.]]
}
return: future<void> @move; [[The future handle.]]
}
}
events {
idle,enter @restart: void; [[Event occurs once the main loop enters the idle state.]]
idle,exit @restart: void; [[Event occurs once the main loop exits the idle state.]]
idle @restart: void; [[Event occurs once the main loop is idle. If you keep listening on this event it may
increase the burden on your CPU.]]
arguments: Efl.Loop_Arguments; [[Event happens when args are provided to the loop by args_add().]]
poll,high: void; [[Event occurs multiple times per second. The exact tick is undefined and can be adjusted
system-wide.]]
poll,medium: void; [[Event occurs multiple times per minute. The exact tick is undefined and can be adjusted
system-wide.]]
poll,low: void; [[Event occurs multiple times every 15 minutes. The exact tick is undefined and can be adjusted
system-wide.]]
quit: void; [[Event occurs when the loop was requested to quit externally e.g. by a ctrl+c signal or a request
from a parent loop/thread to have the child exit.]]
}
implements {
Efl.Object.constructor;
Efl.Object.invalidate;
Efl.Object.destructor;
Efl.Task.run;
Efl.Task.end;
}
}