ScDllWrapper (Java API for SpaceControl Devices)

java.lang.Object
- de.spacecontrol.sc.dllwrapper.ScDllWrapper

```
public class ScDllWrapper
extends java.lang.Object
```
This class wraps all functions of the SC DLL (Windows) or the SC Shared Library (Linux) respectively and makes them accessible with Java, using the Java Native Interface (JNI). See the package documentation for details.

Author:

Friedemann Seebass

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ADV_SETTINGS_CHANGED` advanced settings are changed
`static int`	`APPL_FUNC_START` set rotation mode to "screen"
`static int`	`BAUD` setting parameter 'baud' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`BLINK_PERIOD` setting parameter 'blinkPeriod' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`BSC_SETTINGS_CHANGED` basic settings are changed
`static int`	`CAP_CHARACTERISTIC` setting parameter 'capCharacteristic' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`CFG_AUTO_CHANGE` setting parameter 'cfgAutoChange' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static java.lang.String`	`CMD_ACCEPT_ALL_FTDIS` all FTDI devices shall be recognized (not only those with "SpaceController" in the USB description)
`static java.lang.String`	`CMD_BLINK_LEDS` blue LEDs shall flash
`static java.lang.String`	`CMD_INJECT_STRING` injects a string into the OS' keyboard buffer
`static java.lang.String`	`CMD_SET_FAKE_ZERO` shifts the device's zero position to get data for testing even in the real zero position
`static java.lang.String`	`CMD_UPDATE_FIRMWARE` initiates a firmware update
`static java.lang.String`	`CMD_UPDATE_FIRMWARE_GUI` initiates a firmware update, triggered by the GUI
`static int`	`DEV_BACK` "Back" command is to be executed
`static int`	`DEV_BOTTOM` "Bottom" command is to be executed
`static int`	`DEV_CTRL` "CTRL" command is to be executed (for triggering a function in WFL)
`static int`	`DEV_ERR_BUF_OVERFLOW` device firmware error: buffer overflow occured
`static int`	`DEV_ERR_INTERNAL_ERROR` device firmware error: unspecified internal error
`static int`	`DEV_ERR_INVALID_ID` device firmware error: invalid identifier detected
`static int`	`DEV_ERR_INVALID_VALUE` device firmware error: invalid value detected
`static int`	`DEV_ERR_PARSE_ERROR` device firmware error: error parsing the command string
`static int`	`DEV_ERR_UNKNOWN_COMMAND` device firmware error: unknown command detected
`static int`	`DEV_FIT` "Fit" command is to be executed
`static int`	`DEV_FRONT` "Front" command is to be executed
`static int`	`DEV_LEFT` "Left" command is to be executed
`static int`	`DEV_PARS_CHANGED` some other parameters are changed
`static int`	`DEV_RIGHT` "Right" command is to be executed
`static int`	`DEV_TOP` "Top" command is to be executed
`static int`	`DEV_WHEEL_LEFT` wheel moved to left
`static int`	`DEV_WHEEL_RIGHT` wheel moved to right
`static int`	`DEVICE_CHECKING_TIME` setting parameter 'deviceCheckingTime' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`DEVICE_TIMEOUT` setting parameter 'deviceTimeOut' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`DISABLE_CUBE_DEMO` setting parameter 'disableCubeDemo' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`ENABLE_LEGACY_COM1` setting parameter 'enableLegacyCom1' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`ENABLE_LEGACY_COM2` setting parameter 'enableLegacyCom2' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`EVT_APPL_IN_FRGRND` signals an application that it is in the foreground now
`static int`	`EVT_HNDL_KBD_DLG` the GUI's keyboard dialog should be shown
`static int`	`EVT_HNDL_LCD_DLG` the GUI's LCD brightness slider should be shown
`static int`	`EVT_HNDL_LEDS_DLG` the GUI's LED brightness slider should be shown
`static int`	`EVT_HNDL_SENS_DLG` the GUI's sensitivity slider should be shown
`static int`	`EVT_HNDL_THRESH_DLG` the GUI's threshold slider should be shown
`static int`	`EVT_HNDL_WFL_DLG` the GUI's WFL dialog should be shown
`static int`	`EXPLORER_DELAY` setting parameter 'explorerDelay' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`LED_NUM` Number of LEDs built into the device
`static int`	`MAX_BRIGHTNESS` Max.
`static int`	`MAX_BYTES_IN_RX_QUEUE` setting parameter 'maxBytesInRxQueue' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`NOTHING_CHANGED` nothing to signal
`static int`	`PORT` setting parameter 'port' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`REMEMBER_LAST_CONFIG` setting parameter 'rememberLastCfg' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`SEARCH_TOP_WINDOW` setting parameter 'searchTopWindow' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`SEND_DELAY` setting parameter 'sendDelay' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`SEND_MODE` setting parameter 'sendMode' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`SINGLE_COM_PER_APPL` setting parameter 'singleComPerAppl' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`SKIP_TIMEOUT` setting parameter 'skipTimeout' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`TIME_BEFORE_SLEEPING` setting parameter 'timeBeforeSleeping' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
`static int`	`WHEEL_ACCELERATOR` setting parameter 'wheelAccelerator' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)

Constructor Summary

Constructors
Constructor and Description

ScDllWrapper()

