if (error)
  CDPMessage("Error in %s\n", name.c_str());

bool MyKeyboardHandler(char ch)
{
  switch (ch)
  {
    case 'h':
    {
      CDPMessage("Keys supported my MyLib:\n");
      CDPMessage(" b: Print an info message.\n");
      // Special case for 'h': return false to allow all handlers to print help
      return false;
    }
    case 'b':
    {
      CDPMessage("'b' pressed!\n");
      // Normally, return true to indicate theat the key has been handled
      return true;
    }
  }
  return false;
}

Application::AddKeyboardHandler( MyKeyboardHandler );

Member Function Documentation

Application::Application(int argc = 0, char **argv = 0)

Default constructs an instance of Application.

[override virtual] Application::~Application()

Destroys the instance of Application. The destructor is virtual.

[static] void Application::AddKeyboardHandler(KeyboardHandlerFunction myKeyboardHandler)

Registers a function that will be called when a key is pressed on the keyboard. The keyboard handler returns true to indicate that no further processing of the keyboard event should occur, or false to allow other keyboard-handlers to handle the event. The handler registered last is called first, allowing override of the default behaviour.

[virtual] void Application::AddOneShotWorkerFunction(const char *pzProcessName, const std::function<void() > &function)

[virtual] void Application::AddOneShotWorkerProcess(const char *pzProcessName, CDPComponent *pComp, CDPCOMPONENT_STATEPROCESS pProc)

Adds a component function to be executed once at low priority in worker thread.

The following function adds a (possibly lengthy) process function to be executed to the Application Worker thread execution fifo queue. The function must exit after some time to allow other worker-threads to run. The function takes as input a name and a (CDPCOMPONENT_PROCESS) type (i.e. a void MyComponent::ProcessFunction(void) ) function. The Process function may change the priority of the workerprocess, but it will be reset to the initial low priority after it exits. Exceptions are caught and printed through CDPMessage.

[virtual] bool Application::CDPClockSyncEnabled()

Returns true if CDP ClockSync is enabled (property m_strClockSync has value "CDPClockSync").

void Application::CDPTimeChangedHandler(double secondsChanged, const std::string &oldDateTime, const std::string &newDateTime)

Will generate an extended event if secondsChanged is larger than 1s. This function has been registered into CDPTime::AddGlobalTimeChangedHandler(), and is called if CDPTime has changed, typically by clocksynch.

[virtual] void Application::Configure()

Configures Application. CDP System components are configured first. Then all other components are created and configured.

[virtual] void Application::Create()

Creates Application component and CDP system components

[override virtual protected] void Application::CreateModel()

Reimplemented from CDPBaseObject::CreateModel().

Creates the Application model.

[virtual] void Application::CreateXMLConfigurationDirectory(std::string &src, const std::string &shortName)

Figures out where the subcomponent configuration is, and updates src.

[static] void Application::DeferredNodeDelete(CDP::StudioAPI::CDPNode *property)

[override virtual] void Application::Destroy()

Reimplemented from CDPBaseObject::Destroy().

Suspends and destroys the application and all subcomponents.

[static] void Application::EnableKeyboardHandling(bool bEnable)

Set if keyboard handling is enabled or not.

[override virtual] void Application::FillNodeChildren(CDP::StudioAPI::NodeStream &stream) const

Reimplemented from CDPNode::FillNodeChildren().

Fills the nodestream with information. Calls baseclass implementation.

[static] std::string Application::GetArgumentValue(const std::string &argument)

Returns the corresponding value for argument (e.g. my-argument my_value)

char **Application::GetArguments() const

Returns argument pointer this application was invoked with

int Application::GetArgumentsCount() const

Returns number of arguments this application was invoked with

[static] Application *Application::GetInstance()

Returns the only Application instance

double Application::GetMemUsedRelative()

Returns memory used by the system, relative to available memory. Relative memory used will be returned in range [0.0 .. 1.0].

[override virtual] unsigned int Application::GetNodeID() const

