Index: gtk/gtkprinter.c
===================================================================
--- gtk/gtkprinter.c	(revision 21400)
+++ gtk/gtkprinter.c	(working copy)
@@ -1119,7 +1119,7 @@
 {
   GList *list, *node;
 
-  list = gtk_print_backend_get_printer_list (backend);
+  list = gtk_print_backend_get_printer_list (backend, FALSE);
 
   for (node = list; node != NULL; node = node->next)
     {
Index: gtk/gtk.symbols
===================================================================
--- gtk/gtk.symbols	(revision 21400)
+++ gtk/gtk.symbols	(working copy)
@@ -2720,6 +2720,7 @@
 gtk_print_backend_find_printer
 gtk_print_backend_print_stream
 gtk_print_backend_load_modules
+gtk_print_backend_get_wait_for_server
 #endif
 #endif
 #endif
Index: gtk/gtkprintbackend.c
===================================================================
--- gtk/gtkprintbackend.c	(revision 21400)
+++ gtk/gtkprintbackend.c	(working copy)
@@ -40,6 +40,8 @@
   GHashTable *printers;
   guint printer_list_requested : 1;
   guint printer_list_done : 1;
+  /* This flag indicates whether to wait for unavailable print server or not. */
+  gboolean wait_for_server;
 };
 
 enum {
@@ -366,6 +368,8 @@
   priv->printers = g_hash_table_new_full (g_str_hash, g_str_equal, 
 					  (GDestroyNotify) g_free,
 					  (GDestroyNotify) g_object_unref);
+
+  priv->wait_for_server = TRUE;
 }
 
 static void
@@ -499,7 +503,8 @@
 
 
 GList *
-gtk_print_backend_get_printer_list (GtkPrintBackend *backend)
+gtk_print_backend_get_printer_list (GtkPrintBackend *backend,
+                                    gboolean         wait_for_server)
 {
   GtkPrintBackendPrivate *priv;
   GList *result;
@@ -520,7 +525,9 @@
 	GTK_PRINT_BACKEND_GET_CLASS (backend)->request_printer_list (backend);
       priv->printer_list_requested = TRUE;
     }
-  
+
+  priv->wait_for_server = wait_for_server;
+
   return result;
 }
 
@@ -581,5 +588,16 @@
   g_object_run_dispose (G_OBJECT (print_backend));
 }
 
+gboolean gtk_print_backend_get_wait_for_server (GtkPrintBackend *print_backend)
+{
+  GtkPrintBackendPrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_PRINT_BACKEND (print_backend), TRUE);
+
+  priv = print_backend->priv;
+
+  return priv->wait_for_server;
+}
+
 #define __GTK_PRINT_BACKEND_C__
 #include "gtkaliasdef.c"
Index: gtk/gtkprintbackend.h
===================================================================
--- gtk/gtkprintbackend.h	(revision 21400)
+++ gtk/gtkprintbackend.h	(working copy)
@@ -125,7 +125,8 @@
 
 GType   gtk_print_backend_get_type       (void) G_GNUC_CONST;
 
-GList      *gtk_print_backend_get_printer_list     (GtkPrintBackend         *print_backend);
+GList      *gtk_print_backend_get_printer_list     (GtkPrintBackend         *print_backend,
+						    gboolean                 wait_for_server);
 gboolean    gtk_print_backend_printer_list_is_done (GtkPrintBackend         *print_backend);
 GtkPrinter *gtk_print_backend_find_printer         (GtkPrintBackend         *print_backend,
 						    const gchar             *printer_name);
@@ -137,6 +138,7 @@
 						    GDestroyNotify           dnotify);
 GList *     gtk_print_backend_load_modules         (void);
 void        gtk_print_backend_destroy              (GtkPrintBackend         *print_backend);
+gboolean    gtk_print_backend_get_wait_for_server  (GtkPrintBackend         *print_backend);
 
 /* Backend-only functions for GtkPrintBackend */
 
Index: gtk/gtkpagesetupunixdialog.c
===================================================================
--- gtk/gtkpagesetupunixdialog.c	(revision 21400)
+++ gtk/gtkpagesetupunixdialog.c	(working copy)
@@ -495,7 +495,7 @@
 			   (GCallback) printer_status_cb, 
 			   G_OBJECT (dialog), 0);
 