Constructors
Constructor and Description
`ScDllWrapper()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static java.lang.String`	`eventToString(int event)` Converts an event type into a string.
`static void`	`main(java.lang.String[] args)` Nur zum Testen.
`static void`	`scConnect()` Deprecated.
`static void`	`scConnect2(boolean isAlwaysReceivingData, java.lang.String applName)` Establishes the connection to the SpaceController daemon.
`static void`	`scDelCurrentUserRegValue(ScTwoStrings in)` Deletes a string value in the Windows registry under the base key HKEY_CURRENT_USER.
`static void`	`scDisconnect()` Closes the connection to the SpaceController daemon.
`static void`	`scExecCmd(int devIdx, java.lang.String in)` Executes a special command.
`static void`	`scFetchStdData(int devIdx, ScStdData out)` Fetches the standard data set.
`static void`	`scGetAdvancedSettings(int devIdx, ScAdvancedSettings out)` Retrieves the actual advanced settings parameters.
`static void`	`scGetAdvSens(int devIdx, ScAdvSens out)` Retrieves the actual six sensitivity parameters of the advanced settings.
`static void`	`scGetBasicSettings(int devIdx, ScBasicSettings out)` Retrieves the actual basic settings parameters.
`static void`	`scGetCfgFileName(int devIdx, ScOneString out)` Retrieves the name and path of the device's actual configuration file.
`static void`	`scGetCmprMode(int devIdx, ScOneByte out)` Deprecated.
`static void`	`scGetDaemonPar(int par, ScOneInt out)` Retrieves one of the integer or boolean parameters available in the Daemon's configuration file "daemon.ini".
`static void`	`scGetDefDevPars(int devIdx, ScDevPars out)` Retrieves the default values of the device parameters.
`static void`	`scGetDevInfo(int devIdx, ScDevInfo out)` Retrieves some information data about the device with the given index.
`static void`	`scGetDevNum(ScThreeInts out)` Retrieves the number devNum of SpaceController devices actually connected to the computer and the maximal device index a device maxDevIdx may be addressed with at the moment.
`static void`	`scGetDevPars(int devIdx, ScDevPars out)` Retrieves the device's parameters as listed in the *.cfg files.
`static void`	`scGetDllLogPars(ScLogPars out)` Retrieves the logging parameters and filenames actually used by the internal DLL functions.
`static void`	`scGetDmnVrsn(ScTwoStrings out)` Retrieves the SpaceController daemon's software version and the path to its binary file.
`static void`	`scGetDom(int devIdx, ScOneBoolean out)` Answers with true if the dominant mode is set.
`static void`	`scGetFgAppl(ScTwoStrings out)` Retrieves the name and potentially the state of the foreground application.
`static void`	`scGetFmwUpdtState(int devIdx, ScTwoInts out)` Retrieves the state of a firmware update in progress. The SpaceController contains three micro controllers (MCU): The main micro controller (#1).
`static void`	`scGetLcd(int devIdx, ScOneInt out)` Gets the LCD's brightness.
`static void`	`scGetLed(int devIdx, int ledNo, ScOneInt out)` Gets the brightness of a single LED.
`static void`	`scGetLedsEx(int devIdx, byte[] buf)` Gets the brightnesses of all LEDs.
`static void`	`scGetNullRad(int devIdx, ScOneInt out)` Retrieves the device's null radius (threshold).
`static void`	`scGetRawData(int devIdx, byte[] buf)` The opto-electronical sensor integrated into the cap consists of six LEDs illuminating six position sensitive devices (PSD) producing data between 0 and 1023.
`static void`	`scGetRot(int devIdx, ScOneBoolean out)` Answers with true if the rotational mode is set.
`static void`	`scGetSendDelay(int devIdx, ScTwoInts out)` Retrieves the device's data rate parameters.
`static void`	`scGetSens(int devIdx, ScTwoInts out)` Retrieves the SC device's sensitivity.
`static void`	`scGetStdData(int devIdx, ScStdData out)` Deprecated.
`static void`	`scGetStdMode(int devIdx, ScOneByte out)` Retrieves the operating mode for standard data.
`static void`	`scGetTra(int devIdx, ScOneBoolean out)` Answers with true if the translational mode is set.
`static void`	`scGetXRot(int devIdx, ScOneBoolean out)` Answers with true if the x-axis' rotational data will be transmitted.
`static void`	`scGetXRotRev(int devIdx, ScOneBoolean out)` Answers with true if the x-axis' rotational mode is set to reverse.
`static void`	`scGetXRotSens(int devIdx, ScOneInt out)` Retrieves the device's sensitivity for the x-rotation.
`static void`	`scGetXTra(int devIdx, ScOneBoolean out)` Answers with true if the x-axis' translational data will be transmitted.
`static void`	`scGetXTraRev(int devIdx, ScOneBoolean out)` Answers with true if the x-axis' translational data is set to reverse.
`static void`	`scGetXTraSens(int devIdx, ScOneInt out)` Retrieves the device's sensitivity for the x-translation.
`static void`	`scGetYRot(int devIdx, ScOneBoolean out)` Answers with true if the y-axis' rotational data will be transmitted.
`static void`	`scGetYRotRev(int devIdx, ScOneBoolean out)` Answers with true if the y-axis' rotational mode is set to reverse.
`static void`	`scGetYRotSens(int devIdx, ScOneInt out)` Retrieves the device's sensitivity for the y-rotation.
`static void`	`scGetYTra(int devIdx, ScOneBoolean out)` Answers with true if the y-axis' translational data will be transmitted.
`static void`	`scGetYTraRev(int devIdx, ScOneBoolean out)` Answers with true if the y-axis' translational mode is set to reverse.
`static void`	`scGetYTraSens(int devIdx, ScOneInt out)` Retrieves the device's sensitivity for the y-translation.
`static void`	`scGetZRot(int devIdx, ScOneBoolean out)` Answers with true if the z-axis' rotational data will be transmitted.
`static void`	`scGetZRotRev(int devIdx, ScOneBoolean out)` Answers with true if the z-axis' rotational mode is set to reverse.
`static void`	`scGetZRotSens(int devIdx, ScOneInt out)` Retrieves the device's sensitivity for the z-rotation.
`static void`	`scGetZTra(int devIdx, ScOneBoolean out)` Answers with true if the z-axis' translational data will be transmitted.
`static void`	`scGetZTraRev(int devIdx, ScOneBoolean out)` Answers with true if the z-axis' translational mode is set to reverse.
`static void`	`scGetZTraSens(int devIdx, ScOneInt out)` Retrieves the SC device's sensitivity for the z-translation.
`static void`	`scIsProcessRunning(ScOneString processName, ScOneBoolean isRunning)` Checks if the process with the given name is running or not.\n Example:
`static void`	`scLoadDevPars(int devIdx, ScOneString in, ScDevPars out)` Deprecated.
`static void`	`scLoadDevPars(int devIdx, java.lang.String in, ScDevPars out)` Loads the parameters in the configuration file given in filePath into the device with index devIdx.
`static void`	`scPressKey(int devIdx, int key)` Triggers the same action as is done when a key of the device is pressed.
`static void`	`scQueryCurrentUserRegValue(ScTwoStrings in, int len, ScOneString out)` Queries a string value from the Windows registry under the base key HKEY_CURRENT_USER.
`static void`	`scRelKey(int devIdx, int key)` Triggers the same action as is done when a key of the device is released.
`static void`	`scSaveDevPars(int devIdx, ScOneString in)` Deprecated.
`static void`	`scSaveDevPars(int devIdx, java.lang.String in)` Saves the actual parameters of the device with index devIdx to the configuration file given in filePath.
`static void`	`scSetAdvancedSettings(int devIdx, ScAdvancedSettings inout)` Sets and retrieves the actual advanced settings parameters.
`static void`	`scSetAdvSens(int devIdx, ScAdvSens inout)` Sets and retrieves the six actual sensitivity parameters of the advanced settings.
`static void`	`scSetBasicSettings(int devIdx, ScBasicSettings inout)` Sets and retrieves the actual basic settings parameters.
`static void`	`scSetCmprMode(int devIdx, ScOneByte inout)` Deprecated.
`static void`	`scSetCurrentUserRegValue(ScThreeStrings in)` Sets a new string value into the Windows registry under the base key HKEY_CURRENT_USER.
`static void`	`scSetDaemonPar(int par, ScOneInt inout)` Sets one of the integer or boolean parameters available in the Daemon's configuration file "daemon.ini".
`static void`	`scSetDevPars(int devIdx, ScDevPars inout)` Sets and retrieves the actual device parameters listed in the device's configuration file.
`static void`	`scSetDevParsToDefaults(int devIdx, ScDevPars out)` Sets the actual device parameters to the defaults and retrieves the new parameters.
`static void`	`scSetDllLogPars(ScLogPars in)` Sets the logging parameters actually used by the internal DLL functions. The Daemon and the DLL are using the same routines and have the same initializing logging parameters at program start but are executing in there own address space and have there own copies of all variables.
`static void`	`scSetDom(int devIdx, ScOneBoolean inout)` Sets and retrieves the dominant mode.
`static void`	`scSetDsplString(int devIdx, int row, java.lang.String text, ScOneInt out)` Sets a line of text into the display.
`static void`	`scSetLcd(int devIdx, ScOneInt inout)` Sets and retrieves the LCD's brightness.
`static void`	`scSetLcdColor(int devIdx, ScThreeInts inout)` Sets and retrieves the LCD's background color.
`static void`	`scSetLed(int devIdx, int ledNo, ScOneInt inout)` Sets and retrieves the brightness of a single LED.
`static void`	`scSetLeds(int devIdx, ScThreeInts inout)` Sets and retrieves the brightness of the three types of LEDs built in into the device.
`static void`	`scSetLedsEx(int devIdx, byte[] buf)` Sets and retrieves the brightness of of all LEDs.
`static void`	`scSetMode(ScOneInt in)` This function is for internal use only - do not call it.
`static void`	`scSetNullRad(int devIdx, ScOneInt inout)` Sets and retrieves the device's null radius (threshold).
`static void`	`scSetRot(int devIdx, ScOneBoolean inout)` Sets and retrieves the rotational mode.
`static void`	`scSetSendDelay(int devIdx, ScTwoInts inout)` Sets and retrieves the devices's data rate parameters.
`static void`	`scSetSens(int devIdx, ScTwoInts inout)` Sets and retrieves the device's sensitivity.
`static void`	`scSetState(ScTwoStrings in)` Deprecated.
`static void`	`scSetState2(java.lang.String state)` Informs the daemon about the internal state (mode) of a supported application.
`static void`	`scSetStdMode(int devIdx, ScOneByte inout)` Sets and retrieves the operating mode for standard data.
`static void`	`scSetStdZero(int devIdx)` Sets the actual displacement of the cap as the standard 0 value.
`static void`	`scSetTra(int devIdx, ScOneBoolean inout)` Sets and retrieves the translational mode.
`static void`	`scSetXRot(int devIdx, ScOneBoolean inout)` Sets and retrieves the rotational mode for the x-axis.
`static void`	`scSetXRotRev(int devIdx, ScOneBoolean inout)` Sets and retrieves the x-axis' reverse rotational mode.
`static void`	`scSetXRotSens(int devIdx, ScOneInt inout)` Sets and retrieves the device's sensitivity for the x-axis' rotation.
`static void`	`scSetXTra(int devIdx, ScOneBoolean inout)` Sets and retrieves the translational mode for the x-axis.
`static void`	`scSetXTraRev(int devIdx, ScOneBoolean inout)` Sets and retrieves the x-axis' reverse translational mode.
`static void`	`scSetXTraSens(int devIdx, ScOneInt inout)` Sets and retrieves the SC device's sensitivity for the x-axis' translation.
`static void`	`scSetYRot(int devIdx, ScOneBoolean inout)` Sets and retrieves the rotational mode for the y-axis.
`static void`	`scSetYRotRev(int devIdx, ScOneBoolean inout)` Sets and retrieves the y-axis' reverse rotational mode.
`static void`	`scSetYRotSens(int devIdx, ScOneInt inout)` Sets and retrieves the device's sensitivity for the y-axis' rotation.
`static void`	`scSetYTra(int devIdx, ScOneBoolean inout)` Sets and retrieves the translational mode for the y-axis.
`static void`	`scSetYTraRev(int devIdx, ScOneBoolean inout)` Sets and retrieves the y-axis' reverse translational mode.
`static void`	`scSetYTraSens(int devIdx, ScOneInt inout)` Sets and retrieves the device's sensitivity for the y-axis' translation.
`static void`	`scSetZRot(int devIdx, ScOneBoolean inout)` Sets and retrieves the rotational mode for the z-axis.
`static void`	`scSetZRotRev(int devIdx, ScOneBoolean inout)` Sets and retrieves the z-axis' reverse rotational mode.
`static void`	`scSetZRotSens(int devIdx, ScOneInt inout)` Sets and retrieves the device's sensitivity for the z-axis' rotation.
`static void`	`scSetZTra(int devIdx, ScOneBoolean inout)` Sets and retrieves the translational mode for the z-axis.
`static void`	`scSetZTraRev(int devIdx, ScOneBoolean inout)` Sets and retrieves the z-axis' reverse translational mode.
`static void`	`scSetZTraSens(int devIdx, ScOneInt inout)` Sets and retrieves the device's sensitivity for the z-axis' translation.
`static void`	`scStop()` Sends the SpaceController Daemon a stop message, the process finishes itself after sending an OK message.\n Example:
`static void`	`scTriggerFunction(int devIdx, int funcIdx)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LED_NUM
```
public static final int LED_NUM
```
    Number of LEDs built into the device
    
    See Also:
    
    Constant Field Values
  - MAX_BRIGHTNESS
```
public static final int MAX_BRIGHTNESS
```
    Max. brightness of a LED
    
    See Also:
    
    Constant Field Values
  - NOTHING_CHANGED
```
public static final int NOTHING_CHANGED
```
    nothing to signal
    
    See Also:
    
    Constant Field Values
  - BSC_SETTINGS_CHANGED
```
public static final int BSC_SETTINGS_CHANGED
```
    basic settings are changed
    
    See Also:
    
    Constant Field Values
  - ADV_SETTINGS_CHANGED
```
public static final int ADV_SETTINGS_CHANGED
```
    advanced settings are changed
    
    See Also:
    
    Constant Field Values
  - DEV_PARS_CHANGED
```
public static final int DEV_PARS_CHANGED
```
    some other parameters are changed
    
    See Also:
    
    Constant Field Values
  - DEV_ERR_UNKNOWN_COMMAND
```
public static final int DEV_ERR_UNKNOWN_COMMAND
```
    device firmware error: unknown command detected
    
    See Also:
    
    Constant Field Values
  - DEV_ERR_INVALID_VALUE
```
public static final int DEV_ERR_INVALID_VALUE
```
    device firmware error: invalid value detected
    
    See Also:
    
    Constant Field Values
  - DEV_ERR_PARSE_ERROR
```
public static final int DEV_ERR_PARSE_ERROR
```
    device firmware error: error parsing the command string
    
    See Also:
    
    Constant Field Values
  - DEV_ERR_INTERNAL_ERROR
```
public static final int DEV_ERR_INTERNAL_ERROR
```
    device firmware error: unspecified internal error
    
    See Also:
    
    Constant Field Values
  - DEV_ERR_INVALID_ID
```
public static final int DEV_ERR_INVALID_ID
```
    device firmware error: invalid identifier detected
    
    See Also:
    
    Constant Field Values
  - DEV_ERR_BUF_OVERFLOW
```
public static final int DEV_ERR_BUF_OVERFLOW
```
    device firmware error: buffer overflow occured
    
    See Also:
    
    Constant Field Values
  - DEV_FRONT
```
public static final int DEV_FRONT
```
    "Front" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_RIGHT
```
public static final int DEV_RIGHT
```
    "Right" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_TOP
```
public static final int DEV_TOP
```
    "Top" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_FIT
```
public static final int DEV_FIT
```
    "Fit" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_WHEEL_LEFT
```
public static final int DEV_WHEEL_LEFT
```
    wheel moved to left
    
    See Also:
    
    Constant Field Values
  - DEV_WHEEL_RIGHT
```
public static final int DEV_WHEEL_RIGHT
```
    wheel moved to right
    
    See Also:
    
    Constant Field Values
  - EVT_HNDL_SENS_DLG
```
public static final int EVT_HNDL_SENS_DLG
```
    the GUI's sensitivity slider should be shown
    
    See Also:
    
    Constant Field Values
  - EVT_HNDL_THRESH_DLG
```
public static final int EVT_HNDL_THRESH_DLG
```
    the GUI's threshold slider should be shown
    
    See Also:
    
    Constant Field Values
  - EVT_HNDL_LCD_DLG
```
public static final int EVT_HNDL_LCD_DLG
```
    the GUI's LCD brightness slider should be shown
    
    See Also:
    
    Constant Field Values
  - EVT_HNDL_LEDS_DLG
```
public static final int EVT_HNDL_LEDS_DLG
```
    the GUI's LED brightness slider should be shown
    
    See Also:
    
    Constant Field Values
  - EVT_APPL_IN_FRGRND
```
public static final int EVT_APPL_IN_FRGRND
```
    signals an application that it is in the foreground now
    
    See Also:
    
    Constant Field Values
  - EVT_HNDL_KBD_DLG
```
public static final int EVT_HNDL_KBD_DLG
```
    the GUI's keyboard dialog should be shown
    
    See Also:
    
    Constant Field Values
  - EVT_HNDL_WFL_DLG
```
public static final int EVT_HNDL_WFL_DLG
```
    the GUI's WFL dialog should be shown
    
    See Also:
    
    Constant Field Values
  - DEV_BACK
```
public static final int DEV_BACK
```
    "Back" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_LEFT
```
public static final int DEV_LEFT
```
    "Left" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_BOTTOM
```
public static final int DEV_BOTTOM
```
    "Bottom" command is to be executed
    
    See Also:
    
    Constant Field Values
  - DEV_CTRL
```
public static final int DEV_CTRL
```
    "CTRL" command is to be executed (for triggering a function in WFL)
    
    See Also:
    
    Constant Field Values
  - APPL_FUNC_START
```
public static final int APPL_FUNC_START
```
    set rotation mode to "screen"
    
    See Also:
    
    Constant Field Values
  - CMD_UPDATE_FIRMWARE
```
public static final java.lang.String CMD_UPDATE_FIRMWARE
```
    initiates a firmware update
    
    See Also:
    
    Constant Field Values
  - CMD_UPDATE_FIRMWARE_GUI
```
public static final java.lang.String CMD_UPDATE_FIRMWARE_GUI
```
    initiates a firmware update, triggered by the GUI
    
    See Also:
    
    Constant Field Values
  - CMD_ACCEPT_ALL_FTDIS
```
public static final java.lang.String CMD_ACCEPT_ALL_FTDIS
```
    all FTDI devices shall be recognized (not only those with "SpaceController" in the USB description)
    
    See Also:
    
    Constant Field Values
  - CMD_BLINK_LEDS
```
public static final java.lang.String CMD_BLINK_LEDS
```
    blue LEDs shall flash
    
    See Also:
    
    Constant Field Values
  - CMD_INJECT_STRING
```
public static final java.lang.String CMD_INJECT_STRING
```
    injects a string into the OS' keyboard buffer
    
    See Also:
    
    Constant Field Values
  - CMD_SET_FAKE_ZERO
```
public static final java.lang.String CMD_SET_FAKE_ZERO
```
    shifts the device's zero position to get data for testing even in the real zero position
    
    See Also:
    
    Constant Field Values
  - BAUD
```
public static final int BAUD
```
    setting parameter 'baud' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - MAX_BYTES_IN_RX_QUEUE
```
public static final int MAX_BYTES_IN_RX_QUEUE
```
    setting parameter 'maxBytesInRxQueue' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - PORT
```
public static final int PORT
```
    setting parameter 'port' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - CFG_AUTO_CHANGE
```
public static final int CFG_AUTO_CHANGE
```
    setting parameter 'cfgAutoChange' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - REMEMBER_LAST_CONFIG
```
public static final int REMEMBER_LAST_CONFIG
```
    setting parameter 'rememberLastCfg' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - DISABLE_CUBE_DEMO
```
public static final int DISABLE_CUBE_DEMO
```
    setting parameter 'disableCubeDemo' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - EXPLORER_DELAY
```
public static final int EXPLORER_DELAY
```
    setting parameter 'explorerDelay' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - DEVICE_TIMEOUT
```
public static final int DEVICE_TIMEOUT
```
    setting parameter 'deviceTimeOut' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - SEND_MODE
```
public static final int SEND_MODE
```
    setting parameter 'sendMode' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - SEND_DELAY
```
public static final int SEND_DELAY
```
    setting parameter 'sendDelay' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - CAP_CHARACTERISTIC
```
public static final int CAP_CHARACTERISTIC
```
    setting parameter 'capCharacteristic' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - SINGLE_COM_PER_APPL
```
public static final int SINGLE_COM_PER_APPL
```
    setting parameter 'singleComPerAppl' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - ENABLE_LEGACY_COM1
```
public static final int ENABLE_LEGACY_COM1
```
    setting parameter 'enableLegacyCom1' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - ENABLE_LEGACY_COM2
```
public static final int ENABLE_LEGACY_COM2
```
    setting parameter 'enableLegacyCom2' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - BLINK_PERIOD
```
public static final int BLINK_PERIOD
```
    setting parameter 'blinkPeriod' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - SEARCH_TOP_WINDOW
```
public static final int SEARCH_TOP_WINDOW
```
    setting parameter 'searchTopWindow' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - SKIP_TIMEOUT
```
public static final int SKIP_TIMEOUT
```
    setting parameter 'skipTimeout' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - TIME_BEFORE_SLEEPING
```
public static final int TIME_BEFORE_SLEEPING
```
    setting parameter 'timeBeforeSleeping' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - WHEEL_ACCELERATOR
```
public static final int WHEEL_ACCELERATOR
```
    setting parameter 'wheelAccelerator' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
  - DEVICE_CHECKING_TIME
```
public static final int DEVICE_CHECKING_TIME
```
    setting parameter 'deviceCheckingTime' with methods scGetDaemonPar() and scSetDaemonPar() (see file daemon.ini)
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ScDllWrapper
```
public ScDllWrapper()
```
- Method Detail
  - eventToString
```
public static java.lang.String eventToString(int event)
```
    Converts an event type into a string.
    
    Parameters:
    
    event - die Event-ID
    
    Returns:
    
    Event-ID im Klartext
  - scIsProcessRunning
```
public static void scIsProcessRunning(ScOneString processName,
                                      ScOneBoolean isRunning)
```
    Checks if the process with the given name is running or not.\n
    Example:
```
         ScOneString  processName = new ScOneString("process.exe");
         ScOneBoolean isRunning   = new ScOneBoolean();

         ScDllWrapper.scIsProcessRunning(processName, isRunning);
         if (isRunning.mVal)
                System.out.println("process is running");
         else
                System.out.println("process is not running");
         
```
    Parameters:
    
    processName - mVal contains the process name to be checked
    
    isRunning - mVal contains true if the process is running else false
  - scSetCurrentUserRegValue
```
public static void scSetCurrentUserRegValue(ScThreeStrings in)
                                     throws ScEx
```
    Sets a new string value into the Windows registry under the base key HKEY_CURRENT_USER. The following example sets the entry "sc_daemon.exe" into "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" making the sc_daemon.exe autostarting. This function does nothing used under Linux and throws ScRegistryEx.
    Example:
```
         String         key   = "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
         String         name  = "sc_daemon.exe";
         String         value = "C:\\Program files\\SpaceController\\sc_daemon.exe";
         ScThreeStrings ts = new ScThreeStrings(key, name, value);
         try
         {
                ScDllWrapper.scSetCurrentUserRegValue(ts);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetCurrentUserRegValue() failed.");
         }
         
```
    Parameters:
    
    in - in.mVal1 contains the path to the requested registry key (without "HKEY_CURRENT_USER"), in.mVal2 contains the name of the registry entry to be created or modified, in.mVal3 contains the value of the entry to be created or modified
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scQueryCurrentUserRegValue
```
public static void scQueryCurrentUserRegValue(ScTwoStrings in,
                                              int len,
                                              ScOneString out)
                                       throws ScEx
```
    Queries a string value from the Windows registry under the base key HKEY_CURRENT_USER. If the entry is not there the function throws the Exception ScRegistryEx. The following example queries the entry "sc_daemon.exe" under the key "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run". This function does nothing used under Linux and throws ScRegistryEx.
    Example:
```
         String       key  = "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
         String       name = "sc_daemon.exe";
         ScTwoStrings ts   = new ScTwoStrings(key, name);
         int          len  = 123; // size of the expected string value
         ScOneString  os   = new ScOneString();
         try
         {
                ScDllWrapper.scQueryCurrentUserRegValue(ts, len, os);
                System.out.println("The value is '" + os.mVal + "'.");
         }
         catch(ScEx ex)
         {
                System.out.println("scQueryCurrentUserRegValue() failed.");
         }
         
```
    Parameters:
    
    in - in.mVal1 contains the path to the requested registry key (without "HKEY_CURRENT_USER"), in.mVal2 contains the name of the registry entry to be queried
    
    len - the expected size of the return string (used in the native C library only to allocate enough memory)
    
    out - out.mVal contains the value of the entry to be queried
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scDelCurrentUserRegValue
```
public static void scDelCurrentUserRegValue(ScTwoStrings in)
                                     throws ScEx
```
    Deletes a string value in the Windows registry under the base key HKEY_CURRENT_USER. The following example deletes the entry "sc_daemon.exe" in "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" making the sc_daemon.exe not autostart any longer. This function does nothing used under Linux and throws ScRegistryEx.
    Example:
```
         String       key  = "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
         String       name = "sc_daemon.exe";
         ScTwoStrings ts   = new ScTwoStrings(key, name);
         try
         {
                ScDllWrapper.scDelCurrentUserRegValue(ts);
         }
         catch(ScEx ex)
         {
                System.out.println("scDelCurrentUserRegValue() failed.");
         }
         
```
    Parameters:
    
    in - in.mVal1 contains the path to the requested registry key (without "HKEY_CURRENT_USER"), in.mVal2 contains the name of the registry entry to be deleted
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scConnect2
```
public static void scConnect2(boolean isAlwaysReceivingData,
                              java.lang.String applName)
                       throws ScEx
```
    Establishes the connection to the SpaceController daemon. If this function is not executed successfully no other functions can be used.
    Two parameters can be handed over:
    - isAlwaysReceivingData controls the driver's behaviour concerning your application's foreground status. If set to true your application will receive the standard data set even if it is not in the foreground. If set to false your application will not receive these data any longer as soon it is not the topmost application.
    - applName is your application's name and is only important if your application is a so called "supported application". [See chapter 3.4.2 of the user manual. You can change your application to a supported one by adding an appropriate line into the file "daemon.ini". This file is located in the folder "SpaceController" in the user's home directory. See function scSetState2() for further details.]
      If you do not want to use this feature set applName to null.
    Due to security riscs it is not possible to connect to a daemon started by another user as the one who started the application which has loaded the DLL; exception ScWrongUserEx is thrown in this case.
    Example:
```
         try
         {
                ScDllWrapper.scConnect2(true, null);
         }
         catch(ScEx ex)
         {
                System.out.println("scConnect2() failed.");
         }
         
```
    Parameters:
    
    isAlwaysReceivingData - if false the application will receive the standard data set only if it is in the foreground
    
    applName - your application's name; only needed if your application is a "supported application"; set it to NULL otherwise
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    Since:
    
    2.2.0
    
    See Also:
    
    scSetState2(java.lang.String)
  - scConnect
```
public static void scConnect()
                      throws ScEx
```
    Deprecated.
    This function is replaced by scConnect2() and should not be used any longer.
    Establishes the connection to the SpaceController daemon. If this function is not executed successfully no other DLL wrapper functions can be used.
    Example:
```
         try
         {
                ScDllWrapper.scConnect();
         }
         catch(ScEx ex)
         {
                System.out.println("scConnect() failed.");
         }
         
```
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scDisconnect
```
public static void scDisconnect()
                         throws ScEx
```
    Closes the connection to the SpaceController daemon. The daemon will destroy its proxy objects when receiving this message.
    Example:
```
         try
         {
                ScDllWrapper.scDisconnect();
         }
         catch(ScEx ex)
         {
                System.out.println("scDisconnect() failed.");
         }
         
```
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scStop
```
public static void scStop()
                   throws ScEx
```
    Sends the SpaceController Daemon a stop message, the process finishes itself after sending an OK message.\n
    Example:
```
         try
         {
                ScDllWrapper.scStop();
         }
         catch(ScEx ex)
         {
                System.out.println("scStop() failed.");
         }
         
```
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDmnVrsn
```
public static void scGetDmnVrsn(ScTwoStrings out)
                         throws ScEx
```
    Retrieves the SpaceController daemon's software version and the path to its binary file.
    Example:
```
         ScTwoStrings out = new ScTwoStrings();

         try
         {
                ScDllWrapper.scGetDmnVrsn(out);
                System.out.println("The daemon's version is: " + out.mVal1);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDmnVrsn() failed.");
         }
         
```
    Parameters:
    
    out - out.mVal1 contains the version string, out.mVal2 contains the path and name of the daemon's binary file
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDevNum
```
public static void scGetDevNum(ScThreeInts out)
                        throws ScEx
```
    Retrieves the number devNum of SpaceController devices actually connected to the computer and the maximal device index a device maxDevIdx may be addressed with at the moment.
    All devices are stored in an array; to address a device all DLL functions need the index in this array, and the indices are in the range 0..maxDevIdx. If a device is disconnected from the computer the array element is set to NULL but not removed out of the array (this behaviour ensures that an index does not change if another device is disconnected from the computer). Therefore maxDevIdx may be greater than devNum-1.
    After getting maxDevIdx one can use function scGetDevInfo() to get the description or serial number of a device to identify it for further calls.
    You can plug in more than one device into your computer. But, the driver is able to receive data from more than one device only if there is a "Master" device connected. Therefore there might be a difference between the values devNum and usedDevNum: devNum is the number of devices plugged in actually, usedDevNum is the number of devices actually used. These values are the same only if there is at least one master device connected, if not usedDevNum has the value 1 ore 0.
    Example:
```
         ScThreeInts devNum = new ScThreeInts();
         try
         {
                ScDllWrapper.scGetDevNum(devNum);
                System.out.println("connected devices: " + devNum.mVal1);
                System.out.println("     used devices: " + devNum.mVal2);
                System.out.println("max. device index: " + devNum.mVal3);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDevNum() failed.");
         }
         
```
    Parameters:
    
    out - out.mVal1 contains the number of connected devices, out.mVal2 contains the number of used devices, out.mVal3 contains the maximal device index
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetFgAppl
```
public static void scGetFgAppl(ScTwoStrings out)
                        throws ScEx
```
    Retrieves the name and potentially the state of the foreground application. The daemon checks regularly which application is in the foreground. With this information the daemon loads automatically the appropriate configuration.
    Some applications are better integrated into the daemon than others. These "supported applications" can tell its inner state, Pro/ENGINEER tells e. g. the mode ("drawing", "part" etc.) it is in. This state is returned in the second argument.
    The foreground application's name (what is this?) is not easy to determine: You see the application's window, and you can get it's so called window identifier. The task is to get an unambiguous application name out of this number, and that should work for all operating systems. The daemon uses the following strategy: Try to get the application's binary file name out of the window identifier and deliver this as the application's name. If this fails (this may happen under Linux because there is no direct connection between the window identifier and the application since the X server creates the window and not the application itself, and because the binary name may not be unambiguous [e.g. all Java applications are under control of the same runtime executable]) the window title is used as application name. Be aware that this is ambiguous too; many applications name their windows according to some content of the window and not to the application's name.
    Example:
```
         ScTwoStrings fgAppl = new ScTwoStrings();

         try
         {
                ScDllWrapper.scGetFgAppl(fgAppl);
                System.out.println("The foreground application's name  is: " + fgAppl.mVal1);
                System.out.println("The foreground application's state is: " + fgAppl.mVal2);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetFgAppl() failed.");
         }
         
```
    Parameters:
    
    out - out.mVal1 contains the application's name string, out.mVal2 contains the application's state string
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDllLogPars
```
public static void scGetDllLogPars(ScLogPars out)
```
    Retrieves the logging parameters and filenames actually used by the internal DLL functions.
    The Daemon and the API are using the same routines and have the same initializing logging parameters at program start but are executing in there own address space and have there own copies of all variables.
    Example:
```
         ScLogPars logPars = new ScLogPars();

         ScDllWrapper.scGetDllLogPars(logPars);
         System.out.println("The logging parameters are:");
         System.out.println("        logFile: " + logPars.mLogFile    );
         System.out.println("file    logging: " + logPars.mIsLogToFile);
         System.out.println("console logging: " + logPars.mIsLogToCnsl);
         System.out.println("creation/destr.: " + logPars.mIsCrt      );
         System.out.println("        tracing: " + logPars.mIsTrc      );
         System.out.println("    device com.: " + logPars.mIsDcm      );
         System.out.println("  internal com.: " + logPars.mIsIcm      );
         System.out.println("       warnings: " + logPars.mIsWrn      );
         System.out.println(" debug messages: " + logPars.mIsDbg      );
         System.out.println(" temp. messages: " + logPars.mIsTmp      );
         
```
    Parameters:
    
    out - out.mIsLogToFile, out.mIsCrt etc. contain the logging parameters
  - scSetDllLogPars
```
public static void scSetDllLogPars(ScLogPars in)
```
    Sets the logging parameters actually used by the internal DLL functions.
    The Daemon and the DLL are using the same routines and have the same initializing logging parameters at program start but are executing in there own address space and have there own copies of all variables. Therefore you can set the DLL's logging parameters separately here. As in the daemon's configuration file you can provide the parameter logFile with a full path or with a pure file name. In the latter case the log file will be written in your home directory into the folder "SpaceController". With the parameter exclFileToLog you can specify a source code file. If you do so only the output of this file will be logged, all other logging will be suppressed. To log all files set this parameter to "" as shown in the example.
    Attention: This function has to be called after scConnect() because the logging parameters are reinitialized there with those out of the configuration file.
    Example:
```
         ScLogPars logPars = new ScLogPars();

         // get the actual log parameters:
         ScDllWrapper.scGetDllLogPars(logPars);

         // change some values:
         logPars.mLogFile = "/home/fs/my_log.txt";
         logPars.mIsCrt = true;
         logPars.mIsDbg = false;
         logPars.mExclFileToLog = "";
         ScDllWrapper.scSetDllLogPars(logPars);
         
```
    Parameters:
    
    in - in.mIsLogToFile, in.mIsCrt etc. set the logging parameters
  - scSetState2
```
public static void scSetState2(java.lang.String state)
                        throws ScEx
```
    Informs the daemon about the internal state (mode) of a supported application. The driver will load the appropriate configuration file. The following conditions must be fulfilled that the driver can do this:
    - There must be an entry in the section [SUPP_APPLS] in the driver's initialization file "SpaceController/daemon.ini" in the user's home directory. Place an entry in this section, and your application will be recognized as a supported one. Example:
      ProEngineerWF4 = proe_wf4_plugin.exe xtopWF4 # comment
      As you can see a line in this section consists of four parts:
      
      The part before the equal sign is the application's name as you told the driver in function scConnect2(). The same string is displayed in the SpaceController Panel's status bar to identify the application.
      Example: "ProEngineerWF4".
      The second part is the first word after the equal sign. It can be the name of a binary (plug-in) which the driver starts as soon as your application comes into the foreground.
      Example: "proe_wf4_plugin.exe".
      If the plug-in is a DLL place a dummy name there.
      The third part is the binary name of your application (without the ".exe" extension). The driver checks for this binary to be the foreground application.
      Example: "xtopWF4" - xtopWF4.exe is the binary of Pro/ENGINEER Wildfire 4.
      The fourth part is a comment starting with a hash character and can be omitted.
    - You must have provided the driver with your application's name in function scConnect2().
      Example: scConnect2(false, "ProEngineerWF4").
    - There must be a directory with the same name as your application in the folder "<userName>\SpaceController\Devices\<DeviceSerialNo>\".
      Example: "C:\Users\billy\SpaceController\Devices\DC1UWX09190021T\ProEngineerWF4\".
    - In this folder must be a configuration file with the same name as the state but with the extension "*.cfg".
      Example: "Assembly.cfg".
    Example:
```
         String state = "Assembly";
         try
         {
                ScDllWrapper.scSetState(state);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetState() failed.");
         }
         
```
    Parameters:
    
    state - contains the state (mode) the supported application is in
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    Since:
    
    2.2.0
    
    See Also:
    
    scConnect2(boolean, java.lang.String)
  - scSetState
```
public static void scSetState(ScTwoStrings in)
                       throws ScEx
```
    Deprecated.
    This function is replaced by scSetState2() and should not be used any longer.
    Informs the daemon about the internal state (mode) of a supported application. The daemon will load the appropriate configuration file.
    Example:
```
         ScTwoStrings state = new ScTwoStrings();
         state.mVal1 = "ProEngineer"; // the application's name as known to the daemon
         state.mVal2 = "Assembly";    // the mode the application is in
         try
         {
                ScDllWrapper.scSetState(state);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetState() failed.");
         }
         
```
    This function is also used to tell the daemon the name of the application when the parameter "state" is set to "initializing". In this case the parameter "name" is put into the list of communication partners, and the daemon can identify this application. If the daemon knows an application by name it will stop sending data to it when it is not in the foreground any longer. An application not known to the daemon will always receive data whether it is in the foreground or not.
    So, if you don't want getting data into your application when in background: Figure out how the daemon will identify your application by starting the control panel and getting your application into the foreground. The control panel prints the identifier in the status bar besides the label "Active Application:"; say, it states "MyApplication". Insert the statements
```
         ScTwoStrings state = new ScTwoStrings();
         state.mVal1 = "MyApplication";
         state.mVal2 = "initializing";
         try
         {
                ScDllWrapper.scState(state);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetState() failed.");
         }
         
```
    into your code after your scConnect(), and the daemon knows to send data to your application only when it is in the foreground.
    
    New extension since version 2.0.0:
    To avoid sending data to a second instance of the same application (which has the same application name) you will have to provide the daemon with the process id of each instance. Append it to the application name, separated by a semicolon. Example with process id 1234:
```
            state.mVal1 = "MyApplication;1234";
         
```
    You have to retrieve your processe's id at runtime, of course. See the function ManagementFactory.getRuntimeMXBean().getName().
    Sorry for this unhandy interface; as you can see it is cobbled together a little.
    Parameters:
    
    in - in.mVal1 contains the name of the supported application in.mVal2 contains the state (mode) the supported application is in
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetMode
```
public static void scSetMode(ScOneInt in)
                      throws ScEx
```
    This function is for internal use only - do not call it.
    
    Parameters:
    
    in - in.mVal = 0: normal mode, in.mVal = 1: test mode
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDaemonPar
```
public static void scGetDaemonPar(int par,
                                  ScOneInt out)
                           throws ScEx
```
    Retrieves one of the integer or boolean parameters available in the Daemon's configuration file "daemon.ini". Which one is requested is controlled by the first parameter par. It can have have one of the values given below.
    Boolean parameters are returned as 0 for false and 1 for true.
    String parameters are not accessible for the time being.
    Example:
```
         ScOneInt val = new ScOneInt();

         try
         {
                ScDllWrapper.scGetDaemonPar(ScDllWrapper.ENABLE_LEGACY_COM1, val);
                System.out.println("enableLegacyCom1: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDaemonPar() failed.");
         }
         
```
    Parameters:
    
    par - controls which parameter is requested and can be one of BAUD, MAX_BYTES_IN_RX_QUEUE, PORT, CFG_AUTO_CHANGE, REMEMBER_LAST_CONFIG, DISABLE_CUBE_DEMO, EXPLORER_DELAY, DEVICE_TIMEOUT, SEND_MODE, SEND_DELAY, CAP_CHARACTERISTIC, SINGLE_COM_PER_APPL, ENABLE_LEGACY_COM1, ENABLE_LEGACY_COM2, BLINK_PERIOD, SEARCH_TOP_WINDOW, SKIP_TIMEOUT, TIME_BEFORE_SLEEPING, WHEEL_ACCELERATOR, DEVICE_CHECKING_TIME
    
    out - out.mVal contains the daemon parameter's current value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetDaemonPar(int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetDaemonPar
```
public static void scSetDaemonPar(int par,
                                  ScOneInt inout)
                           throws ScEx
```
    Sets one of the integer or boolean parameters available in the Daemon's configuration file "daemon.ini". Which one is requested is controlled by the first parameter par. It can have have one of the values given below.
    Boolean parameters are to be passed as 0 for false and 1 for true.
    String parameters are not accessible for the time being.
    Example:
```
         ScOneInt val = new ScOneInt(1);

         try
         {
                ScDllWrapper.scSetDaemonPar(ScDllWrapper.ENABLE_LEGACY_COM1, val);
                System.out.println("enableLegacyCom1: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetDaemonPar() failed.");
         }
         
```
    Parameters:
    
    par - controls which parameter is to be set and can be one of BAUD, MAX_BYTES_IN_RX_QUEUE, PORT, CFG_AUTO_CHANGE, REMEMBER_LAST_CONFIG, DISABLE_CUBE_DEMO, EXPLORER_DELAY, DEVICE_TIMEOUT, SEND_MODE, SEND_DELAY, CAP_CHARACTERISTIC, SINGLE_COM_PER_APPL, ENABLE_LEGACY_COM1, ENABLE_LEGACY_COM2, BLINK_PERIOD, SEARCH_TOP_WINDOW, SKIP_TIMEOUT, TIME_BEFORE_SLEEPING, WHEEL_ACCELERATOR, DEVICE_CHECKING_TIME
    
    inout - inout.mVal contains the daemon parameter's value to be set
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetDaemonPar(int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scGetDevInfo
```
public static void scGetDevInfo(int devIdx,
                                ScDevInfo out)
                         throws ScEx
```
    Retrieves some information data about the device with the given index.
    Example:
```
         int       devIdx = 0;
         ScDevInfo devInf = new ScDevInfo();
         try
         {
                ScDllWrapper.scGetDevInfo(devIdx, devInf);
                System.out.println("      index: " + devInf.mId);
                System.out.println(" serial no.: " + devInf.mSerialNo);
                System.out.println("description: " + devInf.mDescrptn);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDevInfo() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mSerialNo etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDefDevPars
```
public static void scGetDefDevPars(int devIdx,
                                   ScDevPars out)
                            throws ScEx
```
    Retrieves the default values of the device parameters.
    Example:
```
         int        devIdx  = 0;
         ScDevPars devPars = new ScDevPars();
         try
         {
                ScDllWrapper.scGetDefDevPars(devIdx, devPars);
                System.out.println("              name: " + devPars.mName);
                System.out.println("x-axis translation: " + devPars.mAs.mIsX);
                System.out.println("z-axis rotation   : " + devPars.mAs.mIsC);
                System.out.println("etc.");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mIsX etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDevPars
```
public static void scGetDevPars(int devIdx,
                                ScDevPars out)
                         throws ScEx
```
    Retrieves the device's parameters as listed in the *.cfg files.
    Example:
```
         int       devIdx  = 0;
         ScDevPars devPars = new ScDevPars();
         try
         {
                ScDllWrapper.scGetDevPars(devIdx, devPars);
                System.out.println("              name: " + devPars.mName);
                System.out.println("x-axis translation: " + devPars.mAs.mIsX);
                System.out.println("z-axis rotation   : " + devPars.mAs.mIsC);
                System.out.println("etc.");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mIsX etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetDevPars
```
public static void scSetDevPars(int devIdx,
                                ScDevPars inout)
                         throws ScEx
```
    Sets and retrieves the actual device parameters listed in the device's configuration file.
    Example:
```
         int       devIdx  = 0;
         ScDevPars devPars = new ScDevPars();
         devPars.mBs.mNullRadius = 10;
         try
         {
                ScDllWrapper.scSetDevPars(devIdx, devPars);
                System.out.println("         threshold: " + devPars.mBs.mNullRadius);
                System.out.println("x-axis translation: " + devPars.mAs.mIsX);
                System.out.println("z-axis rotation   : " + devPars.mAs.mIsC);
                System.out.println("etc.");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    inout - inout.mIsX etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetDevParsToDefaults
```
public static void scSetDevParsToDefaults(int devIdx,
                                          ScDevPars out)
                                   throws ScEx
```
    Sets the actual device parameters to the defaults and retrieves the new parameters.
    Example:
```
         int       devIdx  = 0;
         ScDevPars devPars = new ScDevPars();
         try
         {
                ScDllWrapper.scSetDevParsToDefaults(devIdx, devPars);
                System.out.println("         threshold: " + devPars.mBs.mNullRadius);
                System.out.println("x-axis translation: " + devPars.mAs.mIsX);
                System.out.println("z-axis rotation   : " + devPars.mAs.mIsC);
                System.out.println("etc.");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetDevParsToDefaults() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the defaults are to be set
    
    out - out.mIsX etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetBasicSettings
```
public static void scGetBasicSettings(int devIdx,
                                      ScBasicSettings out)
                               throws ScEx
```
    Retrieves the actual basic settings parameters.
    Example:
```
         int             devIdx = 0;
         ScBasicSettings bs     = new ScBasicSettings();
         try
         {
                ScDllWrapper.scGetBasicSettings(devIdx, bs);
                System.out.println("threshold: " + bs.mNullRadius);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetBasicSettings() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mNullRadius etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetBasicSettings
```
public static void scSetBasicSettings(int devIdx,
                                      ScBasicSettings inout)
                               throws ScEx
```
    Sets and retrieves the actual basic settings parameters.
    Example:
```
         int             devIdx = 0;
         ScBasicSettings bs     = new ScBasicSettings();
         bs.mNullRadius = 10;
         try
         {
                ScDllWrapper.scSetBasicSettings(devIdx, bs);
                System.out.println("threshold: " + bs.mNullRadius);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetBasicSettings() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    inout - inout.mNullRadius etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetAdvancedSettings
```
public static void scGetAdvancedSettings(int devIdx,
                                         ScAdvancedSettings out)
                                  throws ScEx
```
    Retrieves the actual advanced settings parameters.
    Example:
```
         int                devIdx = 0;
         ScAdvancedSettings as     = new ScAdvancedSettings();
         try
         {
                ScDllWrapper.scGetAdvancedSettings(devIdx, as);
                System.out.println("send delay: " + as.mSendDelay);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetAdvancedSettings() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mSendDelay etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetAdvancedSettings
```
public static void scSetAdvancedSettings(int devIdx,
                                         ScAdvancedSettings inout)
                                  throws ScEx
```
    Sets and retrieves the actual advanced settings parameters.
    Example:
```
         int                devIdx = 0;
         ScAdvancedSettings as     = new ScAdvancedSettings();
         as.mSendDelay = 10;
         try
         {
                ScDllWrapper.scSetAdvancedSettings(devIdx, as);
                System.out.println("send delay: " + as.mSendDelay);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetAdvancedSettings() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    inout - inout.mSendDelay etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetAdvSens
```
public static void scGetAdvSens(int devIdx,
                                ScAdvSens out)
                         throws ScEx
```
    Retrieves the actual six sensitivity parameters of the advanced settings.
    Example:
```
         int       devIdx = 0;
         ScAdvSens as     = new ScAdvSens();
         try
         {
                ScDllWrapper.scGetAdvSens(devIdx, as);
                System.out.println("x sensitivity: " + as.mXSens);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetAdvSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mXSens etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetAdvSens
```
public static void scSetAdvSens(int devIdx,
                                ScAdvSens inout)
                         throws ScEx
```
    Sets and retrieves the six actual sensitivity parameters of the advanced settings.
    Example:
```
         int       devIdx = 0;
         ScAdvSens as     = new ScAdvSens();
         as.mXSens = 10;
         try
         {
                ScDllWrapper.scSetAdvSens(devIdx, as);
                System.out.println("x sensitivity: " + as.mXSens);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetAdvSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    inout - inout.mXSens etc. contains the info
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetStdMode
```
public static void scGetStdMode(int devIdx,
                                ScOneByte out)
                         throws ScEx
```
    Retrieves the operating mode for standard data. There are three modes:
    - Dominant mode: If active all data is set to zero except the data with the highest value.
    - Translational mode: If active all translational data values (x, y, z) are transmitted, if not the values are set to 0.
    - Rotational mode: If active all rotational data values (a, b, c) are transmitted, if not the values are set to 0.
    The modes are coded as bits in the byte out.mVal:
```
           Bit no.: 87654321
          out.mVal: 00000000
                           ^ if bit 1 is set rotational mode is active
                          ^ if bit 2 is set translational mode is active
                         ^ if bit 3 is set dominant mode is active
    
```
    Example:
```
         int       devIdx  = 0;
         ScOneByte stdMode = new ScOneByte();
         byte      test    = 4; // set test to 00000100
         try
         {
                ScDllWrapper.scGetStdMode(devIdx, stdMode);
                if ((stdMode.mVal & test) == 0)
                        System.out.println("dominant mode is not active");
                else
                        System.out.println("dominant mode is active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetStdMode() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mVal contains the mode
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetStdMode
```
public static void scSetStdMode(int devIdx,
                                ScOneByte inout)
                         throws ScEx
```
    Sets and retrieves the operating mode for standard data. See scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte) for details.
    Example:
```
         int       devIdx  = 0;
         ScOneByte stdMode = new ScOneByte();
         byte      test    = 2; // set test to 00000010
         
         stdMode.mVal = 3; // 00000011 <=> trans. and rot. mode active
         try
         {
                ScDllWrapper.scSetStdMode(devIdx, stdMode);
                if ((stdMode.mVal & test) == 0)
                        System.out.println("translational mode is not active");
                else
                        System.out.println("translational mode is active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetStdMode() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the data is to be set
    
    inout - inout.mVal contains the mode
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetCmprMode
```
public static void scGetCmprMode(int devIdx,
                                 ScOneByte out)
                          throws ScEx
```
    Deprecated.
    Retrieves the spacemouse's "compression mode". This function is used only for the old Spacemouse protocol the SpaceController daemon is still supporting. Don't use this function.
    The compression mode is a bitmask describing some states:
    - Bits 5, 6 and 7 are the same as in function scGetStdMode().
    - If the first bit is set the data packets are transmitted in the "Turbo Spacemouse" format ("compressed mode").
    - Bits 2, 3, 4 and 8 are not used.
    The modes are coded as bits in the byte out.mVal:
```
           Bit no.: 87654321 
          out.mVal: 00000000
                           ^ if bit 1 is set the spacemouse uses the Turbo Spacemouse protokol
                          ^ bit 2 is unused
                         ^ bit 3 is unused
                        ^ bit 4 is unused
                       ^ if bit 5 is set rotational mode is active
                      ^ if bit 6 is set translational mode is active
                     ^ if bit 7 is set dominant mode is active
                    ^ bit 8 is unused
         
```
    Example:
```
         int       devIdx  = 0;
         ScOneByte cmpMode = new ScOneByte();
         byte      test    = 1; // set test to 00000001
         try
         {
                ScDllWrapper.scGetCmprMode(devIdx, cmpMode);
                if ((cmpMode.mVal & test) == 0)
                        System.out.println("compression mode is not active");
                else
                        System.out.println("compression mode is active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetCmprMode() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mVal contains the mode
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetCmprMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetCmprMode
```
public static void scSetCmprMode(int devIdx,
                                 ScOneByte inout)
                          throws ScEx
```
    Deprecated.
    Sets and retrieves the compression mode for standard data. See scGetCmprMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte) for details.
    Example:
```
         int       devIdx  = 0;
         ScOneByte cmpMode = new ScOneByte();
         byte      test    = 1; // set test to 00000001
         
         cmpMode.mVal = 3; // 00110001 <=> trans., rot. mode and compression active
         try
         {
                ScDllWrapper.scSetCmprMode(devIdx, cmpMode);
                if ((cmpMode.mVal & test) == 0)
                        System.out.println("compression mode is not active");
                else
                        System.out.println("compression mode is active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetCmprMode() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the data is to be set
    
    inout - inout.mVal contains the mode
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetCmprMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetSens
```
public static void scGetSens(int devIdx,
                             ScTwoInts out)
                      throws ScEx
```
    Retrieves the SC device's sensitivity. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int       devIdx = 0;
         ScTwoInts sens   = new ScTwoInts();
         
         try
         {
                ScDllWrapper.scGetSens(devIdx, sens);
                System.out.println("trans. sensitivity: " + sens.mVal1);
                System.out.println("  rot. sensitivity: " + sens.mVal2);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mVal1 contains the translational sensitivity (0..15), out.mVal2 contains the rotational sensititvity (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetSens(int, de.spacecontrol.sc.dllwrapper.ScTwoInts)
  - scSetSens
```
public static void scSetSens(int devIdx,
                             ScTwoInts inout)
                      throws ScEx
```
    Sets and retrieves the device's sensitivity. See scGetSens(int, de.spacecontrol.sc.dllwrapper.ScTwoInts) for details.
    Attention: For the time being only parameter sens.mVal1 is used, whatever is given in parameter sens.mVal2 is ignored and replaced by the same value as given in sens.mVal1. I. e. you can not set different sensitivity values for translation and rotation with this function. If you want to achieve this use functions scGetXTraSens() etc. and scSetXRotSens() etc. To calculate the resulting sensitivity for an axis the driver adds the sensitivities set with scSetSens() and the functions scGetXTraSens() etc.
    Example:
```
         int       devIdx = 0;
         ScTwoInts sens   = new ScTwoInts();
         
         sens.mVal1 = 5; // translational sensitivity
         sens.mVal2 = 8; // this value does not matter, see comment above
         try
         {
                ScDllWrapper.scSetSens(devIdx, sens);
                System.out.println("trans. sensitivity: " + sens.mVal1);
                System.out.println("  rot. sensitivity: " + sens.mVal2);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the data is to be set
    
    inout - inout.mVal1 contains the translational sensitivity (0..15), inout.mVal2 contains the rotational sensititvity (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetSens(int, de.spacecontrol.sc.dllwrapper.ScTwoInts)
  - scGetXTraSens
```
public static void scGetXTraSens(int devIdx,
                                 ScOneInt out)
                          throws ScEx
```
    Retrieves the device's sensitivity for the x-translation. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         try
         {
                ScDllWrapper.scGetXTraSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetXTraSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is requested
    
    out - out.mVal contains the requested value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetXTraSens
```
public static void scSetXTraSens(int devIdx,
                                 ScOneInt inout)
                          throws ScEx
```
    Sets and retrieves the SC device's sensitivity for the x-axis' translation. See scGetXTraSens(int, de.spacecontrol.sc.dllwrapper.ScOneInt) for details.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         val.mVal = 10;
         try
         {
                ScDllWrapper.scSetXTraSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetXTraSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set (0..15)
    
    inout - inout.mVal contains the actual value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetYTraSens
```
public static void scGetYTraSens(int devIdx,
                                 ScOneInt out)
                          throws ScEx
```
    Retrieves the device's sensitivity for the y-translation. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         try
         {
                ScDllWrapper.scGetYTraSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetYTraSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is requested
    
    out - out.mVal contains the requested value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetYTraSens
```
public static void scSetYTraSens(int devIdx,
                                 ScOneInt inout)
                          throws ScEx
```
    Sets and retrieves the device's sensitivity for the y-axis' translation. See scGetYTraSens(int, de.spacecontrol.sc.dllwrapper.ScOneInt) for details.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         val.mVal = 10;
         try
         {
                ScDllWrapper.scSetYTraSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetYTraSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set (0..15)
    
    inout - inout.mVal contains the actual value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetZTraSens
```
public static void scGetZTraSens(int devIdx,
                                 ScOneInt out)
                          throws ScEx
```
    Retrieves the SC device's sensitivity for the z-translation. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         try
         {
                ScDllWrapper.scGetZTraSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetZTraSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is requested
    
    out - out.mVal contains the requested value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetZTraSens
```
public static void scSetZTraSens(int devIdx,
                                 ScOneInt inout)
                          throws ScEx
```
    Sets and retrieves the device's sensitivity for the z-axis' translation. See scGetZTraSens(int, de.spacecontrol.sc.dllwrapper.ScOneInt) for details.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         val.mVal = 10;
         try
         {
                ScDllWrapper.scSetZTraSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetZTraSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set (0..15)
    
    inout - inout.mVal contains the actual value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetXRotSens
```
public static void scGetXRotSens(int devIdx,
                                 ScOneInt out)
                          throws ScEx
```
    Retrieves the device's sensitivity for the x-rotation. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         try
         {
                ScDllWrapper.scGetXRotSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetXRotSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is requested
    
    out - out.mVal contains the requested value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetXRotSens
```
public static void scSetXRotSens(int devIdx,
                                 ScOneInt inout)
                          throws ScEx
```
    Sets and retrieves the device's sensitivity for the x-axis' rotation. See scGetXRotSens(int, de.spacecontrol.sc.dllwrapper.ScOneInt) for details.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         val.mVal = 10;
         try
         {
                ScDllWrapper.scSetXRotSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetXRotSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set (0..15)
    
    inout - inout.mVal contains the actual value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetYRotSens
```
public static void scGetYRotSens(int devIdx,
                                 ScOneInt out)
                          throws ScEx
```
    Retrieves the device's sensitivity for the y-rotation. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         try
         {
                ScDllWrapper.scGetYRotSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetYRotSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is requested
    
    out - out.mVal contains the requested value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetYRotSens
```
public static void scSetYRotSens(int devIdx,
                                 ScOneInt inout)
                          throws ScEx
```
    Sets and retrieves the device's sensitivity for the y-axis' rotation. See scGetYRotSens(int, de.spacecontrol.sc.dllwrapper.ScOneInt) for details.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         val.mVal = 10;
         try
         {
                ScDllWrapper.scSetYRotSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetYRotSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set (0..15)
    
    inout - inout.mVal contains the actual value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetZRotSens
```
public static void scGetZRotSens(int devIdx,
                                 ScOneInt out)
                          throws ScEx
```
    Retrieves the device's sensitivity for the z-rotation. The sensitivity gives the relationship between the displacement of the cap and the standard data values produced by the device. Higher sensitivity values mean that the device will produce higher standard data values.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         try
         {
                ScDllWrapper.scGetZRotSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetZRotSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is requested
    
    out - out.mVal contains the requested value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetZRotSens
```
public static void scSetZRotSens(int devIdx,
                                 ScOneInt inout)
                          throws ScEx
```
    Sets and retrieves the device's sensitivity for the z-axis' rotation. See scGetZRotSens(int, de.spacecontrol.sc.dllwrapper.ScOneInt) for details.
    Example:
```
         int      devIdx = 0;
         ScOneInt val    = new ScOneInt();

         val.mVal = 10;
         try
         {
                ScDllWrapper.scSetZRotSens(devIdx, val);
                System.out.println("sensitivity: " + val.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetZRotSens() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set (0..15)
    
    inout - inout.mVal contains the actual value (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetSendDelay
```
public static void scGetSendDelay(int devIdx,
                                  ScTwoInts out)
                           throws ScEx
```
    Retrieves the device's data rate parameters. In the old spacemouse protocol both parameters given below are used as described, in the SpaceController protocol only the first parameter is used.
    Example:
```
         int       devIdx = 0;
         ScTwoInts rate   = new ScTwoInts();
         
         try
         {
                ScDllWrapper.scGetSendDelay(devIdx, rate);
                System.out.println("max. period: " + rate.mVal1);
                System.out.println("min. period: " + rate.mVal2);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetSendDelay() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the infos are requested
    
    out - out.mVal1: SpaceMouse: after this time (20..500 ms) the device sends new standard data automatically if not all coordinates are 0. SpaceController: The SpaceController will send the next data packet after the delay (20..405 ms) given here; values > 400 mean: send no data at all anymore. out.mVal2: SpaceMouse: soonest after this time (20..500 ms) the spacemouse will send new standard data even if requested sooner. SpaceController: not used.
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetSendDelay(int, de.spacecontrol.sc.dllwrapper.ScTwoInts)
  - scSetSendDelay
```
public static void scSetSendDelay(int devIdx,
                                  ScTwoInts inout)
                           throws ScEx
```
    Sets and retrieves the devices's data rate parameters. In the old spacemouse protocol both parameters given below are used as described, in the SpaceController protocol only the first parameter is used.
    Example:
```
         int       devIdx = 0;
         ScTwoInts rate   = new ScTwoInts();
         
         rate.mVal1 = 60; // max. period
         rate.mVal2 = 80; // min. period
         try
         {
                ScDllWrapper.scSetSendDelay(devIdx, rate);
                System.out.println("max. period: " + rate.mVal1);
                System.out.println("min. period: " + rate.mVal2);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetSendDelay() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the data is to be set
    
    inout - out.mVal1: SpaceMouse: after this time (20..500 ms) the device sends new standard data automatically if not all coordinates are 0. SpaceController: The SpaceController will send the next data packet after the delay (20..405 ms) given here; values > 400 mean: send no data at all anymore. out.mVal2: SpaceMouse: soonest after this time (20..500 ms) the spacemouse will send new standard data even if requested sooner. SpaceController: not used.
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetSendDelay(int, de.spacecontrol.sc.dllwrapper.ScTwoInts)
  - scGetNullRad
```
public static void scGetNullRad(int devIdx,
                                ScOneInt out)
                         throws ScEx
```
    Retrieves the device's null radius (threshold). If the null radius is set to higher values you need a larger displacement of the cap to cause the device sending standard data.
    Example:
```
         int      devIdx  = 0;
         ScOneInt nullRad = new ScOneInt();

         try
         {
                ScDllWrapper.scGetNullRad(devIdx, nullRad);
                System.out.println("null radius: " + nullRad.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetNullRad() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the null radius is requested
    
    out - out.mVal contains the null radius (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetNullRad(int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetNullRad
```
public static void scSetNullRad(int devIdx,
                                ScOneInt inout)
                         throws ScEx
```
    Sets and retrieves the device's null radius (threshold). If the null radius is set to higher values you need a larger displacement of the cap to cause the device sending standard data.
    Example:
```
         int      devIdx  = 0;
         ScOneInt nullRad = new ScOneInt();

         nullRad.mVal = 10;
         try
         {
                ScDllWrapper.scSetNullRad(devIdx, nullRad);
                System.out.println("null radius: " + nullRad.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetNullRad() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the null radius is to be set
    
    inout - inout.mVal contains the null radius (0..15)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetNullRad(int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetStdZero
```
public static void scSetStdZero(int devIdx)
                         throws ScEx
```
    Sets the actual displacement of the cap as the standard 0 value. All subsequent standard data is calculated relative to this 0 value.
    Example:
```
         int devIdx = 0;

         try
         {
                ScDllWrapper.scSetStdZero(devIdx);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetStdZero() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the standard zero is to be set
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetStdData
```
public static void scGetStdData(int devIdx,
                                ScStdData out)
                         throws ScEx
```
    Deprecated.
    Gets the standard data set. The device may be configured to send the standard data only after an explicit request. This request is sent with this function, and the response is given back in the parameters.
    Example:
```
         int       devIdx = 0;
         ScStdData data   = new ScStdData();
         try
         {
            ScDllWrapper.scGetStdData(devIdx, data);
            System.out.println("x: " + data.mX + ", a: " + data.mA);
         }
         catch(ScEx ex)
         {
            System.out.println("scGetStdData() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the standard data is to be get
    
    out - contains the standard data: out.mX : x-translation out.mY : y-translation out.mZ : Z-translation out.mA : rotation around the x-axis out.mB : rotation around the y-axis out.mC : rotation around the z-axis out.mTraLmh: bitmask with the low-, mid- and high-flags of translation out.mRotLmh: bitmask with the low-, mid- and high-flags of rotation out.mEvent : an event no. (0..n) or -1 out.mTvSec : the time the message was generated by the driver: seconds elapsed since jan 01 1970 UTC out.mTvUsec: the time the message was generated by the driver: additional microseconds since mTvSec
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scFetchStdData(int, de.spacecontrol.sc.dllwrapper.ScStdData), scGetRawData(int, byte[])
  - scFetchStdData
```
public static void scFetchStdData(int devIdx,
                                  ScStdData out)
                           throws ScEx
```
    Fetches the standard data set. The device sends the standard data without request. These data can be fetched with this command. scFetchStdData() will wait 30 ms (this can be changed with the parameter mSendDelay of structure ScAdvancedSettings) if no data is delivered and then return with ScStatus SC_COMMUNICATION_ERROR. This is no real error in that case. Since the data is not actively requested you will get SC_COMMUNICATION_ERROR also in case of a wrong device index > 0; a device index < 0 will result in SC_WRONG_DEVICE_INDEX
    The standard data consist out of:
    - The three translational coordinates (x, y, z) and the three rotational data (a [rotation around the x-axis], b [rotation around the y-axis] and c [rotation around the z-axis]).
    - The two flags traLmh and rotLmh. These are binary masks indicating how strong the cap is elongated regarding the advanced settings mTraLmBnd, mTraMhBnd, mRotLmBnd and mRotMhBnd. These four values give bounderies defining what is a low, mid or high elongation for the cap.
      Example: mTraLmBnd may be set to 80, mTraMhBnd may be set to 150. This means a translational elongation less then 80 is defined to be a "low" elongation, between 80 and 150 is a "mid" elongation and one greater than 150 is a "high" elongation (these definitions are used to trigger macro functions if configured in the GUI's function to key assignment dialog). The daemon evaluates this and tells it with the binary flags, so the application programmer does not need to do the calculation again.
      The bits of traLmh are set in this way:
      
      Bit 0 is set if x < 0 and x >= -mTraLmBnd
      Bit 1 is set if x < -mTraLmBnd and x >= -mTraMhBnd
      Bit 2 is set if x < -mTraMhBnd
      Bit 3 is set if x > 0 and x <= mTraLmBnd
      Bit 4 is set if x > mTraLmBnd and x <= mTraMhBnd
      Bit 5 is set if x > mTraMhBnd
      Bit 6 is set if y < 0 and y >= -mTraLmBnd
      Bit 7 is set if y < -mTraLmBnd and y >= -mTraMhBnd
      Bit 8 is set if y < -mTraMhBnd
      Bit 9 is set if y > 0 and y <= mTraLmBnd
      Bit 10 is set if y > mTraLmBnd and y <= mTraMhBnd
      Bit 11 is set if y > mTraMhBnd
      Bit 12 is set if z < 0 and z >= -mTraLmBnd
      Bit 13 is set if z < -mTraLmBnd and z >= -mTraMhBnd
      Bit 14 is set if z < -mTraMhBnd
      Bit 15 is set if z > 0 and z <= mTraLmBnd
      Bit 16 is set if z > mTraLmBnd and z <= mTraMhBnd
      Bit 17 is set if z > mTraMhBnd
      The bits of rotLmh are handled in the same way, but the rotational coordinates a, b and c are used.
    - The event code. With this parameter the daemon informs the application about some events the application might react on. These are the following (see the constants ScDllWrapper.NOTHING_CHANGED ff.):
      
      event has the value NOTHING_CHANGED: As the value says there is no event transmitted with this response.
      event is less then BSC_SETTINGS_CHANGED: The value is a bitmask storing the device keys actually pressed. The meaning of the bits is as follows:
      
      Bit 0 is set: key 1 is pressed.
      Bit 1 is set: key 2 is pressed.
      Bit 2 is set: key 3 is pressed.
      Bit 3 is set: key 4 is pressed.
      Bit 4 is set: key 5 is pressed.
      Bit 5 is set: key 6 is pressed.
      Bit 6 is set: ctrl key is pressed.
      Bit 7 is set: alt key is pressed.
      Bit 8 is set: shift key is pressed.
      Bit 9 is set: esc key is pressed.
      Bit 10 is set: front key is pressed.
      Bit 11 is set: right key is pressed.
      Bit 12 is set: top key is pressed.
      Bit 13 is set: fit key is pressed.
      Bit 14 is set: 2D/3D key is pressed.
      Bit 15 is set: panel key is pressed.
      Bit 16 is set: menu key is pressed.
      
      event is BSC_SETTINGS_CHANGED: Basic settings are changed, the application should retrieve the basic settings parameters from the daemon again (if it is interested in the parameters).
      event is ADV_SETTINGS_CHANGED: Advanced settings are changed, the application should retrieve the advanced settings parameters from the daemon again (if it is interested in the parameters).
      event is DEV_PARS_CHANGED: Any parameters are changed, the application should retrieve the all settings parameters from the daemon again (if it is interested in the parameters).
      event is DEV_ERR_UNKNOWN_COMMAND, DEV_ERR_INVALID_VALUE, DEV_ERR_PARSE_ERROR, DEV_ERR_INTERNAL_ERROR, DEV_ERR_INVALID_ID or DEV_ERR_BUF_OVERFLOW: These signal error states in the device's firmware. The firmware is error free of course and they will not occur :-).
      event is DEV_FRONT, DEV_RIGHT, DEV_TOP or DEV_FIT. The user has triggered one of the commands which are normally located at the Front-, Right-, Top- or Fit-Buttons. Be aware: The user may have reconfigured his keys, therefore getting the DEV_FRONT event e. g. does not mean necessarily that the user has pressed the Front key. May be he laid this command on another one. The application can trigger some appropriate action when getting one of these events.
      event is equal or greater than APPL_FUNC_START. The user has pressed a key configured with a menu function of a "supported application". This is of interest only if one wants to write a SpaceController plug-in. See the plug-in specification document for details.
      Hint: If a device key is pressed the daemon always sends a key bitmask event (value less than BSC_SETTINGS_CHANGED). If the key is configured by the user to some further action the daemon will send a second event specifying the action, e. g. a DEV_FRONT event additionally! In these events all cap coordinates are set to 0.
    - The time the driver has generated the message. It is given as the number of seconds elapsed since jan 01 1970 UTC (in parameter mTvSec) and the number of additional microseconds (in parameter mTvUsec). These are the same as the components in the well known C struct timeval.
    Example:
```
         int       devIdx = 0;
         ScStdData data   = new ScStdData();
         try
         {
            ScDllWrapper.scFetchStdData(devIdx, data);
            System.out.println("y: " + data.mY + ", b: " + data.mB);
         }
         catch(ScEx ex)
         {
            System.out.println("scFetchStdData() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the standard data is to be fetched
    out - contains the standard data:
    out.mX : x-translation out.mY : y-translation out.mZ : Z-translation out.mA : rotation around the x-axis out.mB : rotation around the y-axis out.mC : rotation around the z-axis out.mTraLmh: bitmask with the low-, mid- and high-flags of translation out.mRotLmh: bitmask with the low-, mid- and high-flags of rotation out.mEvent : an event no. (0..n) or -1 out.mTvSec : the time the message was generated by the driver: seconds elapsed since jan 01 1970 UTC out.mTvUsec: the time the message was generated by the driver: additional microseconds since mTvSec
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetStdData(int, de.spacecontrol.sc.dllwrapper.ScStdData), scGetRawData(int, byte[])
  - scGetRawData
```
public static void scGetRawData(int devIdx,
                                byte[] buf)
                         throws ScEx
```
    The opto-electronical sensor integrated into the cap consists of six LEDs illuminating six position sensitive devices (PSD) producing data between 0 and 1023. These raw data can be requested here. Using this function is not recommended, use scFetchStdData() instead. The function returns a buffer of 28 unsigned characters with the following content:
    - buf[ 0]: PSD1, high Byte
    - buf[ 1]: PSD1, low Byte
    - buf[ 2]: PSD2, high Byte
    - buf[ 3]: PSD2, low Byte
    - buf[ 4]: PSD3, high Byte
    - buf[ 5]: PSD3, low Byte
    - buf[ 6]: PSD4, high Byte
    - buf[ 7]: PSD4, low Byte
    - buf[ 8]: PSD5, high Byte
    - buf[ 9]: PSD5, low Byte
    - buf[10]: PSD6, high Byte
    - buf[11]: PSD6, low Byte
    - buf[12]: PSD7, high Byte (this is pseudo data for intnernal use only)
    - buf[13]: PSD7, low Byte (this is pseudo data for intnernal use only)
    - buf[14]: LED1, high Byte
    - buf[15]: LED1, low Byte
    - buf[16]: LED2, high Byte
    - buf[17]: LED2, low Byte
    - buf[18]: LED3, high Byte
    - buf[19]: LED3, low Byte
    - buf[20]: LED4, high Byte
    - buf[21]: LED4, low Byte
    - buf[22]: LED5, high Byte
    - buf[23]: LED5, low Byte
    - buf[24]: LED6, high Byte
    - buf[25]: LED6, low Byte
    - buf[26]: LED7, high Byte (this is pseudo data for intnernal use only)
    - buf[27]: LED7, low Byte (this is pseudo data for intnernal use only)
    Attention: Only seven bits per byte are used. To get a value use the following formula: value = highByte*128 + lowByte.
    Example:
```
         int    devIdx  = 0;
         byte[] buf = new byte[28];
         
         try
         {
                ScDllWrapper.scGetRawData(devIdx, buf);
                System.out.println("PSD1: " + (buf[0]*128+buf[1]));
         }
         catch(ScEx ex)
         {
                System.out.println("scGetRawData() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the raw data is to be get
    
    buf - byte array containing the data
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetStdData(int, de.spacecontrol.sc.dllwrapper.ScStdData), scFetchStdData(int, de.spacecontrol.sc.dllwrapper.ScStdData)
  - scGetTra
```
public static void scGetTra(int devIdx,
                            ScOneBoolean out)
                     throws ScEx
```
    Answers with true if the translational mode is set. See scGetStdMode() for details.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetTra
```
public static void scSetTra(int devIdx,
                            ScOneBoolean inout)
                     throws ScEx
```
    Sets and retrieves the translational mode. This is a convenience function for scSetStdMode(), see there for details.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         isTra.mVal = false;
         try
         {
                ScDllWrapper.scSetTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetXTra
```
public static void scGetXTra(int devIdx,
                             ScOneBoolean out)
                      throws ScEx
```
    Answers with true if the x-axis' translational data will be transmitted.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetXTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetXTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetXTra
```
public static void scSetXTra(int devIdx,
                             ScOneBoolean inout)
                      throws ScEx
```
    Sets and retrieves the translational mode for the x-axis.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         isTra.mVal = false;
         try
         {
                ScDllWrapper.scSetXTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetXTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetYTra
```
public static void scGetYTra(int devIdx,
                             ScOneBoolean out)
                      throws ScEx
```
    Answers with true if the y-axis' translational data will be transmitted.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetYTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetYTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetYTra
```
public static void scSetYTra(int devIdx,
                             ScOneBoolean inout)
                      throws ScEx
```
    Sets and retrieves the translational mode for the y-axis.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         isTra.mVal = false;
         try
         {
                ScDllWrapper.scSetYTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetYTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetZTra
```
public static void scGetZTra(int devIdx,
                             ScOneBoolean out)
                      throws ScEx
```
    Answers with true if the z-axis' translational data will be transmitted.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetZTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetZTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetZTra
```
public static void scSetZTra(int devIdx,
                             ScOneBoolean inout)
                      throws ScEx
```
    Sets and retrieves the translational mode for the z-axis.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isTra  = new ScOneBoolean();

         isTra.mVal = false;
         try
         {
                ScDllWrapper.scSetZTra(devIdx, isTra);
                if (isTra.mVal)
                        System.out.println("translational mode is active");
                else
                        System.out.println("translational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetZTra() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetXTraRev
```
public static void scGetXTraRev(int devIdx,
                                ScOneBoolean out)
                         throws ScEx
```
    Answers with true if the x-axis' translational data is set to reverse.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetXTraRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetXTraRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetXTraRev
```
public static void scSetXTraRev(int devIdx,
                                ScOneBoolean inout)
                         throws ScEx
```
    Sets and retrieves the x-axis' reverse translational mode.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         isRev.mVal = false;
         try
         {
                ScDllWrapper.scSetXTraRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetXTraRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetYTraRev
```
public static void scGetYTraRev(int devIdx,
                                ScOneBoolean out)
                         throws ScEx
```
    Answers with true if the y-axis' translational mode is set to reverse.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetYTraRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetYTraRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetYTraRev
```
public static void scSetYTraRev(int devIdx,
                                ScOneBoolean inout)
                         throws ScEx
```
    Sets and retrieves the y-axis' reverse translational mode.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         isRev.mVal = false;
         try
         {
                ScDllWrapper.scSetYTraRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetYTraRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetZTraRev
```
public static void scGetZTraRev(int devIdx,
                                ScOneBoolean out)
                         throws ScEx
```
    Answers with true if the z-axis' translational mode is set to reverse.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetZTraRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetZTraRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetZTraRev
```
public static void scSetZTraRev(int devIdx,
                                ScOneBoolean inout)
                         throws ScEx
```
    Sets and retrieves the z-axis' reverse translational mode.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         isRev.mVal = false;
         try
         {
                ScDllWrapper.scSetZTraRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetZTraRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetRot
```
public static void scGetRot(int devIdx,
                            ScOneBoolean out)
                     throws ScEx
```
    Answers with true if the rotational mode is set. See scGetStdMode() for details.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetRot() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetRot(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetRot
```
public static void scSetRot(int devIdx,
                            ScOneBoolean inout)
                     throws ScEx
```
    Sets and retrieves the rotational mode. This is a convenience function for scSetStdMode(), see there for details.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         isRot.mVal = false;
         try
         {
                ScDllWrapper.scSetRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetRot() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetRot(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetXRot
```
public static void scGetXRot(int devIdx,
                             ScOneBoolean out)
                      throws ScEx
```
    Answers with true if the x-axis' rotational data will be transmitted.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetXRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetXRot() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetXRot
```
public static void scSetXRot(int devIdx,
                             ScOneBoolean inout)
                      throws ScEx
```
    Sets and retrieves the rotational mode for the x-axis.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         isRot.mVal = false;
         try
         {
                ScDllWrapper.scSetXRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetXRot() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetYRot
```
public static void scGetYRot(int devIdx,
                             ScOneBoolean out)
                      throws ScEx
```
    Answers with true if the y-axis' rotational data will be transmitted.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetYRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetYRot() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetYRot
```
public static void scSetYRot(int devIdx,
                             ScOneBoolean inout)
                      throws ScEx
```
    Sets and retrieves the rotational mode for the y-axis.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         isRot.mVal = false;
         try
         {
                ScDllWrapper.scSetYRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetYRota() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetZRot
```
public static void scGetZRot(int devIdx,
                             ScOneBoolean out)
                      throws ScEx
```
    Answers with true if the z-axis' rotational data will be transmitted.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetZRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetZRot() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetZRot
```
public static void scSetZRot(int devIdx,
                             ScOneBoolean inout)
                      throws ScEx
```
    Sets and retrieves the rotational mode for the z-axis.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRot  = new ScOneBoolean();

         isRot.mVal = false;
         try
         {
                ScDllWrapper.scSetZRot(devIdx, isRot);
                if (isRot.mVal)
                        System.out.println("rotational mode is active");
                else
                        System.out.println("rotational mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetZRota() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetXRotRev
```
public static void scGetXRotRev(int devIdx,
                                ScOneBoolean out)
                         throws ScEx
```
    Answers with true if the x-axis' rotational mode is set to reverse.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetXRotRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetXRotRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetXRotRev
```
public static void scSetXRotRev(int devIdx,
                                ScOneBoolean inout)
                         throws ScEx
```
    Sets and retrieves the x-axis' reverse rotational mode.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         isRev.mVal = false;
         try
         {
                ScDllWrapper.scSetXRotRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetXRotRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetYRotRev
```
public static void scGetYRotRev(int devIdx,
                                ScOneBoolean out)
                         throws ScEx
```
    Answers with true if the y-axis' rotational mode is set to reverse.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetYRotRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetYRotRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetYRotRev
```
public static void scSetYRotRev(int devIdx,
                                ScOneBoolean inout)
                         throws ScEx
```
    Sets and retrieves the y-axis' reverse rotational mode.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         isRev.mVal = false;
         try
         {
                ScDllWrapper.scSetYRotRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetYRotRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetZRotRev
```
public static void scGetZRotRev(int devIdx,
                                ScOneBoolean out)
                         throws ScEx
```
    Answers with true if the z-axis' rotational mode is set to reverse.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetZRotRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetZRotRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetZRotRev
```
public static void scSetZRotRev(int devIdx,
                                ScOneBoolean inout)
                         throws ScEx
```
    Sets and retrieves the z-axis' reverse rotational mode.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isRev  = new ScOneBoolean();

         isRev.mVal = false;
         try
         {
                ScDllWrapper.scSetZRotRev(devIdx, isRev);
                if (isRev.mVal)
                        System.out.println("reverse mode is active");
                else
                        System.out.println("reverse mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetZRotRev() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetDom
```
public static void scGetDom(int devIdx,
                            ScOneBoolean out)
                     throws ScEx
```
    Answers with true if the dominant mode is set. See scGetStdMode() for details.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isDom  = new ScOneBoolean();

         try
         {
                ScDllWrapper.scGetDom(devIdx, isDom);
                if (isDom.mVal)
                        System.out.println("dominant mode is active");
                else
                        System.out.println("dominant mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scGetDom() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetDom(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scSetDom
```
public static void scSetDom(int devIdx,
                            ScOneBoolean inout)
                     throws ScEx
```
    Sets and retrieves the dominant mode. This a convenience function for scSetStdMode(), see there for details.
    Example:
```
         int          devIdx = 0;
         ScOneBoolean isDom  = new ScOneBoolean();

         isDom.mVal = false;
         try
         {
                ScDllWrapper.scSetDom(devIdx, isDom);
                if (isDom.mVal)
                        System.out.println("dominant mode is active");
                else
                        System.out.println("dominant mode is not active");
         }
         catch(ScEx ex)
         {
                System.out.println("scSetDom() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - out.mVal contains the boolean value
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetTra(int, de.spacecontrol.sc.dllwrapper.ScOneBoolean), scGetStdMode(int, de.spacecontrol.sc.dllwrapper.ScOneByte)
  - scGetCfgFileName
```
public static void scGetCfgFileName(int devIdx,
                                    ScOneString out)
                             throws ScEx
```
    Retrieves the name and path of the device's actual configuration file. The configuration file is located in the user's home directory in the folder 'SpaceController'. The folder SpaceController contains a set of folders whose names are constructed out of the serial numbers of all the devices connected to the computer in the past. Each of these folders contain a set of configuration files which are loaded alternatively dependent on the application controlled by the device.
    Example:
```
         int         devIdx   = 0;
         ScOneString filename = new ScOneString();
         try
         {
                ScDllWrapper.scGetCfgFileName(devIdx, filename);
                System.out.println("filename = " + filename.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetCfgFileName() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device
    
    out - file name, e.g. /home/fs/spacecontroller/[serialNo]/last.cfg
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSaveDevPars
```
public static void scSaveDevPars(int devIdx,
                                 ScOneString in)
                          throws ScEx
```
    Deprecated.
    Saves the actual parameters of the device with index devIdx to the configuration file given in filePath.
    Example:
```
         int         devIdx   = 0;
         ScOneString filename = new ScOneString();
         filename.mVal = "myConfigFile.cfg";
         try
         {
                ScDllWrapper.scSaveDevPars(devIdx, filename);
         }
         catch(ScEx ex)
         {
                System.out.println("scSaveDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device
    
    in - file name, e.g. /home/fs/spacecontroller/[serialNo]/last.cfg
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSaveDevPars
```
public static void scSaveDevPars(int devIdx,
                                 java.lang.String in)
                          throws ScEx
```
    Saves the actual parameters of the device with index devIdx to the configuration file given in filePath.
    Example:
```
         int    devIdx   = 0;
         String filename = "myConfigFile.cfg";
         try
         {
                ScDllWrapper.scSaveDevPars(devIdx, filename);
         }
         catch(ScEx ex)
         {
                System.out.println("scSaveDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device
    
    in - file name, e.g. /home/fs/spacecontroller/[serialNo]/last.cfg
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scLoadDevPars
```
public static void scLoadDevPars(int devIdx,
                                 ScOneString in,
                                 ScDevPars out)
                          throws ScEx
```
    Deprecated.
    Loads the parameters in the configuration file given in filePath into the device with index devIdx.
    Example:
```
         int         devIdx   = 0;
         ScOneString filename = new ScOneString();
         ScDevPars   devpars  = new ScDevPars();

         filename.mVal = "myConfigFile.cfg";
         try
         {
                ScDllWrapper.scLoadDevPars(devIdx, filename, devpars);
         }
         catch(ScEx ex)
         {
                System.out.println("scLoadDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device
    
    in - file name, e.g. /home/fs/my.cfg
    
    out - parameters just loaded
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scLoadDevPars
```
public static void scLoadDevPars(int devIdx,
                                 java.lang.String in,
                                 ScDevPars out)
                          throws ScEx
```
    Loads the parameters in the configuration file given in filePath into the device with index devIdx.
    Example:
```
         int         devIdx   = 0;
         String      filename = "myConfigFile.cfg";
         ScDevPars   devpars  = new ScDevPars();

         try
         {
                ScDllWrapper.scLoadDevPars(devIdx, filename, devpars);
         }
         catch(ScEx ex)
         {
                System.out.println("scLoadDevPars() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device
    
    in - file name, e.g. /home/fs/my.cfg
    
    out - parameters just loaded
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scPressKey
```
public static void scPressKey(int devIdx,
                              int key)
                       throws ScEx
```
    Triggers the same action as is done when a key of the device is pressed.
    Example:
```
         int devIdx = 0;
         int key    = 5;

         try
         {
                ScDllWrapper.scPressKey(devIdx, key);
         }
         catch(ScEx ex)
         {
                System.out.println("scPressKey() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the key seems to be pressed
    
    key - the key's index (0..16)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scRelKey(int, int)
  - scRelKey
```
public static void scRelKey(int devIdx,
                            int key)
                     throws ScEx
```
    Triggers the same action as is done when a key of the device is released.
    Example:
```
         int devIdx = 0;
         int key    = 5;

         try
         {
                ScDllWrapper.scRelKey(devIdx, key);
         }
         catch(ScEx ex)
         {
                System.out.println("scRelKey() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the key seems to be released
    
    key - the key's index (0..16)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scRelKey(int, int)
  - scTriggerFunction
```
public static void scTriggerFunction(int devIdx,
                                     int funcIdx)
                              throws ScEx
```
    Throws:
    
    ScEx
  - scSetLeds
```
public static void scSetLeds(int devIdx,
                             ScThreeInts inout)
                      throws ScEx
```
    Sets and retrieves the brightness of the three types of LEDs built in into the device. Hint: There is an optimization done in the daemon: The daemon stores the last set brightness and sends a new brightness to the device only in case the brightness has changed. But, there is a special case in the GUI where it is necessary to really set the brightness even if the brightness values are the same as before. This can be achieved by adding the value of 20 to the wanted value (of course this is an unaesthetic workaround and should be replaced by an extra parameter).
    Example:
```
         int         devIdx = 0;
         ScThreeInts brightnesses = new ScThreeInts();
         brightnesses.mVal1 = 15; // all red LEDs to maximum
         brightnesses.mVal2 = 5;  // all green LEDs to 5
         brightnesses.mVal3 = 0;  // switch all blue LEDs off

         try
         {
                ScDllWrapper.scSetLeds(devIdx, brightnesses);
                System.out.println("red   LEDs brightness: " + brightnesses.mVal1);
                System.out.println("green LEDs brightness: " + brightnesses.mVal2);
                System.out.println("blue  LEDs brightness: " + brightnesses.mVal3);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetLeds() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - inout.mVal1 contains the red, inout.mVal2 the green and inout.mVal3 the blue LED's brightness
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetLed(int, int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scGetLed
```
public static void scGetLed(int devIdx,
                            int ledNo,
                            ScOneInt out)
                     throws ScEx
```
    Gets the brightness of a single LED.
    Example:
```
         int      devIdx     = 0;
         int      ledNo      = 5;
         ScOneInt brightness = new ScOneInt();

         try
         {
                ScDllWrapper.scGetLed(devIdx, ledNo, brightness);
                System.out.println("brightness of LED no. 5: " + brightness.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetLed() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    ledNo - index of the requested LED (0..32)
    
    out - out.mVal contains the LED's brightness
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetLed(int, int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetLed
```
public static void scSetLed(int devIdx,
                            int ledNo,
                            ScOneInt inout)
                     throws ScEx
```
    Sets and retrieves the brightness of a single LED.
    Example:
```
         int      devIdx = 0;
         int      ledNo = 5;
         ScOneInt brightness = new ScOneInt();

         brightness.mVal = 10;

         try
         {
                ScDllWrapper.scSetLed(devIdx, ledNo, brightness);
                System.out.println("brightness of LED no. 5: " + brightness.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetLed() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    ledNo - the LED the brightness is to be set (0..32)
    
    inout - inout.mVal contains the LED's brightness
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetLed(int, int, de.spacecontrol.sc.dllwrapper.ScOneInt), scSetLeds(int, de.spacecontrol.sc.dllwrapper.ScThreeInts)
  - scGetLedsEx
```
public static void scGetLedsEx(int devIdx,
                               byte[] buf)
                        throws ScEx
```
    Gets the brightnesses of all LEDs.
    Example:
```
         int    devIdx  = 0;
         byte[] buf     = new byte[33];
         
         try
         {
                ScDllWrapper.scGetLedsEx(devIdx, buf);
                System.out.println("brightness of LED with index 5: " + buf[5]);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetLedsEx() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the LED data is to be get
    
    buf - byte array containing the data
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetLedsEx(int, byte[]), scGetLed(int, int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetLedsEx
```
public static void scSetLedsEx(int devIdx,
                               byte[] buf)
                        throws ScEx
```
    Sets and retrieves the brightness of of all LEDs.
    Example:
```
         int    devIdx  = 0;
         byte[] buf = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                        1, 2, 3 };
         try
         {
                ScDllWrapper.scSetLedsEx(devIdx, buf);
                System.out.println("brightness of LED with index 5: " + buf[5]);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetLedsEx() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the LED data is to be set
    
    buf - byte array containing the data
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetLedsEx(int, byte[]), scSetLeds(int, de.spacecontrol.sc.dllwrapper.ScThreeInts), scSetLed(int, int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scGetLcd
```
public static void scGetLcd(int devIdx,
                            ScOneInt out)
                     throws ScEx
```
    Gets the LCD's brightness.
    Example:
```
         int      devIdx     = 0;
         ScOneInt brightness = new ScOneInt();

         try
         {
                ScDllWrapper.scGetLcd(devIdx, brightness);
                System.out.println("LCD's brightness: " + brightness.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetLcd() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the info is requested
    
    out - out.mVal contains the LCD's brightness
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scSetLcd(int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetLcd
```
public static void scSetLcd(int devIdx,
                            ScOneInt inout)
                     throws ScEx
```
    Sets and retrieves the LCD's brightness.
    Example:
```
         int      devIdx     = 0;
         ScOneInt brightness = new ScOneInt();

         brightness.mVal = 10;
         try
         {
                ScDllWrapper.scSetLcd(devIdx, brightness);
                System.out.println("LCD's brightness: " + brightness.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetLcd() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    inout - inout.mVal contains the LCD's brightness
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
    
    See Also:
    
    scGetLcd(int, de.spacecontrol.sc.dllwrapper.ScOneInt)
  - scSetLcdColor
```
public static void scSetLcdColor(int devIdx,
                                 ScThreeInts inout)
                          throws ScEx
```
    Sets and retrieves the LCD's background color. This function is for testing purposes only and sets the LCD to a monochrome color. The color values are given as RGB in the range 0 .. 255. But, the display does not have the full color range, the values are mapped as follows automatically: - Red: 0..255 -> 0..31 (5 bit) - Green: 0..255 -> 0..63 (6 bit) - Blue: 0..255 -> 0..31 (5 bit) Due to unavoidable rounding errors concerning the mapping the values given back will not be the same as you have put in.
    Example:
```
         int      devIdx = 0;
         ScThreeInts inout = new ScThreeInts(255, 100, 100);  // this RGB gives a light red alltogether
         ScStatus status = scSetLcdColor(devIdx, inout);
         if (status == SC_OK)
                 printf("green: %d\n", inout.mVal2);
         else
                 printf("error\n");
         
```
    Parameters:
    
    devIdx - the index of the device to be requested
    
    inout - inout.mVal1: red part of the color (0..255), inout.mVal2: green part of the color (0..255) inout.mVal3: blue part of the color (0..255)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scSetDsplString
```
public static void scSetDsplString(int devIdx,
                                   int row,
                                   java.lang.String text,
                                   ScOneInt out)
                            throws ScEx
```
    Sets a line of text into the display. The max. length is 40.
    Example:
```
         int      devIdx = 0;
         int      row    = 2;
         String   text   = "new display line";
         ScOneInt out    = new ScOneInt();

         try
         {
                ScDllWrapper.scSetDsplString(devIdx, row, text, out);
                System.out.println("number of characters set: " + out.mVal);
         }
         catch(ScEx ex)
         {
                System.out.println("scSetDsplString() failed.");
         }
         
```
    Parameters:
    
    devIdx - index of the device the value is to be set
    
    row - line the text is to be put into (0..6)
    
    text - the text to be set (up to 40 characters)
    
    out - out.mVal contains the number of characters set into the display
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scGetFmwUpdtState
```
public static void scGetFmwUpdtState(int devIdx,
                                     ScTwoInts out)
                              throws ScEx
```
    Retrieves the state of a firmware update in progress.
    The SpaceController contains three micro controllers (MCU):
    - The main micro controller (#1).
    - The micro controller for the Display (#2).
    - The micro controller of the sensor to measure the cap deflection (#4).
    A firmware file is a zipped file with the extension "fmw" that contains the three files KMM.hex, KSM.hex and KDM.hex. If the user initiates a firmware update via the GUI the firmware file is unzipped, and the three hex files are written into the controllers' flash memory. The actual state can be retrieved with this command. If out.mVal1 is < 0 an error has occured.
    Example:
```
         int       devIdx = 0;
         ScTwoInts state  = new ScTwoInts();

         try
         {
                ScDllWrapper.scGetFmwUpdtState(devIdx, rate);
                System.out.println("Micro controller: " + state.mVal1);
                System.out.println("      progress/%: " + state.mVal2);
         }
         catch(ScEx ex)
         {
                System.out.println("scGetFmwUpdtState() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device to be requested
    
    out - out.mVal1 contains the ID of the micro controller just updating ( 0: no update in progress, 1: mainboard microcontroller is updating, 2: display microcontroller is updating, 4: sensor microcontroller is updating, -1: error while updating mainboard MCU, -2: error while updating display MCU, -4: error while updating sensor MCU), out.mVal2 cointains the update sequence's progress of one of the three micro controllers in percent (0..100)
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - scExecCmd
```
public static void scExecCmd(int devIdx,
                             java.lang.String in)
                      throws ScEx
```
    Executes a special command. To avoid an extensive growing of API functions this function can be used to execute different commands. It is made for SpaceControl's internal use rather than for the common audience. A special syntax is needed for the command buffer:
    The first character is the command identifier. The content of the others depends on the first one. For the time being the following command is defined only:
    First character: '3': Causes all blue LEDs to blink with the period given in the following four characters.
    Example: "30150": The LEDs will be 150 ms on and 150 ms off and so on.
    Example: "30000": Blinking is shut off.
    Example: "3-001": Values less than 0 mean, the period is retrieved from the parameter "blinkPeriod" in file "SpaceController/daemon.ini" in the user's home directory.
    Example:
```
         int      devIdx = 0;
         String   cmd = "30500";
         try
         {
                ScDllWrapper.scExecCmd(devIdx, cmd);
         }
         catch(ScEx ex)
         {
                System.out.println("scExecCmd() failed.");
         }
         
```
    Parameters:
    
    devIdx - the index of the device (if needed, -1 in other cases)
    
    in - command to be executed
    
    Throws:
    
    ScEx - throws one of the SpaceControl exceptions in case of an error
  - main
```
public static void main(java.lang.String[] args)
```
    Nur zum Testen.
    
    Parameters:
    
    args - command line arguments

Class ScDllWrapper

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LED_NUM

MAX_BRIGHTNESS

NOTHING_CHANGED

BSC_SETTINGS_CHANGED

ADV_SETTINGS_CHANGED

DEV_PARS_CHANGED

DEV_ERR_UNKNOWN_COMMAND

DEV_ERR_INVALID_VALUE

DEV_ERR_PARSE_ERROR

DEV_ERR_INTERNAL_ERROR

DEV_ERR_INVALID_ID

DEV_ERR_BUF_OVERFLOW

DEV_FRONT

DEV_RIGHT

DEV_TOP

DEV_FIT

DEV_WHEEL_LEFT

DEV_WHEEL_RIGHT

EVT_HNDL_SENS_DLG

EVT_HNDL_THRESH_DLG

EVT_HNDL_LCD_DLG

EVT_HNDL_LEDS_DLG

EVT_APPL_IN_FRGRND

EVT_HNDL_KBD_DLG

EVT_HNDL_WFL_DLG

DEV_BACK

DEV_LEFT

DEV_BOTTOM

DEV_CTRL

APPL_FUNC_START

CMD_UPDATE_FIRMWARE

CMD_UPDATE_FIRMWARE_GUI

CMD_ACCEPT_ALL_FTDIS

CMD_BLINK_LEDS

CMD_INJECT_STRING

CMD_SET_FAKE_ZERO

BAUD

MAX_BYTES_IN_RX_QUEUE

PORT

CFG_AUTO_CHANGE

REMEMBER_LAST_CONFIG

DISABLE_CUBE_DEMO

EXPLORER_DELAY

DEVICE_TIMEOUT

SEND_MODE

SEND_DELAY

CAP_CHARACTERISTIC

SINGLE_COM_PER_APPL

ENABLE_LEGACY_COM1

ENABLE_LEGACY_COM2

BLINK_PERIOD

SEARCH_TOP_WINDOW

SKIP_TIMEOUT

TIME_BEFORE_SLEEPING

WHEEL_ACCELERATOR

DEVICE_CHECKING_TIME

Constructor Detail

ScDllWrapper

Method Detail

eventToString

scIsProcessRunning

scSetCurrentUserRegValue

scQueryCurrentUserRegValue

scDelCurrentUserRegValue

scConnect2

scConnect

scDisconnect

scStop

scGetDmnVrsn

scGetDevNum

scGetFgAppl

scGetDllLogPars

scSetDllLogPars

scSetState2