Well, so did I (only goes to show how silly I am) until I found that a number of constraints was not working at all. Example

drop table testme;
create table testme (
z NVARCHAR2(13),
a NVARCHAR2(13) CHECK (a IN ( 'foo', 'bar' ) ),
b NVARCHAR2(13) CHECK (b IN ( '', 'bar' ) )
);

insert into testme values ( '1', '', '' ); -- OK, a allowed to be null
insert into testme values ( '2', 'foo', '' ); -- OK, b allowed to ''/null
insert into testme values ( '3', '', 'bar' ); -- OK, b allowed to be bar
insert into testme values ( '4', 'foo', 'bar' ); -- OK
insert into testme values ( '5', 'foobar', 'bar' ); -- Fails: a not allowed to be foobar: OK
insert into testme values ( '6', 'foo', 'foo' ); -- DOES NOT FAIL??? b not allowed to be foo?

The reason the check on b does not work, is because of three things:

a) ” becomes null in oracle (but you knew that, because you learn that very early on)

b) comparing something to null becomes unknown in oracle (I did not*really* appreciate this)

c) CHECK only fails, if the result is actually False. (I did not at all know this)

c) means that CHECK does not fail, if the result is unknown…

Enter Wikipedia:

“While a DML WHERE clause must evaluate to True for a row, a check
constraint must not evaluate to False. This means that a check
constraint will succeed if the result of the check is either True or
Unknown.”

http://en.wikipedia.org/wiki/Null_(SQL)#Check_constraints

So, the check does not fail.

Now, if you tried the same in statement, with a select, it would not actually return any rows. Assume the table contains a row where b = ‘foobar’

select * from testme where b in ( '', 'bar )

As you would expect, this only returns rows where b == ‘bar’.

…

Ok, so I know this now. I still believe the engineer that thought up this particular piece of sematics should be hugely ashamed…

I stumbled upon the Hooq system to script these things. For some reason the images are missing in my end. If you look through the discussion at the end, you will se that a lot of people have trouble gettuing hooq to record anything on their applications. I did to, this post describes how I got it to work.

I downloaded the source using:

git clone https://git.gitorious.org/hooq/hooq.git.

I am running Kubuntu 11.4, and I needed to apply the following patch, heavily inspired by the source here, to make it work:

diff --git a/hooqInjector/GdbInjector.cpp b/hooqInjector/GdbInjector.cpp
index a390601..9668926 100644
--- a/hooqInjector/GdbInjector.cpp
+++ b/hooqInjector/GdbInjector.cpp
@@ -92,27 +92,28 @@ void GdbInjector::startProcess()
Q_ASSERT(m_gdb->state() == QProcess::Running);
Q_ASSERT(m_gdb->isWritable());
m_gdbStream.setDevice(m_gdb);
-       m_gdbStream << "set auto-solib-add off" << endl; // avoid loading symbols for shared libraries
-                                                        // that we do not need to interact with from GDB
-       m_gdbStream << "break _start" << endl; // C entry point - after main libraries have been loaded
-       m_gdbStream << "set args" << argumentsString << endl;
-       m_gdbStream << "run" << endl; // run until we hit it, and therefore Qt shared libraries are loaded
-       m_gdbStream << "sharedlibrary libdl" << endl; // load the libdl library so that we can call __dlopen()
-       m_gdbStream << "sharedlibrary libc" << endl;  // load the libc library so that we can call __dlopen()
-       m_gdbStream << "sharedlibrary libQtCore" << endl; // load QtCore for breaking on QCoreApplication::exec()
-       m_gdbStream << "break QCoreApplication::exec()" << endl; // now, we can set this breakpoint...
-       m_gdbStream << "continue" << endl;
-
-       // Newer systems
-       m_gdbStream << QString("call dlopen(\"%1\", %2)").arg(libraryPath()).arg(QString::number(RTLD_NOW)) << endl; // load our library
-       // Older systems
-       m_gdbStream << QString("call __dlopen(\"%1\", %2)").arg(libraryPath()).arg(QString::number(RTLD_NOW)) << endl; // load our library
-
-       m_gdbStream << "sharedlibrary injectedHooq" << endl; // load the hooq injector library so that we can call startHooq()
-       m_gdbStream << "call startHooq()" << endl; // install our plugin (which required QCoreApplication setup)
-       m_gdbStream << "continue" << endl; // run the app
-       m_gdbStream << "backtrace" << endl; // just in case (use with --spam)
-       m_gdbStream << "quit" << endl; // after the application has exited, quit gdb
+        m_gdbStream << "set breakpoint pending on" << endl;
+        m_gdbStream << "set auto-solib-add off" << endl; // avoid loading symbols for shared libraries
+                                                         // that we do not need to interact with from GDB
+        m_gdbStream << "break _start" << endl; // C entry point - after main libraries have been loaded
+        m_gdbStream << "set args" << argumentsString << endl;
+        m_gdbStream << "run" << endl; // run until we hit it, and therefore Qt shared libraries are loaded
+        m_gdbStream << "sharedlibrary libdl" << endl; // load the libdl library so that we can call __dlopen()
+        m_gdbStream << "sharedlibrary libc" << endl;  // load the libc library so that we can call __dlopen()
+        //m_gdbStream << QString("call dlopen(\"/usr/lib64/libQtCore.so.4\",%1)").arg(QString::number(RTLD_NOW)) << endl;
+        // Newer systems
+        m_gdbStream << QString("call dlopen(\"%1\", %2)").arg(libraryPath()).arg(QString::number(RTLD_NOW)) << endl; // load our library
+        // Older systems
+        m_gdbStream << QString("call __dlopen(\"%1\", %2)").arg(libraryPath()).arg(QString::number(RTLD_NOW)) << endl; // load our library
+        m_gdbStream << "sharedlibrary libQtCore" << endl; // load QtCore for breaking on QCoreApplication::exec()
+        m_gdbStream << "sharedlibrary libQtGui" << endl; // load QtCore for breaking on QCoreApplication::exec()
+        m_gdbStream << "break QCoreApplication::exec" << endl; // now, we can set this breakpoint...
+        m_gdbStream << "continue" << endl;
+        m_gdbStream << "sharedlibrary injectedHooq" << endl; // load the hooq injector library so that we can call startHooq()
+        m_gdbStream << "call startHooq()" << endl; // install our plugin (which required QCoreApplication setup)
+        m_gdbStream << "continue" << endl; // run the app
+        m_gdbStream << "backtrace" << endl; // just in case (use with --spam)
+        m_gdbStream << "quit" << endl; // after the application has exited, quit gdb
}