-  list = gtk_print_backend_get_printer_list (print_backend);
+  list = gtk_print_backend_get_printer_list (print_backend, TRUE);
 
   node = list;
   while (node != NULL)
Index: gtk/gtkprintunixdialog.c
===================================================================
--- gtk/gtkprintunixdialog.c	(revision 21400)
+++ gtk/gtkprintunixdialog.c	(working copy)
@@ -101,6 +101,8 @@
 				                    GtkTreeModel      *model,
 				                    GtkTreeIter       *iter,
 				                    gpointer           data);
+static gboolean set_active_printer                 (GtkPrintUnixDialog *dialog,
+						    const gchar        *printer_name);
 
 /* GtkBuildable */
 static void gtk_print_unix_dialog_buildable_init                    (GtkBuildableIface *iface);
@@ -644,6 +646,11 @@
    * of GTK_RESPONSE_OK button inside of selected_printer_changed function. */
   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
   selected_printer_changed (selection, dialog);
+
+  if (gtk_print_backend_printer_list_is_done (backend) &&
+      gtk_printer_is_default (printer) &&
+      (gtk_tree_selection_count_selected_rows (selection) == 0))
+    set_active_printer (dialog, gtk_printer_get_name (printer));
 }
 
 static void
@@ -727,7 +734,7 @@
 			   (GCallback) printer_status_cb, 
 			   G_OBJECT (dialog), 0);
 
-  list = gtk_print_backend_get_printer_list (print_backend);
+  list = gtk_print_backend_get_printer_list (print_backend, TRUE);
 
   node = list;
   while (node != NULL)
Index: gtk/gtkprintoperation-unix.c
===================================================================
--- gtk/gtkprintoperation-unix.c	(revision 21400)
+++ gtk/gtkprintoperation-unix.c	(working copy)
@@ -1003,7 +1003,7 @@
   GList *list;
   GList *node;
 
-  list = gtk_print_backend_get_printer_list (backend);
+  list = gtk_print_backend_get_printer_list (backend, TRUE);
 
   node = list;
   while (node != NULL)
Index: modules/printbackends/cups/gtkcupsutils.c
===================================================================
--- modules/printbackends/cups/gtkcupsutils.c	(revision 21400)
+++ modules/printbackends/cups/gtkcupsutils.c	(working copy)
@@ -1220,9 +1220,9 @@
 
   result->socket = -1;
   result->current_addr = NULL;
-  result->success_at_init = FALSE;
+  result->at_init = GTK_CUPS_CONNECTION_NOT_AVAILABLE;
 
-  result->success_at_init = gtk_cups_connection_test_is_server_available (result);
+  result->at_init = gtk_cups_connection_test_get_state (result);
 #else
   result = g_new (GtkCupsConnectionTest, 1);
 #endif
@@ -1236,22 +1236,23 @@
  *  - you need to check it more then once.
  * The connection is closed after a successful connection.
  */
-gboolean 
-gtk_cups_connection_test_is_server_available (GtkCupsConnectionTest *test)
+GtkCupsConnectionState 
+gtk_cups_connection_test_get_state (GtkCupsConnectionTest *test)
 {
 #ifdef HAVE_CUPS_API_1_2
-  http_addrlist_t *iter;
-  gboolean         result = FALSE;
-  gint             flags;
-  gint             code;
+  GtkCupsConnectionState result = GTK_CUPS_CONNECTION_NOT_AVAILABLE;
+  http_addrlist_t       *iter;
+  gint                   error_code;
+  gint                   flags;
+  gint                   code;
 
   if (test == NULL)
-    return FALSE;
+    return GTK_CUPS_CONNECTION_NOT_AVAILABLE;
 
-  if (test->success_at_init)
+  if (test->at_init == GTK_CUPS_CONNECTION_AVAILABLE)
     {
-      test->success_at_init = FALSE;
-      return TRUE;
+      test->at_init = GTK_CUPS_CONNECTION_NOT_AVAILABLE;
+      return GTK_CUPS_CONNECTION_AVAILABLE;
     }
   else
     {
@@ -1287,21 +1288,28 @@
                           &test->current_addr->addr.addr,
                           httpAddrLength (&test->current_addr->addr));
 
+          error_code = errno;
+
           if (code == 0)
             {
               close (test->socket);
               test->socket = -1;
               test->current_addr = NULL;
-              result = TRUE;
+              result = GTK_CUPS_CONNECTION_AVAILABLE;
             }
           else
-            result = FALSE;
+            {
+              if (error_code == EALREADY || error_code == EINPROGRESS)
+                result = GTK_CUPS_CONNECTION_IN_PROGRESS;
+              else
+                result = GTK_CUPS_CONNECTION_NOT_AVAILABLE;
+            }
          }
 
       return result;
     }
 #else
