N0VA/BeamMeUp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Tobias Bernard
2017-10-28 19:05:07 +02:00
parent 7d591376e2 6b7d5c2acc
commit 9e88bb3005
9 changed files with 669 additions and 464 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/meson.build
View File

@@ -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',

26
src/remote_list.ui
View File

@@ -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>

174
src/teleport-browser.c
View File

@@ -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, interface, protocol, name, type, domain, AVAHI_PROTO_INET, 0, resolve_callback, c)))
fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_client_errno(c)));
if (!(avahi_service_resolver_new(c,
interface,
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);
//teleport_app_remove_peer(name);
fprintf(stderr,
"(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);
ret = 0;
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
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, AVAHI_IF_UNSPEC, AVAHI_PROTO_INET, "_teleport._tcp", NULL, 0, browse_callback, client))) {
if (!(avahi_service_browser_new(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);

2
src/teleport-browser.h
View File

@@ -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);

431
src/teleport-remote-device.c Normal file
View File

@@ -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)
{
}

41
src/teleport-remote-device.h Normal file
View File

@@ -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 */

309
src/teleport-window.c
View File

@@ -4,27 +4,7 @@
#include "teleport-window.h"
#include "teleport-server.h"
#include "teleport-peer.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);
#include "teleport-remote-device.h"
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 *row;
GtkLabel *name_label;
GtkButton *send_btn;
//GtkWidget *line;
GtkWidget *remote_device;
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"));
name_label = GTK_LABEL (gtk_builder_get_object (builder_remote_list, "device_name"));
gtk_label_set_text(name_label, device->name);
gtk_list_box_insert(GTK_LIST_BOX(priv->remote_devices_list), row, -1);
send_btn = GTK_BUTTON (gtk_builder_get_object (builder_remote_list, "send_btn"));
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);
gtk_box_pack_end (GTK_BOX (priv->remote_devices_box),
remote_device,
TRUE,
TRUE,
0);
}
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);
while (remote_row != NULL) {
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));
gtk_container_foreach (GTK_CONTAINER(priv->remote_devices_box),
remove_remote_peer,
device);
}
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 *

18
src/window.ui
View File

@@ -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>