void GdbInjector::attach(Q_PID processId)

Now, you also make *sure* that your have the Qt library debug symbols installed on your system. I had to do:

sudo apt-get install libqt4-dbg

and then recompile both my app and hooq for it to work.

Then it just worked, and hooq recorded events, and so on. Whether this system works to my full satisfaction remains to be seen.

So, remember to tick that “modal” property in qtcreator/designer.

Sigh.

Sigh.

Luckily it works with a key formated under Linux, using the mtools like this:

mformat -F -v PVR z:


This is with two partitions; /dev/sdb and /dev/sdb1, where z: points to /dev/sdb.

Oh, and my serial number starts with 5753 – it seems there is a big change at around 5801.

I got some good information on ESC/POS here and also here.

Turns out, that ESC/POS has a number of commands to print bitmaps. I ended up using the GS * command, which defines a bitmap, and then, the GS / command, which can print it.

Here is some example Qt/C++ code, that loads an image, and creates a QByteArray containing the bytes needed to do a GS * command. Even if you do not use Qt, the code should be so straightforward, that you should be able to get it working with other libs/languages quite easily.

// C++
#include <iostream>
#include <iomanip>
#include <vector>

// Qt
#include <QCoreApplication>
#include <QImage>

using namespace std;

class ESCPOSImage {
private:
    int m_width;
    int m_height;
    int m_gs_x;
    int m_gs_y;
    int m_gs_k;
    // Actual bytes for image - could have used QByteArray for this, I guess.
    vector <unsigned char> m_bytes;

    // This turns on a pixel a position x, y as you would expect. 
    // The bytes in the bitmap is stored in a weird "y first", "x second" order.
    // The bit fiddling here takes care of it.
    void setPixel( int x, int y ) {
        size_t byte_index = x * m_gs_y + y / 8;
        int bit_no = y % 8;
        // Swap msb/lsb order. This probably only works on machines with "normal" endianess.....
        unsigned char bit = 1 << ( 7 - bit_no );
        m_bytes.at( byte_index ) = m_bytes.at( byte_index ) | bit;
    }

public:
    ESCPOSImage( const QImage & image ) {
        // Set up x and y as pr. epson manual
        m_width = image.width();
        m_height = image.height();

        m_gs_x = m_width / 8 + (m_width % 8 != 0?1:0);
        m_gs_y = m_height / 8 + (m_height % 8 != 0?1:0);
        
         if ( m_gs_x > 255 || m_gs_y > 255 ) {
            // You may want to write an error message here
            throw "Too large on dimension"; 
        }

        m_gs_k = m_gs_x * m_gs_y * 8;
        // Bit unsure about this limit. It depends on the actual printer....
        if ( m_gs_k > (3072*8) ) {
            // You may want to write an error message here
            throw "Too large on area"; 
        }

        vector<unsigned char> bytes( m_gs_k, 0 ); // Blank all bytes.
        m_bytes = bytes;
        
        // Iterate over the image, turn on any pixels that are set in the monochromo image.
        for ( int i_y = 0; i_y < m_height; ++i_y ) {
            for ( int i_x = 0; i_x < m_width; ++i_x ) {
                if ( image.pixelIndex( i_x, i_y ) == Qt::color1 ) {
                    setPixel( i_x, i_y );
                }
            }
        }
    }

