Skip to content

Linux + iPhone Continuity / iMessage / SMS

more gtk

Zack Bartela84f3f8ab8ca
diff --git a/src/cli/main.cpp b/src/cli/main.cpp
index 1359985..0cc2bd5 100644
--- a/src/cli/main.cpp
+++ b/src/cli/main.cpp
@@ -81,7 +81,12 @@ int main(int argc, char* argv[]) {
std::string err;
if (action == "pair") {
- std::cout << "Pairing response: " << client.pair(err) << std::flush;
+ std::string resp = client.pair("CLI", err);
+ if (!err.empty()) {
+ std::cerr << err << "\n";
+ return 1;
+ }
+ std::cout << "Pairing response: " << resp << std::flush;
} else if (action == "get") {
std::string clip = client.get_clipboard(err);
if (!err.empty()) {
diff --git a/src/core/include/tether/client.hpp b/src/core/include/tether/client.hpp
index 1f906f6..28e7f45 100644
--- a/src/core/include/tether/client.hpp
+++ b/src/core/include/tether/client.hpp
@@ -10,9 +10,11 @@ public:
Client();
~Client();
- // host="" limits targeting to UNIX Socket securely, implicitly triggering daemon boot!
+ // host="" uses the local UNIX socket, auto-launching the daemon if needed.
+ // host!="" opens a TCP+TLS connection to a remote daemon.
bool connect(const std::string& host = "", int port = 5134);
void disconnect();
+ bool is_connected() const;
// Base Level payload loop
std::string send_and_wait(const std::string& payload);
@@ -22,8 +24,8 @@ public:
bool set_clipboard(const std::string& text, std::string& err_out);
std::string list_devices();
- bool accept_device(const std::string& fingerprint);
- std::string pair(std::string& err_out);
+ bool accept_device(const std::string& fingerprint, const std::string& name = "Paired Device");
+ std::string pair(const std::string& device_name, std::string& err_out);
bool send_file(const std::string& path, std::string& err_out);
diff --git a/src/core/src/client.cpp b/src/core/src/client.cpp
index 64ab681..6ab28bd 100644
--- a/src/core/src/client.cpp
+++ b/src/core/src/client.cpp
@@ -34,6 +34,10 @@ void Client::disconnect() {
}
}
+bool Client::is_connected() const {
+ return sock_ >= 0;
+}
+
int Client::connect_unix(bool retry) {
int sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0) return -1;
@@ -155,17 +159,24 @@ std::string Client::list_devices() {
return tether::Crypto::instance().get_known_hosts_dump();
}
-bool Client::accept_device(const std::string& fingerprint) {
+bool Client::accept_device(const std::string& fingerprint, const std::string& name) {
tether::Crypto::instance().init();
- tether::Crypto::instance().add_known_host("Paired App Instance", fingerprint);
+ tether::Crypto::instance().add_known_host(name, fingerprint);
return true;
}
-std::string Client::pair(std::string& err_out) {
+std::string Client::pair(const std::string& device_name, std::string& err_out) {
+ if (!ssl_) {
+ err_out = "Pairing requires a TCP+TLS connection. Use --host to specify a target.";
+ return "";
+ }
nlohmann::json j;
j["command"] = "pair_request";
- j["device_name"] = "Tether Desktop Environment";
+ j["device_name"] = device_name;
std::string response = send_and_wait(j.dump() + "\n");
+ if (response.empty()) {
+ err_out = "No response from daemon.";
+ }
return response;
}
diff --git a/src/core/src/crypto.cpp b/src/core/src/crypto.cpp
index 6bbd74e..358dd14 100644
--- a/src/core/src/crypto.cpp
+++ b/src/core/src/crypto.cpp
@@ -148,6 +148,7 @@ void Crypto::add_known_host(const std::string& name, const std::string& fingerpr
std::ifstream iff(hosts_path_);
if (iff.is_open()) {
try { j = nlohmann::json::parse(iff); } catch (...) {}
+ iff.close();
}
j[fingerprint] = name;
@@ -160,7 +161,7 @@ std::string Crypto::get_known_hosts_dump() const {
if (iff.is_open()) {
try {
nlohmann::json j = nlohmann::json::parse(iff);
- return j.dump();
+ return j.dump(2);
} catch (...) {}
}
return "{}";
diff --git a/src/gtk/main.cpp b/src/gtk/main.cpp
index 6c15376..33ab228 100644
--- a/src/gtk/main.cpp
+++ b/src/gtk/main.cpp
@@ -1,139 +1,449 @@
#include <gtk/gtk.h>
#include <tether/client.hpp>
+#include <tether/crypto.hpp>
#include <iostream>
#include <string>
+#include <nlohmann/json.hpp>
-// Global persistent instance to maintain Wayland socket
-static tether::Client* g_client = nullptr;
+// Always-connected local unix socket client.
+static tether::Client* g_local = nullptr;
-// UI Globals
-GtkWidget* text_view_clip;
-GtkWidget* lbl_status;
-GtkWidget* list_box_devices;
+// Optional remote TCP+TLS client, created when "Connect" is clicked.
+static tether::Client* g_remote = nullptr;
-void on_btn_get_clicked(GtkWidget* widget, gpointer data) {
- if (!g_client) return;
+// UI Widgets
+static GtkWidget* text_view_clip;
+static GtkWidget* lbl_status;
+static GtkWidget* devices_list_box;
+static GtkWidget* entry_fingerprint;
+static GtkWidget* entry_pair_host;
+static GtkWidget* entry_pair_port;
+static GtkWidget* lbl_file_status;
+static GtkWidget* entry_connect_host;
+static GtkWidget* entry_connect_port;
+static GtkWidget* lbl_connect_status;
+static GtkWidget* btn_connect;
+
+// Returns whichever client is active — remote if connected, otherwise local.
+static tether::Client* active_client() {
+ if (g_remote && g_remote->is_connected()) return g_remote;
+ return g_local;
+}
+
+// ─── Connection Bar ───
+
+static void on_btn_connect_clicked(GtkWidget* w, gpointer) {
+ const gchar* h = gtk_entry_get_text(GTK_ENTRY(entry_connect_host));
+ const gchar* p = gtk_entry_get_text(GTK_ENTRY(entry_connect_port));
+
+ if (!h || strlen(h) == 0) {
+ // Disconnect back to local
+ if (g_remote) { delete g_remote; g_remote = nullptr; }
+ gtk_label_set_text(GTK_LABEL(lbl_connect_status), "Local daemon");
+ gtk_button_set_label(GTK_BUTTON(btn_connect), "Connect");
+ return;
+ }
+
+ // If already connected remotely, disconnect first
+ if (g_remote) { delete g_remote; g_remote = nullptr; }
+
+ int port = (p && strlen(p) > 0) ? atoi(p) : 5134;
+ g_remote = new tether::Client();
+ if (g_remote->connect(h, port)) {
+ std::string msg = std::string("Connected to ") + h + ":" + std::to_string(port);
+ gtk_label_set_text(GTK_LABEL(lbl_connect_status), msg.c_str());
+ gtk_button_set_label(GTK_BUTTON(btn_connect), "Disconnect");
+ gtk_entry_set_text(GTK_ENTRY(entry_connect_host), "");
+ } else {
+ gtk_label_set_text(GTK_LABEL(lbl_connect_status), "Connection failed.");
+ delete g_remote; g_remote = nullptr;
+ }
+}
+
+// ─── Clipboard Tab ───
+
+static void on_btn_get_clicked(GtkWidget* w, gpointer) {
+ tether::Client* c = active_client();
+ if (!c) return;
std::string err;
- std::string content = g_client->get_clipboard(err);
+ std::string content = c->get_clipboard(err);
if (!err.empty()) {
- gtk_label_set_text(GTK_LABEL(lbl_status), ("Error: " + err).c_str());
+ gtk_label_set_text(GTK_LABEL(lbl_status), err.c_str());
return;
}
-
- GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view_clip));
- gtk_text_buffer_set_text(buffer, content.c_str(), -1);
- gtk_label_set_text(GTK_LABEL(lbl_status), "Clipboard successfully retrieved.");
+ GtkTextBuffer* buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view_clip));
+ gtk_text_buffer_set_text(buf, content.c_str(), -1);
+ gtk_label_set_text(GTK_LABEL(lbl_status), "Clipboard retrieved.");
}
-void on_btn_set_clicked(GtkWidget* widget, gpointer data) {
- if (!g_client) return;
- GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view_clip));
+static void on_btn_set_clicked(GtkWidget* w, gpointer) {
+ tether::Client* c = active_client();
+ if (!c) return;
+ GtkTextBuffer* buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view_clip));
GtkTextIter start, end;
- gtk_text_buffer_get_bounds(buffer, &start, &end);
- std::string text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
-
+ gtk_text_buffer_get_bounds(buf, &start, &end);
+ std::string text = gtk_text_buffer_get_text(buf, &start, &end, FALSE);
std::string err;
- if (g_client->set_clipboard(text, err)) {
- gtk_label_set_text(GTK_LABEL(lbl_status), "Clipboard successfully updated.");
+ if (c->set_clipboard(text, err)) {
+ gtk_label_set_text(GTK_LABEL(lbl_status), "Clipboard updated.");
} else {
- gtk_label_set_text(GTK_LABEL(lbl_status), ("Error: " + err).c_str());
+ gtk_label_set_text(GTK_LABEL(lbl_status), err.c_str());
+ }
+}
+
+static GtkWidget* build_clipboard_tab() {
+ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
+ gtk_container_set_border_width(GTK_CONTAINER(box), 16);
+
+ GtkWidget* header = gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(header), "<b>Clipboard</b>");
+ gtk_widget_set_halign(header, GTK_ALIGN_START);
+ gtk_box_pack_start(GTK_BOX(box), header, FALSE, FALSE, 0);
+
+ GtkWidget* scroll = gtk_scrolled_window_new(NULL, NULL);
+ gtk_widget_set_vexpand(scroll, TRUE);
+ text_view_clip = gtk_text_view_new();
+ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view_clip), GTK_WRAP_WORD_CHAR);
+ gtk_container_add(GTK_CONTAINER(scroll), text_view_clip);
+ gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 0);
+
+ GtkWidget* btn_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
+ GtkWidget* btn_get = gtk_button_new_with_label("Read From Host");
+ GtkWidget* btn_set = gtk_button_new_with_label("Push To Host");
+ g_signal_connect(btn_get, "clicked", G_CALLBACK(on_btn_get_clicked), NULL);
+ g_signal_connect(btn_set, "clicked", G_CALLBACK(on_btn_set_clicked), NULL);
+ gtk_box_pack_start(GTK_BOX(btn_box), btn_get, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX(btn_box), btn_set, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX(box), btn_box, FALSE, FALSE, 0);
+
+ lbl_status = gtk_label_new("Ready.");
+ gtk_style_context_add_class(gtk_widget_get_style_context(lbl_status), "status-label");
+ gtk_box_pack_start(GTK_BOX(box), lbl_status, FALSE, FALSE, 0);
+
+ return box;
+}
+
+// ─── Devices Tab ───
+
+static void refresh_device_list() {
+ GList* children = gtk_container_get_children(GTK_CONTAINER(devices_list_box));
+ for (GList* iter = children; iter; iter = g_list_next(iter))
+ gtk_widget_destroy(GTK_WIDGET(iter->data));
+ g_list_free(children);
+
+ tether::Crypto::instance().init();
+ std::string dump = tether::Crypto::instance().get_known_hosts_dump();
+
+ try {
+ nlohmann::json hosts = nlohmann::json::parse(dump);
+ if (hosts.empty()) {
+ GtkWidget* row = gtk_label_new("No paired devices.");
+ gtk_widget_set_halign(row, GTK_ALIGN_START);
+ gtk_container_add(GTK_CONTAINER(devices_list_box), row);
+ } else {
+ for (auto& [fp, name_val] : hosts.items()) {
+ std::string name = name_val.is_string() ? name_val.get<std::string>() : "Unknown";
+ std::string markup = "<b>" + name + "</b>\n<small><tt>" + fp + "</tt></small>";
+
+ GtkWidget* row_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
+ gtk_container_set_border_width(GTK_CONTAINER(row_box), 6);
+
+ GtkWidget* icon = gtk_image_new_from_icon_name("network-wired-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
+ gtk_box_pack_start(GTK_BOX(row_box), icon, FALSE, FALSE, 0);
+
+ GtkWidget* label = gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(label), markup.c_str());
+ gtk_label_set_xalign(GTK_LABEL(label), 0.0);
+ gtk_label_set_selectable(GTK_LABEL(label), TRUE);
+ gtk_box_pack_start(GTK_BOX(row_box), label, TRUE, TRUE, 0);
+
+ gtk_list_box_insert(GTK_LIST_BOX(devices_list_box), row_box, -1);
+ }
+ }
+ } catch (...) {
+ GtkWidget* row = gtk_label_new("No paired devices.");
+ gtk_widget_set_halign(row, GTK_ALIGN_START);
+ gtk_container_add(GTK_CONTAINER(devices_list_box), row);
+ }
+ gtk_widget_show_all(devices_list_box);
+}
+
+static void on_btn_accept_clicked(GtkWidget*, gpointer) {
+ const gchar* fp = gtk_entry_get_text(GTK_ENTRY(entry_fingerprint));
+ if (!fp || strlen(fp) == 0) return;
+
+ tether::Client tmp;
+ tmp.accept_device(fp);
+ gtk_entry_set_text(GTK_ENTRY(entry_fingerprint), "");
+ refresh_device_list();
+}
+
+static void on_btn_pair_clicked(GtkWidget* widget, gpointer) {
+ const gchar* h = gtk_entry_get_text(GTK_ENTRY(entry_pair_host));
+ const gchar* p = gtk_entry_get_text(GTK_ENTRY(entry_pair_port));
+ if (!h || strlen(h) == 0) return;
+ int port = (p && strlen(p) > 0) ? atoi(p) : 5134;
+
+ tether::Client pair_client;
+ if (!pair_client.connect(h, port)) {
+ GtkWidget* dlg = gtk_message_dialog_new(
+ GTK_WINDOW(gtk_widget_get_toplevel(widget)),
+ GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+ "Failed to connect to %s:%d", h, port);
+ gtk_dialog_run(GTK_DIALOG(dlg));
+ gtk_widget_destroy(dlg);
+ return;
}
+
+ std::string err;
+ std::string resp = pair_client.pair("Tether GTK", err);
+
+ GtkWidget* dlg = gtk_message_dialog_new(
+ GTK_WINDOW(gtk_widget_get_toplevel(widget)),
+ GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
+ "%s\n\n%s\n\nCheck the remote daemon's output for the fingerprint,\n"
+ "then paste it below and click Accept.",
+ err.empty() ? "Pair request sent." : err.c_str(),
+ resp.c_str());
+ gtk_dialog_run(GTK_DIALOG(dlg));
+ gtk_widget_destroy(dlg);
}
-void apply_css(GtkWidget* widget) {
+static GtkWidget* build_devices_tab() {
+ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
+ gtk_container_set_border_width(GTK_CONTAINER(box), 16);
+
+ GtkWidget* header = gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(header), "<b>Trusted Devices</b>");
+ gtk_widget_set_halign(header, GTK_ALIGN_START);
+ gtk_box_pack_start(GTK_BOX(box), header, FALSE, FALSE, 0);
+
+ // Device list
+ GtkWidget* frame = gtk_frame_new(NULL);
+ GtkWidget* scroll = gtk_scrolled_window_new(NULL, NULL);
+ gtk_widget_set_vexpand(scroll, TRUE);
+ devices_list_box = gtk_list_box_new();
+ gtk_list_box_set_selection_mode(GTK_LIST_BOX(devices_list_box), GTK_SELECTION_NONE);
+ gtk_container_add(GTK_CONTAINER(scroll), devices_list_box);
+ gtk_container_add(GTK_CONTAINER(frame), scroll);
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);
+
+ // Accept
+ GtkWidget* sep1 = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
+ gtk_box_pack_start(GTK_BOX(box), sep1, FALSE, FALSE, 2);
+
+ GtkWidget* accept_lbl = gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(accept_lbl), "<b>Accept a Device</b>");
+ gtk_widget_set_halign(accept_lbl, GTK_ALIGN_START);
+ gtk_box_pack_start(GTK_BOX(box), accept_lbl, FALSE, FALSE, 0);
+
+ GtkWidget* accept_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+ entry_fingerprint = gtk_entry_new();
+ gtk_entry_set_placeholder_text(GTK_ENTRY(entry_fingerprint), "Paste SHA-256 fingerprint");
+ gtk_widget_set_hexpand(entry_fingerprint, TRUE);
+ GtkWidget* btn_accept = gtk_button_new_with_label("Accept");
+ g_signal_connect(btn_accept, "clicked", G_CALLBACK(on_btn_accept_clicked), NULL);
+ gtk_box_pack_start(GTK_BOX(accept_row), entry_fingerprint, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX(accept_row), btn_accept, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(box), accept_row, FALSE, FALSE, 0);
+
+ // Pair with remote
+ GtkWidget* sep2 = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
+ gtk_box_pack_start(GTK_BOX(box), sep2, FALSE, FALSE, 2);
+
+ GtkWidget* pair_lbl = gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(pair_lbl), "<b>Pair with Remote Host</b>");
+ gtk_widget_set_halign(pair_lbl, GTK_ALIGN_START);
+ gtk_box_pack_start(GTK_BOX(box), pair_lbl, FALSE, FALSE, 0);
+
+ GtkWidget* pair_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+ entry_pair_host = gtk_entry_new();
+ gtk_entry_set_placeholder_text(GTK_ENTRY(entry_pair_host), "Host IP");
+ gtk_widget_set_hexpand(entry_pair_host, TRUE);
+ entry_pair_port = gtk_entry_new();
+ gtk_entry_set_placeholder_text(GTK_ENTRY(entry_pair_port), "5134");
+ gtk_entry_set_width_chars(GTK_ENTRY(entry_pair_port), 6);
+ GtkWidget* btn_pair = gtk_button_new_with_label("Send Pair Request");
+ g_signal_connect(btn_pair, "clicked", G_CALLBACK(on_btn_pair_clicked), NULL);
+ gtk_box_pack_start(GTK_BOX(pair_row), entry_pair_host, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX(pair_row), entry_pair_port, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(pair_row), btn_pair, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(box), pair_row, FALSE, FALSE, 0);
+
+ return box;
+}
+
+// ─── File Transfer Tab ───
+
+static void on_file_chosen(GtkWidget* widget, gpointer) {
+ GtkWidget* dialog = gtk_file_chooser_dialog_new(
+ "Select File to Transfer",
+ GTK_WINDOW(gtk_widget_get_toplevel(widget)),
+ GTK_FILE_CHOOSER_ACTION_OPEN,
+ "_Cancel", GTK_RESPONSE_CANCEL,
+ "_Send", GTK_RESPONSE_ACCEPT,
+ NULL);
+
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+ char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+ std::string path(filename);
+ g_free(filename);
+ gtk_widget_destroy(dialog);
+
+ tether::Client* c = active_client();
+ if (!c) {
+ gtk_label_set_text(GTK_LABEL(lbl_file_status), "Not connected.");
+ return;
+ }
+
+ gtk_label_set_text(GTK_LABEL(lbl_file_status), ("Sending: " + path + "...").c_str());
+ while (gtk_events_pending()) gtk_main_iteration();
+
+ std::string err;
+ if (c->send_file(path, err)) {
+ gtk_label_set_text(GTK_LABEL(lbl_file_status), ("Sent: " + path).c_str());
+ } else {
+ gtk_label_set_text(GTK_LABEL(lbl_file_status), ("Error: " + err).c_str());
+ }
+ } else {
+ gtk_widget_destroy(dialog);
+ }
+}
+
+static GtkWidget* build_file_transfer_tab() {
+ GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
+ gtk_container_set_border_width(GTK_CONTAINER(box), 16);
+
+ GtkWidget* header = gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(header), "<b>File Transfer</b>");
+ gtk_widget_set_halign(header, GTK_ALIGN_START);
+ gtk_box_pack_start(GTK_BOX(box), header, FALSE, FALSE, 0);
+
+ GtkWidget* desc = gtk_label_new(
+ "Pick a file to send to the connected host.\n"
+ "Files are chunked via Base64 and saved to the remote Downloads directory.");
+ gtk_label_set_xalign(GTK_LABEL(desc), 0.0);
+ gtk_label_set_line_wrap(GTK_LABEL(desc), TRUE);
+ gtk_style_context_add_class(gtk_widget_get_style_context(desc), "dim-label");
+ gtk_box_pack_start(GTK_BOX(box), desc, FALSE, FALSE, 0);
+
+ GtkWidget* center = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
+ gtk_widget_set_vexpand(center, TRUE);
+ gtk_widget_set_valign(center, GTK_ALIGN_CENTER);
+
+ GtkWidget* icon = gtk_image_new_from_icon_name("document-send-symbolic", GTK_ICON_SIZE_DIALOG);
+ gtk_box_pack_start(GTK_BOX(center), icon, FALSE, FALSE, 0);
+
+ GtkWidget* btn_send = gtk_button_new_with_label("Choose File to Send");
+ gtk_style_context_add_class(gtk_widget_get_style_context(btn_send), "suggested-action");
+ g_signal_connect(btn_send, "clicked", G_CALLBACK(on_file_chosen), NULL);
+ gtk_box_pack_start(GTK_BOX(center), btn_send, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(box), center, TRUE, TRUE, 0);
+
+ lbl_file_status = gtk_label_new("No transfers yet.");
+ gtk_style_context_add_class(gtk_widget_get_style_context(lbl_file_status), "status-label");
+ gtk_box_pack_start(GTK_BOX(box), lbl_file_status, FALSE, FALSE, 0);
+
+ return box;
+}
+
+// ─── CSS ───
+
+static void apply_css() {
GtkCssProvider* provider = gtk_css_provider_new();
- const gchar* css =
- "window { "
- " background-color: @theme_bg_color; "
- "} "
- "textview { "
+ const gchar* css =
+ "textview text { "
" background-color: @theme_base_color; "
" color: @theme_fg_color; "
+ "} "
+ "textview { "
" font-family: monospace; "
" border-radius: 8px; "
- " padding: 12px; "
+ " padding: 8px; "
"} "
"button { "
" border-radius: 6px; "
- " padding: 8px 16px; "
- " font-weight: bold; "
- "} "
- "button:hover { "
- " background-color: @theme_selected_bg_color; "
- " color: @theme_selected_fg_color; "
- "} "
- ".header-label { "
- " font-size: 16px; "
- " font-weight: 800; "
- " color: @theme_fg_color; "
+ " padding: 6px 14px; "
"} "
".status-label { "
- " color: @theme_selected_bg_color; "
" font-weight: bold; "
- "}";
-
+ " color: @theme_selected_bg_color; "
+ "} "
+ "notebook tab { "
+ " padding: 6px 16px; "
+ "} "
+ "frame { "
+ " border-radius: 8px; "
+ "} ";
+
gtk_css_provider_load_from_data(provider, css, -1, NULL);
- gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
- GTK_STYLE_PROVIDER(provider),
- GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+ gtk_style_context_add_provider_for_screen(
+ gdk_screen_get_default(),
+ GTK_STYLE_PROVIDER(provider),
+ GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(provider);
}
-static void activate(GtkApplication* app, gpointer user_data) {
- // Scaffold initial network multiplexer natively
- if (!g_client) {
- g_client = new tether::Client();
- if (!g_client->connect()) {
- std::cerr << "CRITICAL: Could not engage local unix tetherd pipeline natively.\n";
- exit(1);
+// ─── Application ───
+
+static void activate(GtkApplication* app, gpointer) {
+ if (!g_local) {
+ g_local = new tether::Client();
+ if (!g_local->connect()) {
+ std::cerr << "Warning: could not connect to local tetherd.\n";
}
}
+ g_object_set(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", TRUE, NULL);
+ apply_css();
+
GtkWidget* window = gtk_application_window_new(app);
- gtk_window_set_title(GTK_WINDOW(window), "Tether Control Center");
- gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
+ gtk_window_set_title(GTK_WINDOW(window), "Tether");
+ gtk_window_set_default_size(GTK_WINDOW(window), 580, 500);
- // Prefer Dark Theme
- g_object_set(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", TRUE, NULL);
- apply_css(window);
+ GtkWidget* outer = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+ gtk_container_add(GTK_CONTAINER(window), outer);
- GtkWidget* main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 16);
- gtk_container_set_border_width(GTK_CONTAINER(main_box), 20);
- gtk_container_add(GTK_CONTAINER(window), main_box);
+ // Connection bar at top
+ GtkWidget* conn_bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_container_set_border_width(GTK_CONTAINER(conn_bar), 8);
- // Header Frame
- GtkWidget* header = gtk_label_new("Wayland Clipboard Engine");
- gtk_widget_set_halign(header, GTK_ALIGN_START);
- GtkStyleContext* ctx = gtk_widget_get_style_context(header);
- gtk_style_context_add_class(ctx, "header-label");
- gtk_box_pack_start(GTK_BOX(main_box), header, FALSE, FALSE, 0);
+ GtkWidget* conn_lbl = gtk_label_new("Remote:");
+ gtk_box_pack_start(GTK_BOX(conn_bar), conn_lbl, FALSE, FALSE, 0);
- // Text View Frame
- GtkWidget* scroll = gtk_scrolled_window_new(NULL, NULL);
- gtk_widget_set_vexpand(scroll, TRUE);
- text_view_clip = gtk_text_view_new();
- gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view_clip), GTK_WRAP_WORD_CHAR);
- gtk_container_add(GTK_CONTAINER(scroll), text_view_clip);
- gtk_box_pack_start(GTK_BOX(main_box), scroll, TRUE, TRUE, 0);
+ entry_connect_host = gtk_entry_new();
+ gtk_entry_set_placeholder_text(GTK_ENTRY(entry_connect_host), "Host IP (leave empty for local)");
+ gtk_widget_set_hexpand(entry_connect_host, TRUE);
+ gtk_box_pack_start(GTK_BOX(conn_bar), entry_connect_host, TRUE, TRUE, 0);
- // Button Row
- GtkWidget* btn_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
- GtkWidget* btn_get = gtk_button_new_with_label("Read From Host");
- GtkWidget* btn_set = gtk_button_new_with_label("Push To Host");
-
- g_signal_connect(btn_get, "clicked", G_CALLBACK(on_btn_get_clicked), NULL);
- g_signal_connect(btn_set, "clicked", G_CALLBACK(on_btn_set_clicked), NULL);
+ entry_connect_port = gtk_entry_new();
+ gtk_entry_set_placeholder_text(GTK_ENTRY(entry_connect_port), "5134");
+ gtk_entry_set_width_chars(GTK_ENTRY(entry_connect_port), 6);
+ gtk_box_pack_start(GTK_BOX(conn_bar), entry_connect_port, FALSE, FALSE, 0);
- gtk_box_pack_start(GTK_BOX(btn_box), btn_get, TRUE, TRUE, 0);
- gtk_box_pack_start(GTK_BOX(btn_box), btn_set, TRUE, TRUE, 0);
- gtk_box_pack_start(GTK_BOX(main_box), btn_box, FALSE, FALSE, 0);
+ btn_connect = gtk_button_new_with_label("Connect");
+ g_signal_connect(btn_connect, "clicked", G_CALLBACK(on_btn_connect_clicked), NULL);
+ gtk_box_pack_start(GTK_BOX(conn_bar), btn_connect, FALSE, FALSE, 0);
- // Status Footprint
- lbl_status = gtk_label_new("Connected natively via UNIX sockets.");
- gtk_widget_set_halign(lbl_status, GTK_ALIGN_CENTER);
- gtk_style_context_add_class(gtk_widget_get_style_context(lbl_status), "status-label");
- gtk_box_pack_start(GTK_BOX(main_box), lbl_status, FALSE, FALSE, 0);
+ lbl_connect_status = gtk_label_new("Local daemon");
+ gtk_style_context_add_class(gtk_widget_get_style_context(lbl_connect_status), "status-label");
+ gtk_box_pack_start(GTK_BOX(conn_bar), lbl_connect_status, FALSE, FALSE, 0);
+
+ gtk_box_pack_start(GTK_BOX(outer), conn_bar, FALSE, FALSE, 0);
+
+ GtkWidget* sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
+ gtk_box_pack_start(GTK_BOX(outer), sep, FALSE, FALSE, 0);
+
+ // Notebook
+ GtkWidget* notebook = gtk_notebook_new();
+ gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
+ gtk_box_pack_start(GTK_BOX(outer), notebook, TRUE, TRUE, 0);
+
+ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), build_clipboard_tab(), gtk_label_new("Clipboard"));
+ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), build_devices_tab(), gtk_label_new("Devices"));
+ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), build_file_transfer_tab(), gtk_label_new("Files"));
+ refresh_device_list();
gtk_widget_show_all(window);
}
@@ -142,6 +452,7 @@ int main(int argc, char** argv) {
g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);
int status = g_application_run(G_APPLICATION(app), argc, argv);
g_object_unref(app);
- if (g_client) { delete g_client; }
+ delete g_local;
+ delete g_remote;
return status;
}