Make it possible to have callbacks for replies to calls.

21 files changed, 616 insertions, 146 deletions

diff --git a/kde/gen/callbacks_generated.c b/kde/gen/callbacks_generated.c
new file mode 100644
index 0000000..c72455d
--- /dev/null
+++ b/kde/gen/callbacks_generated.c
@@ -0,0 +1,287 @@
+int dapi_callbackInit( DapiConnection* conn, dapi_Init_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandInit( conn );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_INIT;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackCapabilities( DapiConnection* conn, dapi_Capabilities_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandCapabilities( conn );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_CAPABILITIES;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackOpenUrl( DapiConnection* conn, const char* url, dapi_OpenUrl_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandOpenUrl( conn, url );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_OPENURL;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackExecuteUrl( DapiConnection* conn, const char* url, dapi_ExecuteUrl_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandExecuteUrl( conn, url );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_EXECUTEURL;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackButtonOrder( DapiConnection* conn, dapi_ButtonOrder_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandButtonOrder( conn );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_BUTTONORDER;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackRunAsUser( DapiConnection* conn, const char* user, const char* command,
+    dapi_RunAsUser_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandRunAsUser( conn, user, command );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_RUNASUSER;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackSuspendScreensaving( DapiConnection* conn, int suspend, dapi_SuspendScreensaving_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandSuspendScreensaving( conn, suspend );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_SUSPENDSCREENSAVING;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackMailTo( DapiConnection* conn, const char* subject, const char* body,
+    const char* to, const char* cc, const char* bcc, stringarr attachments, dapi_MailTo_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandMailTo( conn, subject, body, to, cc, bcc, attachments );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_MAILTO;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackLocalFile( DapiConnection* conn, const char* remote, const char* local,
+    int allow_download, dapi_LocalFile_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandLocalFile( conn, remote, local, allow_download );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_LOCALFILE;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackUploadFile( DapiConnection* conn, const char* local, const char* file,
+    int remove_local, dapi_UploadFile_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandUploadFile( conn, local, file, remove_local );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_UPLOADFILE;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+int dapi_callbackRemoveTemporaryLocalFile( DapiConnection* conn, const char* local,
+    dapi_RemoveTemporaryLocalFile_callback callback )
+    {
+    int seq;
+    DapiCallbackData* call;
+    seq = dapi_writeCommandRemoveTemporaryLocalFile( conn, local );
+    if( seq == 0 )
+        return 0;
+    call = malloc( sizeof( *call ));
+    if( call == NULL )
+        return 0;
+    call->seq = seq;
+    call->callback = callback;
+    call->command = DAPI_COMMAND_REMOVETEMPORARYLOCALFILE;
+    call->next = conn->callbacks;
+    conn->callbacks = call;
+    return seq;
+    }
+
+static void genericCallbackDispatch( DapiConnection* conn, DapiCallbackData* data, int command, int seq )
+    {
+    switch( command )
+        {
+        case DAPI_REPLY_INIT:
+            {
+            int ok;
+            dapi_readReplyInit( conn, &ok );
+            (( dapi_Init_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_CAPABILITIES:
+            {
+            intarr capabitilies;
+            int ok;
+            dapi_readReplyCapabilities( conn, &capabitilies, &ok );
+            (( dapi_Capabilities_callback ) data->callback )( conn, data->seq, capabitilies, ok );
+            break;
+            }
+        case DAPI_REPLY_OPENURL:
+            {
+            int ok;
+            dapi_readReplyOpenUrl( conn, &ok );
+            (( dapi_OpenUrl_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_EXECUTEURL:
+            {
+            int ok;
+            dapi_readReplyExecuteUrl( conn, &ok );
+            (( dapi_ExecuteUrl_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_BUTTONORDER:
+            {
+            int order;
+            dapi_readReplyButtonOrder( conn, &order );
+            (( dapi_ButtonOrder_callback ) data->callback )( conn, data->seq, order );
+            break;
+            }
+        case DAPI_REPLY_RUNASUSER:
+            {
+            int ok;
+            dapi_readReplyRunAsUser( conn, &ok );
+            (( dapi_RunAsUser_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_SUSPENDSCREENSAVING:
+            {
+            int ok;
+            dapi_readReplySuspendScreensaving( conn, &ok );
+            (( dapi_SuspendScreensaving_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_MAILTO:
+            {
+            int ok;
+            dapi_readReplyMailTo( conn, &ok );
+            (( dapi_MailTo_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_LOCALFILE:
+            {
+            char* result;
+            dapi_readReplyLocalFile( conn, &result );
+            (( dapi_LocalFile_callback ) data->callback )( conn, data->seq, result );
+            break;
+            }
+        case DAPI_REPLY_UPLOADFILE:
+            {
+            int ok;
+            dapi_readReplyUploadFile( conn, &ok );
+            (( dapi_UploadFile_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        case DAPI_REPLY_REMOVETEMPORARYLOCALFILE:
+            {
+            int ok;
+            dapi_readReplyRemoveTemporaryLocalFile( conn, &ok );
+            (( dapi_RemoveTemporaryLocalFile_callback ) data->callback )( conn, data->seq, ok );
+            break;
+            }
+        }
+    }
diff --git a/kde/gen/callbacks_generated.h b/kde/gen/callbacks_generated.h
new file mode 100644
index 0000000..06c37ce
--- /dev/null
+++ b/kde/gen/callbacks_generated.h
@@ -0,0 +1,30 @@
+typedef void( * dapi_Init_callback )( DapiConnection* conn, int seq, int ok );
+int dapi_callbackInit( DapiConnection* conn, dapi_Init_callback callback );
+typedef void( * dapi_Capabilities_callback )( DapiConnection* conn, int seq, intarr capabitilies,
+    int ok );
+int dapi_callbackCapabilities( DapiConnection* conn, dapi_Capabilities_callback callback );
+typedef void( * dapi_OpenUrl_callback )( DapiConnection* conn, int seq, int ok );
+int dapi_callbackOpenUrl( DapiConnection* conn, const char* url, dapi_OpenUrl_callback callback );
+typedef void( * dapi_ExecuteUrl_callback )( DapiConnection* conn, int seq, int ok );
+int dapi_callbackExecuteUrl( DapiConnection* conn, const char* url, dapi_ExecuteUrl_callback callback );
+typedef void( * dapi_ButtonOrder_callback )( DapiConnection* conn, int seq, int order );
+int dapi_callbackButtonOrder( DapiConnection* conn, dapi_ButtonOrder_callback callback );
+typedef void( * dapi_RunAsUser_callback )( DapiConnection* conn, int seq, int ok );
+int dapi_callbackRunAsUser( DapiConnection* conn, const char* user, const char* command,
+    dapi_RunAsUser_callback callback );
+typedef void( * dapi_SuspendScreensaving_callback )( DapiConnection* conn, int seq,
+    int ok );
+int dapi_callbackSuspendScreensaving( DapiConnection* conn, int suspend, dapi_SuspendScreensaving_callback callback );
+typedef void( * dapi_MailTo_callback )( DapiConnection* conn, int seq, int ok );
+int dapi_callbackMailTo( DapiConnection* conn, const char* subject, const char* body,
+    const char* to, const char* cc, const char* bcc, stringarr attachments, dapi_MailTo_callback callback );
+typedef void( * dapi_LocalFile_callback )( DapiConnection* conn, int seq, const char* result );
+int dapi_callbackLocalFile( DapiConnection* conn, const char* remote, const char* local,
+    int allow_download, dapi_LocalFile_callback callback );
+typedef void( * dapi_UploadFile_callback )( DapiConnection* conn, int seq, int ok );
+int dapi_callbackUploadFile( DapiConnection* conn, const char* local, const char* file,
+    int remove_local, dapi_UploadFile_callback callback );
+typedef void( * dapi_RemoveTemporaryLocalFile_callback )( DapiConnection* conn, int seq,
+    int ok );
+int dapi_callbackRemoveTemporaryLocalFile( DapiConnection* conn, const char* local,
+    dapi_RemoveTemporaryLocalFile_callback callback );
diff --git a/kde/gen/calls_generated.c b/kde/gen/calls_generated.c
index 704b76d..4146768 100644
--- a/kde/gen/calls_generated.c
+++ b/kde/gen/calls_generated.c
@@ -1,11 +1,6 @@
 int dapi_Init( DapiConnection* conn )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandInit( conn );
     if( seq == 0 )
@@ -17,7 +12,7 @@ int dapi_Init( DapiConnection* conn )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_INIT )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyInit( conn, &ret ))
         return 0;
@@ -27,11 +22,6 @@ int dapi_Init( DapiConnection* conn )
 int dapi_Capabilities( DapiConnection* conn, intarr* capabitilies )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandCapabilities( conn );
     if( seq == 0 )
@@ -43,7 +33,7 @@ int dapi_Capabilities( DapiConnection* conn, intarr* capabitilies )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_CAPABILITIES )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyCapabilities( conn, capabitilies, &ret ))
         return 0;
@@ -53,11 +43,6 @@ int dapi_Capabilities( DapiConnection* conn, intarr* capabitilies )
 int dapi_OpenUrl( DapiConnection* conn, const char* url )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandOpenUrl( conn, url );
     if( seq == 0 )
@@ -69,7 +54,7 @@ int dapi_OpenUrl( DapiConnection* conn, const char* url )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_OPENURL )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyOpenUrl( conn, &ret ))
         return 0;
@@ -79,11 +64,6 @@ int dapi_OpenUrl( DapiConnection* conn, const char* url )
 int dapi_ExecuteUrl( DapiConnection* conn, const char* url )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandExecuteUrl( conn, url );
     if( seq == 0 )
@@ -95,7 +75,7 @@ int dapi_ExecuteUrl( DapiConnection* conn, const char* url )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_EXECUTEURL )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyExecuteUrl( conn, &ret ))
         return 0;
@@ -105,11 +85,6 @@ int dapi_ExecuteUrl( DapiConnection* conn, const char* url )
 int dapi_ButtonOrder( DapiConnection* conn )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandButtonOrder( conn );
     if( seq == 0 )
@@ -121,7 +96,7 @@ int dapi_ButtonOrder( DapiConnection* conn )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_BUTTONORDER )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyButtonOrder( conn, &ret ))
         return 0;
@@ -131,11 +106,6 @@ int dapi_ButtonOrder( DapiConnection* conn )
 int dapi_RunAsUser( DapiConnection* conn, const char* user, const char* command )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandRunAsUser( conn, user, command );
     if( seq == 0 )
@@ -147,7 +117,7 @@ int dapi_RunAsUser( DapiConnection* conn, const char* user, const char* command
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_RUNASUSER )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyRunAsUser( conn, &ret ))
         return 0;
@@ -157,11 +127,6 @@ int dapi_RunAsUser( DapiConnection* conn, const char* user, const char* command
 int dapi_SuspendScreensaving( DapiConnection* conn, int suspend )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandSuspendScreensaving( conn, suspend );
     if( seq == 0 )
@@ -173,7 +138,7 @@ int dapi_SuspendScreensaving( DapiConnection* conn, int suspend )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_SUSPENDSCREENSAVING )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplySuspendScreensaving( conn, &ret ))
         return 0;
@@ -184,11 +149,6 @@ int dapi_MailTo( DapiConnection* conn, const char* subject, const char* body, co
     const char* cc, const char* bcc, stringarr attachments )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandMailTo( conn, subject, body, to, cc, bcc, attachments );
     if( seq == 0 )
@@ -200,7 +160,7 @@ int dapi_MailTo( DapiConnection* conn, const char* subject, const char* body, co
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_MAILTO )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyMailTo( conn, &ret ))
         return 0;
@@ -211,11 +171,6 @@ char* dapi_LocalFile( DapiConnection* conn, const char* remote, const char* loca
     int allow_download )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     char* ret;
     seq = dapi_writeCommandLocalFile( conn, remote, local, allow_download );
     if( seq == 0 )
@@ -227,7 +182,7 @@ char* dapi_LocalFile( DapiConnection* conn, const char* remote, const char* loca
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_LOCALFILE )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyLocalFile( conn, &ret ))
         return 0;
@@ -242,11 +197,6 @@ char* dapi_LocalFile( DapiConnection* conn, const char* remote, const char* loca
 int dapi_UploadFile( DapiConnection* conn, const char* local, const char* file, int remove_local )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandUploadFile( conn, local, file, remove_local );
     if( seq == 0 )
@@ -258,7 +208,7 @@ int dapi_UploadFile( DapiConnection* conn, const char* local, const char* file,
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_UPLOADFILE )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyUploadFile( conn, &ret ))
         return 0;
@@ -268,11 +218,6 @@ int dapi_UploadFile( DapiConnection* conn, const char* local, const char* file,
 int dapi_RemoveTemporaryLocalFile( DapiConnection* conn, const char* local )
     {
     int seq;
-    if( conn->sync_callback == NULL )
-        {
-        fprintf( stderr, "DAPI sync callback not set!\n" );
-        abort();
-        }
     int ret;
     seq = dapi_writeCommandRemoveTemporaryLocalFile( conn, local );
     if( seq == 0 )
@@ -284,7 +229,7 @@ int dapi_RemoveTemporaryLocalFile( DapiConnection* conn, const char* local )
             return 0;
         if( seq2 == seq && comm == DAPI_REPLY_REMOVETEMPORARYLOCALFILE )
             break; /* --> */
-        conn->sync_callback( conn, comm, seq2 );
+        conn->generic_callback( conn, comm, seq2 );
         }
     if( !dapi_readReplyRemoveTemporaryLocalFile( conn, &ret ))
         return 0;
diff --git a/kde/gen/gen.cpp b/kde/gen/gen.cpp
index c255b6e..b1044a7 100644
--- a/kde/gen/gen.cpp
+++ b/kde/gen/gen.cpp
@@ -34,7 +34,11 @@ struct Arg
 
 typedef QValueList< Arg > ArgList;
 
-enum FunctionType { ReadCommand, WriteCommand, ReadReply, WriteReply, HighLevel };
+enum FunctionType
+    {
+    ReadCommand, WriteCommand, ReadReply, WriteReply,
+    HighLevel, HighLevelCallback, Callback
+    };
 
 struct Function
     {
@@ -182,26 +186,40 @@ void Function::generateC( QTextStream& stream, int indent, FunctionType type ) c
     {
     QString line;
     line += makeIndent( indent );
+    if( type == Callback )
+        line += "typedef ";
     if( type == HighLevel )
         {
         QString rettype = returnType();
         line += Arg::cType( rettype, true );
         }
     else
-        line += type != WriteReply ? "int" : "void";
+        line += type != WriteReply && type != Callback ? "int" : "void";
+    if( type == Callback )
+        line += "( *";
     line += " dapi_";
-    if( type != HighLevel )
+    if( type == HighLevel || type == Callback )
+        ; // nothing
+    else if( type == HighLevelCallback )
+        line += "callback";
+    else
         {
         line += type == ReadCommand || type == ReadReply ? "read" : "write";
         line += type == ReadCommand || type == WriteCommand ? "Command" : "Reply";
         }
     line += name;
+    if( type == Callback )
+        line += "_callback )";
     line += "( DapiConnection* conn";
-    if( type == WriteReply )
+    if( type == WriteReply || type == Callback )
         line += ", int seq";
     ArgList args2;
     if( type == HighLevel )
         args2 = Arg::stripReturnArgument( args );
+    else if( type == HighLevelCallback )
+        args2 = Arg::stripOutArguments( args );
+    else if( type == Callback )
+        args2 = Arg::stripNonOutArguments( args );
     else if( type == ReadReply || type == WriteReply )
         args2 = Arg::stripNonOutArguments( args );
     else
@@ -225,6 +243,17 @@ void Function::generateC( QTextStream& stream, int indent, FunctionType type ) c
             line += "*";
         line += " " + arg.name;
         }
+    if( type == HighLevelCallback )
+        {
+        if( line.length() > 80 )
+            {
+            stream << line << ",\n";
+            line = makeIndent( indent + 4 );
+            }
+        else
+            line += ", ";
+        line += "dapi_" + name + "_callback callback";
+        }
     line += " )";
     stream << line;
     }
@@ -515,12 +544,7 @@ void generateSharedCallsC()
         QString rettype = function.returnType();
         function.generateC( stream, 0, HighLevel );
         stream << "\n    {\n"
-               << "    int seq;\n"
-               << "    if( conn->sync_callback == NULL )\n"
-               << "        {\n"
-               << "        fprintf( stderr, \"DAPI sync callback not set!\\n\" );\n"
-               << "        abort();\n"
-               << "        }\n";
+               << "    int seq;\n";
         stream << "    " << Arg::cType( rettype, true ) << " ret;\n";
         stream << "    seq = dapi_writeCommand" << function.name << "( conn";
         ArgList args = Arg::stripReturnArgument( function.args );
@@ -542,7 +566,7 @@ void generateSharedCallsC()
                << "            return 0;\n"
                << "        if( seq2 == seq && comm == DAPI_REPLY_" << function.name.upper() << " )\n"
                << "            break; /* --> */\n"
-               << "        conn->sync_callback( conn, comm, seq2 );\n"
+               << "        conn->generic_callback( conn, comm, seq2 );\n"
                << "        }\n"
                << "    if( !dapi_readReply" << function.name << "( conn";
         ArgList args2 = Arg::stripNonOutArguments( function.args );
@@ -572,12 +596,118 @@ void generateSharedCallsC()
         }
     }
 
+void generateSharedCallbacksH()
+    {
+    QFile file( "callbacks_generated.h" );
+    if( !file.open( IO_WriteOnly ))
+        error();
+    QTextStream stream( &file );
+    for( QValueList< Function >::ConstIterator it = functions.begin();
+         it != functions.end();
+         ++it )
+        {
+        const Function& function = *it;
+        function.generateC( stream, 0, Callback );
+        stream << ";\n";
+        function.generateC( stream, 0, HighLevelCallback );
+        stream << ";\n";
+        }
+    }
+
+void generateSharedCallbacksC()
+    {
+    QFile file( "callbacks_generated.c" );
+    if( !file.open( IO_WriteOnly ))
+        error();
+    QTextStream stream( &file );
+    for( QValueList< Function >::ConstIterator it = functions.begin();
+         it != functions.end();
+         ++it )
+        {
+        const Function& function = *it;
+        function.generateC( stream, 0, HighLevelCallback );
+        stream << "\n"
+               << "    {\n"
+               << "    int seq;\n"
+               << "    DapiCallbackData* call;\n"
+               << "    seq = dapi_writeCommand" << function.name << "( conn";
+        ArgList args2 = Arg::stripOutArguments( function.args );
+        for( ArgList::ConstIterator it = args2.begin();
+             it != args2.end();
+             ++it )
+            {
+            const Arg& arg = *it;
+            stream << ", " << arg.name;
+            }
+        stream << " );\n";
+        stream << "    if( seq == 0 )\n"
+               << "        return 0;\n"
+               << "    call = malloc( sizeof( *call ));\n"
+               << "    if( call == NULL )\n"
+               << "        return 0;\n"
+               << "    call->seq = seq;\n"
+               << "    call->callback = callback;\n"
+               << "    call->command = DAPI_COMMAND_" << function.name.upper() << ";\n"
+               << "    call->next = conn->callbacks;\n"
+               << "    conn->callbacks = call;\n"
+               << "    return seq;\n"
+               << "    }\n\n";
+        }
+    stream << "static void genericCallbackDispatch( DapiConnection* conn, DapiCallbackData* data, int command, int seq )\n"
+           << "    {\n"
+           << "    switch( command )\n"
+           << "        {\n";
+    for( QValueList< Function >::ConstIterator it = functions.begin();
+         it != functions.end();
+         ++it )
+        {
+        const Function& function = *it;
+        stream << "        case DAPI_REPLY_" << function.name.upper() << ":\n"
+               << "            {\n";
+        ArgList args = Arg::stripNonOutArguments( function.args );
+        for( ArgList::ConstIterator it = args.begin();
+             it != args.end();
+             ++it )
+            {
+            const Arg& arg = *it;
+            stream << makeIndent( 12 ) << arg.cType( true ) << " " << arg.name << ";\n";
+            }
+        // TODO check that command "matches" data->command? i.e. that the reply matches the expected reply
+        // for the sent command
+        stream << makeIndent( 12 ) << "dapi_readReply" << function.name << "( conn";
+        for( ArgList::ConstIterator it = args.begin();
+             it != args.end();
+             ++it )
+            {
+            const Arg& arg = *it;
+            stream << ", &" << arg.name;
+            }
+        stream << " );\n"
+               << makeIndent( 12 ) << "(( dapi_" << function.name << "_callback ) data->callback )( conn, data->seq";
+        for( ArgList::ConstIterator it = args.begin();
+             it != args.end();
+             ++it )
+            {
+            const Arg& arg = *it;
+            stream << ", " << arg.name;
+            }
+        // TODO tady cleanup, stejne jako u calls.c - udelat nejak genericky
+        stream << " );\n"
+               << makeIndent( 12 ) << "break;\n"
+               << makeIndent( 12 ) << "}\n";
+        }
+    stream << "        }\n"
+           << "    }\n";
+    }
+
 void generateShared()
     {
     generateSharedCommH();
     generateSharedCommC();
     generateSharedCallsH();
     generateSharedCallsC();
+    generateSharedCallbacksH();
+    generateSharedCallbacksC();
     }
 
 void generate()
diff --git a/lib/Makefile.am b/lib/Makefile.am
index 11730b0..4fdd479 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -1,6 +1,6 @@
 lib_LTLIBRARIES = libdapi.la
 
-libdapi_la_SOURCES = comm.c utils.c calls.c
+libdapi_la_SOURCES = comm.c utils.c calls.c callbacks.c
 libdapi_la_LIBADD =
 libdapi_la_LDFLAGS = $(all_libraries) -no-undefined
 
diff --git a/lib/callbacks.c b/lib/callbacks.c
new file mode 100644
index 0000000..54be2ad
--- /dev/null
+++ b/lib/callbacks.c
@@ -0,0 +1,50 @@
+#include "callbacks.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "comm_internal.h"
+
+#include "../kde/gen/callbacks_generated.c"
+
+DapiGenericCallback dapi_setGenericCallback( DapiConnection* conn, DapiGenericCallback callback )
+    {
+    DapiGenericCallback ret = conn->generic_callback;
+    conn->generic_callback = callback;
+    return ret;
+    }
+
+void dapi_processCallbacks( DapiConnection* conn )
+    {
+    while( dapi_hasData( conn ))
+        {
+        int command;
+        int seq;
+        if( !dapi_readCommand( conn, &command, &seq ))
+            return; /* TODO error-handling? */
+        conn->generic_callback( conn, command, seq );
+        }
+    }
+
+void dapi_genericCallback( DapiConnection* conn, int command, int seq )
+    {
+    DapiCallbackData* pos;
+    DapiCallbackData* prev = NULL;
+    for( pos = conn->callbacks;
+         pos != NULL;
+         prev = pos, pos = pos->next )
+        {
+        if( pos->seq == seq )
+            {
+            if( pos->callback != NULL )
+                genericCallbackDispatch( conn, pos, command, seq );
+            if( prev != NULL )
+                prev = pos->next;
+            else
+                conn->callbacks = pos->next;
+            free( pos );
+            return;
+            }
+        }
+/* TODO handle unhandled */
+    }
diff --git a/lib/callbacks.h b/lib/callbacks.h
new file mode 100644
index 0000000..2342fd7
--- /dev/null
+++ b/lib/callbacks.h
@@ -0,0 +1,24 @@
+#ifndef DAPI_CALLBACKS_H
+#define DAPI_CALLBACKS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "comm.h"
+
+#include "../kde/gen/callbacks_generated.h"
+
+typedef void (*DapiGenericCallback)( DapiConnection* conn, int command, int seq );
+
+DapiGenericCallback dapi_setGenericCallback( DapiConnection* conn, DapiGenericCallback callback );
+
+void dapi_processCallbacks( DapiConnection* conn );
+
+void dapi_genericCallback( DapiConnection* conn, int command, int seq );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/calls.c b/lib/calls.c
index cea41b2..a86c309 100644
--- a/lib/calls.c
+++ b/lib/calls.c
@@ -7,8 +7,3 @@
 #include "comm_internal.h"
 
 #include "../kde/gen/calls_generated.c"
-
-void dapi_setSyncCallback( DapiConnection* conn, DapiSyncCallback callback )
-    {
-    conn->sync_callback = callback;
-    }
diff --git a/lib/calls.h b/lib/calls.h
index f2d4606..296bb0a 100644
--- a/lib/calls.h
+++ b/lib/calls.h
@@ -9,10 +9,6 @@ extern "C" {
 
 #include "../kde/gen/calls_generated.h"
 
-typedef void (*DapiSyncCallback)( DapiConnection* conn, int command, int seq );
-
-void dapi_setSyncCallback( DapiConnection* conn, DapiSyncCallback callback );
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/comm.c b/lib/comm.c
index 227031a..b09caff 100644
--- a/lib/comm.c
+++ b/lib/comm.c
@@ -12,6 +12,7 @@
 #include <unistd.h>
 
 #include "comm_internal.h"
+#include "callbacks.h"
 
 static void getDisplay( char* ret, int max )
     {
@@ -66,9 +67,10 @@ DapiConnection* dapi_connect()
     if( ret != NULL )
         {
         ret->sock = sock;
-        ret->sync_callback = NULL;
+        ret->generic_callback = dapi_genericCallback;
         ret->in_server = 0;
         ret->last_seq = 0;
+        ret->callbacks = NULL;
         }
     return ret;
     }
@@ -171,9 +173,10 @@ DapiConnection* dapi_acceptSocket( int sock )
         if( ret != NULL )
             {
             ret->sock = sock2;
-            ret->sync_callback = NULL;
+            ret->generic_callback = dapi_genericCallback;
             ret->in_server = 1;
             ret->last_seq = 0;
+            ret->callbacks = NULL;
             }
         else
             close( sock2 );
@@ -186,6 +189,17 @@ void dapi_close( DapiConnection* conn )
     close( conn->sock );
     }
 
+int dapi_hasData( DapiConnection* conn )
+    {
+    fd_set fd;
+    struct timeval tm = { 0, 0 };
+    FD_ZERO( &fd );
+    FD_SET( conn->sock, &fd );
+    if( select( conn->sock + 1, &fd, NULL, NULL, &tm ) > 0 )
+        return FD_ISSET( conn->sock, &fd );
+    return 0;
+    }
+
 static int getNextSeq( DapiConnection* conn )
     {
     if( ++conn->last_seq == 0 ) // 0 means invalid
diff --git a/lib/comm_internal.h b/lib/comm_internal.h
index a321d5e..c509d41 100644
--- a/lib/comm_internal.h
+++ b/lib/comm_internal.h
@@ -3,11 +3,23 @@ enum { MAGIC = 0x152355 };
 #include "../kde/gen/comm_internal_generated.h"
 
 #include "calls.h"
+#include "callbacks.h"
+
+typedef struct DapiCallbackData
+    {
+    struct DapiCallbackData* next;
+    int seq;
+    int command;
+    void* callback;
+    } DapiCallbackData;
 
 struct DapiConnection
     {
     int sock;
-    DapiSyncCallback sync_callback;
+    DapiGenericCallback generic_callback;
     int in_server;
     int last_seq;
+    DapiCallbackData* callbacks;
     };
+
+int dapi_hasData( DapiConnection* conn );
diff --git a/tests/.cvsignore b/tests/.cvsignore
index bf9eac1..aa94b38 100644
--- a/tests/.cvsignore
+++ b/tests/.cvsignore
@@ -10,3 +10,4 @@ test_remotefile
 test_runasuser
 test_screensaving
 test_capabilities
+test_callbacks
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 9bc482f..897bafb 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -1,5 +1,5 @@
 bin_PROGRAMS = test_comm test_calls test_runasuser test_screensaving test_mailto test_remotefile test_async \
-    test_capabilities
+    test_capabilities test_callbacks
 
 test_comm_SOURCES = test_comm.c
 test_comm_LDADD = ../lib/libdapi.la
@@ -33,4 +33,8 @@ test_capabilities_SOURCES = test_capabilities.c
 test_capabilities_LDADD = ../lib/libdapi.la
 test_capabilities_LDFLAGS = $(all_libraries)
 
+test_callbacks_SOURCES = test_callbacks.c
+test_callbacks_LDADD = ../lib/libdapi.la
+test_callbacks_LDFLAGS = $(all_libraries)
+
 INCLUDES = $(all_includes) -I$(top_srcdir)/lib
diff --git a/tests/test_async.c b/tests/test_async.c
index b805e41..518d7f5 100644
--- a/tests/test_async.c
+++ b/tests/test_async.c
@@ -2,6 +2,7 @@
 
 #include "comm.h"
 #include "calls.h"
+#include "callbacks.h"
 
 static int seq1;
 
@@ -35,7 +36,7 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
+    dapi_setGenericCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );
diff --git a/tests/test_callbacks.c b/tests/test_callbacks.c
new file mode 100644
index 0000000..4847b36
--- /dev/null
+++ b/tests/test_callbacks.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <unistd.h>
+
+#include "comm.h"
+#include "calls.h"
+#include "callbacks.h"
+
+static void callback( DapiConnection* conn, int seq, int ord )
+    {
+    printf( "Order async: %d %d (%s)\n", seq, ord, ord == 0 ? "Failed" : ord == 1 ? "Ok/Cancel" : "Cancel/Ok" );
+    }
+
+int main()
+    {
+    int seq;
+    DapiConnection* conn = dapi_connect();
+    if( conn == NULL )
+        {
+        fprintf( stderr, "Cannot connect!\n" );
+        return 1;
+        }
+    if( !dapi_Init( conn ))
+        {
+        fprintf( stderr, "Initialization failed!\n" );
+        return 2;
+        }
+    seq = dapi_callbackButtonOrder( conn, callback );
+    printf( "Order call1: %d\n", seq );
+    seq = dapi_callbackButtonOrder( conn, callback );
+    printf( "Order call2: %d\n", seq );
+    sleep( 1 ); /* give time to process */
+    dapi_processCallbacks( conn );
+    dapi_close( conn );
+    return 0;
+    }
diff --git a/tests/test_calls.c b/tests/test_calls.c
index 50ccd2a..e4afd92 100644
--- a/tests/test_calls.c
+++ b/tests/test_calls.c
@@ -3,14 +3,6 @@
 #include "comm.h"
 #include "calls.h"
 
-static void callback( DapiConnection* a1, int a2, int a3 )
-    {
-    (void) a1;
-    (void) a2;
-    (void) a3;
-    fprintf( stderr, "Unexpected async reply, ignoring.\n" );
-    }
-
 int main()
     {
     int ord;
@@ -20,7 +12,6 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );
diff --git a/tests/test_capabilities.c b/tests/test_capabilities.c
index ba25efa..ded1a5a 100644
--- a/tests/test_capabilities.c
+++ b/tests/test_capabilities.c
@@ -4,14 +4,6 @@
 #include "comm.h"
 #include "calls.h"
 
-static void callback( DapiConnection* a1, int a2, int a3 )
-    {
-    (void) a1;
-    (void) a2;
-    (void) a3;
-    fprintf( stderr, "Unexpected async reply, ignoring.\n" );
-    }
-
 int main()
     {
     intarr capabilities;
@@ -22,7 +14,6 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );
diff --git a/tests/test_mailto.c b/tests/test_mailto.c
index a5eefcd..c0cb244 100644
--- a/tests/test_mailto.c
+++ b/tests/test_mailto.c
@@ -4,14 +4,6 @@
 #include "comm.h"
 #include "calls.h"
 
-static void callback( DapiConnection* a1, int a2, int a3 )
-    {
-    (void) a1;
-    (void) a2;
-    (void) a3;
-    fprintf( stderr, "Unexpected async reply, ignoring.\n" );
-    }
-
 int main()
     {
     int ok;
@@ -23,7 +15,6 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );
diff --git a/tests/test_remotefile.c b/tests/test_remotefile.c
index 750c4a0..56818f5 100644
--- a/tests/test_remotefile.c
+++ b/tests/test_remotefile.c
@@ -5,14 +5,6 @@
 #include "comm.h"
 #include "calls.h"
 
-static void callback( DapiConnection* a1, int a2, int a3 )
-    {
-    (void) a1;
-    (void) a2;
-    (void) a3;
-    fprintf( stderr, "Unexpected async reply, ignoring.\n" );
-    }
-
 int main()
     {
     char* local;
@@ -23,7 +15,6 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );
diff --git a/tests/test_runasuser.c b/tests/test_runasuser.c
index 3198a7e..2d37687 100644
--- a/tests/test_runasuser.c
+++ b/tests/test_runasuser.c
@@ -3,14 +3,6 @@
 #include "comm.h"
 #include "calls.h"
 
-static void callback( DapiConnection* a1, int a2, int a3 )
-    {
-    (void) a1;
-    (void) a2;
-    (void) a3;
-    fprintf( stderr, "Unexpected async reply, ignoring.\n" );
-    }
-
 int main()
     {
     int ok;
@@ -20,7 +12,6 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );
diff --git a/tests/test_screensaving.c b/tests/test_screensaving.c
index b74d49d..86fbb4c 100644
--- a/tests/test_screensaving.c
+++ b/tests/test_screensaving.c
@@ -4,14 +4,6 @@
 #include "comm.h"
 #include "calls.h"
 
-static void callback( DapiConnection* a1, int a2, int a3 )
-    {
-    (void) a1;
-    (void) a2;
-    (void) a3;
-    fprintf( stderr, "Unexpected async reply, ignoring.\n" );
-    }
-
 int main()
     {
     int ok;
@@ -21,7 +13,6 @@ int main()
         fprintf( stderr, "Cannot connect!\n" );
         return 1;
         }
-    dapi_setSyncCallback( conn, callback );
     if( !dapi_Init( conn ))
         {
         fprintf( stderr, "Initialization failed!\n" );