-  return TRUE;
+  return GTK_CUPS_CONNECTION_AVAILABLE;
 #endif
 }
 
Index: modules/printbackends/cups/gtkprintbackendcups.c
===================================================================
--- modules/printbackends/cups/gtkprintbackendcups.c	(revision 21400)
+++ modules/printbackends/cups/gtkprintbackendcups.c	(working copy)
@@ -107,7 +107,7 @@
   guint list_printers_pending : 1;
   guint got_default_printer   : 1;
   guint default_printer_poll;
-  GtkCupsConnectionTest *default_printer_connection_test;
+  GtkCupsConnectionTest *cups_connection_test;
 
   char **covers;
   char  *default_cover_before;
@@ -123,6 +123,7 @@
 static void                 gtk_print_backend_cups_dispose         (GObject                           *object);
 static void                 cups_get_printer_list                  (GtkPrintBackend                   *print_backend);
 static void                 cups_get_default_printer               (GtkPrintBackendCups               *print_backend);
+static void                 cups_get_local_default_printer         (GtkPrintBackendCups               *print_backend);
 static void                 cups_request_execute                   (GtkPrintBackendCups               *print_backend,
 								    GtkCupsRequest                    *request,
 								    GtkPrintCupsResponseCallbackFunc   callback,
@@ -513,9 +514,9 @@
   backend_cups->number_of_covers = 0;
 
   backend_cups->default_printer_poll = 0;
-  backend_cups->default_printer_connection_test = NULL;
+  backend_cups->cups_connection_test = NULL;
 
-  cups_get_default_printer (backend_cups);
+  cups_get_local_default_printer (backend_cups);
 }
 
 static void
@@ -537,8 +538,9 @@
   g_free (backend_cups->default_cover_before);
   g_free (backend_cups->default_cover_after);
 
-  gtk_cups_connection_test_free (backend_cups->default_printer_connection_test);
-  
+  gtk_cups_connection_test_free (backend_cups->cups_connection_test);
+  backend_cups->cups_connection_test = NULL;
+
   backend_parent_class->finalize (object);
 }
 
@@ -1067,7 +1069,7 @@
   /* Gather the names of the printers in the current queue
    * so we may check to see if they were removed 
    */
-  removed_printer_checklist = gtk_print_backend_get_printer_list (backend);
+  removed_printer_checklist = gtk_print_backend_get_printer_list (backend, gtk_print_backend_get_wait_for_server (backend));
 								  
   response = gtk_cups_result_get_response (result);
 
@@ -1130,6 +1132,8 @@
         };
       gboolean is_paused = FALSE;
       gboolean is_accepting_jobs = TRUE;
+      gboolean default_printer = FALSE;
+      gboolean got_printer_type = FALSE;
       
       /* Skip leading attributes until we hit a printer...
        */
@@ -1240,6 +1244,14 @@
                   }
               }
           }