Reimplemented from ICDPNode::GetNodeID().

Returns the application handle

[override virtual] CDP::StudioAPI::CDPNodeType Application::GetNodeType() const

Reimplemented from ICDPNode::GetNodeType().

Returns CDPNode type

[static] bool Application::GetNotRootEnabled()

Returns true if executing CDP as non root is enabled.

[override virtual] std::string Application::GetProperty(std::string propertyName)

Reimplemented from CDPBaseObject::GetProperty().

Returns the property value for a named property. May return a base property if propertyName is not found in this instance. Supports "GlobalTime"

[static] std::set<std::string> Application::GetRemoteFullNameByHandle(unsigned int objectHandle)

Returns a set of connection-names (remote fullnames), if found in CDPConnection's connectionsByHandle. Usually, only one connection is found for one handle, but if there are several connections having CDPNodes at the end of the remote names, after the same CDPComponent/CDPObject, there will be several connections for one handle. E.g.if there are two connections named 'App.CDPComponent.CDPNode1' and 'App.CDPComponent.CDPNode2', both will have same handle. Both these names will be returned by this function.

See also GetRemoteFullNameByHandleParentCDPObject().

[static] std::string Application::GetRemoteFullNameByHandleParentCDPObject(unsigned int objectHandle)

Returns remote fullname to nearest CDPObject identified by name of the connection, if connected and found in CDPConnection connectionsByHandle.

If e.g. the name of the connection is 'App.CDPComponent.CDPObject', this function will return 'App.CDPComponent.CDPObject'.

If e.g. the name of the connection is 'App.CDPComponent', this function will return 'App.CDPComponent'.

If e.g. there are several connections for same handle, like 'App.CDPComponent.CDPObject.CDPNode1.CDPNode2'and 'App.CDPComponent.CDPObject.CDPNode1.CDPNode3', this function will return 'App.CDPComponent.CDPObject'.

See also GetRemoteFullNameByHandle().

[override virtual] XMLElementEx *Application::GetXMLElement()

Reimplemented from CDPObject::GetXMLElement().

Get the XMLElement pointing to <Application>

void Application::HandleKeyboard()

Checks keyboard input and calls all registered keyboard handlers.

[static] bool Application::HasArgument(const std::string &argument)

Returns true if argument is found in the application argument list.

bool Application::IsConfigurationSaveBlocked()

Returns true if DelayConfigurationSave is set and time spent delaying save is less than MaxConfigurationSaveDelay. If not it returns false. If DelayConfigurationSave is set and time spent delaying save is equal or more than MaxConfigurationSaveDelay, the DelayConfigurationSaveAborted alarm is set.

bool Application::IsStarted(void)

Returns true when Application::Configure() is finished, meaning all components are configured and ready to start.

[virtual] bool Application::IsTimeServer()

Returns true if this Application shall act as a Time server for CDPClockSync. Only relevant if clocksynch is "CDPClockSync".

void Application::ListComponentThreads()

Prints all thread id's in this application space to CDPMessages console.

void Application::ListObjectStates()

Prints all object states in this application space to CDPMessages console.

void Application::ListObjects(CDPObject *pObject, int level)

Prints all objects in this application space to CDPMessages console.

[virtual protected] int Application::MessageSendKeyToKeyboard(void *message)

Messagehandler that forwards specified key/char to Keyboard handler. message must be a MessageTextCommandWithParameterSend-pointer. Character found in MessageTextCommandWithParameterSend's parameters[0] will be used as argument when calling ReceiveKey().

[virtual protected] int Application::MessageSetDiskAlarmAndText(void *message)

Messagehandler for the alarm "Disk Alarm". message must be a MessageDiskAlarmText-pointer. The alarm will be Set with updated alarm-text.

[virtual] bool Application::OSTimeClockSyncEnabled()

Returns true if OS Time ClockSync is enabled (property m_strClockSync has value "OS_Time").

[virtual] unsigned int Application::OStimeInterval()