    // Access internal representation. Should be const something, I guess.
    vector<unsigned char> & getBytes() {
        return m_bytes;
    }

    // Bytes suitable to send to the printer to define the bitmap.
    QByteArray getGSStar() {
        QByteArray res( m_bytes.size() + 4, 0 );
        res[0] = 29;
        res[1] = '*';
        res[2] = (unsigned char) m_gs_x;
        res[3] = (unsigned char) m_gs_y;
        for ( size_t i = 0; i < m_bytes.size(); ++i ) {
            res[ 4 + i ] = m_bytes.at( i );
        }
        return res;
    };

};

int main( int argc, char ** argv ) {
    // Note, that exception code is not handled here!
    // If you get weird errors, try putting in an exception handler around the body of main.

    // Fire up Qt.
    QCoreApplication app( argc, argv );
 
    // Assume the user was friendly enough to pass the name of an image, load it.
    QImage orgImage( argv[1] );
    if ( orgImage.isNull() ) {
        cerr << "Unable to load image" << endl;
        return 1;
    }

    // Convert to monochrome. The conversion done by Qt is a bit bad. So probably a good idea to be monochrome already...
    QImage monoImage = orgImage.convertToFormat( QImage::Format_Mono, Qt::MonoOnly );
    if ( monoImage.isNull() ) {
        cerr << "Unable to convert image to monochrome" << endl;
        return 1;
    }

    // Create the ESCPOS image representation, get the bytes that represents the GS Star command, and dump the raw bytes to stdout.
    ESCPOSImage posImage( monoImage );
    QByteArray ar = posImage.getGSStar();
    for ( int i = 0; i < ar.size(); ++i ) {
        cout << (unsigned char) ar[i];
    }
    cout << "\n"; // This may not be needed, actually.

    // Do a GS / to actually output the bitmap.
    cout << (unsigned char) 29 << "/" << (unsigned char) 0 << "\n";
    
    return 0;
}

If you are running linux, you want to do something like:


g++ -L/usr/lib -lQtSql -lQtGui -lQtCore -lpthread -g -Wall -W -D_REENTRANT -DQT_SQL_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED -I/usr/share/qt4/mkspecs/linux-g++ -I. -I/usr/include/qt4/QtCore -I/usr/include/qt4/QtGui -I/usr/include/qt4/QtSql -I/usr/include/qt4 -I. -I. -o test-bitmap test-bitmap.cc


and then, something like


./test-bitmap some-image.png > /dev/usblp0


and you should be set.

Its probably pretty OEM. The only markings it have is POS 104, and possibly PRP-085IIIT and then, perhaps, full name is: PRP-085IIIT-BI-B-UP.

I needed it to print the danish letters. Took me pretty long to figure out that I needed it to go away from two byte character mode (FS .), and use ESC t 6 to select “Western Europe” aka Latin1. Then it prints Latin1 happily.

Small shell script to configure for this (values are octal)

echo -n "\0034.\0033t\0006"

Hex:
1c 2e 1b 74 06

Just wanted to share here, in case anyone else gets such a POS printer.

There is a good reason for this, in the Qt source:

QByteArray qMakeOraDate(const QDateTime& dt)
{
QByteArray ba;
ba.resize(7);
int year = dt.date().year();
ba[0]= (year / 100) + 100; // century
ba[1]= (year % 100) + 100; // year
ba[2]= dt.date().month();
ba[3]= dt.date().day();
ba[4]= dt.time().hour() + 1;
ba[5]= dt.time().minute() + 1;
ba[6]= dt.time().second() + 1;
return ba;
}

Basically Qt treats all QDateTime as DATE, TIME or DATETIME values, and does not transfer the fractional seconds.
So, you have to figure out some other way… as I do as well…

ffmpeg -i input.mpeg -vcodec libxvid -s 320x240 -b 528000 -aspect 4:3 -r 20 -vtag XVID -acodec mp2 -ab 128000 output.avi

The key would seem to be -vcodec libxvid AND -vtag XVID.

Its a sucky player, but whatever it takes to make the kid happy…

Turns out that the file $HOME/.kde/share/apps/konqueror/closeditems_saved was corrupted. Deleting this file fixed everything up.

Now, I really look forward to a new release that fixes the krunner problems and adds dbus functionality to konsole. Then perhaps at some point, an inclusion in ubuntu of the kpilot and a finished akonadi. Then we are about where kde 3.5.9 was when I left it. Especially if I get the apt: io slave back. Sorely missing that one, I am.