Description
While designing experiments in EventIDE, you operate with three types of design objects:
experiments,
events and
elements. The experiment object is a root container for everything. The events are time blocks that define the experiment scenario and, in addition, host the elements. The elements handle various singular functions in an experiment, for example, some elements present stimuli, some register responses and other communicate with hardware.
Every design object has a fixed list of properties that represent object's status. In the first approach, the properties are variables (fields) of simple data types, e.g: string, boolean, integer and so on. For example, the event has a property called ‘Background Color’, which can be used to set a color of the event background. Another event's property, 'Elapsed time', returns the amount of milliseconds that have passed since the event's onset. This property can be read and used as a local timer in user code.
When a design object is selected in the EventIDE designer, its properties are shown in the
property grid (on the right of the main window) and can be modified there (see the screenshots below). The most relevant properties are marked in orange.
Property Interface
The properties provide a simple, unified and very intuitive interface for controlling data and functions of the design objects. The properties can be accessed both in the EventIDE designer and in the
code snippets at runtime. EventIDE automatically handles all necessary updates on every property change. For instance, after you change the Position property of the Text element, the associated text block will be immediately removed and redrawn at the new position on the screen. There is no need to call any drawing function for this operation, because the properties combine concepts of data variables and functions. Due to that combination, you should be careful as you change properties at runtime. Property update processing can be time consuming, which can harm timing accuracy at critical moments. For example, it is recommended to complete all trial preparations (via the properties) before the stimulus presentation is started.
Some properties are designed to return the current state of a design object at runtime. For example, you can check whether a keyboard button is in the down or up state by reading the boolean IsDown property of the
Button element. The status properties can be naturally used as flags to control the flow of your experiment.
Property usage attributes
Property attributes determine how properties can be accessed and used. Although most of properties are available for use in code snippets through the parameters functionality, the property attributes can impose a specific mode.
Ordinal properties
The most of the object properties in EventIDE have no special access attributes, which means that they can be changed both at design and run-time, like a ordinal variable.
Status properties
The status properties return certain information about the current object's status. Note that the status properties are read-only and can not be modified by a user. They are updated internally, by its parent object. The status properties names often start with 'Is', e.g. IsTriggered and IsDown properties of the Button element. Another group of the status properties return various online statistics, e.g. actual durations of events (Actual Duration on the event object) or time of a button press (Triggering Time of the Button element)
Runtime command properties ¶
Some EventIDE objects provide an possibility to invoke user-initiated commands at runtime. For example, if you want to send an asynchronous trigger via the parallel port, you can use the 'Send Now' command property on the
LPT Port Element. To invoke the runtime command, make an assignment to it in your code, e.g. for the above example:
SendNow=true;
Names of the runtime command properties often end with 'Now', which indicates that this property is a command, rather than a data variable.
Designtime actions properties
Some EventIDE objects have properties that invoke the design-time actions. For example, you can open a data designer on the Reporter element via the Data Designer property. The Designtime-action properties are marked with the green play button in the property grid, like on the picture below.
Generic data types
Most of the properties of the EventIDE objects have standard data type, such as boolean, int, double, string.
EventIDE build-in data types
There are some properties that utilize
the EventIDE built-in data types. For example, the Position property of the
Renderer Element has a data type, called clPoint. clPoint is a custom struct that stores screen coordinates in the three coordinate systems: pixel, visual degrees and proportion to the screen size.
Property attributes
Property attributes determine the property can be accessed. Although the most of properties are available for use in code snippets via
proxy variables, the property attributes can impose certain restrictions on property access.
- Not attributed: The most of the properties has no access attributes, which means that they can be changed both at design and run-time.
- Run-time: This attribute indicates that the property can be accessed only in the run-time. Such a property can be accessed only via a proxy variable and then can be read and written in code snippets.
- Status: The status properties return status information about the current object state. For example, with the status properties you can collect timing statistics through a experiment run. The status properties are typically read-only and can not be modified by user code.
- Design-time: The design-time properties can be changed only at design-time. When the experiment is running, values of such properties are fixed and not accessible. The design-time properties include, for example, an event titles or persistent hardware settings, such as the display resolution. Design-time properties cannot be access via the proxy variables.