Merge branch 'master' of github.com:frac-tion/teleport

src/meson.build

@@ -1,5 +1,6 @@
 
 headers = files(
+  'teleport-remote-device.h',
   'teleport-browser.h',
   'teleport-get.h',
   'teleport-publish.h',
@@ -17,6 +18,7 @@ install_headers(headers, subdir: meson.project_name())
 ################
 
 sources = files(
+  'teleport-remote-device.c',
   'teleport-browser.c',
   'teleport-get.c',
   'teleport-publish.c',

src/remote_list.ui

@@ -1,6 +1,20 @@
 <?xml version="1.0"?>
 <interface>
   <!-- interface-requires gtk+ 3.0 -->
+  <template class="TeleportRemoteDevice" parent="GtkFrame">
+    <property name="visible">True</property>
+    <property name="can_focus">False</property>
+    <property name="shadow_type">in</property>
+    <property name="shadow_type">none</property>
+    <style>
+      <class name="frame"/>
+    </style>
+    <child>
+      <object class="GtkListBox">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="selection_mode">none</property>
+        <child>
           <object class="GtkListBoxRow" id="remote_device_row">
             <property name="visible">True</property>
             <property name="can_focus">false</property>
@@ -54,16 +68,8 @@
               </object>
             </child>
           </object>
-  <object class="GtkListBoxRow" id="remote_space_row">
-    <property name="visible">True</property>
-    <property name="can_focus">True</property>
-    <property name="activatable">false</property>
-    <property name="selectable">false</property>
-    <child>
-      <object class="GtkSeparator">
-        <property name="visible">true</property>
-        <property name="orientation">horizontal</property>
-      </object>
         </child>
       </object>
+    </child>
+  </template>>
 </interface>

src/teleport-browser.c

@@ -1,28 +1,23 @@
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
 #include <stdio.h>
 #include <assert.h>
 #include <stdlib.h>
-#include <time.h>
 #include <string.h>
 #include <avahi-client/client.h>
 #include <avahi-client/lookup.h>
-#include <avahi-common/simple-watch.h>
 #include <avahi-common/malloc.h>
 #include <avahi-common/error.h>
 #include <avahi-common/thread-watch.h>
 
+#include "teleport-browser.h"
 #include "teleport-app.h"
 #include "teleport-peer.h"
-#include "teleport-browser.h"
 
-//static AvahiSimplePoll *simple_poll = NULL;
 static AvahiThreadedPoll *threaded_poll = NULL;
 static AvahiClient *client = NULL;
 static TeleportPeer *peerList = NULL;
 
-static void resolve_callback (AvahiServiceResolver *r,
+static void
+resolve_callback (AvahiServiceResolver *r,
                   AVAHI_GCC_UNUSED AvahiIfIndex interface,
                   AVAHI_GCC_UNUSED AvahiProtocol protocol,
                   AvahiResolverEvent event,
@@ -34,44 +29,38 @@ static void resolve_callback (AvahiServiceResolver *r,
                   uint16_t port,
                   AvahiStringList *txt,
                   AvahiLookupResultFlags flags,
-                              AVAHI_GCC_UNUSED void* userdata) {
+                  AVAHI_GCC_UNUSED void* userdata)
+{
   assert(r);
   /* Called whenever a service has been resolved successfully or timed out */
   switch (event) {
   case AVAHI_RESOLVER_FAILURE:
-    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
+    fprintf(stderr,
+            "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
+            name,
+            type,
+            domain,
+            avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
     break;
   case AVAHI_RESOLVER_FOUND: {
                                char a[AVAHI_ADDRESS_STR_MAX], *t;
-                               fprintf(stderr, "Service '%s' of type '%s' in domain '%s':\n", name, type, domain);
+                               fprintf(stderr,
+                                       "Service '%s' of type '%s' in domain '%s':\n",
+                                       name,
+                                       type,
+                                       domain);
                                avahi_address_snprint(a, sizeof(a), address);
                                t = avahi_string_list_to_string(txt);
                                teleport_peer_add_peer(peerList, g_strdup(name), g_strdup(a), port);
-                               //teleport_app_add_peer(name, port, a);
-                               /*fprintf(stderr,
-                                 "\t%s:%u (%s)\n"
-                                 "\tTXT=%s\n"
-                                 "\tcookie is %u\n"
-                                 "\tis_local: %i\n"
-                                 "\tour_own: %i\n"
-                                 "\twide_area: %i\n"
-                                 "\tmulticast: %i\n"
-                                 "\tcached: %i\n",
-                                 host_name, port, a,
-                                 t,
-                                 avahi_string_list_get_service_cookie(txt),
-                                 !!(flags & AVAHI_LOOKUP_RESULT_LOCAL),
-                                 !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN),
-                                 !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA),
-                                 !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
-                                 !!(flags & AVAHI_LOOKUP_RESULT_CACHED));
-                                 */
                                avahi_free(t);
                              }
   }
+
   avahi_service_resolver_free(r);
 }
-static void browse_callback(
+
+static void
+browse_callback(
                 AvahiServiceBrowser *b,
                 AvahiIfIndex interface,
                 AvahiProtocol protocol,
@@ -80,93 +69,82 @@ static void browse_callback(
                 const char *type,
                 const char *domain,
                 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
-                            void* userdata) {
+                void* userdata)
+{
   AvahiClient *c = userdata;
   assert(b);
+
   /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
   switch (event) {
   case AVAHI_BROWSER_FAILURE:
-    fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
+    fprintf(stderr,
+            "(Browser) %s\n",
+            avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
     teleport_browser_avahi_shutdown();
-    //avahi_simple_poll_quit(simple_poll);
     return;
   case AVAHI_BROWSER_NEW:
-    fprintf(stderr, "(Browser) NEW: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
+    fprintf(stderr,
+            "(Browser) NEW: service '%s' of type '%s' in domain '%s'\n",
+            name,
+            type,
+            domain);
     if (flags & AVAHI_LOOKUP_RESULT_LOCAL)
       break;
     /* We ignore the returned resolver object. In the callback
        function we free it. If the server is terminated before
        the callback function is called the server will free
        the resolver for us. */
-    if (!(avahi_service_resolver_new(c, interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, 0, resolve_callback, c)))
+    if (!(avahi_service_resolver_new(c,
-      //if (!(avahi_service_resolver_new(c, interface, protocol, name, type, domain, AVAHI_PROTO_INET, 0, resolve_callback, c)))
+                                     interface,
-      fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_client_errno(c)));
+                                     protocol,
+                                     name,
+                                     type,
+                                     domain,
+                                     AVAHI_PROTO_UNSPEC,
+                                     0,
+                                     resolve_callback,
+                                     c)))
+
+      fprintf(stderr,
+              "Failed to resolve service '%s': %s\n",
+              name,
+              avahi_strerror(avahi_client_errno(c)));
     break;
   case AVAHI_BROWSER_REMOVE:
-    fprintf(stderr, "(Browser) REMOVE: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
+    fprintf(stderr,
-    //teleport_app_remove_peer(name);
+            "(Browser) REMOVE: service '%s' of type '%s' in domain '%s'\n",
+            name,
+            type,
+            domain);
     teleport_peer_remove_peer_by_name(peerList, g_strdup(name));
     break;
   case AVAHI_BROWSER_ALL_FOR_NOW:
   case AVAHI_BROWSER_CACHE_EXHAUSTED:
-    fprintf(stderr, "(Browser) %s\n", event == AVAHI_BROWSER_CACHE_EXHAUSTED ? "CACHE_EXHAUSTED" : "ALL_FOR_NOW");
+    fprintf(stderr,
+            "(Browser) %s\n",
+            event == AVAHI_BROWSER_CACHE_EXHAUSTED ? "CACHE_EXHAUSTED" : "ALL_FOR_NOW");
     break;
   }
 }
-static void client_callback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata) {
+
+static void
+client_callback (AvahiClient *c,
+                 AvahiClientState state,
+                 AVAHI_GCC_UNUSED void * userdata)
+{
   assert(c);
   /* Called whenever the client or server state changes */
   if (state == AVAHI_CLIENT_FAILURE) {
-    fprintf(stderr, "Server connection failure: %s\n", avahi_strerror(avahi_client_errno(c)));
+    fprintf(stderr,
+            "Server connection failure: %s\n",
+            avahi_strerror(avahi_client_errno(c)));
     teleport_browser_avahi_shutdown();
-    //avahi_simple_poll_quit(simple_poll);
   }
 }
-/*int run_avahi_service() {
-  AvahiClient *client = NULL;
-  AvahiServiceBrowser *sb = NULL;
-  int error;
-  int ret = 1;
-  */
-/* Allocate main loop object */
-/*if (!(simple_poll = avahi_simple_poll_new())) {
-  fprintf(stderr, "Failed to create simple poll object.\n");
-  goto fail;
-  }
-  */
-/* Allocate a new client */
-//client = avahi_client_new(avahi_simple_poll_get(simple_poll), 0, client_callback, NULL, &error);
-/* Check wether creating the client object succeeded */
-/*if (!client) {
-  fprintf(stderr, "Failed to create client: %s\n", avahi_strerror(error));
-  goto fail;
-  }
-  *//* Create the service browser */
-/*if (!(sb = avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_http._tcp", NULL, 0, browse_callback, client))) {
-  fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_client_errno(client)));
-  goto fail;
-  }
-  */
-/* Run the main loop */
-/*
 
-   avahi_simple_poll_loop(simple_poll);
+int
-   ret = 0;
+teleport_browser_run_avahi_service (TeleportPeer *peers)
-fail:
+{
-*/
-/* Cleanup things */
-/*
-   if (sb)
-   avahi_service_browser_free(sb);
-   if (client)
-   avahi_client_free(client);
-   if (simple_poll)
-   avahi_simple_poll_free(simple_poll);
-   return ret;
-   }
-   */
-
-int teleport_browser_run_avahi_service(TeleportPeer *peers) {
   int error;
   peerList = peers;
 
@@ -177,15 +155,25 @@ int teleport_browser_run_avahi_service(TeleportPeer *peers) {
     return 1;
   }
 
-  if (!(client = avahi_client_new(avahi_threaded_poll_get(threaded_poll), 0, client_callback, NULL, &error))) {
+  if (!(client = avahi_client_new(avahi_threaded_poll_get(threaded_poll),
+                                  0,
+                                  client_callback,
+                                  NULL,
+                                  &error))) {
     fprintf(stderr, "Failed to create client: %s\n", avahi_strerror(error));
     /* do something bad */
     return 1;
   }
 
   /* create some browsers on the client object here, if you wish */
-  //if (!(avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_teleport._tcp", NULL, 0, browse_callback, client))) {
+  if (!(avahi_service_browser_new(client,
-  if (!(avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_INET, "_teleport._tcp", NULL, 0, browse_callback, client))) {
+                                  AVAHI_IF_UNSPEC,
+                                  AVAHI_PROTO_INET,
+                                  "_teleport._tcp",
+                                  NULL,
+                                  0,
+                                  browse_callback,
+                                  client))) {
     /* so something bad */
     return 1;
   }
@@ -198,7 +186,9 @@ int teleport_browser_run_avahi_service(TeleportPeer *peers) {
   return 0;
 }
 
-void teleport_browser_avahi_shutdown(void) {
+void
+teleport_browser_avahi_shutdown(void)
+{
   /* Call this when the app shuts down */
 
   avahi_threaded_poll_stop(threaded_poll);

src/teleport-browser.h

@@ -1,6 +1,8 @@
 #ifndef __TELEPORT_BROWSER_H
 #define __TELEPORT_BROWSER_H
 
+#include "teleport-peer.h"
+
 int teleport_browser_run_avahi_service(TeleportPeer *);
 void teleport_browser_avahi_shutdown(void);
 

src/teleport-remote-device.c

@@ -0,0 +1,431 @@
+/* teleport-remote-device.c
+ *
+ * Copyright (C) 2017 Julian Sparber <julian@sparver.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtk/gtk.h>
+#include "teleport-remote-device.h"
+#include "teleport-peer.h"
+#include "teleport-server.h"
+
+enum {
+  TARGET_INT32,
+  TARGET_STRING,
+  TARGET_URIS,
+  TARGET_ROOTWIN
+};
+
+enum                                                                            
+{                                                                               
+  PROP_0,                                                                       
+  PROP_PEER,                                                                    
+  LAST_PROP                                                                     
+}; 
+
+/* datatype (string), restrictions on DnD (GtkTargetFlags), datatype (int) */
+static GtkTargetEntry target_list[] = {
+  //{ "INTEGER",    0, TARGET_INT32 },
+  //{ "STRING",     0, TARGET_STRING },
+  //{ "text/plain", 0, TARGET_STRING },
+    { "text/uri-list", 0, TARGET_URIS }
+  //{ "application/octet-stream", 0, TARGET_STRING },
+  //{ "application/x-rootwindow-drop", 0, TARGET_ROOTWIN }
+};
+
+static guint n_targets = G_N_ELEMENTS (target_list);
+
+struct _TeleportRemoteDevice
+{
+  GtkFrame      parent;
+  GtkWidget 	*remote_device_row;
+  GtkWidget 	*device_name;
+  GtkWidget 	*send_btn;
+
+  /* data */
+  Peer          *peer;
+};
+
+G_DEFINE_TYPE (TeleportRemoteDevice, teleport_remote_device, GTK_TYPE_FRAME)
+
+    /*
+     * GObject overrides
+     */
+
+static void
+teleport_remote_device_finalize (GObject *object)
+{
+  //TeleportRemoteDevice *self = TELEPORT_REMOTE_DEVICE (object);
+
+  G_OBJECT_CLASS (teleport_remote_device_parent_class)->finalize (object);
+}
+
+static void
+teleport_remote_device_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (teleport_remote_device_parent_class)->dispose (object);
+}
+
+static void
+teleport_remote_device_get_property (GObject    *object,
+                                     guint       prop_id,
+                                     GValue     *value,
+                                     GParamSpec *pspec)
+{
+  TeleportRemoteDevice *self = TELEPORT_REMOTE_DEVICE (object);
+
+  switch (prop_id)
+    {
+    case PROP_PEER:
+      g_value_set_pointer (value, self->peer);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+teleport_remote_device_set_property (GObject      *object,
+                                     guint         prop_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+{
+  TeleportRemoteDevice *self = TELEPORT_REMOTE_DEVICE (object);
+
+  switch (prop_id)
+    {
+    case PROP_PEER:
+      teleport_remote_device_set_peer (self, g_value_get_pointer (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+teleport_remote_device_class_init (TeleportRemoteDeviceClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = teleport_remote_device_dispose;
+  object_class->finalize = teleport_remote_device_finalize;
+  object_class->get_property = teleport_remote_device_get_property;
+  object_class->set_property = teleport_remote_device_set_property;
+
+  /**
+   * TeleportRemoteDevice::peer:
+   *
+   * The peer that this row represents, or %NULL.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_PEER,
+                                   g_param_spec_pointer ("peer",
+                                                         "Peer of the row",
+                                                         "The peer that this row represents",
+                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+
+  /*g_param_spec_object ("peer",
+    "Task of the row",
+    "The task that this row represents",
+    (Peer *),
+    G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+    */
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/com/frac_tion/teleport/remote_list.ui");
+  gtk_widget_class_bind_template_child (widget_class, TeleportRemoteDevice, remote_device_row);
+  gtk_widget_class_bind_template_child (widget_class, TeleportRemoteDevice, device_name);
+  gtk_widget_class_bind_template_child (widget_class, TeleportRemoteDevice, send_btn);
+}
+
+static void
+open_file_picker(GtkButton *btn,
+                 Peer *device) {
+  GtkWidget *dialog;
+  GtkWidget * window;
+  GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+  gint res;
+  g_print("Open file chooser for submitting a file to %s with Address %s\n", device->name, device->ip);
+
+  window = gtk_widget_get_toplevel (GTK_WIDGET (btn));
+  if (gtk_widget_is_toplevel (window))
+    {
+      dialog =  gtk_file_chooser_dialog_new ("Open File",
+                                             GTK_WINDOW(window),
+                                             action,
+                                             ("_Cancel"),
+                                             GTK_RESPONSE_CANCEL,
+                                             ("_Open"),
+                                             GTK_RESPONSE_ACCEPT,
+                                             NULL);
+
+      res = gtk_dialog_run (GTK_DIALOG (dialog));
+      if (res == GTK_RESPONSE_ACCEPT)
+        {
+          char *filename;
+          GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
+          filename = gtk_file_chooser_get_filename (chooser);
+          g_print("Choosen file is %s\n", filename);
+          gtk_widget_destroy (dialog);
+          teleport_server_add_route (g_compute_checksum_for_string (G_CHECKSUM_SHA256, filename,  -1), filename, device->ip);
+          g_free (filename);
+        }
+      else
+        {
+          gtk_widget_destroy (dialog);
+        }
+
+    }
+}
+
+
+static void 
+send_file_to_device (gchar *uri, gpointer data)
+{
+  Peer *device = (Peer *) data;
+  GFile *file = g_file_new_for_uri (uri);
+  gchar *filename  = NULL;
+  if (g_file_query_exists (file, NULL)) {
+    filename = g_file_get_path (file);
+    teleport_server_add_route (g_compute_checksum_for_string (G_CHECKSUM_SHA256, filename,  -1), g_strdup(filename), device->ip);
+    g_free (filename);
+  }
+  else {
+    g_print ("File doesn't exist: %s\n", uri);
+  }
+  g_object_unref(file);
+}
+
+
+static void
+drag_data_received_handl
+(GtkWidget *widget, GdkDragContext *context, gint x, gint y,
+ GtkSelectionData *selection_data, guint target_type, guint time,
+ gpointer data)
+{
+  glong   *_idata;
+  gchar   *_sdata;
+  gchar   **uris;
+
+  gboolean dnd_success = FALSE;
+  gboolean delete_selection_data = FALSE;
+
+  /* Deal with what we are given from source */
+  if((selection_data != NULL) && (gtk_selection_data_get_length(selection_data) >= 0))
+    {
+      if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_ASK)
+        {
+          /* Ask the user to move or copy, then set the context action. */
+        }
+
+      if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_MOVE)
+        delete_selection_data = TRUE;
+
+      /* Check that we got the format we can use */
+      switch (target_type)
+        {
+        case TARGET_INT32:
+          _idata = (glong*)gtk_selection_data_get_data(selection_data);
+          g_print ("integer: %ld", *_idata);
+          dnd_success = TRUE;
+          break;
+
+        case TARGET_STRING:
+          _sdata = (gchar*)gtk_selection_data_get_data(selection_data);
+          g_print ("string: %s", _sdata);
+          dnd_success = TRUE;
+          break;
+
+        case TARGET_URIS:
+          uris = gtk_selection_data_get_uris(selection_data);
+          if (uris != NULL && uris[1] == NULL) {
+            send_file_to_device (uris[0], data);
+            dnd_success = TRUE;
+          }
+          break;
+
+        default:
+          g_print ("Something bad!");
+        }
+    }
+
+  if (dnd_success == FALSE)
+    {
+      g_print ("DnD data transfer failed!\n");
+      g_print ("You can not drag more then one file!\n");
+    }
+
+  gtk_drag_finish (context, dnd_success, delete_selection_data, time);
+}
+
+/* Emitted when a drag is over the destination */
+static gboolean
+drag_motion_handl
+(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint t,
+ gpointer user_data)
+{
+  // Fancy stuff here. This signal spams the console something horrible.
+  //const gchar *name = gtk_widget_get_name (widget);
+  //g_print ("%s: drag_motion_handl\n", name);
+  return  FALSE;
+}
+
+/* Emitted when a drag leaves the destination */
+static void
+drag_leave_handl
+(GtkWidget *widget, GdkDragContext *context, guint time, gpointer user_data)
+{
+}
+
+/* Emitted when the user releases (drops) the selection. It should check that
+ * the drop is over a valid part of the widget (if its a complex widget), and
+ * itself to return true if the operation should continue. Next choose the
+ * target type it wishes to ask the source for. Finally call gtk_drag_get_data
+ * which will emit "drag-data-get" on the source. */
+static gboolean
+drag_drop_handl
+(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time,
+ gpointer user_data)
+{
+  gboolean        is_valid_drop_site;
+  GdkAtom         target_type;
+
+  /* Check to see if (x,y) is a valid drop site within widget */
+  is_valid_drop_site = TRUE;
+
+  /* If the source offers a target */
+  if (gdk_drag_context_list_targets (context))
+    {
+      /* Choose the best target type */
+      target_type = GDK_POINTER_TO_ATOM
+       (g_list_nth_data (gdk_drag_context_list_targets(context), TARGET_INT32));
+
+
+      /* Request the data from the source. */
+      gtk_drag_get_data
+       (
+        widget,         /* will receive 'drag-data-received' signal */
+        context,        /* represents the current state of the DnD */
+        target_type,    /* the target type we want */
+        time            /* time stamp */
+       );
+    }
+  /* No target offered by source => error */
+  else
+    {
+      is_valid_drop_site = FALSE;
+    }
+
+  return  is_valid_drop_site;
+}
+
+static void
+teleport_remote_device_init (TeleportRemoteDevice *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  /* Make the widget a DnD destination. */
+  gtk_drag_dest_set
+   (
+    GTK_WIDGET (self),              /* widget that will accept a drop */
+    GTK_DEST_DEFAULT_ALL,
+    target_list,            /* lists of target to support */
+    n_targets,              /* size of list */
+    GDK_ACTION_COPY         /* what to do with data after dropped */
+   );
+}
+
+GtkWidget*
+teleport_remote_device_new (Peer *peer)
+{
+  return g_object_new (TELEPORT_TYPE_REMOTE_DEVICE,
+                       "peer", peer,
+                       NULL);
+}
+
+/**
+ * teleport_remote_device_get_peer:
+ * @row: a #TeleportRemoteDevice
+ *
+ * Retrieves the #Peer that @row manages, or %NULL if none
+ * is set.
+ *
+ * Returns: (transfer none): the internal peer of @row
+ */
+Peer *
+      teleport_remote_device_get_peer (GtkWidget *widget)
+{
+  TeleportRemoteDevice *row;
+
+  g_return_val_if_fail (TELEPORT_IS_REMOTE_DEVICE (widget), NULL);
+
+  row = TELEPORT_REMOTE_DEVICE (widget);
+
+  return row->peer;
+}
+
+void
+teleport_remote_device_set_peer (TeleportRemoteDevice *widget,
+                                 Peer    *peer)
+{
+  g_return_if_fail (TELEPORT_IS_REMOTE_DEVICE (widget));
+  widget->peer = peer;
+
+  /*
+     we need to create a peer object instate of a struct to be able to bind it
+  if (!g_set_object (&widget->peer, peer))
+    return;
+
+  g_object_bind_property (peer,
+                          "name",
+                          widget->device_name,
+                          "label",
+                          G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
+                          */
+
+  if (peer)
+    {
+      gtk_label_set_text(GTK_LABEL (widget->device_name), peer->name);
+
+      g_signal_connect (widget->send_btn, "clicked", G_CALLBACK (open_file_picker), peer);
+
+
+      g_signal_connect (widget, "drag-data-received",
+                        G_CALLBACK(drag_data_received_handl), peer);
+
+      g_signal_connect (widget, "drag-leave",
+                        G_CALLBACK (drag_leave_handl), peer);
+
+      g_signal_connect (widget, "drag-motion",
+                        G_CALLBACK (drag_motion_handl), peer);
+
+      g_signal_connect (widget, "drag-drop",
+                        G_CALLBACK (drag_drop_handl), peer);
+    }
+}
+
+/**
+ * teleport_remote_device_destroy:
+ * @self: a #TeleportRemoteDevice
+ *
+ * Destroy @self after hiding it.
+ */
+void
+teleport_remote_device_destroy (TeleportRemoteDevice *self)
+{
+}
+

src/teleport-remote-device.h

@@ -0,0 +1,41 @@
+/* teleport-remote-device.h
+ *
+ * Copyright (C) 2017 Julian Sparber <julian@sparver.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TELEPORT_REMOTE_DEVICE_H
+#define TELEPORT_REMOTE_DEVICE_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include "teleport-peer.h"
+
+G_BEGIN_DECLS
+
+#define TELEPORT_TYPE_REMOTE_DEVICE (teleport_remote_device_get_type())
+
+G_DECLARE_FINAL_TYPE (TeleportRemoteDevice, teleport_remote_device, TELEPORT, REMOTE_DEVICE, GtkFrame)
+
+GtkWidget *     teleport_remote_device_new      (Peer         *         );
+
+Peer *  teleport_remote_device_get_peer (GtkWidget            *         );
+void    teleport_remote_device_set_peer (TeleportRemoteDevice *, Peer  *);
+void    teleport_remote_device_destroy  (TeleportRemoteDevice *);
+
+
+G_END_DECLS
+
+#endif /* TELEPORT_REMOTE_DEVICE_H */

src/teleport-window.c

@@ -4,27 +4,7 @@
 #include "teleport-window.h"
 #include "teleport-server.h"
 #include "teleport-peer.h"
-
+#include "teleport-remote-device.h"
-GtkWidget *find_child(GtkWidget *, const gchar *);
-
-enum {
-  TARGET_INT32,
-  TARGET_STRING,
-  TARGET_URIS,
-  TARGET_ROOTWIN
-};
-
-/* datatype (string), restrictions on DnD (GtkTargetFlags), datatype (int) */
-static GtkTargetEntry target_list[] = {
-    //{ "INTEGER",    0, TARGET_INT32 },
-    //{ "STRING",     0, TARGET_STRING },
-    //{ "text/plain", 0, TARGET_STRING },
-    { "text/uri-list", 0, TARGET_URIS }
-    //{ "application/octet-stream", 0, TARGET_STRING },
-    //{ "application/x-rootwindow-drop", 0, TARGET_ROOTWIN }
-};
-
-static guint n_targets = G_N_ELEMENTS (target_list);
 
 TeleportWindow *mainWin;
 
@@ -39,7 +19,7 @@ struct _TeleportWindowPrivate
 {
   GSettings *settings;
   GtkWidget *gears;
-  GtkWidget *remote_devices_list;
+  GtkWidget *remote_devices_box;
   GtkWidget *this_device_name_label;
   GtkWidget *remote_no_devices;
 };
@@ -61,145 +41,6 @@ change_download_directory_cb (GtkWidget *widget,
   g_free(newDownloadDir);
 }
 
-static void 
-send_file_to_device (gchar *uri, gpointer data)
-{
-  Peer *device = (Peer *) data;
-  GFile *file = g_file_new_for_uri (uri);
-  gchar *filename  = NULL;
-  if (g_file_query_exists (file, NULL)) {
-    filename = g_file_get_path (file);
-    teleport_server_add_route (g_compute_checksum_for_string (G_CHECKSUM_SHA256, filename,  -1), g_strdup(filename), device->ip);
-    g_free (filename);
-  }
-  else {
-    g_print ("File doesn't exist: %s\n", uri);
- }
-  g_object_unref(file);
-}
-static void
-drag_data_received_handl
-(GtkWidget *widget, GdkDragContext *context, gint x, gint y,
- GtkSelectionData *selection_data, guint target_type, guint time,
- gpointer data)
-{
-  glong   *_idata;
-  gchar   *_sdata;
-  gchar   **uris;
-
-  gboolean dnd_success = FALSE;
-  gboolean delete_selection_data = FALSE;
-
-  /* Deal with what we are given from source */
-  if((selection_data != NULL) && (gtk_selection_data_get_length(selection_data) >= 0))
-    {
-      if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_ASK)
-        {
-          /* Ask the user to move or copy, then set the context action. */
-        }
-
-      if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_MOVE)
-        delete_selection_data = TRUE;
-
-      /* Check that we got the format we can use */
-      switch (target_type)
-        {
-        case TARGET_INT32:
-          _idata = (glong*)gtk_selection_data_get_data(selection_data);
-          g_print ("integer: %ld", *_idata);
-          dnd_success = TRUE;
-          break;
-
-        case TARGET_STRING:
-          _sdata = (gchar*)gtk_selection_data_get_data(selection_data);
-          g_print ("string: %s", _sdata);
-          dnd_success = TRUE;
-          break;
-
-        case TARGET_URIS:
-          uris = gtk_selection_data_get_uris(selection_data);
-          if (uris != NULL && uris[1] == NULL) {
-            send_file_to_device (uris[0], data);
-            dnd_success = TRUE;
-          }
-          break;
-
-        default:
-          g_print ("Something bad!");
-        }
-    }
-
-  if (dnd_success == FALSE)
-    {
-      g_print ("DnD data transfer failed!\n");
-      g_print ("You can not drag more then one file!\n");
-    }
-
-  gtk_drag_finish (context, dnd_success, delete_selection_data, time);
-}
-
-/* Emitted when a drag is over the destination */
-static gboolean
-drag_motion_handl
-(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint t,
- gpointer user_data)
-{
-  // Fancy stuff here. This signal spams the console something horrible.
-  //const gchar *name = gtk_widget_get_name (widget);
-  //g_print ("%s: drag_motion_handl\n", name);
-  return  FALSE;
-}
-
-/* Emitted when a drag leaves the destination */
-static void
-drag_leave_handl
-(GtkWidget *widget, GdkDragContext *context, guint time, gpointer user_data)
-{
-}
-
-/* Emitted when the user releases (drops) the selection. It should check that
- * the drop is over a valid part of the widget (if its a complex widget), and
- * itself to return true if the operation should continue. Next choose the
- * target type it wishes to ask the source for. Finally call gtk_drag_get_data
- * which will emit "drag-data-get" on the source. */
-static gboolean
-drag_drop_handl
-(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time,
- gpointer user_data)
-{
-  gboolean        is_valid_drop_site;
-  GdkAtom         target_type;
-
-  /* Check to see if (x,y) is a valid drop site within widget */
-  is_valid_drop_site = TRUE;
-
-  /* If the source offers a target */
-  if (gdk_drag_context_list_targets (context))
-    {
-      /* Choose the best target type */
-      target_type = GDK_POINTER_TO_ATOM
-       (g_list_nth_data (gdk_drag_context_list_targets(context), TARGET_INT32));
-
-
-      /* Request the data from the source. */
-      gtk_drag_get_data
-       (
-        widget,         /* will receive 'drag-data-received' signal */
-        context,        /* represents the current state of the DnD */
-        target_type,    /* the target type we want */
-        time            /* time stamp */
-       );
-    }
-  /* No target offered by source => error */
-  else
-    {
-      is_valid_drop_site = FALSE;
-    }
-
-  return  is_valid_drop_site;
-}
-
-
 static void
 teleport_window_init (TeleportWindow *win)
 {
@@ -257,155 +98,47 @@ teleport_window_init (TeleportWindow *win)
 }
 
 
-/*Doing Dnd init stuff */
-static void
-add_dnd (GtkWidget *widget, gpointer data)
-{
-  /* Make the widget a DnD destination. */
-  gtk_drag_dest_set
-   (
-    widget,              /* widget that will accept a drop */
-    GTK_DEST_DEFAULT_ALL,
-    target_list,            /* lists of target to support */
-    n_targets,              /* size of list */
-    GDK_ACTION_COPY         /* what to do with data after dropped */
-   );
-
-  /* All possible destination signals */
-  g_signal_connect (widget, "drag-data-received",
-                    G_CALLBACK(drag_data_received_handl), data);
-
-  g_signal_connect (widget, "drag-leave",
-                    G_CALLBACK (drag_leave_handl), data);
-
-  g_signal_connect (widget, "drag-motion",
-                    G_CALLBACK (drag_motion_handl), data);
-
-  g_signal_connect (widget, "drag-drop",
-                    G_CALLBACK (drag_drop_handl), data);
-}
-
-static void
-open_file_picker(GtkButton *btn,
-                 Peer *device) {
-  GtkWidget *dialog;
-  GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
-  gint res;
-  g_print("Open file chooser for submitting a file to %s with Address %s\n", device->name, device->ip);
-
-  dialog =  gtk_file_chooser_dialog_new ("Open File",
-                                         GTK_WINDOW(mainWin),
-                                         action,
-                                         ("_Cancel"),
-                                         GTK_RESPONSE_CANCEL,
-                                         ("_Open"),
-                                         GTK_RESPONSE_ACCEPT,
-                                         NULL);
-
-  res = gtk_dialog_run (GTK_DIALOG (dialog));
-  if (res == GTK_RESPONSE_ACCEPT)
-    {
-      char *filename;
-      GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
-      filename = gtk_file_chooser_get_filename (chooser);
-      g_print("Choosen file is %s\n", filename);
-      gtk_widget_destroy (dialog);
-      teleport_server_add_route (g_compute_checksum_for_string (G_CHECKSUM_SHA256, filename,  -1), filename, device->ip);
-      g_free (filename);
-    }
-  else
-    {
-      gtk_widget_destroy (dialog);
-    }
-}
-
 void
 update_remote_device_list(TeleportWindow *win,
                           Peer           *device)
 {
   TeleportWindowPrivate *priv;
-  GtkBuilder *builder_remote_list;
+  GtkWidget *remote_device;
-  GtkWidget *row;
-  GtkLabel *name_label;
-  GtkButton *send_btn;
-  //GtkWidget *line;
 
   priv = teleport_window_get_instance_private (win);
 
   gtk_widget_hide (priv->remote_no_devices);
 
-  builder_remote_list = gtk_builder_new_from_resource ("/com/frac_tion/teleport/remote_list.ui");
+  remote_device = teleport_remote_device_new (device);
 
-  row = GTK_WIDGET (gtk_builder_get_object (builder_remote_list, "remote_device_row"));
+  gtk_box_pack_end (GTK_BOX (priv->remote_devices_box),
-  name_label = GTK_LABEL (gtk_builder_get_object (builder_remote_list, "device_name"));
+                    remote_device,
-  gtk_label_set_text(name_label, device->name);
+                    TRUE,
-  gtk_list_box_insert(GTK_LIST_BOX(priv->remote_devices_list), row, -1);
+                    TRUE,
-  send_btn = GTK_BUTTON (gtk_builder_get_object (builder_remote_list, "send_btn"));
+                    0);
-  g_signal_connect (send_btn, "clicked", G_CALLBACK (open_file_picker), device);
-
-  //Add drag n drop
-  add_dnd (row, device);
-
-  //line = GTK_WIDGET (gtk_builder_get_object (builder_remote_list, "remote_space_row"));
-  //gtk_list_box_insert(GTK_LIST_BOX(priv->remote_devices_list), line, -1);
-  g_object_unref (builder_remote_list);
 }
 
+static void
+remove_remote_peer (GtkWidget *widget,
+                    gpointer data)
+{
+  if (TELEPORT_IS_REMOTE_DEVICE (widget) && teleport_remote_device_get_peer(widget) == ((Peer *) data)) {
+    gtk_widget_destroy (widget);
+  }
+}
 
 void
 update_remote_device_list_remove(TeleportWindow *win,
                                  Peer *device)
 {
   TeleportWindowPrivate *priv;
-  GtkWidget *box;
-  GtkListBoxRow *remote_row;
-  GtkLabel *name_label;
-  gint i = 0;
 
   priv = teleport_window_get_instance_private (win);
-  box = priv->remote_devices_list;
 
-  remote_row = gtk_list_box_get_row_at_index (GTK_LIST_BOX(box), i);
+  gtk_container_foreach (GTK_CONTAINER(priv->remote_devices_box),
-
+                         remove_remote_peer,
-  while (remote_row != NULL) {
+                         device);
-    name_label = GTK_LABEL(find_child(GTK_WIDGET(remote_row), "GtkLabel"));
-    if (name_label != NULL && g_strcmp0(device->name, gtk_label_get_text(name_label)) == 0) {
-      gtk_container_remove (GTK_CONTAINER(box), GTK_WIDGET(remote_row));
 }
-    i++;
-    remote_row = gtk_list_box_get_row_at_index (GTK_LIST_BOX(box), i);
-  }
-  // the last row got removed and we have to display the searching box
-  if (i <= 2) {
-    gtk_widget_show (priv->remote_no_devices);
-  }
-}
-
-GtkWidget *
-find_child(GtkWidget *parent, const gchar *name)
-{
-  if (g_strcmp0(gtk_widget_get_name((GtkWidget *)parent), (gchar *)name) == 0) {
-    return parent;
-  }
-
-  if (GTK_IS_BIN(parent)) {
-    GtkWidget *child = gtk_bin_get_child(GTK_BIN(parent));
-    return find_child(child, name);
-  }
-
-  if (GTK_IS_CONTAINER(parent)) {
-    GList *children = gtk_container_get_children(GTK_CONTAINER(parent));
-    while ((children = g_list_next(children)) != NULL) {
-      GtkWidget *widget = find_child(children->data, name);
-      if (widget != NULL) {
-        return widget;
-      }
-    }
-  }
-
-  return NULL;
-}
-
 
 static void
 teleport_window_dispose (GObject *object)
@@ -432,7 +165,7 @@ teleport_window_class_init (TeleportWindowClass *class)
   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), TeleportWindow, gears);
   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), TeleportWindow, this_device_name_label);
   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), TeleportWindow, remote_no_devices);
-  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), TeleportWindow, remote_devices_list);
+  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), TeleportWindow, remote_devices_box);
 }
 
 TeleportWindow *

src/window.ui

@@ -210,24 +210,24 @@
                 </child>
 
                 <child>
-                  <object class="GtkFrame" id="remote-devices-frame-listbox">
+                  <object class="GtkBox" id="remote_devices_box">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
+                    <property name="spacing">6</property>
                     <property name="margin_top">6</property>
-                    <property name="margin_bottom">12</property>
-                    <property name="shadow_type">in</property>
-                    <child>
-                      <object class="GtkBox" id="remote-devices-box">
-                        <property name="visible">True</property>
-                        <property name="can_focus">False</property>
                     <property name="orientation">vertical</property>
                     <child>
-                          <object class="GtkListBox" id="remote_devices_list">
+                      <object class="GtkFrame" id="remote_no_devices">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="shadow_type">in</property>
+                        <child>
+                          <object class="GtkListBox">
                             <property name="visible">True</property>
                             <property name="can_focus">True</property>
                             <property name="selection_mode">none</property>
                             <child>
-                              <object class="GtkListBoxRow" id="remote_no_devices">
+                              <object class="GtkListBoxRow">
                                 <property name="visible">True</property>
                                 <property name="can_focus">False</property>
                                 <property name="activatable">False</property>