bool SystemFile::writeString( const string & kstr )
{
return writeString( kstr.c_str(), kstr.size() );
}
std::string ExternalQueryBuilder::composeLoadAllQuery() const
{
WriteBufferFromOwnString out;
writeString("SELECT ", out);
if (dict_struct.id)
{
if (!dict_struct.id->expression.empty())
{
writeParenthesisedString(dict_struct.id->expression, out);
writeString(" AS ", out);
}
writeQuoted(dict_struct.id->name, out);
if (dict_struct.range_min && dict_struct.range_max)
{
writeString(", ", out);
if (!dict_struct.range_min->expression.empty())
{
writeParenthesisedString(dict_struct.range_min->expression, out);
writeString(" AS ", out);
}
writeQuoted(dict_struct.range_min->name, out);
writeString(", ", out);
if (!dict_struct.range_max->expression.empty())
{
writeParenthesisedString(dict_struct.range_max->expression, out);
writeString(" AS ", out);
}
writeQuoted(dict_struct.range_max->name, out);
}
}
else if (dict_struct.key)
{
auto first = true;
for (const auto & key : *dict_struct.key)
{
if (!first)
writeString(", ", out);
first = false;
if (!key.expression.empty())
{
writeParenthesisedString(key.expression, out);
writeString(" AS ", out);
}
writeQuoted(key.name, out);
}
}
for (const auto & attr : dict_struct.attributes)
{
writeString(", ", out);
if (!attr.expression.empty())
{
writeParenthesisedString(attr.expression, out);
writeString(" AS ", out);
}
writeQuoted(attr.name, out);
}
writeString(" FROM ", out);
if (!db.empty())
{
writeQuoted(db, out);
writeChar('.', out);
}
if (!schema.empty())
{
writeQuoted(schema, out);
writeChar('.', out);
}
writeQuoted(table, out);
if (!where.empty())
{
writeString(" WHERE ", out);
writeString(where, out);
}
writeChar(';', out);
return out.str();
}
int main(void) {
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
char * endMessageTop = "You am ";
char * endMessageBottomLose = "lose ";
char * endMessageBottomWin = "Not lose";
char * deadMessage = "Dead ";
unsigned char player;
unsigned char mines[NUM_MINES];
while (1) {
timer = 0;
button = 0;
player = initPlayer();
initProgram();
printPlayer(player);
generateMines(mines);
//run while none of the end-game situations have occurred
while ((timer < 4) && !didPlayerWin(player)
&& !didPlayerHitMine(player, mines)) {
if (button) {
switch (button) {
case BIT0:
player = movePlayer(player, RIGHT);
break;
case BIT1:
player = movePlayer(player, LEFT);
break;
case BIT2:
player = movePlayer(player, UP);
break;
case BIT3:
player = movePlayer(player, DOWN);
break;
}
button = 0;
}
}
//if the timer hits 2 seconds, or if the player hits a mine, the game is over
if (timer == 4 || didPlayerHitMine(player, mines)) {
//displays a special message if the player lost due to hitting a mine
if (didPlayerHitMine(player, mines)) {
cursorToLineOne();
writeString(deadMessage, 8);
_delay_cycles(500000);
}
button = 0;
//displays game over message
cursorToLineOne();
writeString(endMessageTop, 8);
cursorToLineTwo();
writeString(endMessageBottomLose, 8);
}
//if the player hits 0xC7 they win, display the win message
else if (didPlayerWin(player)) {
button = 0;
cursorToLineOne();
writeString(endMessageTop, 8);
cursorToLineTwo();
writeString(endMessageBottomWin, 8);
}
// Waits for a button input and then resets the game
while (button != 0) {
}
}
}
void writeTypedListElement( TAThread thread, const TypedListElement * value ) {
const int * start;
switch ( value->type ) {
case IntTObjCode : writeString( thread, "IntTObj" ); writeInt ( thread, value->data.IntTObj ); break;
case CharTObjCode : writeString( thread, "CharTObj" ); writeChar ( thread, value->data.CharTObj ); break;
case ShortTObjCode : writeString( thread, "ShortTObj" ); writeShort ( thread, value->data.ShortTObj ); break;
case LongTObjCode : writeString( thread, "LongTObj" ); writeLong ( thread, value->data.LongTObj ); break;
case LLongTObjCode : writeString( thread, "LLongTObj" ); writeLLong ( thread, value->data.LLongTObj ); break;
case IntMaxTObjCode : writeString( thread, "IntMaxTObj" ); writeIntMax( thread, value->data.IntMaxTObj ); break;
case SizeTObjCode : writeString( thread, "SizeTObj" ); writeSize ( thread, value->data.SizeTObj ); break;
case PtrDiffTObjCode: writeString( thread, "PtrDiffTObj" ); writeLong ( thread, value->data.PtrDiffTObj ); break;
case WIntTObjCode : writeString( thread, "WIntTObj" ); writeWChar ( thread, value->data.WIntTObj ); break;
case FloatTObjCode:
start = (int *)& value->data.FloatTObj;
writeString( thread, "FloatTObj" );
writeIntArray( thread, start, sizeof( float ) / sizeof( int ) );
break;
case DoubleTObjCode:
start = (int *)& value->data.DoubleTObj;
writeString( thread, "DoubleTObj" );
writeIntArray( thread, start, sizeof( double ) / sizeof( int ) );
break;
case LongDoubleTObjCode:
start = (int *)& value->data.LongDoubleTObj;
writeString( thread, "LongDoubleTObj" );
writeIntArray( thread, start, sizeof( long double ) / sizeof( int ) );
break;
case CStringCode : writeString( thread, "CString" ); writeString ( thread, value->data.CString ); break;
case WStringCode : writeString( thread, "WString" ); writeWString( thread, value->data.WString ); break;
case VoidTPtrObjCode: writeString( thread, "VoidTPtrObj" ); writePointer( thread, value->data.VoidTPtrObj ); break;
default: assertion( 0, "writeTypedListElement : unsupported type" ); break;
}
} // writeTypedListElement
std::string ExternalQueryBuilder::composeLoadIdsQuery(const std::vector<UInt64> & ids)
{
if (!dict_struct.id)
throw Exception{"Simple key required for method", ErrorCodes::UNSUPPORTED_METHOD};
WriteBufferFromOwnString out;
writeString("SELECT ", out);
if (!dict_struct.id->expression.empty())
{
writeParenthesisedString(dict_struct.id->expression, out);
writeString(" AS ", out);
}
writeQuoted(dict_struct.id->name, out);
for (const auto & attr : dict_struct.attributes)
{
writeString(", ", out);
if (!attr.expression.empty())
{
writeParenthesisedString(attr.expression, out);
writeString(" AS ", out);
}
writeQuoted(attr.name, out);
}
writeString(" FROM ", out);
if (!db.empty())
{
writeQuoted(db, out);
writeChar('.', out);
}
if (!schema.empty())
{
writeQuoted(schema, out);
writeChar('.', out);
}
writeQuoted(table, out);
writeString(" WHERE ", out);
if (!where.empty())
{
writeString(where, out);
writeString(" AND ", out);
}
writeQuoted(dict_struct.id->name, out);
writeString(" IN (", out);
auto first = true;
for (const auto id : ids)
{
if (!first)
writeString(", ", out);
first = false;
writeString(DB::toString(id), out);
}
writeString(");", out);
return out.str();
}
void KdbxXmlWriter::writeNumber(const QString& qualifiedName, int number)
{
writeString(qualifiedName, QString::number(number));
}
void KdbxXmlWriter::writeBinary(const QString& qualifiedName, const QByteArray& ba)
{
writeString(qualifiedName, QString::fromLatin1(ba.toBase64()));
}
void File::writeLine()
{
writeString("\n");
}
void BinaryOutput::writeString32(const char* s) {
writeUInt32(strlen(s) + 1);
writeString(s);
}
int main( int argc, char* argv[] )
{
char cwd[2048];
_getcwd( cwd, sizeof(cwd) );
// zar <opt> <dir>
if ( argc != 4 )
{
printf( "Usage:\n"
"archive: zar -a <name> <dir>\n"
"unarchive: zar -x <name> <dir>\n"
"remove: zar -d <name> <filelist>\n" );
return 0;
}
const char* opt = argv[1];
const char* name = argv[2];
const char* dir = argv[3];
if ( std::string(opt) == "-a" )
{
// read files
std::vector<File> files;
if ( -1 != _chdir(dir) )
{
printf( "Processing %s...\n", dir );
readFiles( files, "*.*" );
}
else
{
printf( "Path %s not found\n", dir );
}
_chdir( cwd );
// check for duplicate file names
int i;
for ( i = 0 ; i < (int)files.size() ; ++i )
{
for ( int j = i+1 ; j < (int)files.size() ; ++j )
{
if ( files[i].name == files[j].name )
{
printf( "Warning: Two files have identical names (%s). Paths:\n", files[i].name.c_str() );
printf( "%s\n", files[i].path.c_str() );
printf( "%s\n", files[j].path.c_str() );
printf( "Removing %s/%s...\n", files[j].path.c_str(), files[j].name.c_str() );
files.erase( files.begin()+j );
--j;
}
}
}
// write zip
printf( "Writing %s...\n", name );
gzFile zip = gzopen( name, "wb" );
writeInt( zip, files.size() );
for ( i = 0 ; i < (int)files.size() ; ++i )
{
File& file = files[i];
writeString( zip, file.name.c_str() );
writeBytes( zip, file.data.begin(), file.data.size() );
}
gzclose( zip );
}
else if ( std::string(opt) == "-x" )
{
// read zip
printf( "Reading %s...\n", name );
gzFile zip = gzopen( name, "rb" );
if ( !zip )
{
printf( "Failed to open %s.", name );
return 1;
}
std::vector<File> files;
int count = readInt( zip );
files.resize( count );
for ( int i = 0 ; i < count ; ++i )
{
File& file = files[i];
readString( zip, file.name );
readBytes( zip, file.data );
}
gzclose( zip );
// write files
if ( -1 != _chdir(dir) )
{
for ( int i = 0 ; i < (int)files.size() ; ++i )
{
File& file = files[i];
printf( "Writing %s...\n", file.name.c_str() );
FILE* fh = fopen( file.name.c_str(), "wb" );
if ( fh )
{
fwrite( file.data.begin(), 1, file.data.size(), fh );
fclose( fh );
}
else
{
printf( "Cannot write to file: %s\n", file.name.c_str() );
}
}
}
else
{
printf( "Path %s not found\n", dir );
}
_chdir( cwd );
}
else if ( std::string(opt) == "-d" )
{
// read zip
printf( "Reading %s...\n", name );
gzFile zip = gzopen( name, "rb" );
if ( !zip )
{
printf( "Failed to open %s.", name );
return 1;
}
std::vector<File> files;
int count = readInt( zip );
files.resize( count );
for ( int i = 0 ; i < count ; ++i )
{
File& file = files[i];
readString( zip, file.name );
readBytes( zip, file.data );
}
gzclose( zip );
// read file list
printf( "Reading list %s...\n", dir );
FILE* fh = fopen( dir, "rt" );
if ( !fh )
{
printf( "File list not found: %s\n", dir );
return 1;
}
std::vector<std::string> filelist;
char buf[2048];
while ( !feof(fh) )
{
if ( 1 != fscanf(fh,"%s",buf) )
break;
filelist.push_back( buf );
}
// remove listed files
for ( int i = 0 ; i < (int)filelist.size() ; ++i )
{
std::string str = filelist[i];
for ( int j = 0 ; j < (int)files.size() ; ++j )
{
if ( files[j].name == str )
{
files.erase( files.begin()+j );
--j;
}
}
}
// write zip
printf( "Writing %s...\n", name );
zip = gzopen( name, "wb" );
writeInt( zip, files.size() );
for ( int i = 0 ; i < (int)files.size() ; ++i )
{
File& file = files[i];
writeString( zip, file.name.c_str() );
writeBytes( zip, file.data.begin(), file.data.size() );
}
gzclose( zip );
}
else
{
printf( "Invalid option: %s\n", opt );
}
return 0;
}
static void writeItem(WTF::Vector<char>& vector, WebCore::HistoryItem* item)
{
// Original url
writeString(vector, item->originalURLString());
// Url
writeString(vector, item->urlString());
// Title
writeString(vector, item->title());
// Form content type
writeString(vector, item->formContentType());
// Form data
const WebCore::FormData* formData = item->formData();
if (formData) {
WTF::String flattenedFormData = formData->flattenToString();
writeString(vector, flattenedFormData);
if (!flattenedFormData.isEmpty()) {
// save the identifier as it is not included in the flatten data
int64_t id = formData->identifier();
vector.append((char*)&id, sizeof(int64_t));
}
} else
writeString(vector, WTF::String()); // Empty constructor does not allocate a buffer.
// Target
writeString(vector, item->target());
AndroidWebHistoryBridge* bridge = item->bridge();
ALOG_ASSERT(bridge, "We should have a bridge here!");
// Screen scale
const float scale = bridge->scale();
ALOGV("Writing scale %f", scale);
vector.append((char*)&scale, sizeof(float));
const float textWrapScale = bridge->textWrapScale();
ALOGV("Writing text wrap scale %f", textWrapScale);
vector.append((char*)&textWrapScale, sizeof(float));
// Scroll position.
const int scrollX = item->scrollPoint().x();
vector.append((char*)&scrollX, sizeof(int));
const int scrollY = item->scrollPoint().y();
vector.append((char*)&scrollY, sizeof(int));
// Document state
const WTF::Vector<WTF::String>& docState = item->documentState();
WTF::Vector<WTF::String>::const_iterator end = docState.end();
unsigned stateSize = docState.size();
ALOGV("Writing docState %d", stateSize);
vector.append((char*)&stateSize, sizeof(unsigned));
for (WTF::Vector<WTF::String>::const_iterator i = docState.begin(); i != end; ++i) {
writeString(vector, *i);
}
// Is target item
ALOGV("Writing isTargetItem %d", item->isTargetItem());
vector.append((char)item->isTargetItem());
// Children count
unsigned childCount = item->children().size();
ALOGV("Writing childCount %d", childCount);
vector.append((char*)&childCount, sizeof(unsigned));
}
/*
* Write a string to a file
*/
int8_t sd::writeString(FIL* f, char* str) {
return writeString(f,(uint8_t*)str);
}
void printRTC(uint8_t digits)
{
// 8 chars, X decimal points, and \0 at the end
static char str[BUF_SIZE];
uint8_t cnt = 0;
uint8_t bits = countBits(digits);
uint8_t i;
menu_loop:
switch (bits)
{
case 8:
switch (rtcMenu.state)
{
case ddd_hhmm:
sprintf(str, "%s %02d.%02d", dow[date.dow], date.hour, date.minute);
break;
case DD_MM_YY:
sprintf(str, "%02d-%02d-%02d", date.day, date.month, date.year % 100);
break;
case hhmmss:
sprintf(str, " %02d.%02d.%02d", date.hour, date.minute, date.second);
break;
/*case dd_hhmm:
sprintf(str, " %c%c %02d.%02d", DOW(date.dow)[0], DOW(date.dow)[1], date.hour, date.minute);
break;*/
/*case DDMMYY:
sprintf(str, " %02d.%02d.%02d", date.day, date.month, date.year % 100);
break;*/
/*case hhmm:
sprintf(str, " %02d.%02d", date.hour, date.minute);
break;
case DDMM:
sprintf(str, " %02d.%02d", date.day, date.month);
break;*/
default:
i = BUF_SIZE;
while (--i)
str[i-1] = '\0';
break;
}
break;
case 6 ... 7:
switch (rtcMenu.state)
{
case hhmmss:
sprintf(str, "%02d.%02d.%02d", date.hour, date.minute, date.second);
break;
case dd_hhmm:
sprintf(str, "%c%c %02d.%02d", DOW(date.dow)[0], DOW(date.dow)[1], date.minute, date.second);
break;
case DDMMYY:
sprintf(str, "%02d.%02d.%02d", date.day, date.month, date.year % 100);
break;
/*case hhmm:
sprintf(str, " %02d.%02d", date.hour, date.minute);
break;
case DDMM:
sprintf(str, " %02d.%02d", date.day, date.month);
break;*/
default:
i = BUF_SIZE;
while (--i)
str[i - 1] = '\0';
break;
}
break;
case 4 ... 5:
switch (rtcMenu.state)
{
case hhmm:
sprintf(str, "%02d.%02d", date.hour, date.minute);
break;
case DDMM:
sprintf(str, "%02d.%02d", date.day, date.month);
break;
default:
i = BUF_SIZE;
while (--i)
str[i - 1] = '\0';
break;
}
break;
case 3:
switch (rtcMenu.state)
{
case ddd:
sprintf(str, "%02d.%02d", date.hour, date.minute);
break;
}
break;
case 2:
switch (rtcMenu.state)
{
case dd:
sprintf(str, "%c%c", date.hour, date.minute);
break;
default:
i = BUF_SIZE;
while (--i)
str[i - 1] = '\0';
break;
}
break;
case 0 ... 1:
sprintf(str, " ");
break;
}
if (*str == 0)
{
cnt++;
advState();
if (cnt < DATEVIEWS)
{
goto menu_loop;
}
else
{
sprintf(str, "ERR");
}
}
writeString(digits, str);
screen.changed |= digits;
}
bool RC2UI::makeDialog()
{
line = in->readLine();
do {
QFile fileOut;
QString buffer;
int count;
QCString className;
uint x, y, w, h;
uint endDesc;
bool space = FALSE;
for ( endDesc = 0; endDesc < line.length() ; endDesc++ ) {
char c = (QChar)line.at(endDesc);
if ( space && (c >= '0') && (c <= '9') )
break;
space = c==' ';
}
QString desc = line.left(endDesc-1);
line = line.right( line.length() - endDesc );
className = parseNext( desc, ' ' );
count = sscanf( line, "%d, %d, %d, %d", &x, &y, &w, &h );
if ( !count && count == EOF )
return FALSE;
char property[256];
QStringList styles;
QStringList extendedStyles;
QString caption = "";
QString baseClass = "";
QString widgetType;
QString widgetName;
QString arguments;
int pointsize;
QString fontname;
do {
if ( in->eof() )
return TRUE;
line = "";
do {
line += in->readLine();
} while ( line[(int)line.length()-1] == '|' ||
line[(int)line.length()-1] == ',' );
count = sscanf( line, "%s", property );
line = line.right( line.length() - line.find(" ") -1 );
if ( QString(property) == "STYLE" ) {
styles = splitStyles(line);
if ( styles.contains( "WS_CAPTION" ) )
baseClass = "QDialog";
else
baseClass = "QWidget";
} else if ( QString(property) == "CAPTION" ) {
caption = stripQM( line );
} else if ( QString(property) == "FONT" ) {
QString pt = line.left( line.find(",") );
pointsize = pt.toInt();
fontname = stripQM(line.right( line.length() - line.find(",") - 2 ));
}
} while ( line != "BEGIN" );
if ( writeToFile ) {
QString outputFile = QString(className) + ".ui";
fileOut.setName( outputFile );
if (!fileOut.open( IO_WriteOnly ) )
qFatal( "rc2ui: Could not open output file '%s'", outputFile.latin1() );
out = new QTextStream( &fileOut );
} else {
out = new QTextStream( &buffer, IO_WriteOnly );
}
*out << "<!DOCTYPE UI><UI>" << endl;
writeClass( className );
wi(); *out << "<widget>"<< endl; indent();
writeClass( baseClass );
writeCString( "name", className );
writeRect( "geometry", x, y, w, h );
writeString( "caption", caption );
writeFont( fontname, pointsize );
do {
line = in->readLine().stripWhiteSpace();
if ( line == "END" )
continue;
widgetType = parseNext(line, ' ');
arguments = line.stripWhiteSpace();
while ( arguments[(int)arguments.length()-1] == ',' ||
arguments[(int)arguments.length()-1] == '|' )
arguments += " "+in->readLine().stripWhiteSpace();
wi(); *out << "<widget>" << endl; indent();
WidgetType ID = IDUnknown;
QString controlType;
QString widgetID;
QString widgetText;
bool hasText = FALSE;
bool isControl = FALSE;
bool isFrame = FALSE;
if ( widgetType == "PUSHBUTTON" ) {
ID = IDPushButton;
hasText = TRUE;
} else if ( widgetType == "DEFPUSHBUTTON" ) {
ID = IDPushButton;
hasText = TRUE;
} else if ( widgetType == "LTEXT" ) {
ID = IDLabel;
hasText = TRUE;
} else if ( widgetType == "CTEXT" ) {
ID = IDLabel;
hasText = TRUE;
} else if ( widgetType == "RTEXT" ) {
ID = IDLabel;
hasText = TRUE;
} else if ( widgetType == "EDITTEXT" ) {
ID = IDLineEdit;
} else if ( widgetType == "GROUPBOX" ) {
ID = IDGroupBox;
hasText = TRUE;
} else if ( widgetType == "COMBOBOX" ) {
ID = IDComboBox;
} else if ( widgetType == "LISTBOX" ) {
ID = IDListBox;
} else if ( widgetType == "SCROLLBAR" ) {
ID = IDScrollBar;
} else if ( widgetType == "CHECKBOX" ) {
ID = IDCheckBox;
hasText = TRUE;
} else if ( widgetType == "RADIOBUTTON" ) {
ID = IDRadioButton;
hasText = TRUE;
} else if ( widgetType == "CONTROL" ) {
isControl = TRUE;
widgetText = stripQM(parseNext( arguments ));
widgetID = parseNext( arguments );
controlType = stripQM(parseNext( arguments ));
styles = splitStyles(parseNext( arguments ));
if ( controlType == "Static" ) {
ID = IDLabel;
} else if ( controlType == "Button" ) {
if ( styles.contains("BS_AUTOCHECKBOX") ||
styles.contains("BS_3STATE") )
ID = IDCheckBox;
else if ( styles.contains("BS_AUTORADIOBUTTON") )
ID = IDRadioButton;
} else if ( controlType == "msctls_updown32" ) {
ID = IDSpinBox;
} else if ( controlType == "msctls_progress32" ) {
ID = IDProgressBar;
} else if ( controlType == "msctls_trackbar32" ) {
ID = IDSlider;
} else if ( controlType == "SysListView32" ) {
ID = IDIconView;
} else if ( controlType == "SysTreeView32" ) {
ID = IDListView;
} else if ( controlType == "SysTabControl32" ) {
ID = IDTabWidget;
} else if ( controlType == "SysAnimate32" ) {
ID = IDLabel;
} else if ( controlType == "RICHEDIT" ) {
ID = IDMultiLineEdit;
} else if ( controlType == "ComboBoxEx32" ) {
ID = IDComboBox;
} else if ( controlType == "" ) {
ID = IDCustom;
} else {
ID = IDUnknown;
}
} else
ID = IDUnknown;
if ( hasText )
widgetText = stripQM(parseNext( arguments ));
if ( isControl ) {
x = parseNext( arguments ).toInt();
y = parseNext( arguments ).toInt();
w = parseNext( arguments ).toInt();
h = parseNext( arguments ).toInt();
} else {
widgetID = parseNext( arguments );
x = parseNext( arguments ).toInt();
y = parseNext( arguments ).toInt();
w = parseNext( arguments ).toInt();
h = parseNext( arguments ).toInt();
styles.clear();
}
do {
extendedStyles = splitStyles(parseNext( arguments ));
for ( uint i = 0; i < extendedStyles.count(); i++ )
styles << (*extendedStyles.at(i));
} while ( arguments.find(',') > -1 );
switch ( ID ) {
case IDWidget:
break;
case IDPushButton:
{
writeClass("QPushButton");
writeCString( "name", useName("PushButton_"+widgetID) );
writeRect( "geometry", x, y, w, h );
writeString( "text", widgetText );
if ( widgetType == "DEFPUSHBUTTON" )
writeBool( "default", TRUE );
}
break;
case IDLabel:
{
isFrame = TRUE,
writeClass("QLabel");
writeCString( "name", useName("Label_"+widgetID) );
writeRect( "geometry", x,y,w,h );
writeString( "text", widgetText );
QString align;
if ( !styles.contains("SS_CENTERIMAGE") )
align += "|AlignTop";
else
align += "|AlignVCenter";
if ( widgetType == "LTEXT" ) {
align += "|AlignLeft";
} else if ( widgetType == "CTEXT") {
align += "|AlignHCenter";
} else if ( widgetType == "RTEXT") {
align += "|AlignRight";
}
writeSet("alignment", align );
}
break;
case IDCheckBox:
{
writeClass("QCheckBox");
writeCString("name", useName("CheckBox_"+widgetID) );
writeRect("geometry", x,y,w,h);
writeString("text", widgetText );
if ( styles.contains( "BS_3STATE" ) )
writeBool( "tristate", TRUE );
}
break;
case IDRadioButton:
{
writeClass("QRadioButton");
writeCString("name", useName("RadioButton_"+widgetID) );
writeRect("geometry", x,y,w,h);
writeString("text", widgetText );
}
break;
case IDGroupBox:
{
isFrame = TRUE;
writeClass("QGroupBox");
writeCString( "name", useName("GroupBox_"+widgetID) );
writeRect( "geometry", x,y,w,h );
writeString( "title", widgetText );
if ( !styles.contains( "WS_BORDER" ) )
styles.append( "WS_BORDER" );
}
break;
case IDLineEdit:
{
if ( !styles.contains("ES_MULTILINE") ) {
writeClass("QLineEdit");
writeCString( "name", useName("LineEdit_"+widgetID) );
} else {
writeClass("QMultiLineEdit");
writeCString( "name", useName("MultiLineEdit_"+widgetID) );
}
writeRect( "geometry", x,y,w,h );
QString align = "AlignTop";
if ( styles.contains("ES_CENTER") )
align+="|AlignHCenter";
else if ( styles.contains("ES_RIGHT") )
align+="|AlignRight";
else
align+="|AlignLeft";
writeSet("alignment", align);
}
break;
case IDMultiLineEdit:
{
writeClass("QMultiLineEdit");
writeCString("name", useName("MultiLineEdit_"+widgetID) );
writeRect("geometry", x,y,w,h );
}
break;
case IDIconView:
{
isFrame = TRUE;
writeClass("QIconView");
writeCString("name", useName("IconView_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( !styles.contains( "LVS_SINGLESEL" ) )
writeEnum( "selectionMode", "Extended" );
if ( styles.contains( "LVS_NOLABELWRAP" ) )
writeBool("wordWrapIconText", FALSE );
}
break;
case IDListView:
{
isFrame = TRUE;
writeClass("QListView");
writeCString("name", useName("ListView_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains( "TVS_LINESATROOT" ) )
writeBool( "rootIsDecorated", TRUE );
if ( styles.contains( "TVS_FULLROWSELECT" ) )
writeBool( "allColumnsShowFocus", TRUE );
}
break;
case IDProgressBar:
{
isFrame = TRUE;
writeClass("QProgressBar");
writeCString("name", useName("ProgressBar_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains("TBS_VERT") )
writeEnum("orientation", "Vertical");
else
writeEnum("orientation", "Horizontal");
}
break;
case IDTabWidget:
{
writeClass("QTabWidget");
writeCString("name", useName("TabWidget_"+widgetID) );
writeRect("geometry", x,y,w,h );
wi(); *out << "<widget>" << endl; indent();
writeClass("QWidget");
wi(); *out << "<attribute>" << endl; indent();
wi(); *out << "<name>title</name>" << endl;
wi(); *out << "<string>Tab1</string>" << endl; undent();
wi(); *out << "</attribute>" << endl; undent();
wi(); *out << "</widget>" << endl;
}
break;
case IDSpinBox:
{
isFrame = TRUE;
writeClass("QSpinBox");
writeCString("name", useName("SpinBox_"+widgetID) );
writeRect("geometry", x,y,w,h);
}
break;
case IDSlider:
{
writeClass("QSlider");
writeCString("name", useName("Slider_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains("TBS_VERT") )
writeEnum("orientation", "Vertical");
else
writeEnum("orientation", "Horizontal");
if ( !styles.contains("TBS_NOTICKS") )
writeEnum("tickmarks", "Left" );
}
break;
case IDComboBox:
{
writeClass("QComboBox");
writeCString("name", useName("ComboBox_"+widgetID) );
if ( isControl )
writeRect( "geometry", x,y,w,14 );
else
writeRect( "geometry", x,y,w,h );
}
break;
case IDListBox:
{
isFrame = TRUE;
writeClass("QListBox");
writeCString("name", useName("ListBox_"+widgetID) );
writeRect( "geometry", x,y,w,h );
if ( styles.contains("WS_HSCROLL") )
writeEnum("hScrollBarMode", "Auto");
else
writeEnum("hScrollBarMode", "AlwaysOff");
if ( styles.contains("WS_VSCROLL") )
writeEnum("vScrollBarMode", "Auto");
else
writeEnum("vScrollBarMode", "AlwaysOff");
if ( styles.contains("LBS_EXTENDEDSEL") )
writeEnum("selectionMode", "Extended");
else if ( styles.contains("LBS_MULTIPLESEL") )
writeEnum("selectionMode", "Multi");
else if ( styles.contains("LBS_NOSEL") )
writeEnum("selectionMode", "NoSelection");
else
writeEnum("selectionMode", "Single");
if ( !styles.contains( "NO WS_BORDER" ) )
styles.append( "WS_BORDER" );
}
break;
case IDScrollBar:
{
writeClass("QScrollBar");
writeCString("name", useName("ScrollBar_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains("SBS_VERT") )
writeEnum("orientation", "Vertical");
else
writeEnum("orientation", "Horizontal");
}
break;
case IDCustom:
{
writeClass("QLabel");
writeCString("name", useName("Custom_"+widgetID) );
writeRect("geometry", x,y,w,h );
writeString("text", "Create a custom widget and place it here." );
}
default:
{
writeClass("QLabel");
writeCString("name", useName("Unknown_"+widgetID) );
writeRect("geometry", x,y,w,h );
writeString("text", QString("No support for %1.").arg(controlType) );
}
break;
}
writeStyles( styles, isFrame );
styles.clear();
undent();
wi(); *out << "</widget>" << endl;
} while ( line != "END" );
undent();
wi(); *out << "</widget>" << endl;
*out << "</UI>" << endl;
do {
line = in->readLine();
} while ( line.isEmpty() );
if ( !writeToFile )
target.append( buffer.copy() );
if (out) {
delete out;
out = 0;
}
fileOut.close();
if ( writeToFile )
printf( QDir::currentDirPath() + "/" + fileOut.name() + '\n' );
} while ( line != blockStart1 );
return TRUE;
}
void MessageEncoder::writeMap(const qpid::types::Variant::Map& properties, const Descriptor* d, bool large)
{
void* token = large ? startMap32(d) : startMap8(d);
for (qpid::types::Variant::Map::const_iterator i = properties.begin(); i != properties.end(); ++i) {
writeString(i->first);
switch (i->second.getType()) {
case qpid::types::VAR_MAP:
case qpid::types::VAR_LIST:
//not allowed (TODO: revise, only strictly true for application-properties) whereas this is now a more general method)
QPID_LOG(warning, "Ignoring nested map/list; not allowed in application-properties for AMQP 1.0");
case qpid::types::VAR_VOID:
writeNull();
break;
case qpid::types::VAR_BOOL:
writeBoolean(i->second);
break;
case qpid::types::VAR_UINT8:
writeUByte(i->second);
break;
case qpid::types::VAR_UINT16:
writeUShort(i->second);
break;
case qpid::types::VAR_UINT32:
writeUInt(i->second);
break;
case qpid::types::VAR_UINT64:
writeULong(i->second);
break;
case qpid::types::VAR_INT8:
writeByte(i->second);
break;
case qpid::types::VAR_INT16:
writeShort(i->second);
break;
case qpid::types::VAR_INT32:
writeInt(i->second);
break;
case qpid::types::VAR_INT64:
writeULong(i->second);
break;
case qpid::types::VAR_FLOAT:
writeFloat(i->second);
break;
case qpid::types::VAR_DOUBLE:
writeDouble(i->second);
break;
case qpid::types::VAR_STRING:
if (i->second.getEncoding() == BINARY) {
writeBinary(i->second);
} else {
writeString(i->second);
}
break;
case qpid::types::VAR_UUID:
writeUuid(i->second);
break;
}
}
if (large) endMap32(properties.size()*2, token);
else endMap8(properties.size()*2, token);
}
void Function_Tests (void)
{
int i, j ;
int k ;
int l ;
int m ;
WORD handle, h1, h2 ;
WORD parms[20];
unsigned char wks1[255] ;
unsigned char wks2[255] ;
unsigned char wks3[255] ;
gfx_Cls() ;
putstr("file_Run, file_Exec and\nfile_LoadFunction Tests") ;
printf("file_Run, file_Exec and file_LoadFunction Tests\n") ;
j = mem_Heap() ;
handle = file_LoadFunction(functest) ;
h1 = writeString(0, "Please enter your name") ; // prompts string
h2 = writeString(h1, "") ; // result string, must be max length if following strings are to be 'kept'
printf("String Handles %d %d\n", h1, h2) ;
parms[0] = h1 ; // prompt string
parms[1] = h2 ; // result string
parms[2] = 20 ;
parms[3] = 1 ; // 1 = save screen, 0 = don't save screen
TimeLimit4D = 5000000 ;
i = file_CallFunction(handle, 4, parms) ; // calls a function
printf("You typed %d characters", i) ;
readString(h2, wks1) ; // read string immediately as it will be overwritten 'soon'
printf(">%s<\n", wks1) ;
k = mem_Heap() ;
mem_Free(handle) ;
l = mem_Heap() ;
sleep(5000) ; // give time to read the 'restored' screen
h1 = writeString(0, "Please type anything") ; // prompts string
h2 = writeString(h1, "") ; // result string, must be max length if following strings are to be 'kept'
parms[0] = h1 ; // prompt string
parms[1] = h2 ; // result string
parms[2] = 20 ;
parms[3] = 0 ; // 1 = save screen, 0 = don't save screen
i = file_Exec(functest, 4, parms) ;
readString(h2, wks2) ; // read string immediately as it will be overwritten 'soon'
gfx_Cls() ;
h1 = writeString(0, "Please some more") ; // prompts string
h2 = writeString(h1, "") ; // result string, must be max length if following strings are to be 'kept'
parms[0] = h1 ; // prompt string
parms[1] = h2 ; // result string
parms[2] = 20 ;
parms[3] = 0 ; // 1 = save screen, 0 = don't save screen
i = file_Run(functest, 4, parms) ;
readString(h2, wks3) ; // read string immediately as it will be overwritten 'soon'
gfx_Cls() ;
m = mem_Heap() ;
printf("Memfree before loadfunction = %d\n", j) ;
printf("Memfree after loadfunction = %d\n", k) ;
printf("Memfree after free = %d\n", l) ;
printf("Memfree at end = %d\n", m) ;
printf("You typed\n") ;
printf(wks1) ;
printf("\n") ;
printf(wks2) ;
printf("\n") ;
printf(wks3) ;
printf("\n") ;
TimeLimit4D = 2000 ;
}
void KdbxXmlWriter::writeEntry(const Entry* entry)
{
Q_ASSERT(!entry->uuid().isNull());
m_xml.writeStartElement("Entry");
writeUuid("UUID", entry->uuid());
writeNumber("IconID", entry->iconNumber());
if (!entry->iconUuid().isNull()) {
writeUuid("CustomIconUUID", entry->iconUuid());
}
writeColor("ForegroundColor", entry->foregroundColor());
writeColor("BackgroundColor", entry->backgroundColor());
writeString("OverrideURL", entry->overrideUrl());
writeString("Tags", entry->tags());
writeTimes(entry->timeInfo());
const QList<QString> attributesKeyList = entry->attributes()->keys();
for (const QString& key : attributesKeyList) {
m_xml.writeStartElement("String");
// clang-format off
bool protect =
(((key == "Title") && m_meta->protectTitle()) || ((key == "UserName") && m_meta->protectUsername())
|| ((key == "Password") && m_meta->protectPassword())
|| ((key == "URL") && m_meta->protectUrl())
|| ((key == "Notes") && m_meta->protectNotes())
|| entry->attributes()->isProtected(key));
// clang-format on
writeString("Key", key);
m_xml.writeStartElement("Value");
QString value;
if (protect) {
if (!m_innerStreamProtectionDisabled && m_randomStream) {
m_xml.writeAttribute("Protected", "True");
bool ok;
QByteArray rawData = m_randomStream->process(entry->attributes()->value(key).toUtf8(), &ok);
if (!ok) {
raiseError(m_randomStream->errorString());
}
value = QString::fromLatin1(rawData.toBase64());
} else {
m_xml.writeAttribute("ProtectInMemory", "True");
value = entry->attributes()->value(key);
}
} else {
value = entry->attributes()->value(key);
}
if (!value.isEmpty()) {
m_xml.writeCharacters(stripInvalidXml10Chars(value));
}
m_xml.writeEndElement();
m_xml.writeEndElement();
}
const QList<QString> attachmentsKeyList = entry->attachments()->keys();
for (const QString& key : attachmentsKeyList) {
m_xml.writeStartElement("Binary");
writeString("Key", key);
m_xml.writeStartElement("Value");
m_xml.writeAttribute("Ref", QString::number(m_idMap[entry->attachments()->value(key)]));
m_xml.writeEndElement();
m_xml.writeEndElement();
}
writeAutoType(entry);
if (m_kdbxVersion >= KeePass2::FILE_VERSION_4) {
writeCustomData(entry->customData());
}
// write history only for entries that are not history items
if (entry->parent()) {
writeEntryHistory(entry);
}
m_xml.writeEndElement();
}
errorT
TreeCache::WriteFile (const char * fname)
{
#ifdef WINCE
/*FILE **/Tcl_Channel fp;
fileNameT fullname;
strCopy (fullname, fname);
strAppend (fullname, TREEFILE_SUFFIX);
// fp = fopen (fullname, "wb");
fp = my_Tcl_OpenFileChannel(NULL, fullname, "w", 0666);
if (fp == NULL) { return ERROR_FileOpen; }
my_Tcl_SetChannelOption(NULL, fp, "-encoding", "binary");
my_Tcl_SetChannelOption(NULL, fp, "-translation", "binary");
#else
FILE * fp;
fileNameT fullname;
strCopy (fullname, fname);
strAppend (fullname, TREEFILE_SUFFIX);
fp = fopen (fullname, "wb");
if (fp == NULL) { return ERROR_FileOpen; }
#endif
writeFourBytes (fp, TREEFILE_MAGIC);
writeTwoBytes (fp, SCID_VERSION);
writeFourBytes (fp, CacheSize);
writeFourBytes (fp, NumInUse);
writeFourBytes (fp, LowestTotal);
writeFourBytes (fp, LowestTotalIndex);
for (uint count = 0; count < NumInUse; count++) {
// Write this cached position:
cachedTreeT * ctree = &(Cache[count]);
writeOneByte (fp, ctree->toMove);
for (squareT sq=0; sq < 64; sq++) {
writeOneByte (fp, ctree->board[sq]);
}
// Write the moves:
writeFourBytes (fp, ctree->tree.moveCount);
writeFourBytes (fp, ctree->tree.totalCount);
uint numMoves = ctree->tree.moveCount;
for (uint i=0; i < numMoves; i++) {
// Write this move node:
treeNodeT * tnode = &(ctree->tree.node[i]);
writeSimpleMove (fp, &(tnode->sm));
writeString (fp, tnode->san, 8);
for (uint res = 0; res < 4; res++) {
writeFourBytes (fp, tnode->freq[res]);
}
writeFourBytes (fp, tnode->total);
writeFourBytes (fp, tnode->score);
writeTwoBytes (fp, tnode->ecoCode);
writeFourBytes (fp, tnode->eloCount);
writeFourBytes (fp, tnode->eloSum);
writeFourBytes (fp, tnode->perfCount);
writeFourBytes (fp, tnode->perfSum);
writeFourBytes (fp, tnode->yearCount);
writeFourBytes (fp, tnode->yearSum);
}
// Write the compressed filter:
ctree->cfilter->WriteToFile (fp);
}
#ifdef WINCE
my_Tcl_Close(NULL, fp);
#else
fclose (fp);
#endif
return OK;
}
void KdbxXmlWriter::writeUuid(const QString& qualifiedName, const QUuid& uuid)
{
writeString(qualifiedName, uuid.toRfc4122().toBase64());
}
std::unique_ptr<NLPacket> createAudioPacket(PacketType type, int size, quint16 sequence, QString codec) {
auto audioPacket = NLPacket::create(type, size);
audioPacket->writePrimitive(sequence);
audioPacket->writeString(codec);
return audioPacket;
}
void JFont::centerString(String s,RGBmp *j,int cx,int y,float scale,myRGB c) {
int x=cx-scale*1.5*(Slen(s)-1)/2.0;
writeString(s,j,x,y,scale,c);
}
void DataTypeEnum<Type>::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
writeString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr);
}
static int
writeCommand (const char *command, int reopen) {
return writeString(command, reopen) && writeString("\n", 0);
}
void JsonSerializer::serializeArrayItem(const char* value)
{
writeBlockComma();
writeString(value);
m_is_first_in_block = false;
}
std::string
ExternalQueryBuilder::composeLoadKeysQuery(const Columns & key_columns, const std::vector<size_t> & requested_rows, LoadKeysMethod method)
{
if (!dict_struct.key)
throw Exception{"Composite key required for method", ErrorCodes::UNSUPPORTED_METHOD};
WriteBufferFromOwnString out;
writeString("SELECT ", out);
auto first = true;
for (const auto & key_or_attribute : boost::join(*dict_struct.key, dict_struct.attributes))
{
if (!first)
writeString(", ", out);
first = false;
if (!key_or_attribute.expression.empty())
{
writeParenthesisedString(key_or_attribute.expression, out);
writeString(" AS ", out);
}
writeQuoted(key_or_attribute.name, out);
}
writeString(" FROM ", out);
if (!db.empty())
{
writeQuoted(db, out);
writeChar('.', out);
}
if (!schema.empty())
{
writeQuoted(schema, out);
writeChar('.', out);
}
writeQuoted(table, out);
writeString(" WHERE ", out);
if (!where.empty())
{
writeString("(", out);
writeString(where, out);
writeString(") AND (", out);
}
if (method == AND_OR_CHAIN)
{
first = true;
for (const auto row : requested_rows)
{
if (!first)
writeString(" OR ", out);
first = false;
composeKeyCondition(key_columns, row, out);
}
}
else /* if (method == IN_WITH_TUPLES) */
{
writeString(composeKeyTupleDefinition(), out);
writeString(" IN (", out);
first = true;
for (const auto row : requested_rows)
{
if (!first)
writeString(", ", out);
first = false;
composeKeyTuple(key_columns, row, out);
}
writeString(")", out);
}
if (!where.empty())
{
writeString(")", out);
}
writeString(";", out);
return out.str();
}
int writeFont(const char* inFilePath, const char* outFilePath, unsigned int fontSize, const char* id, bool fontpreview = false)
{
Glyph glyphArray[END_INDEX - START_INDEX];
// Initialize freetype library.
FT_Library library;
FT_Error error = FT_Init_FreeType(&library);
if (error)
{
LOG(1, "FT_Init_FreeType error: %d \n", error);
return -1;
}
// Initialize font face.
FT_Face face;
error = FT_New_Face(library, inFilePath, 0, &face);
if (error)
{
LOG(1, "FT_New_Face error: %d \n", error);
return -1;
}
// Set the pixel size.
error = FT_Set_Char_Size(
face, // handle to face object.
0, // char_width in 1/64th of points.
fontSize * 64, // char_height in 1/64th of points.
0, // horizontal device resolution (defaults to 72 dpi if resolution (0, 0)).
0 ); // vertical device resolution.
if (error)
{
LOG(1, "FT_Set_Char_Size error: %d \n", error);
return -1;
}
/*
error = FT_Set_Pixel_Sizes(face, FONT_SIZE, 0);
if (error)
{
LOG(1, "FT_Set_Pixel_Sizes error : %d \n", error);
exit(1);
}
*/
// Save glyph information (slot contains the actual glyph bitmap).
FT_GlyphSlot slot = face->glyph;
int actualfontHeight = 0;
int rowSize = 0; // Stores the total number of rows required to all glyphs.
// Find the width of the image.
for (unsigned char ascii = START_INDEX; ascii < END_INDEX; ++ascii)
{
// Load glyph image into the slot (erase previous one)
error = FT_Load_Char(face, ascii, FT_LOAD_RENDER);
if (error)
{
LOG(1, "FT_Load_Char error : %d \n", error);
}
int bitmapRows = slot->bitmap.rows;
actualfontHeight = (actualfontHeight < bitmapRows) ? bitmapRows : actualfontHeight;
if (slot->bitmap.rows > slot->bitmap_top)
{
bitmapRows += (slot->bitmap.rows - slot->bitmap_top);
}
rowSize = (rowSize < bitmapRows) ? bitmapRows : rowSize;
}
// Include padding in the rowSize.
rowSize += GLYPH_PADDING;
// Initialize with padding.
int penX = 0;
int penY = 0;
int row = 0;
double powerOf2 = 2;
unsigned int imageWidth = 0;
unsigned int imageHeight = 0;
bool textureSizeFound = false;
int advance;
int i;
while (textureSizeFound == false)
{
imageWidth = (unsigned int)pow(2.0, powerOf2);
imageHeight = (unsigned int)pow(2.0, powerOf2);
penX = 0;
penY = 0;
row = 0;
// Find out the squared texture size that would fit all the require font glyphs.
i = 0;
for (unsigned char ascii = START_INDEX; ascii < END_INDEX; ++ascii)
{
// Load glyph image into the slot (erase the previous one).
error = FT_Load_Char(face, ascii, FT_LOAD_RENDER);
if (error)
{
LOG(1, "FT_Load_Char error : %d \n", error);
}
// Glyph image.
int glyphWidth = slot->bitmap.pitch;
int glyphHeight = slot->bitmap.rows;
advance = glyphWidth + GLYPH_PADDING; //((int)slot->advance.x >> 6) + GLYPH_PADDING;
// If we reach the end of the image wrap aroud to the next row.
if ((penX + advance) > (int)imageWidth)
{
penX = 0;
row += 1;
penY = row * rowSize;
if (penY + rowSize > (int)imageHeight)
{
powerOf2++;
break;
}
}
// penY should include the glyph offsets.
penY += (actualfontHeight - glyphHeight) + (glyphHeight - slot->bitmap_top);
// Set the pen position for the next glyph
penX += advance; // Move X to next glyph position
// Move Y back to the top of the row.
penY = row * rowSize;
if (ascii == (END_INDEX-1))
{
textureSizeFound = true;
}
i++;
}
}
// Try further to find a tighter texture size.
powerOf2 = 1;
for (;;)
{
if ((penY + rowSize) >= pow(2.0, powerOf2))
{
powerOf2++;
}
else
{
imageHeight = (int)pow(2.0, powerOf2);
break;
}
}
// Allocate temporary image buffer to draw the glyphs into.
unsigned char* imageBuffer = (unsigned char *)malloc(imageWidth * imageHeight);
memset(imageBuffer, 0, imageWidth * imageHeight);
penX = 0;
penY = 0;
row = 0;
i = 0;
for (unsigned char ascii = START_INDEX; ascii < END_INDEX; ++ascii)
{
// Load glyph image into the slot (erase the previous one).
error = FT_Load_Char(face, ascii, FT_LOAD_RENDER);
if (error)
{
LOG(1, "FT_Load_Char error : %d \n", error);
}
// Glyph image.
unsigned char* glyphBuffer = slot->bitmap.buffer;
int glyphWidth = slot->bitmap.pitch;
int glyphHeight = slot->bitmap.rows;
advance = glyphWidth + GLYPH_PADDING;//((int)slot->advance.x >> 6) + GLYPH_PADDING;
// If we reach the end of the image wrap aroud to the next row.
if ((penX + advance) > (int)imageWidth)
{
penX = 0;
row += 1;
penY = row * rowSize;
if (penY + rowSize > (int)imageHeight)
{
free(imageBuffer);
LOG(1, "Image size exceeded!");
return -1;
}
}
// penY should include the glyph offsets.
penY += (actualfontHeight - glyphHeight) + (glyphHeight - slot->bitmap_top);
// Draw the glyph to the bitmap with a one pixel padding.
drawBitmap(imageBuffer, penX, penY, imageWidth, glyphBuffer, glyphWidth, glyphHeight);
// Move Y back to the top of the row.
penY = row * rowSize;
glyphArray[i].index = ascii;
glyphArray[i].width = advance - GLYPH_PADDING;
// Generate UV coords.
glyphArray[i].uvCoords[0] = (float)penX / (float)imageWidth;
glyphArray[i].uvCoords[1] = (float)penY / (float)imageHeight;
glyphArray[i].uvCoords[2] = (float)(penX + advance - GLYPH_PADDING) / (float)imageWidth;
glyphArray[i].uvCoords[3] = (float)(penY + rowSize) / (float)imageHeight;
// Set the pen position for the next glyph
penX += advance; // Move X to next glyph position
i++;
}
FILE *gpbFp = fopen(outFilePath, "wb");
// File header and version.
char fileHeader[9] = {'«', 'G', 'P', 'B', '»', '\r', '\n', '\x1A', '\n'};
fwrite(fileHeader, sizeof(char), 9, gpbFp);
fwrite(gameplay::GPB_VERSION, sizeof(char), 2, gpbFp);
// Write Ref table (for a single font)
writeUint(gpbFp, 1); // Ref[] count
writeString(gpbFp, id); // Ref id
writeUint(gpbFp, 128); // Ref type
writeUint(gpbFp, ftell(gpbFp) + 4); // Ref offset (current pos + 4 bytes)
// Write Font object.
// Family name.
writeString(gpbFp, face->family_name);
// Style.
// TODO: Switch based on TTF style name and write appropriate font style unsigned int
// For now just hardcoding to 0.
//char* style = face->style_name;
writeUint(gpbFp, 0); // 0 == PLAIN
// Font size.
writeUint(gpbFp, rowSize);
// Character set.
// TODO: Empty for now
writeString(gpbFp, "");
// Glyphs.
unsigned int glyphSetSize = END_INDEX - START_INDEX;
writeUint(gpbFp, glyphSetSize);
fwrite(&glyphArray, sizeof(Glyph), glyphSetSize, gpbFp);
// Texture.
unsigned int textureSize = imageWidth * imageHeight;
writeUint(gpbFp, imageWidth);
writeUint(gpbFp, imageHeight);
writeUint(gpbFp, textureSize);
fwrite(imageBuffer, sizeof(unsigned char), textureSize, gpbFp);
// Close file.
fclose(gpbFp);
LOG(1, "%s.gpb created successfully. \n", getBaseName(outFilePath).c_str());
if (fontpreview)
{
// Write out font map to an image.
std::string pgmFilePath = getFilenameNoExt(outFilePath);
pgmFilePath.append(".pgm");
FILE *imageFp = fopen(pgmFilePath.c_str(), "wb");
fprintf(imageFp, "P5 %u %u 255\n", imageWidth, imageHeight);
fwrite((const char *)imageBuffer, sizeof(unsigned char), imageWidth * imageHeight, imageFp);
fclose(imageFp);
}
// Cleanup resources.
free(imageBuffer);
FT_Done_Face(face);
FT_Done_FreeType(library);
return 0;
}
v = 0x02;
}
if(user != NULL) {
v = v|0x80;
if(pass != NULL) {
v = v|(0x80>>1);
}
}
buffer[length++] = v;
buffer[length++] = ((MQTT_KEEPALIVE) >> 8);
buffer[length++] = ((MQTT_KEEPALIVE) & 0xFF);
length = writeString(id,buffer,length);
if (willTopic) {
length = writeString(willTopic,buffer,length);
length = writeString(willMessage,buffer,length);
}
if(user != NULL) {
length = writeString(user,buffer,length);
if(pass != NULL) {
length = writeString(pass,buffer,length);
}
}
write(MQTTCONNECT,buffer,length-5);
lastInActivity = lastOutActivity = millis();
AREXPORT char *ArSocket::readString(void)
{
size_t i;
int n;
myReadStringMutex.lock();
myStringBufEmpty[0] = '\0';
// read one byte at a time
for (i = myStringPos; i < sizeof(myStringBuf); i++)
{
n = read(&myStringBuf[i], 1);
if (n > 0)
{
if (i == 0 && myStringBuf[i] < 0)
{
myStringGotEscapeChars = true;
}
if (myStringBuf[i] == '\n' || myStringBuf[i] == '\r')
{
if (i != 0)
myStringGotComplete = true;
myStringBuf[i] = '\0';
myStringPos = 0;
myStringPosLast = 0;
// if we have leading escape characters get rid of them
if (myStringBuf[0] < 0)
{
int ei;
myStringGotEscapeChars = true;
// increment out the escape chars
for (ei = 0;
myStringBuf[ei] < 0 || (ei > 0 && myStringBuf[ei - 1] < 0);
ei++);
// okay now return the good stuff
doStringEcho();
myReadStringMutex.unlock();
return &myStringBuf[ei];
}
// if we don't return what we got
doStringEcho();
myReadStringMutex.unlock();
return myStringBuf;
}
// if its not an ending character but was good keep going
else
continue;
}
// failed
else if (n == 0)
{
myReadStringMutex.unlock();
return NULL;
}
else // which means (n < 0)
{
#ifdef WIN32
if (WSAGetLastError() == WSAEWOULDBLOCK)
{
myStringPos = i;
doStringEcho();
myReadStringMutex.unlock();
return myStringBufEmpty;
}
#endif
#ifndef WIN32
if (errno == EAGAIN)
{
myStringPos = i;
doStringEcho();
myReadStringMutex.unlock();
return myStringBufEmpty;
}
#endif
perror("Error in reading from network");
myReadStringMutex.unlock();
return NULL;
}
}
// if they want a 0 length string
ArLog::log(ArLog::Normal, "Some trouble in ArSocket::readString to %s", getIPString());
writeString("String too long");
myReadStringMutex.unlock();
return NULL;
}
// Mesh bin export
bool exportMeshBin(const char * filename, MMesh * mesh)
{
int version = 2;
char rep[256];
bool state;
// create file
MFile * file = M_fopen(filename, "wb");
if(! file)
{
printf("Error : can't create file %s\n", filename);
return false;
}
// get file directory
getRepertory(rep, filename);
// header
M_fwrite(M_MESH_HEADER, sizeof(char), 8, file);
// version
M_fwrite(&version, sizeof(int), 1, file);
// Animation
{
// anim refs
MArmatureAnimRef * armatureAnimRef = mesh->getArmatureAnimRef();
MTexturesAnimRef * texturesAnimRef = mesh->getTexturesAnimRef();
MMaterialsAnimRef * materialsAnimRef = mesh->getMaterialsAnimRef();
// armature anim ref
writeDataRef(file, armatureAnimRef, rep);
// textures anim ref
writeDataRef(file, texturesAnimRef, rep);
// materials anim ref
writeDataRef(file, materialsAnimRef, rep);
// anims ranges
unsigned int animsRangesNumber = mesh->getAnimsRangesNumber();
MAnimRange * animsRanges = mesh->getAnimsRanges();
M_fwrite(&animsRangesNumber, sizeof(int), 1, file);
if(animsRangesNumber > 0)
M_fwrite(animsRanges, sizeof(MAnimRange), animsRangesNumber, file);
}
// Textures
{
unsigned int t, texturesNumber = mesh->getTexturesNumber();
M_fwrite(&texturesNumber, sizeof(int), 1, file);
for(t=0; t<texturesNumber; t++)
{
MTexture * texture = mesh->getTexture(t);
MTextureRef * textureRef = texture->getTextureRef();
M_TEX_GEN_MODES genMode = texture->getGenMode();
M_WRAP_MODES UWrapMode = texture->getUWrapMode();
M_WRAP_MODES VWrapMode = texture->getVWrapMode();
MVector2 texTranslate = texture->getTexTranslate();
MVector2 texScale = texture->getTexScale();
float texRotate = texture->getTexRotate();
// texture ref
writeDataRef(file, textureRef, rep);
if(textureRef)
{
bool mipmap = textureRef->isMipmapEnabled();
M_fwrite(&mipmap, sizeof(bool), 1, file);
}
// data
M_fwrite(&genMode, sizeof(M_TEX_GEN_MODES), 1, file);
M_fwrite(&UWrapMode, sizeof(M_WRAP_MODES), 1, file);
M_fwrite(&VWrapMode, sizeof(M_WRAP_MODES), 1, file);
M_fwrite(&texTranslate, sizeof(MVector2), 1, file);
M_fwrite(&texScale, sizeof(MVector2), 1, file);
M_fwrite(&texRotate, sizeof(float), 1, file);
}
}
// Materials
{
unsigned int m, materialsNumber = mesh->getMaterialsNumber();
M_fwrite(&materialsNumber, sizeof(int), 1, file);
for(m=0; m<materialsNumber; m++)
{
MMaterial * material = mesh->getMaterial(m);
int type = material->getType();
float opacity = material->getOpacity();
float shininess = material->getShininess();
float customValue = material->getCustomValue();
M_BLENDING_MODES blendMode = material->getBlendMode();
MVector3 emit = material->getEmit();
MVector3 diffuse = material->getDiffuse();
MVector3 specular = material->getSpecular();
MVector3 customColor = material->getCustomColor();
MFXRef * FXRef = material->getFXRef();
MFXRef * ZFXRef = material->getZFXRef();
// FX ref
state = FXRef != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(FXRef)
{
MShaderRef * vertShadRef = FXRef->getVertexShaderRef();
MShaderRef * pixShadRef = FXRef->getPixelShaderRef();
writeDataRef(file, vertShadRef, rep);
writeDataRef(file, pixShadRef, rep);
}
// Z FX ref
state = ZFXRef != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(ZFXRef)
{
MShaderRef * vertShadRef = ZFXRef->getVertexShaderRef();
MShaderRef * pixShadRef = ZFXRef->getPixelShaderRef();
writeDataRef(file, vertShadRef, rep);
writeDataRef(file, pixShadRef, rep);
}
// data
M_fwrite(&type, sizeof(int), 1, file);
M_fwrite(&opacity, sizeof(float), 1, file);
M_fwrite(&shininess, sizeof(float), 1, file);
M_fwrite(&customValue, sizeof(float), 1, file);
M_fwrite(&blendMode, sizeof(M_BLENDING_MODES), 1, file);
M_fwrite(&emit, sizeof(MVector3), 1, file);
M_fwrite(&diffuse, sizeof(MVector3), 1, file);
M_fwrite(&specular, sizeof(MVector3), 1, file);
M_fwrite(&customColor, sizeof(MVector3), 1, file);
// textures pass
unsigned int t, texturesPassNumber = material->getTexturesPassNumber();
M_fwrite(&texturesPassNumber, sizeof(int), 1, file);
for(t=0; t<texturesPassNumber; t++)
{
MTexturePass * texturePass = material->getTexturePass(t);
MTexture * texture = texturePass->getTexture();
unsigned int mapChannel = texturePass->getMapChannel();
M_TEX_COMBINE_MODES combineMode = texturePass->getCombineMode();
// texture id
int textureId = getTextureId(mesh, texture);
M_fwrite(&textureId, sizeof(int), 1, file);
// data
M_fwrite(&mapChannel, sizeof(int), 1, file);
M_fwrite(&combineMode, sizeof(M_TEX_COMBINE_MODES), 1, file);
}
}
}
// Bones
{
MArmature * armature = mesh->getArmature();
state = armature != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(armature)
{
unsigned int b, bonesNumber = armature->getBonesNumber();
M_fwrite(&bonesNumber, sizeof(int), 1, file);
for(b=0; b<bonesNumber; b++)
{
MOBone * bone = armature->getBone(b);
MObject3d * parent = bone->getParent();
MVector3 position = bone->getPosition();
MVector3 scale = bone->getScale();
MQuaternion rotation = bone->getRotation();
// name
writeString(file, bone->getName());
// parent id
int parentId = -1;
if(parent)
{
unsigned int id;
if(armature->getBoneId(parent->getName(), &id))
parentId = (int)id;
}
M_fwrite(&parentId, sizeof(int), 1, file);
// position / rotation / scale
M_fwrite(&position, sizeof(MVector3), 1, file);
M_fwrite(&rotation, sizeof(MQuaternion), 1, file);
M_fwrite(&scale, sizeof(MVector3), 1, file);
}
}
}
// BoundingBox
{
MBox3d * box = mesh->getBoundingBox();
M_fwrite(box, sizeof(MBox3d), 1, file);
}
// SubMeshs
{
unsigned int s, subMeshsNumber = mesh->getSubMeshsNumber();
MSubMesh * subMeshs = mesh->getSubMeshs();
M_fwrite(&subMeshsNumber, sizeof(int), 1, file);
for(s=0; s<subMeshsNumber; s++)
{
MSubMesh * subMesh = &(subMeshs[s]);
unsigned int indicesSize = subMesh->getIndicesSize();
unsigned int verticesSize = subMesh->getVerticesSize();
unsigned int normalsSize = subMesh->getNormalsSize();
unsigned int tangentsSize = subMesh->getTangentsSize();
unsigned int texCoordsSize = subMesh->getTexCoordsSize();
unsigned int colorsSize = subMesh->getColorsSize();
M_TYPES indicesType = subMesh->getIndicesType();
void * indices = subMesh->getIndices();
MColor * colors = subMesh->getColors();
MVector3 * vertices = subMesh->getVertices();
MVector3 * normals = subMesh->getNormals();
MVector3 * tangents = subMesh->getTangents();
MVector2 * texCoords = subMesh->getTexCoords();
MBox3d * box = subMesh->getBoundingBox();
MSkinData * skin = subMesh->getSkinData();
map<unsigned int, unsigned int> * mapChannelOffsets = subMesh->getMapChannelOffsets();
// BoundingBox
M_fwrite(box, sizeof(MBox3d), 1, file);
// indices
M_fwrite(&indicesSize, sizeof(int), 1, file);
if(indicesSize > 0)
{
// indice type
M_fwrite(&indicesType, sizeof(M_TYPES), 1, file);
switch(indicesType)
{
case M_USHORT:
M_fwrite(indices, sizeof(short), indicesSize, file);
break;
case M_UINT:
M_fwrite(indices, sizeof(int), indicesSize, file);
break;
}
}
// vertices
M_fwrite(&verticesSize, sizeof(int), 1, file);
if(verticesSize > 0)
M_fwrite(vertices, sizeof(MVector3), verticesSize, file);
// normals
M_fwrite(&normalsSize, sizeof(int), 1, file);
if(normalsSize > 0)
M_fwrite(normals, sizeof(MVector3), normalsSize, file);
// tangents
M_fwrite(&tangentsSize, sizeof(int), 1, file);
if(tangentsSize > 0)
M_fwrite(tangents, sizeof(MVector3), tangentsSize, file);
// texCoords
M_fwrite(&texCoordsSize, sizeof(int), 1, file);
if(texCoordsSize > 0)
M_fwrite(texCoords, sizeof(MVector2), texCoordsSize, file);
// colors
M_fwrite(&colorsSize, sizeof(int), 1, file);
if(colorsSize > 0)
M_fwrite(colors, sizeof(MColor), colorsSize, file);
// mapChannels
{
unsigned int size = mapChannelOffsets->size();
M_fwrite(&size, sizeof(int), 1, file);
map<unsigned int, unsigned int>::iterator
mit (mapChannelOffsets->begin()),
mend(mapChannelOffsets->end());
for(;mit!=mend;++mit)
{
M_fwrite(&mit->first, sizeof(int), 1, file);
M_fwrite(&mit->second, sizeof(int), 1, file);
}
}
// Skins
state = skin != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(skin)
{
// skin point
unsigned int p, pointsNumber = skin->getPointsNumber();
M_fwrite(&pointsNumber, sizeof(int), 1, file);
for(p=0; p<pointsNumber; p++)
{
MSkinPoint * skinPoint = skin->getPoint(p);
unsigned int vertexId = skinPoint->getVertexId();
unsigned int bonesNumber = skinPoint->getBonesNumber();
unsigned short * bonesIds = skinPoint->getBonesIds();
float * bonesWeights = skinPoint->getBonesWeights();
// data
M_fwrite(&vertexId, sizeof(int), 1, file);
M_fwrite(&bonesNumber, sizeof(int), 1, file);
if(bonesNumber > 0)
{
M_fwrite(bonesIds, sizeof(short), bonesNumber, file);
M_fwrite(bonesWeights, sizeof(float), bonesNumber, file);
}
}
}
// Displays
unsigned int d, displaysNumber = subMesh->getDisplaysNumber();
M_fwrite(&displaysNumber, sizeof(int), 1, file);
for(d=0; d<displaysNumber; d++)
{
MDisplay * display = subMesh->getDisplay(d);
M_PRIMITIVE_TYPES primitiveType = display->getPrimitiveType();
unsigned int begin = display->getBegin();
unsigned int size = display->getSize();
MMaterial * material = display->getMaterial();
M_CULL_MODES cullMode = display->getCullMode();
int materialId = getMaterialId(mesh, material);
// data
M_fwrite(&primitiveType, sizeof(M_PRIMITIVE_TYPES), 1, file);
M_fwrite(&begin, sizeof(int), 1, file);
M_fwrite(&size, sizeof(int), 1, file);
M_fwrite(&materialId, sizeof(int), 1, file);
M_fwrite(&cullMode, sizeof(M_CULL_MODES), 1, file);
}
}
}
M_fclose(file);
return true;
}
bool Configurator::writeConfiguration (const char *filename)
{
std::ofstream file(filename == 0 ? Configurator::filename : filename, std::ios_base::out | std::ios_base::trunc);
if (!file.good())
return false;
if (!writeInt(file, 3))
return false;
std::vector<VrrpService *> services = Configurator::services();
if (!writeInt(file, services.size()))
return false;
for (std::vector<VrrpService *>::const_iterator it = services.begin(); it != services.end(); ++it)
{
const VrrpService *service = *it;
char ifname[IFNAMSIZ];
if_indextoname(service->interface(), ifname);
int flags = 0;
if (!service->hasAutoPrimaryIpAddress())
flags |= FLAG_HAS_PRIMARY_IP_ADDRESS;
if (
!writeString(file, ifname)
|| !writeInt(file, service->virtualRouterId())
|| !writeInt(file, service->family())
|| !writeInt(file, service->priority())
|| !writeInt(file, service->advertisementInterval() * 10)
|| !writeBoolean(file, service->acceptMode())
|| !writeBoolean(file, service->preemptMode())
|| !writeBoolean(file, service->enabled())
|| !writeInt(file, flags))
return false;
if (flags & FLAG_HAS_PRIMARY_IP_ADDRESS)
{
if (!writeIp(file, service->primaryIpAddress()))
return false;
}
if (
!writeString(file, service->masterCommand())
|| !writeString(file, service->backupCommand())
|| !writeInt(file, service->vlanId()))
{
return false;
}
const IpSubnetSet &subnets = service->subnets();
if (!writeInt(file, subnets.size()))
return false;
for (IpSubnetSet::const_iterator subnet = subnets.begin(); subnet != subnets.end(); ++subnet)
{
if (!writeSubnet(file, *subnet))
return false;
}
}
return true;
}