Returns value of Interval (in s) of reading OS time. Only relevant if clocksynch is "OS_Time".

[static] void Application::PrintCommandLineArgumentList()

Prints supported command line arguments

[virtual protected] void Application::ProcessRunning()

Runs periodic state process. Updates CDPConnections, handles clock sync and updates CPU info etc.

void Application::RealSuspend()

Stops the application by suspending all components and stopping cdp infrastructure

void Application::ReceiveKey(char key)

Inserts key into keyboard input buffer.

[override virtual protected] int Application::ReceiveMessage(void *message)

Reimplemented from CDPBaseObject::ReceiveMessage().

Processes application messages. Will call CDPComponent::ReceiveMessage() if not handled here.

[static] void Application::RunInMainThread(std::function<void() > command, double delayInSeconds = 0.0)

Executes a callback command in the thread were `int main()` is defined.

Usually this is the only thread were functions are allowed to access GUI components. If optional parameter delayInSeconds is set, the command is run after specified delay.

Application::RunInMainThread([=] () { m_label.setText("New text"); }, 0.5);

[static] bool Application::Running()

Returns true after Start is called and before RealSuspend is executed

[virtual] void Application::SetClockSyncType(const std::string &newClockSyncType)

Specifies which clocksync to use. The property m_strClockSync gets value "CDPClockSync", "OS_Time" or "None".

void Application::SetDiskAlarm(std::string strAlarmText)

Sets the Disk Alarm in the application in a thread-safe manner. The strAlarmText should include information such as filename and type of error (read/write/seek etc).

[static] void Application::SetGlobalDebugLevel(int value)

Set the global debugEx variable (also adjusted by keyboard input 'Z' and 'z')

[virtual] void Application::SetIsTimeServer(bool newIsTimeServer)

Sets if this Application shall act as a Time server or not. Only relevant if clocksynch is "CDPClockSync". Default value is false.

[static] void Application::SetNotRootEnabled(bool enable = true)

Sets value of flag enabling executing CDP as non root (not real time) or not.

[virtual] void Application::SetOStimeInterval(unsigned int newOStimeInterval)

Sets new value of Interval (in s) of reading OS time. Only relevant if clocksynch is "OS_Time".

[override virtual] void Application::SetProperty(std::string propertyName, std::string propertyValue)

Reimplemented from CDPBaseObject::SetProperty().

Sets a property in the object to a specified value. Called by MessageSetProperty after property name and value has been figured out. If propery is not found, CDPComponent::SetProperty() is called. Supported Properties: "ApplicationHandle".

[override virtual] void Application::SetPropertyHandler(CDPPropertyBase *pProp)

Reimplemented from CDPObject::SetPropertyHandler().

Catches property 'Set' events

[static] void Application::SetReturnStatus(int status)

Set the application exit status.

int Application::Start()

Starts system components. Will not return before application is stopped. Returns application exit status.

[static] void Application::Stop()

Stops execution of all components and system services in this application space.

[static] bool Application::Stopped()

Returns true when RealSuspend has started or finished executing

[override virtual] void Application::Suspend()

Reimplemented from CDPBaseObject::Suspend().

Suspends the application and all other components.

[virtual protected] bool Application::TransitionNullToRunning()

Changes to Running state if requestedState == 'Running'

[override virtual] bool Application::ValidatePropertyHandler(CDP::StudioAPI::CDPVariantValue &newValue, CDPPropertyBase *property)

Reimplemented from CDPObject::ValidatePropertyHandler().

Validates properties before they are set to a new value. Return true to allow change, or false to disallow.

[virtual protected] void Application::WorkerTask(void)

This is the he WorkerTask which processes list of worker processes, and executes them in sequence. Restores initial Process priority after each run.

[static protected] OSAPITASK Application::WorkerTaskWrapper(LPVOID pClass)

Starts the worker task

[virtual] std::string &Application::XMLConfigurationDirectory()

Returns the XML configuration directory where subcomponent configuration is. If directory is not set, this will call CreateXMLConfigurationDirectory().