First of all, let me refer to an article that explains the basics of interfaces between a GUI application and the underlying system: Device class and device driver - How to integrate a device?
Now let's focus on the aspect of exchanging strings in both directions:
1. Transferring a string from the GUI to native C code
Typically, a device class is the interface between the GUI application and the underlying system (as recommended in the above mentioned article). Within this device class, you can implement a command that transfers a string, for example:
method void Application::DeviceClass.SendString( arg string aText )
{
/* the following native code is used only for target system */
$if !$prototyper
native ( aText )
{
/* just send the string to your device driver written in C */
YourDevice_PrintString( aText );
}
$endif
}If you are using a string property, just implement the onset method and transfer the string:
onset Application::DeviceClass.Name
{
/* store the new value in the internal memory of the property */
pure Name = value;
/* the following native code is used only for target system */
$if !$prototyper
native ( value )
{
/* just send the string to your device driver written in C */
YourDevice_SetName( value );
}
$endif
/* notify all associated property observers */
notifyobservers ^Name;
}As you can see, strings are handled like other data types within a GUI project.
Within your device driver (written in C) you can access the string very easy, because the given XString can be used as a pointer to an array with unsigned short values, which is terminated by 0x0000. This means, XString is a zero terminated 16 bit string, that can be evaluated according your needs. For example you can convert the given string into an ANSI string:
void YourDevice_PrintString( XString aText )
{
char buf[ bufLen ];
char* ptr = buf;
/* check for an empty string */
if ( aText == 0 )
return;
/* read each 16-bit character and convert it to 8-bit character */
while ( aText && *aText )
*ptr++ = (char)(*aText++);
/* terminate the converted string */
*ptr = 0x00;
/* do something with the converted string */
printf( "The string is %s\n", buf );
}Important notes:
Please be aware, that an empty string can be represented by a null pointer - thus, it is necessary to check always the given string!
Additionally, it is important that the given string is not stored for later usage because the Garbage Collector might free the string! If you want to keep the given string for later usage, please make your own copy!
2. Transferring a string from native C code to the GUI
For the other direction, you can implement functions within your device driver (written in C) that return an XString. The device class can later use this string like other Chora strings.
In order to return an XString from native C code it is important that the string is created by one of the following Runtime Enviroment functions:
EwNewString()
EwNewStringAnsi()
EwNewStringUtf8()
EwNewStringUInt()
EwNewStringInt()
EwNewStringFloat()
EwNewStringChar()
For example you can convert an ANSI string (received from your device) into an XString:
XString YourDevice_GetString()
{
char* ansiString;
XString emwiString;
/* read the string from somewhere of your device... */
ansiString = ...;
/* create an XString with the content of the ANSI string */
emwiString = EwNewStringAnsi( ansiString );
/* return the XString */
return emwiString;
}Please take care, that the ANSI string is zero terminated.
In some cases it might be interessting to create a XString with a fixed number of characters. This can be achieved by using the function EwNewStringChar( aChar, aCount ).
After creating the string, you can fill the string one character after the other. This might be helpful, if the size of the source string is unknown or the string is not terminated.
int* sourceString = ...;
int noOfSignsInSourceString = ...;
int i;
/* create the XString with a fixed size */
XString EmWiString = EwNewStringChar( 0, noOfSignsInSourceString );
/* fill one character after the other into the XString */
for ( i = 0; i < noOfSignsInSourceString; i++ )
EmWiString[i] = (XChar)sourceString[i];For more details concerning the different EwNewString...() functions, please have a look into the file 'ewrte.h'.
Within the device class, you can implement a simple command that reads the string from the device driver:
method string Application::DeviceClass.ReceiveString()
{
XString text = "";
/* the following native code is used only for target system */
$if !$prototyper
native ( text )
{
/* just get the string from your device driver written in C */
text = YourDevice_GetString();
}
$endif
return text;
}