+        else if (strcmp (attr->name, "printer-type") == 0)
+          {
+            got_printer_type = TRUE;
+            if (attr->values[0].integer & 0x00020000)
+              default_printer = TRUE;
+            else
+              default_printer = FALSE;
+          }
         else
 	  {
 	    GTK_NOTE (PRINTING,
@@ -1257,7 +1269,21 @@
 	else
           continue;
       }
-   
+
+      if (got_printer_type)
+        {
+          if (default_printer && !cups_backend->got_default_printer)
+            {
+              cups_backend->got_default_printer = TRUE;
+              cups_backend->default_printer = g_strdup (printer_name);
+            }
+        }
+      else
+        {
+          if (!cups_backend->got_default_printer)
+            cups_get_default_printer (cups_backend);
+        }
+
       /* remove name from checklist if it was found */
       node = g_list_find_custom (removed_printer_checklist, printer_name, (GCompareFunc) find_printer);
       removed_printer_checklist = g_list_delete_link (removed_printer_checklist, node);
@@ -1476,6 +1502,7 @@
 static gboolean
 cups_request_printer_list (GtkPrintBackendCups *cups_backend)
 {
+  GtkCupsConnectionState state;
   GtkCupsRequest *request;
   static const char * const pattrs[] =	/* Attributes we're interested in */
     {
@@ -1490,13 +1517,32 @@
       "queued-job-count",
       "printer-is-accepting-jobs",
       "job-sheets-supported",
-      "job-sheets-default"
+      "job-sheets-default",
+      "printer-type"
     };
- 
-  if (cups_backend->list_printers_pending ||
-      !cups_backend->got_default_printer)
+
+  if (cups_backend->list_printers_pending)
     return TRUE;
 
+  state = gtk_cups_connection_test_get_state (cups_backend->cups_connection_test);
+
+  if (gtk_print_backend_get_wait_for_server (GTK_PRINT_BACKEND (cups_backend)))
+    {
+      if (state == GTK_CUPS_CONNECTION_IN_PROGRESS || state == GTK_CUPS_CONNECTION_NOT_AVAILABLE)
+        return TRUE;
+    }
+  else
+    {
+      if (state == GTK_CUPS_CONNECTION_IN_PROGRESS)
+        return TRUE;
+
+      if (state == GTK_CUPS_CONNECTION_NOT_AVAILABLE)
+        {
+          gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (cups_backend));
+          return FALSE;
+        }
+    }
+
   cups_backend->list_printers_pending = TRUE;
 
   request = gtk_cups_request_new (NULL,
@@ -1525,10 +1571,14 @@
   GtkPrintBackendCups *cups_backend;
 
   cups_backend = GTK_PRINT_BACKEND_CUPS (backend);
+
+  if (cups_backend->cups_connection_test == NULL)
+    cups_backend->cups_connection_test = gtk_cups_connection_test_new (NULL);
+
   if (cups_backend->list_printers_poll == 0)
     {
-      cups_request_printer_list (cups_backend);
-      cups_backend->list_printers_poll = gdk_threads_add_timeout_seconds (3,
+      if (cups_request_printer_list (cups_backend))
+        cups_backend->list_printers_poll = gdk_threads_add_timeout_seconds (3,
                                                         (GSourceFunc) cups_request_printer_list,
                                                         backend);
     }
@@ -1850,23 +1900,57 @@
 
   cups_backend = backend;
 
-  cups_backend->default_printer_connection_test = gtk_cups_connection_test_new (NULL);
+  if (cups_backend->cups_connection_test == NULL)
+    cups_backend->cups_connection_test = gtk_cups_connection_test_new (NULL);
+
   if (cups_backend->default_printer_poll == 0)
     {
       if (cups_request_default_printer (cups_backend))
-        cups_backend->default_printer_poll = gdk_threads_add_timeout_seconds (1,
-                                                                              (GSourceFunc) cups_request_default_printer,
-                                                                              backend);
+        cups_backend->default_printer_poll = gdk_threads_add_timeout (500,
+                                                                      (GSourceFunc) cups_request_default_printer,
+                                                                      backend);
     }
 }
 
+/* This function gets default printer from local settings.*/
 static void
+cups_get_local_default_printer (GtkPrintBackendCups *backend)
+{
+  const char *str;
+  char *name = NULL;
+
+  if ((str = g_getenv ("LPDEST")) != NULL)
+    {
+      backend->default_printer = g_strdup (str);
+      backend->got_default_printer = TRUE;
+      return;
+    }
+  else if ((str = g_getenv ("PRINTER")) != NULL &&
+	   strcmp (str, "lp") != 0)
+    {
+      backend->default_printer = g_strdup (str);
+      backend->got_default_printer = TRUE;
+      return;
+    }
+  
+  /* Figure out user setting for default printer */  
+  cups_get_user_default_printer (&name);
+  if (name != NULL)
+    {
+      backend->default_printer = name;
+      backend->got_default_printer = TRUE;
+      return;
+    }
+}
+
+static void
 cups_request_default_printer_cb (GtkPrintBackendCups *print_backend,
 				 GtkCupsResult       *result,
 				 gpointer             user_data)
 {
   ipp_t *response;
   ipp_attribute_t *attr;
+  GtkPrinter *printer;
 
   GDK_THREADS_ENTER ();
 
@@ -1877,6 +1961,16 @@
 
   print_backend->got_default_printer = TRUE;
 
+  if (print_backend->default_printer != NULL)
+    {
+      printer = gtk_print_backend_find_printer (GTK_PRINT_BACKEND (print_backend), print_backend->default_printer);
+      if (printer != NULL)
+        {
+          gtk_printer_set_is_default (printer, TRUE);
+          g_signal_emit_by_name (GTK_PRINT_BACKEND (print_backend), "printer-status-changed", printer);
+        }
+    }
+
   /* Make sure to kick off get_printers if we are polling it, 
    * as we could have blocked this reading the default printer 
    */
@@ -1889,38 +1983,24 @@
 static gboolean
 cups_request_default_printer (GtkPrintBackendCups *print_backend)
 {
+  GtkCupsConnectionState state;
   GtkCupsRequest *request;
-  const char *str;
-  char *name = NULL;
 
-  if (!gtk_cups_connection_test_is_server_available (print_backend->default_printer_connection_test))
-    return TRUE;
+  state = gtk_cups_connection_test_get_state (print_backend->cups_connection_test);
 
-  gtk_cups_connection_test_free (print_backend->default_printer_connection_test);
-  print_backend->default_printer_connection_test = NULL;
-
-  if ((str = g_getenv ("LPDEST")) != NULL)
+  if (gtk_print_backend_get_wait_for_server (GTK_PRINT_BACKEND (print_backend)))
     {
-      print_backend->default_printer = g_strdup (str);
-      print_backend->got_default_printer = TRUE;
-      return FALSE;
+      if (state == GTK_CUPS_CONNECTION_IN_PROGRESS || state == GTK_CUPS_CONNECTION_NOT_AVAILABLE)
+        return TRUE;
     }
-  else if ((str = g_getenv ("PRINTER")) != NULL &&
-	   strcmp (str, "lp") != 0)
+  else
     {
-      print_backend->default_printer = g_strdup (str);
-      print_backend->got_default_printer = TRUE;
-      return FALSE;
+      if (state == GTK_CUPS_CONNECTION_IN_PROGRESS)
+        return TRUE;
+
+      if (state == GTK_CUPS_CONNECTION_NOT_AVAILABLE)
+        return FALSE;
     }
-  
-  /* Figure out user setting for default printer */  
-  cups_get_user_default_printer (&name);
-  if (name != NULL)
-    {
-       print_backend->default_printer = name;
-       print_backend->got_default_printer = TRUE;
-       return FALSE;
-    }
 
   request = gtk_cups_request_new (NULL,
                                   GTK_CUPS_POST,
Index: modules/printbackends/cups/gtkcupsutils.h
===================================================================
--- modules/printbackends/cups/gtkcupsutils.h	(revision 21400)
+++ modules/printbackends/cups/gtkcupsutils.h	(working copy)
@@ -59,6 +59,12 @@
   GTK_CUPS_HTTP_WRITE
 } GtkCupsPollState;
 
+typedef enum
+{
+  GTK_CUPS_CONNECTION_AVAILABLE,
+  GTK_CUPS_CONNECTION_NOT_AVAILABLE,
+  GTK_CUPS_CONNECTION_IN_PROGRESS  
+} GtkCupsConnectionState;
 
 struct _GtkCupsRequest 
 {
@@ -84,10 +90,10 @@
 struct _GtkCupsConnectionTest
 {
 #ifdef HAVE_CUPS_API_1_2
-  http_addrlist_t *addrlist;
-  http_addrlist_t *current_addr;
-  gboolean         success_at_init;
-  gint             socket;
+  GtkCupsConnectionState at_init;
+  http_addrlist_t       *addrlist;
+  http_addrlist_t       *current_addr;
+  gint                   socket;
 #endif
 };
 
@@ -116,42 +122,42 @@
   GTK_CUPS_GET_DONE = GTK_CUPS_REQUEST_DONE
 };
 
-GtkCupsRequest        * gtk_cups_request_new                         (http_t             *connection,
-								      GtkCupsRequestType  req_type,
-								      gint                operation_id,
-								      GIOChannel         *data_io,
-								      const char         *server,
-								      const char         *resource);
-void                    gtk_cups_request_ipp_add_string              (GtkCupsRequest     *request,
-								      ipp_tag_t           group,
-								      ipp_tag_t           tag,
-								      const char         *name,
-								      const char         *charset,
-								      const char         *value);
-void                    gtk_cups_request_ipp_add_strings             (GtkCupsRequest     *request,
-								      ipp_tag_t           group,
-								      ipp_tag_t           tag,
-								      const char         *name,
-								      int                 num_values,
-								      const char         *charset,
-								      const char * const *values);
-gboolean                gtk_cups_request_read_write                  (GtkCupsRequest     *request);
-GtkCupsPollState        gtk_cups_request_get_poll_state              (GtkCupsRequest     *request);
-void                    gtk_cups_request_free                        (GtkCupsRequest     *request);
-GtkCupsResult         * gtk_cups_request_get_result                  (GtkCupsRequest     *request);
-gboolean                gtk_cups_request_is_done                     (GtkCupsRequest     *request);
-void                    gtk_cups_request_encode_option               (GtkCupsRequest     *request,
-						                      const gchar        *option,
-						                      const gchar        *value);
-gboolean                gtk_cups_result_is_error                     (GtkCupsResult      *result);
-ipp_t                 * gtk_cups_result_get_response                 (GtkCupsResult      *result);
-GtkCupsErrorType        gtk_cups_result_get_error_type               (GtkCupsResult      *result);
-int                     gtk_cups_result_get_error_status             (GtkCupsResult      *result);
-int                     gtk_cups_result_get_error_code               (GtkCupsResult      *result);
-const char            * gtk_cups_result_get_error_string             (GtkCupsResult      *result);
-GtkCupsConnectionTest * gtk_cups_connection_test_new                 (const char            *server);
-gboolean                gtk_cups_connection_test_is_server_available (GtkCupsConnectionTest *test);
-void                    gtk_cups_connection_test_free                (GtkCupsConnectionTest *test);
+GtkCupsRequest        * gtk_cups_request_new               (http_t             *connection,
+							    GtkCupsRequestType  req_type,
+							    gint                operation_id,
+							    GIOChannel         *data_io,
+							    const char         *server,
+							    const char         *resource);
+void                    gtk_cups_request_ipp_add_string    (GtkCupsRequest     *request,
+							    ipp_tag_t           group,
+							    ipp_tag_t           tag,
+							    const char         *name,
+							    const char         *charset,
+							    const char         *value);
+void                    gtk_cups_request_ipp_add_strings   (GtkCupsRequest     *request,
+							    ipp_tag_t           group,
+							    ipp_tag_t           tag,
+							    const char         *name,
+							    int                 num_values,
+							    const char         *charset,
+							    const char * const *values);
+gboolean                gtk_cups_request_read_write        (GtkCupsRequest     *request);
+GtkCupsPollState        gtk_cups_request_get_poll_state    (GtkCupsRequest     *request);
+void                    gtk_cups_request_free              (GtkCupsRequest     *request);
+GtkCupsResult         * gtk_cups_request_get_result        (GtkCupsRequest     *request);
+gboolean                gtk_cups_request_is_done           (GtkCupsRequest     *request);
+void                    gtk_cups_request_encode_option     (GtkCupsRequest     *request,
+						            const gchar        *option,
+							    const gchar        *value);
+gboolean                gtk_cups_result_is_error           (GtkCupsResult      *result);
+ipp_t                 * gtk_cups_result_get_response       (GtkCupsResult      *result);
+GtkCupsErrorType        gtk_cups_result_get_error_type     (GtkCupsResult      *result);
+int                     gtk_cups_result_get_error_status   (GtkCupsResult      *result);
+int                     gtk_cups_result_get_error_code     (GtkCupsResult      *result);
+const char            * gtk_cups_result_get_error_string   (GtkCupsResult      *result);
+GtkCupsConnectionTest * gtk_cups_connection_test_new       (const char            *server);
+GtkCupsConnectionState  gtk_cups_connection_test_get_state (GtkCupsConnectionTest *test);
+void                    gtk_cups_connection_test_free      (GtkCupsConnectionTest *test);
 
 G_END_DECLS
 #endif 
