forked from enlightenment/efl
124 lines
5.2 KiB
Plaintext
124 lines
5.2 KiB
Plaintext
struct Efl.Loop_Arguments {
|
|
[[EFL loop arguments data structure
|
|
|
|
@since 1.22
|
|
]]
|
|
argv: const(array<const(stringshare)>); [[Array with loop arguments]]
|
|
initialization: bool; [[Set to $true when the program should initialize its internal state. This happen 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_ptr; [[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> @owned; [[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> @owned; [[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> @owned; [[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;
|
|
}
|
|
}
|