/* * xlog - GTK+ logging program for amateur radio operators * Copyright (C) 2001 - 2005 Joop Stakenborg * * 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 2 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 Library General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include "support.h" #include "netkeyer.h" #include "gui_netkeyer.h" #include "utils.h" #include "types.h" GtkWidget *keyerwindow = NULL; extern preferencestype preferences; extern statetype state; /* delete keyer window and save settings, close connection to cwdaemon */ static gboolean on_keyerwindow_delete_event (GtkWidget * widget, GdkEvent * event, gpointer user_data) { GtkWidget *f1entry, *f2entry, *f3entry, *f4entry, *f5entry, *f6entry, *f7entry, *f8entry, *f9entry, *f10entry, *wpm; gchar *temp; wpm = lookup_widget (keyerwindow, "wpm"); f1entry = lookup_widget (keyerwindow, "f1entry"); f2entry = lookup_widget (keyerwindow, "f2entry"); f3entry = lookup_widget (keyerwindow, "f3entry"); f4entry = lookup_widget (keyerwindow, "f4entry"); f5entry = lookup_widget (keyerwindow, "f5entry"); f6entry = lookup_widget (keyerwindow, "f6entry"); f7entry = lookup_widget (keyerwindow, "f7entry"); f8entry = lookup_widget (keyerwindow, "f8entry"); f9entry = lookup_widget (keyerwindow, "f9entry"); f10entry = lookup_widget (keyerwindow, "f10entry"); preferences.cwspeed = gtk_spin_button_get_value (GTK_SPIN_BUTTON(wpm)); temp = gtk_editable_get_chars (GTK_EDITABLE (f1entry), 0, -1); if (strlen (temp) == 0) preferences.cwf1 = g_strdup ("^"); else preferences.cwf1 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f2entry), 0, -1); if (strlen (temp) == 0) preferences.cwf2 = g_strdup ("^"); else preferences.cwf2 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f3entry), 0, -1); if (strlen (temp) == 0) preferences.cwf3 = g_strdup ("^"); else preferences.cwf3 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f4entry), 0, -1); if (strlen (temp) == 0) preferences.cwf4 = g_strdup ("^"); else preferences.cwf4 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f5entry), 0, -1); if (strlen (temp) == 0) preferences.cwf5 = g_strdup ("^"); else preferences.cwf5 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f6entry), 0, -1); if (strlen (temp) == 0) preferences.cwf6 = g_strdup ("^"); else preferences.cwf6 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f7entry), 0, -1); if (strlen (temp) == 0) preferences.cwf7 = g_strdup ("^"); else preferences.cwf7 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f8entry), 0, -1); if (strlen (temp) == 0) preferences.cwf8 = g_strdup ("^"); else preferences.cwf8 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f9entry), 0, -1); if (strlen (temp) == 0) preferences.cwf9 = g_strdup ("^"); else preferences.cwf9 = g_strdup (temp); temp = gtk_editable_get_chars (GTK_EDITABLE (f10entry), 0, -1); if (strlen (temp) == 0) preferences.cwf10 = g_strdup ("^"); else preferences.cwf10 = g_strdup (temp); g_free (temp); netkeyer_close (); keyerwindow = NULL; return FALSE; } /* grab an entry and send it over the UDP socket */ void cw (GtkButton *button, gpointer user_data) { GtkWidget *entry; gchar *entryname, *sendentry; gint result; entryname = g_strdup_printf("%sentry", (gchar *)user_data); entry = lookup_widget (keyerwindow, entryname); sendentry = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); if (strlen (sendentry) > 0) { result = tonetkeyer (K_MESSAGE, sendentry); if (result == -1) update_statusbar (_("send to cwdaemon failed")); } g_free (sendentry); g_free (entryname); } /* stop button clicked */ static void stop (GtkButton *button, gpointer user_data) { gint result; result = tonetkeyer (K_ABORT, NULL); } /* catch keys when keyerwindow has focus, so we can use F1-F10, ESC and PgUp, PgDn */ static gboolean on_keyerwindow_keypress (GtkWidget *widget, GdkEventKey *event, gpointer data) { gint result, cwspeed; GtkWidget *wpm; switch (event->keyval) { case GDK_F1: cw (NULL, "f1"); break; case GDK_F2: cw (NULL, "f2"); break; case GDK_F3: cw (NULL, "f3"); break; case GDK_F4: cw (NULL, "f4"); break; case GDK_F5: cw (NULL, "f5"); break; case GDK_F6: cw (NULL, "f6"); break; case GDK_F7: cw (NULL, "f7"); break; case GDK_F8: cw (NULL, "f8"); break; case GDK_F9: cw (NULL, "f9"); break; case GDK_F10: cw (NULL, "f10"); break; case GDK_Escape: result = tonetkeyer (K_ABORT, NULL); case GDK_Page_Up: wpm = lookup_widget (keyerwindow, "wpm"); if (!GTK_WIDGET_HAS_FOCUS (wpm)) { cwspeed = gtk_spin_button_get_value (GTK_SPIN_BUTTON(wpm)); gtk_spin_button_set_value (GTK_SPIN_BUTTON(wpm), cwspeed + 2); } break; case GDK_Page_Down: wpm = lookup_widget (keyerwindow, "wpm"); if (!GTK_WIDGET_HAS_FOCUS (wpm)) { cwspeed = gtk_spin_button_get_value (GTK_SPIN_BUTTON(wpm)); gtk_spin_button_set_value (GTK_SPIN_BUTTON(wpm), cwspeed - 2); } break; break; default: break; } return FALSE; } /* handle changes to the wpm spin button */ static void change_wpm (GtkSpinButton *wpm, gpointer user_data) { gint cwspeed, result; gchar *value; cwspeed = gtk_spin_button_get_value (wpm); value = g_strdup_printf ("%d", cwspeed); result = tonetkeyer (K_SPEED, value); g_free (value); } /* send typed text */ static void send_text (GtkTextBuffer * buffer, GtkTextIter * iter, gchar * text, gint len, gpointer user_data) { gint result; result = tonetkeyer (K_MESSAGE, text); if (result < 0) update_statusbar (_("Keyer send failed")); } /* do we run a contest? */ static void on_contest_toggled (GtkToggleButton * togglebutton, gpointer user_data) { state.contest = gtk_toggle_button_get_active (togglebutton); } /* activate keyer window and initialize UDP socket */ void on_keyer_activate (GtkMenuItem * menuitem, gpointer user_data) { GtkWidget *keyervbox, *hbox1, *hbox2, *hbox3, *hbox4, *hbox5, *hbox6, *hbox7, *hsep, *f1button, *f1entry, *f6button, *f6entry, *f2button, *f2entry, *f7button, *f7entry, *f3button, *f3entry, *f8button, *f8entry, *f4button, *f4entry, *f9button, *f9entry, *f5button, *f5entry, *f10button, *f10entry, *scrolledkeyerwindow, *keyertext, *wpm, *wpmcountlabel, *count, *stopbutton, *contestcheckbutton, *checkstopbutton, *checkbutton9, *checkbutton0; GtkObject *wpm_adj, *count_adj; GdkPixbuf *keyer_icon_pixbuf; GtkTextBuffer *buffer; gint result = 0; gchar *speed; keyerwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (keyerwindow), _("xlog - cwdaemon")); keyer_icon_pixbuf = create_pixbuf ("xlog.png"); if (keyer_icon_pixbuf) { gtk_window_set_icon (GTK_WINDOW (keyerwindow), keyer_icon_pixbuf); g_object_unref (keyer_icon_pixbuf); } gtk_window_set_destroy_with_parent (GTK_WINDOW(keyerwindow), TRUE); keyervbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (keyerwindow), keyervbox); gtk_container_set_border_width (GTK_CONTAINER (keyervbox), 4); hbox1 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox1, TRUE, TRUE, 0); f1button = gtk_button_new_with_label ("F1"); gtk_box_pack_start (GTK_BOX (hbox1), f1button, FALSE, FALSE, 0); gtk_widget_set_size_request (f1button, 50, -1); f1entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox1), f1entry, TRUE, TRUE, 0); f6button = gtk_button_new_with_label ("F6"); gtk_box_pack_start (GTK_BOX (hbox1), f6button, FALSE, FALSE, 0); gtk_widget_set_size_request (f6button, 50, -1); f6entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox1), f6entry, TRUE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox2, TRUE, TRUE, 0); f2button = gtk_button_new_with_label ("F2"); gtk_box_pack_start (GTK_BOX (hbox2), f2button, FALSE, FALSE, 0); gtk_widget_set_size_request (f2button, 50, -1); f2entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox2), f2entry, TRUE, TRUE, 0); f7button = gtk_button_new_with_label ("F7"); gtk_box_pack_start (GTK_BOX (hbox2), f7button, FALSE, FALSE, 0); gtk_widget_set_size_request (f7button, 50, -1); f7entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox2), f7entry, TRUE, TRUE, 0); hbox3 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox3, TRUE, TRUE, 0); f3button = gtk_button_new_with_label ("F3"); gtk_box_pack_start (GTK_BOX (hbox3), f3button, FALSE, FALSE, 0); gtk_widget_set_size_request (f3button, 50, -1); f3entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox3), f3entry, TRUE, TRUE, 0); f8button = gtk_button_new_with_label ("F8"); gtk_box_pack_start (GTK_BOX (hbox3), f8button, FALSE, FALSE, 0); gtk_widget_set_size_request (f8button, 50, -1); f8entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox3), f8entry, TRUE, TRUE, 0); hbox4 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox4, TRUE, TRUE, 0); f4button = gtk_button_new_with_label ("F4"); gtk_box_pack_start (GTK_BOX (hbox4), f4button, FALSE, FALSE, 0); gtk_widget_set_size_request (f4button, 50, -1); f4entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox4), f4entry, TRUE, TRUE, 0); f9button = gtk_button_new_with_label ("F9"); gtk_box_pack_start (GTK_BOX (hbox4), f9button, FALSE, FALSE, 0); gtk_widget_set_size_request (f9button, 50, -1); f9entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox4), f9entry, TRUE, TRUE, 0); hbox5 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox5, TRUE, TRUE, 0); f5button = gtk_button_new_with_label ("F5"); gtk_box_pack_start (GTK_BOX (hbox5), f5button, FALSE, FALSE, 0); gtk_widget_set_size_request (f5button, 50, -1); f5entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox5), f5entry, TRUE, TRUE, 0); f10button = gtk_button_new_with_label ("F10"); gtk_box_pack_start (GTK_BOX (hbox5), f10button, FALSE, FALSE, 0); gtk_widget_set_size_request (f10button, 50, -1); f10entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox5), f10entry, TRUE, TRUE, 0); hsep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (keyervbox), hsep, TRUE, TRUE, 3); hbox6 = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox6, FALSE, FALSE, 0); wpm_adj = gtk_adjustment_new (10, 5, 60, 1, 2, 10); wpm = gtk_spin_button_new (GTK_ADJUSTMENT (wpm_adj), 1, 0); gtk_box_pack_start (GTK_BOX (hbox6), wpm, TRUE, TRUE, 0); gtk_widget_set_size_request (wpm, 50, -1); wpmcountlabel = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox6), wpmcountlabel, FALSE, FALSE, 0); count_adj = gtk_adjustment_new (1, 1, 10000, 1, 10, 10); count = gtk_spin_button_new (GTK_ADJUSTMENT (count_adj), 1, 0); gtk_box_pack_start (GTK_BOX (hbox6), count, TRUE, TRUE, 0); gtk_widget_set_size_request (count, 50, -1); stopbutton = gtk_button_new_from_stock (GTK_STOCK_STOP); gtk_box_pack_start (GTK_BOX (hbox6), stopbutton, FALSE, FALSE, 0); hsep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (keyervbox), hsep, TRUE, TRUE, 3); hbox7 = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (keyervbox), hbox7, FALSE, FALSE, 0); contestcheckbutton = gtk_check_button_new_with_label ("Contest"); gtk_box_pack_start (GTK_BOX (hbox7), contestcheckbutton, FALSE, FALSE, 0); // checkstopbutton = gtk_check_button_new_with_label ("1=a, 2=u"); // gtk_box_pack_start (GTK_BOX (hbox7), checkstopbutton, FALSE, FALSE, 0); // checkbutton9 = gtk_check_button_new_with_label ("9=n"); // gtk_box_pack_start (GTK_BOX (hbox7), checkbutton9, FALSE, FALSE, 0); // checkbutton0 = gtk_check_button_new_with_label ("0=t"); // gtk_box_pack_start (GTK_BOX (hbox7), checkbutton0, FALSE, FALSE, 0); scrolledkeyerwindow = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_end (GTK_BOX (keyervbox), scrolledkeyerwindow, FALSE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledkeyerwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledkeyerwindow), GTK_SHADOW_IN); keyertext = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (scrolledkeyerwindow), keyertext); gtk_entry_set_max_length (GTK_ENTRY (f1entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f2entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f3entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f4entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f5entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f6entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f7entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f8entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f9entry), 80); gtk_entry_set_max_length (GTK_ENTRY (f10entry), 80); /* init keyer and set speed */ result = netkeyer_init (); if (result == 1) { update_statusbar (_("gethostbyname for keyer failed")); return; } else if (result == 2) { update_statusbar (_("creation of socket for keyer failed")); return; } gtk_spin_button_set_value (GTK_SPIN_BUTTON (wpm), preferences.cwspeed); speed = g_strdup_printf ("%d", preferences.cwspeed); result = tonetkeyer (K_SPEED, speed); g_free (speed); /* set entries for function keys */ if (g_ascii_strcasecmp (preferences.cwf1, "^")) gtk_entry_set_text (GTK_ENTRY(f1entry), preferences.cwf1); if (g_ascii_strcasecmp (preferences.cwf2, "^")) gtk_entry_set_text (GTK_ENTRY(f2entry), preferences.cwf2); if (g_ascii_strcasecmp (preferences.cwf3, "^")) gtk_entry_set_text (GTK_ENTRY(f3entry), preferences.cwf3); if (g_ascii_strcasecmp (preferences.cwf4, "^")) gtk_entry_set_text (GTK_ENTRY(f4entry), preferences.cwf4); if (g_ascii_strcasecmp (preferences.cwf5, "^")) gtk_entry_set_text (GTK_ENTRY(f5entry), preferences.cwf5); if (g_ascii_strcasecmp (preferences.cwf6, "^")) gtk_entry_set_text (GTK_ENTRY(f6entry), preferences.cwf6); if (g_ascii_strcasecmp (preferences.cwf7, "^")) gtk_entry_set_text (GTK_ENTRY(f7entry), preferences.cwf7); if (g_ascii_strcasecmp (preferences.cwf8, "^")) gtk_entry_set_text (GTK_ENTRY(f8entry), preferences.cwf8); if (g_ascii_strcasecmp (preferences.cwf9, "^")) gtk_entry_set_text (GTK_ENTRY(f9entry), preferences.cwf9); if (g_ascii_strcasecmp (preferences.cwf10, "^")) gtk_entry_set_text (GTK_ENTRY(f10entry), preferences.cwf10); GLADE_HOOKUP_OBJECT (keyerwindow, f1entry, "f1entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f2entry, "f2entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f3entry, "f3entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f4entry, "f4entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f5entry, "f5entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f6entry, "f6entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f7entry, "f7entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f8entry, "f8entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f9entry, "f9entry"); GLADE_HOOKUP_OBJECT (keyerwindow, f10entry, "f10entry"); GLADE_HOOKUP_OBJECT (keyerwindow, wpm, "wpm"); g_signal_connect ((gpointer) keyerwindow, "delete_event", G_CALLBACK (on_keyerwindow_delete_event), NULL); g_signal_connect ((gpointer) keyerwindow, "key_press_event", G_CALLBACK (on_keyerwindow_keypress), NULL); g_signal_connect (G_OBJECT (f1button), "clicked", G_CALLBACK (cw), "f1"); g_signal_connect (G_OBJECT (f2button), "clicked", G_CALLBACK (cw), "f2"); g_signal_connect (G_OBJECT (f3button), "clicked", G_CALLBACK (cw), "f3"); g_signal_connect (G_OBJECT (f4button), "clicked", G_CALLBACK (cw), "f4"); g_signal_connect (G_OBJECT (f5button), "clicked", G_CALLBACK (cw), "f5"); g_signal_connect (G_OBJECT (f6button), "clicked", G_CALLBACK (cw), "f6"); g_signal_connect (G_OBJECT (f7button), "clicked", G_CALLBACK (cw), "f7"); g_signal_connect (G_OBJECT (f8button), "clicked", G_CALLBACK (cw), "f8"); g_signal_connect (G_OBJECT (f9button), "clicked", G_CALLBACK (cw), "f9"); g_signal_connect (G_OBJECT (f10button), "clicked", G_CALLBACK (cw), "f10"); g_signal_connect (G_OBJECT (stopbutton), "clicked", G_CALLBACK (stop), NULL); g_signal_connect (G_OBJECT (wpm), "value_changed", G_CALLBACK (change_wpm), NULL); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(keyertext)); g_signal_connect (G_OBJECT(buffer), "insert-text", G_CALLBACK (send_text), NULL); g_signal_connect (G_OBJECT (contestcheckbutton), "toggled", G_CALLBACK (on_contest_toggled), NULL); gtk_widget_show_all (keyerwindow); }