void SQLite::createDatabase(const String &name)
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
throw UnsupportedFeatureException("SQLite::createDatabase");
#endif
}
void SQLite::selectDB(const String &databasename)
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
throw UnsupportedFeatureException("SQLite:selectDB");
#endif
}
void SQLite::exec(const String &query)
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
if (!conn) throw NoConnectionException();
String err;
double t_start;
affectedrows=0;
sqlite3_stmt *stmt=NULL;
t_start=GetMicrotime();
int ret=sqlite3_prepare_v2((sqlite3*)conn, (const char*)query, query.size(),&stmt,NULL);
if (ret!=SQLITE_OK) {
throw QueryFailedException("sqlite3_prepare_v2 failed: %s",sqlite3_errmsg((sqlite3*)conn));
}
if (stmt==NULL) {
throw OutOfMemoryException();
}
ret=sqlite3_step(stmt);
if (ret!=SQLITE_DONE && ret!=SQLITE_ROW) {
err.setf("sqlite3_step: %s, Query: %s",sqlite3_errmsg((sqlite3*)conn),(const char*)query);
sqlite3_finalize(stmt);
throw QueryFailedException(err);
}
ret=sqlite3_finalize(stmt);
if (ret !=SQLITE_OK) {
err.setf("sqlite3_finalize: %s, Query: %s",sqlite3_errmsg((sqlite3*)conn),(const char*)query);
throw QueryFailedException(err);
}
affectedrows=sqlite3_changes((sqlite3*)conn);
updateLastUse();
logQuery(query,(float)(GetMicrotime()-t_start));
#endif
}
void SQLite::cancelTransactionComplete()
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
exec("ROLLBACK");
transactiondepth=0;
affectedrows=0;
#endif
}
void SQLite::reconnect()
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
close();
AssocArray a=condata;
connect(a);
#endif
}
void SQLite::close()
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite3");
#else
if (!conn) {
return;
}
sqlite3_close((sqlite3*)conn);
conn=NULL;
clearLastUse();
#endif
}
void SQLite::startTransaction()
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
if (transactiondepth==0) { // Neue Transaktion
exec("BEGIN");
transactiondepth++;
} else {
execf("SAVEPOINT LEVEL%i",transactiondepth);
transactiondepth++;
}
#endif
}
void SQLite::cancelTransaction()
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
if (transactiondepth==1) {
exec("ROLLBACK");
transactiondepth=0;
} else {
execf("ROLLBACK TO SAVEPOINT LEVEL%i",transactiondepth-1);
transactiondepth--;
}
affectedrows=0;
#endif
}
void SQLite::endTransaction()
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
if (transactiondepth==1) {
exec("COMMIT");
transactiondepth=0;
} else {
execf("RELEASE SAVEPOINT LEVEL%i",transactiondepth-1);
transactiondepth--;
}
affectedrows=0;
#endif
}
String SQLite::escape(const String &str) const
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
// SQLite hat keine Escape-Funktion, daher müssen wir das selbst machen
String n;
const char *tmp=str.getPtr();
int c;
while ((c=tmp[0])) {
if (c=='\'') n+="'";
n+=c;
tmp++;
}
return n;
#endif
}
/*!\brief Connect auf eine SQLite-Datenbank erstellen
*
* \descr
* Mit dieser Funktion wird eine Verbindung zu einer SQLite Datenbank hergestellt, wobei
* die dafür notwendigen Parameter dem Array \p params entnommen werden.
* \par
* Mögliche Parameter:
* - \b filename: Dateiname der Datenbank
*
* \param params Ein Assoziatives Array mit den für den Connect erforderlichen Parameter.
*
* \exception OutOfMemoryException
* \exception ConnectionFailedException
*
*/
void SQLite::connect(const AssocArray ¶ms)
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
if (conn) close();
condata=params;
String filename=params["filename"];
int ret=sqlite3_open((const char*)filename,(sqlite3 **)&conn);
if (!conn) throw OutOfMemoryException();
if (ret != SQLITE_OK) {
String err(sqlite3_errmsg((sqlite3*)conn));
sqlite3_close((sqlite3*)conn);
conn=NULL;
throw ConnectionFailedException(err);
}
#endif
}
ResultSet *SQLite::query(const String &query)
{
#ifndef HAVE_SQLITE3
throw UnsupportedFeatureException("SQLite");
#else
if (!conn) throw NoConnectionException();
String err;
double t_start;
affectedrows=0;
sqlite3_stmt *stmt=NULL;
t_start=GetMicrotime();
int ret=sqlite3_prepare_v2((sqlite3*)conn, (const char*)query, query.size(),&stmt,NULL);
if (ret!=SQLITE_OK) {
throw QueryFailedException("sqlite3_prepare_v2 failed: %s",sqlite3_errmsg((sqlite3*)conn));
}
if (stmt==NULL) {
throw OutOfMemoryException();
}
ret=sqlite3_step(stmt);
if (ret!=SQLITE_DONE && ret!=SQLITE_ROW) {
err.setf("sqlite3_step: %s, Query: %s",sqlite3_errmsg((sqlite3*)conn),(const char*)query);
sqlite3_finalize(stmt);
throw QueryFailedException(err);
}
affectedrows=sqlite3_changes((sqlite3*)conn);
updateLastUse();
logQuery(query,(float)(GetMicrotime()-t_start));
SQLiteResult *pr=new SQLiteResult;
if (!pr) {
sqlite3_finalize(stmt);
throw OutOfMemoryException();
}
pr->stmt=stmt;
pr->last_res=ret;
pr->sqlite_class=this;
pr->conn=(sqlite3 *)conn;
pr->affectedrows=affectedrows;
pr->num_fields=sqlite3_column_count(stmt);
return pr;
#endif
}
void ImageFilter_PNG::save (const Drawable &surface, FileObject &file, const AssocArray ¶m)
{
#ifdef HAVE_PNG
Color farbe;
int pitch,colortype;
//int r,g,b,a;
int width,height;
png_byte *buffer;
png_color pc[256];
//RGBA rgb;
if (surface.isEmpty()) throw EmptyImageException();
file.seek(0);
width=surface.width();
height=surface.height();
pitch=colortype=0;
int png_color_type=PNG_COLOR_TYPE_GRAY;
int compression_level=Z_BEST_COMPRESSION;
RGBFormat srgb=surface.rgbformat();
if (srgb==RGBFormat::A8R8G8B8) png_color_type=PNG_COLOR_TYPE_RGB_ALPHA;
if (param.exists("colortype")) png_color_type=param.getString("colortype").toInt();
if (!png_color_type) png_color_type=PNG_COLOR_TYPE_RGB;
switch (png_color_type) {
case PNG_COLOR_TYPE_GRAY:
colortype=PNG_COLOR_TYPE_GRAY;
pitch=width*1;
break;
case PNG_COLOR_TYPE_PALETTE:
colortype=PNG_COLOR_TYPE_PALETTE;
pitch=width*1;
break;
case PNG_COLOR_TYPE_RGB:
colortype=PNG_COLOR_TYPE_RGB;
pitch=width*3;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
colortype=PNG_COLOR_TYPE_RGB_ALPHA;
pitch=width*4;
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
colortype=PNG_COLOR_TYPE_GRAY_ALPHA;
pitch=width*2;
break;
default:
colortype=PNG_COLOR_TYPE_RGB;
pitch=width*3;
break;
};
png_structp png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL,NULL,NULL);
if (!png_ptr) throw OperationFailedException("ImageFilter_PNG::save");
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr,(png_infopp)NULL);
throw OperationFailedException("ImageFilter_PNG::save");
}
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr,&info_ptr);
throw OperationFailedException("ImageFilter_PNG::save");
}
//png_set_read_fn(png_ptr,(voidp) file, (png_rw_ptr) user_read_data);
png_set_write_fn(png_ptr, &file, (png_rw_ptr) user_write_data, (png_flush_ptr) user_flush_data);
// Compression-Level setzen
png_set_compression_level (png_ptr, compression_level);
png_set_IHDR(png_ptr, info_ptr, width,height,8,colortype,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
buffer=(png_byte*)png_malloc(png_ptr,pitch);
if (!buffer) {
png_destroy_write_struct(&png_ptr,&info_ptr);
throw OutOfMemoryException();
}
if (buffer!=NULL) {
// png_write_row(png_ptr, row_pointer);
int bpp;
switch (colortype) {
case PNG_COLOR_TYPE_PALETTE:
bpp=1;
if (surface.rgbformat()==RGBFormat::Palette) { // Surface verwendet Palette
for (int i=0;i<256;i++) {
// TODO:
//surface->GetColor(i,&rgb);
//pc[i].red=rgb.red;
//pc[i].green=rgb.green;
//pc[i].blue=rgb.blue;
}
png_set_PLTE(png_ptr,info_ptr, &pc[0], 256);
png_write_info(png_ptr, info_ptr);
//png_write_PLTE (png_ptr, &pc[0],256);
for (int y=0;y<height;y++) {
for (int x=0;x<width;x++) {
farbe=surface.getPixel(x,y);
buffer[x]=(ppluint8)(farbe.color()&0xff);
}
png_write_row(png_ptr, buffer);
}
} else { // Surface verwendet keine Palette -> Konvertierung
/* TODO:
RGBA *pal=Get8BitTrueColorPalette ();
for (int i=0;i<256;i++) {
pc[i].red=pal[i].c.red;
pc[i].green=pal[i].c.green;
pc[i].blue=pal[i].c.blue;
DLOG ("Farbe %i: RGB=%u, %u, %u",i,pc[i].red,pc[i].green,pc[i].blue);
}
png_set_PLTE(png_ptr,info_ptr, &pc[0], 256);
png_write_info(png_ptr, info_ptr);
//png_write_PLTE (png_ptr, &pc[0],256);
for (y=area->top;y<area->bottom;y++) {
DLOGLEVEL(2) ("png_write_row Zeile %u",y);
for (x=0;x<width;x++) {
farbe=surface->Surface2RGB(surface->GetPixel(area->left+x,y));
r=(farbe&255)*7/255;
g=((farbe>>8)&255)*7/255;
b=((farbe>>16)&255)*3/255;
buffer[x]=(ppldb)(r+(g<<3)+(b<<6));
}
png_write_row(png_ptr, buffer);
}
*/
}
break;
case PNG_COLOR_TYPE_RGB:
bpp=3;
png_write_info(png_ptr, info_ptr);
for (int y=0;y<height;y++) {
for (int x=0;x<width;x++) {
//farbe=surface->GetPixel(area->left+x,y);
farbe=surface.getPixel(x,y);
buffer[x*bpp+0]=(ppluint8)farbe.red();
buffer[x*bpp+1]=(ppluint8)farbe.green();
buffer[x*bpp+2]=(ppluint8)farbe.blue();
}
png_write_row(png_ptr, buffer);
}
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
bpp=4;
png_write_info(png_ptr, info_ptr);
for (int y=0;y<height;y++) {
for (int x=0;x<width;x++) {
farbe=surface.getPixel(x,y);
buffer[x*bpp+0]=(ppluint8)farbe.red();
buffer[x*bpp+1]=(ppluint8)farbe.green();
buffer[x*bpp+2]=(ppluint8)farbe.blue();
buffer[x*bpp+3]=(ppluint8)farbe.alpha();
}
png_write_row(png_ptr, buffer);
}
break;
case PNG_COLOR_TYPE_GRAY:
bpp=1;
png_write_info(png_ptr, info_ptr);
for (int y=0;y<height;y++) {
for (int x=0;x<width;x++) {
farbe=surface.getPixel(x,y);
buffer[x*bpp]=(ppluint8)farbe.brightness();
}
png_write_row(png_ptr, buffer);
}
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
bpp=2;
png_write_info(png_ptr, info_ptr);
for (int y=0;y<height;y++) {
for (int x=0;x<width;x++) {
farbe=surface.getPixel(x,y);
buffer[x*bpp]=(ppluint8)farbe.brightness();
buffer[x*bpp+1]=(ppluint8)farbe.alpha();
}
png_write_row(png_ptr, buffer);
}
break;
}
png_free(png_ptr,buffer);
}
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr,&info_ptr);
#else
throw UnsupportedFeatureException("ImageFilter_PNG");
#endif
}
void ImageFilter_PNG::load(FileObject &file, Drawable &surface, IMAGE &img)
{
#ifdef HAVE_PNG
file.seek(0);
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL ,NULL, NULL);
if (!png_ptr) throw IllegalImageFormatException();
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr,(png_infopp)NULL, (png_infopp)NULL);
throw IllegalImageFormatException();
}
png_infop end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
throw IllegalImageFormatException();
}
png_set_read_fn(png_ptr, &file, (png_rw_ptr) user_read_data);
//png_set_write_fn(png_structp write_ptr, voidp write_io_ptr, png_rw_ptr write_data_fn,
// png_flush_ptr output_flush_fn);
png_read_info(png_ptr, info_ptr);
//png_read_png(png_ptr, info_ptr,0,NULL);
png_bytep row_pointer=(png_bytep) png_malloc(png_ptr,img.pitch);
RGBFormat zformat=surface.rgbformat(); // Zielformat holen
if (row_pointer!=NULL) {
int bpp;
switch (png_get_color_type(png_ptr, info_ptr)) {
case PNG_COLOR_TYPE_RGB_ALPHA:
//bpp=png_get_bit_depth(png_ptr, info_ptr);
bpp=4; // TODO: Bittiefe kann auch 16 Bit pro Farbkanal sein
//printf ("PNG RGBA, bpp=%i\n",bpp);
for (int y=0;y<img.height;y++) {
png_read_row(png_ptr, row_pointer, NULL);
for (int x=0;x<img.width;x++) {
int r=row_pointer[x*bpp+0];
int g=row_pointer[x*bpp+1];
int b=row_pointer[x*bpp+2];
int a=row_pointer[x*bpp+3];
surface.putPixel(x,y,Color(r,g,b,a));
}
}
break;
case PNG_COLOR_TYPE_RGB:
//bpp=png_get_bit_depth(png_ptr, info_ptr)/8;
bpp=3;
for (int y=0;y<img.height;y++) {
png_read_row(png_ptr, row_pointer, NULL);
for (int x=0;x<img.width;x++) {
int r=row_pointer[x*bpp+0];
int g=row_pointer[x*bpp+1];
int b=row_pointer[x*bpp+2];
surface.putPixel(x,y,Color(r,g,b,255));
}
}
break;
case PNG_COLOR_TYPE_GRAY:
//bpp=png_get_bit_depth(png_ptr, info_ptr)/8;
bpp=1;
// Ist das Zielformat auch Greyscale?
if (zformat==RGBFormat::A8 || zformat==RGBFormat::GREY8) {
for (int y=0;y<img.height;y++) {
png_read_row(png_ptr, row_pointer, NULL);
for (int x=0;x<img.width;x++) {
int r=row_pointer[x*bpp+0];
surface.putPixel(x,y,Color(r,r,r));
}
}
} else {
for (int y=0;y<img.height;y++) {
png_read_row(png_ptr, row_pointer, NULL);
for (int x=0;x<img.width;x++) {
int r=row_pointer[x*bpp+0];
surface.putPixel(x,y,Color(r,r,r));
}
}
}
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
bpp=2;
//bpp=png_get_bit_depth(png_ptr, info_ptr)/8;
for (int y=0;y<img.height;y++) {
png_read_row(png_ptr, row_pointer, NULL);
for (int x=0;x<img.width;x++) {
int r=row_pointer[x*bpp+0];
int a=row_pointer[x*bpp+1];
surface.putPixel(x,y,Color(r,r,r,a));
}
}
break;
case PNG_COLOR_TYPE_PALETTE:
int num_trans=0;
bpp=png_get_bit_depth(png_ptr, info_ptr)/8;
png_colorp pal;
int num_palette;
png_get_PLTE(png_ptr, info_ptr, &pal,&num_palette);
png_get_tRNS(png_ptr, info_ptr, NULL, &num_trans, NULL);
/*
if (num_trans>0) {
r=pal[num_trans-1].red;
g=pal[num_trans-1].green;
b=pal[num_trans-1].blue;
//surface->SetColorKey(surface->RGB(r,g,b,0));
}
*/
for (int y=0;y<img.height;y++) {
png_read_row(png_ptr, row_pointer, NULL);
for (int x=0;x<img.width;x++) {
int a=row_pointer[x*bpp+0];
int r=pal[a].red;
int g=pal[a].green;
int b=pal[a].blue;
if (num_trans>0) {
if (a==num_trans-1) a=0; else a=255;
} else a=255;
surface.putPixel(x,y,Color(r,g,b,a));
}
}
break;
}
} else {
throw IllegalImageFormatException();
}
png_free(png_ptr,row_pointer);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
#else
throw UnsupportedFeatureException("ImageFilter_PNG");
#endif
}
/**********************************************************************************************
* NextToken
*********************************************************************************************/
XMLScanner::TOKEN XMLScanner::NextToken () {
if (state == STATE_STREAM_END)
return TOKEN_STREAM_END;
do {
switch (state) {
/* Content */
case STATE_CONTENT:
switch (current) {
/* Element tag */
case '<' :
state = STATE_ELEMENT_TAG;
if (! output.isEmpty ()) {
// TODO : check for whitespace only elements ...
return TOKEN_CHARACTER_DATA;
}
break;
case '&' :
ReadReference ();
break;
case ']' :
/* checks for invalid CDATA section end */
ReadCharacter ();
if (current == ']') {
ReadCharacter ();
if (current == '>') {
ReadCharacter ();
throw IllegalCharacterException ();
} else {
output.Append (']');
output.Append (']');
output.Append (current);
}
} else {
output.Append (']');
output.Append (current);
}
break;
default :
output.Append (current);
break;
}
break;
/* Element Tag */
case STATE_ELEMENT_START_OPENING:
if (current == '!') {
ReadCharacter ();
state = STATE_SPECIAL_ELEMENT;
} else if (current == '?') {
ReadCharacter ();
state = STATE_CONTENT;
return ReadProcessingInstruction ();
} else if (current == '/') {
ReadCharacter ();
state = STATE_ELEMENT_END_NAME;
return TOKEN_ELEMENT_END_TAG;
} else if (isNameFirst (current)) {
state = STATE_ELEMENT_START_NAME;
return TOKEN_ELEMENT_START_OPENING;
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* Special elements (comments and CDATA sections etc ...) */
/* '<!' ... */
case STATE_SPECIAL_ELEMENT:
if (current == '-') {
ReadComment ();
} else if (current == '[') {
ReadCDATASection ();
} else {
throw UnsupportedFeatureException (position);
}
state = STATE_CONTENT;
break;
/* Element start name target */
/* '<' ... */
case STATE_ELEMENT_START_NAME:
if (isNameFirst (current)) {
state = STATE_ELEMENT_ATTRIBUTES_START;
return ReadQualifiedName ();
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* Element start name target */
/* '</' ... */
case STATE_ELEMENT_END_NAME:
if (isNameFirst (current)) {
state = STATE_ELEMENT_END_TAG;
return ReadQualifiedName ();
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* Attributes */
case STATE_ATTRIBUTES_START:
if (isWhitespace (current)) {
state = STATE_ATTRIBUTES;
} else if (current == '/') {
state = STATE_ELEMENT_END_CLOSING;
} else if (current == '>') {
state = STATE_CONTENT;
return TOKEN_ELEMENT_START_CLOSING;
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* '<' QualifiedName ... */
case STATE_ATTRIBUTES :
if (isWhitespace (current)) {
break;
} else if (isNameFirst (current)) {
state = STATE_ATTRIBUTE_EQUAL;
return ReadQualifiedName ();
} else {
throw UnexpectedCharacterException (previous);
}
break;
case STATE_ELEMENT_END_CLOSING:
if (current == '>') {
state = STATE_CONTENT;
return TOKEN_ELEMENT_END_CLOSING;
} else {
throw UnexpectedCharacterException (previous);
}
break;
case STATE_ATTRIBUTE_EQUAL:
if (current == '\'' || current == '\"') {
state = STATE_ATTRIBUTES_START;
return ReadLiteral ();
}
break;
case STATE_ELEMENT_END_TAG:
if (current == '>') {
state = STATE_CONTENT;
return TOKEN_ELEMENT_END_TAG_CLOSING;
}
break;
}
} while (ReadCharacter ());
/* Stream end */
return TOKEN_STREAM_END;
}
static int out_bind(SOCKET sockfd, const char *host, int port)
{
throw UnsupportedFeatureException("TCPSocket.connect after TCPSocket.bind");
}
