From f9589902bb29dcba43d4ea739a475ac4e3439089 Mon Sep 17 00:00:00 2001 From: KB8PMY Date: Wed, 3 Apr 2024 22:02:43 -0400 Subject: [PATCH] first commit --- BPQTermTCP.ini | 11 + TermTCP.cbp | 45 ++ TermTCP32 | Bin 0 -> 41723 bytes TermTCP32.c | 1396 ++++++++++++++++++++++++++++++++++++++++ bpqicon.ico | Bin 0 -> 766 bytes bpqicon.png | Bin 0 -> 253 bytes oldTermTCP.c | 1650 ++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 3102 insertions(+) create mode 100644 BPQTermTCP.ini create mode 100644 TermTCP.cbp create mode 100755 TermTCP32 create mode 100644 TermTCP32.c create mode 100644 bpqicon.ico create mode 100644 bpqicon.png create mode 100644 oldTermTCP.c diff --git a/BPQTermTCP.ini b/BPQTermTCP.ini new file mode 100644 index 0000000..c490f19 --- /dev/null +++ b/BPQTermTCP.ini @@ -0,0 +1,11 @@ +[Session 1] +MTX=1 +MCOM=1 +MonNODES=0 +ChatMode=0 +Bells=0 +CurrentHost=0 +MONColour=1 +MonPorts=6 +PortMask=65519 +MUIONLY=0 diff --git a/TermTCP.cbp b/TermTCP.cbp new file mode 100644 index 0000000..4b4059e --- /dev/null +++ b/TermTCP.cbp @@ -0,0 +1,45 @@ + + + + + + diff --git a/TermTCP32 b/TermTCP32 new file mode 100755 index 0000000000000000000000000000000000000000..d217b33ea1f08af9067088e91d94328f02a73cd8 GIT binary patch literal 41723 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 +#include +#include +#include "readconfig.h" +#include "configmenu.h" +#include "disconnect.h" +#include "ptoggled.h" +#include "tcpconnect.h" +#include "toggled.h" + +GdkPixbuf *create_pixbuf(const gchar * filename) +{ + GdkPixbuf *pixbuf; + GError *error = NULL; + pixbuf = gdk_pixbuf_new_from_file(filename, &error); + if(!pixbuf) { + fprintf(stderr, "%s\n", error->message); + g_error_free(error); + } + + return pixbuf; +} + +#ifdef WIN32 +#include "winsock2.h" +#include "WS2tcpip.h" + +#else +#include +#include +#include +#include +#include +#include +#include +#include + +#define SOCKET int +#define closesocket close +typedef gint32 COLORREF; +#define RGB(r,g,b) ((COLORREF)(((guint8)(r)|((guint16)((guint8)(g))<<8))|(((guint32)(guint8)(b))<<16))) + +#endif + + +gint gx, gy; +int height; +int width; +int PortMask=65535; +int Bells = FALSE; +int MonNODES = FALSE; +int MONColour = TRUE; +int ChatMode = FALSE; +int MonPorts = 1; +int muionly = 1; +int mtxparam=1; +int MCOM=1; +int CurrentHost = 0; + +char Host[5][100]; +char Port[5][10]; +char UserName[5][80]; +char Password[5][80]; +char fPath[5][100]; + + +char Host[5][100]; +char Port[5][10]; +char UserName[5][80]; +char Password[5][80]; +char Path[5][100]; +char Test1[5][100]; +char Test2[5][100]; +char Pass[5][100]; +char path[5][100]; + +char HN[5][6] = {"Host1", "Host2", "Host3", "Host4"}; +char PN[5][6] = {"Port1", "Port2", "Port3", "Port4"}; +char PASSN[5][6] = {"Pass1", "Pass2", "Pass3", "Pass4"}; +char UN[5][6] = {"User1", "User2", "User3", "User4"}; +char pn[5][6] = {"Path"}; +char VersionString[80] = "1.0.0.32"; + +char DisMsg[] = "*** Disconnected\r"; +char Save[1000]; +int SaveLen; +int Split; +int x, y; +int StripLF = FALSE; +int LogMonitor = FALSE; +int LogOutput = FALSE; +int SendDisconnected = TRUE; + +int position; +int left = 100, top = 100, right = 500, bottom = 500; +char Position[50]; + +gint xx, yy; +gint xxx, yyy; +char outputmon[50]; +char monitormon [50]; +int Connecting = FALSE; +int Disconnecting = FALSE; +int Connected = FALSE; +int SocketActive = FALSE; +int monitormon1; + +char Title[80]; + +void SendTraceOptions(); + +int TCPConnect(char * Host, char * Port); +void WritetoOutputWindow(const char * Text, int Len); +void WritetoMonWindow(char * Text, int Len); +int Telnet_Connected(SOCKET sock, int Error); +int SendMsg(const char * msg, int len); + +#ifdef WIN32 + +void __cdecl Debugprintf(const char * format, ...) +{ + char Mess[1000]; + va_list(arglist); + + va_start(arglist, format); + vsprintf(Mess, format, arglist); + strcat(Mess, "\r\n"); + OutputDebugString(Mess); + + return; +} +#endif + +COLORREF Colours[256] = {0, + RGB(0,0,0), RGB(0,0,128), RGB(0,0,192), RGB(0,0,255), // 1 - 4 + RGB(0,64,0), RGB(0,64,128), RGB(0,64,192), RGB(0,64,255), // 5 - 8 + RGB(0,128,0), RGB(0,128,128), RGB(0,128,192), RGB(0,128,255), // 9 - 12 + RGB(0,192,0), RGB(0,192,128), RGB(0,192,192), RGB(0,192,255), // 13 - 16 + RGB(0,255,0), RGB(0,255,128), RGB(0,255,192), RGB(0,255,255), // 17 - 20 + + RGB(64,0,0), RGB(64,0,128), RGB(64,0,192), RGB(0,0,255), // 21 + RGB(64,64,0), RGB(64,64,128), RGB(64,64,192), RGB(64,64,255), + RGB(64,128,0), RGB(64,128,128), RGB(64,128,192), RGB(64,128,255), + RGB(64,192,0), RGB(64,192,128), RGB(64,192,192), RGB(64,192,255), + RGB(64,255,0), RGB(64,255,128), RGB(64,255,192), RGB(64,255,255), + + RGB(128,0,0), RGB(128,0,128), RGB(128,0,192), RGB(128,0,255), // 41 + RGB(128,64,0), RGB(128,64,128), RGB(128,64,192), RGB(128,64,255), + RGB(128,128,0), RGB(128,128,128), RGB(128,128,192), RGB(128,128,255), + RGB(128,192,0), RGB(128,192,128), RGB(128,192,192), RGB(128,192,255), + RGB(128,255,0), RGB(128,255,128), RGB(128,255,192), RGB(128,255,255), + + RGB(192,0,0), RGB(192,0,128), RGB(192,0,192), RGB(192,0,255), // 61 + RGB(192,64,0), RGB(192,64,128), RGB(192,64,192), RGB(192,64,255), + RGB(192,128,0), RGB(192,128,128), RGB(192,128,192), RGB(192,128,255), + RGB(192,192,0), RGB(192,192,128), RGB(192,192,192), RGB(192,192,255), + RGB(192,255,0), RGB(192,255,128), RGB(192,255,192), RGB(192,2552,255), + + RGB(255,0,0), RGB(255,0,128), RGB(255,0,192), RGB(255,0,255), // 81 + RGB(255,64,0), RGB(255,64,128), RGB(255,64,192), RGB(255,64,255), + RGB(255,128,0), RGB(255,128,128), RGB(255,128,192), RGB(255,128,255), + RGB(255,192,0), RGB(255,192,128), RGB(255,192,192), RGB(255,192,255), + RGB(255,255,0), RGB(255,255,128), RGB(255,255,192), RGB(255,2552,255) +}; + + +SOCKET RecvSocket; +SOCKET sock; + +GtkWidget *dialog; +GtkWidget *window; +GtkWidget *box1; +GtkWidget *box2; +GtkWidget *box3; +GtkWidget *box10; +GtkWidget *hbox; +GtkWidget *button; +GtkWidget *check; +GtkWidget *separator; +GtkWidget *table; +GtkWidget *vscrollbar; +GtkWidget *vscrollbar2; +GtkTextBuffer *text; +GtkTextBuffer *text2; +GtkWidget *entry; +GtkWidget *vpaned; +GtkWidget *frame1; +GtkWidget *frame2; +GIOChannel *RecvChannel; +GtkWidget *menubar; +GtkWidget *view; +GtkWidget* scrolledwin; +GtkWidget *view2; +GtkWidget* scrolledwin2; +GtkWidget *montx; +GtkWidget *monsup; +GtkWidget *monnode; +GtkWidget *encol; +GtkWidget *mui; +GtkWidget *addpor; +GtkWidget *menubar; +GtkWidget *conmenu, *conn_item, *Conn[4], *Conn2, *Conn3, *Conn4; +GtkWidget *discmenu, *dis_item, sid_item; +GtkWidget *cfgmenu, *tcp_item, *font_item, *strip_item, *logmon_item, *logout_item, *cfg_item, *chat_term, *Cfg[4], *Cfg2, *Cfg3, *Cfg4; +GtkWidget *monmenu, *mon_item, *mon[32]; +GtkWidget *tcpmenu; +GtkWidget *enbel, *enbel_item; +GtkWidget *propmenu,*propitem,*Prop; + +GtkTextTag *rtag, *btag, *tag[256], *tagm[256]; + +void EnableDisconnectMenu(); +void DisableConnectMenu(); +void EnableConnectMenu(); +void DisableDisconnectMenu(); + +void close_application(GtkWidget *widget, gpointer data) +{ + gtk_main_quit (); + return 0; +} + +void enter_callback( GtkWidget *widget, + GtkWidget *entry ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (entry)); + + if (!Connected && ! Connecting) + { + TCPConnect(Host[CurrentHost], Port[CurrentHost]); + gtk_entry_set_text (GTK_ENTRY (entry), ""); + return ; + } + + SendMsg(entry_text, strlen(entry_text)); + SendMsg("\r", 1); + WritetoOutputWindow(entry_text, strlen(entry_text)); + WritetoOutputWindow("\r ", 1); + gtk_entry_set_text (GTK_ENTRY (entry), ""); +} + +// Disconnect(GtkWidget *w, gpointer data); + +// gtk_widget_destroy (dialog); +//} +static void AddPortItem(GtkWidget *w, int * data ) +{ + char Port[10]; + sprintf(Port, "Port %d", MonPorts + 1); + mon[MonPorts] = gtk_check_menu_item_new_with_label (Port); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)mon[MonPorts], (PortMask >> MonPorts) & MonPorts); + + // Set Callback to PToggled. Parameter is Port Number + g_signal_connect (mon[MonPorts], "toggled", G_CALLBACK (PToggled), (void *) MonPorts); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, mon[MonPorts]); + + MonPorts++; + + gtk_widget_show_all (menubar); + + return; +} + + void Configure(); + +GtkWidget *get_menubar_menu(GtkWidget *window) +{ + int i; + + menubar = gtk_menu_bar_new(); + conmenu = gtk_menu_new(); + cfgmenu = gtk_menu_new(); + discmenu = gtk_menu_new(); + monmenu = gtk_menu_new(); + montx = gtk_menu_new(); + monsup = gtk_menu_new(); + monnode = gtk_menu_new(); + encol = gtk_menu_new(); + addpor = gtk_menu_new(); + tcpmenu = gtk_menu_new(); + enbel = gtk_menu_new(); + mui = gtk_menu_new(); + propmenu = gtk_menu_new(); + + /* Create the menu items */ + + for (i = 0; i < 4; i++) + { + Conn[i] = gtk_check_menu_item_new_with_label (Host[i]); + gtk_menu_shell_append (GTK_MENU_SHELL (conmenu), Conn[i]); + gtk_check_menu_item_set_active((GtkCheckMenuItem *) Conn[i], CurrentHost == i); + g_signal_connect (Conn[i], ("toggled"), G_CALLBACK (Toggled), (void *) &CurrentHost); + + Cfg[i] = gtk_menu_item_new_with_label (Host[i]); + gtk_menu_shell_append (GTK_MENU_SHELL (tcpmenu), Cfg[i]); + + + /* Attach the callback functions to the activate signal */ + + g_signal_connect (Conn[i], "activate", G_CALLBACK (Connect), (void *) i); + g_signal_connect (Cfg[i], "activate", G_CALLBACK (Configure), (void *) i); + + } + + conn_item = gtk_menu_item_new_with_label ("Connect"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (conn_item), conmenu); + + dis_item = gtk_menu_item_new_with_label ("Disconnect"); + g_signal_connect (dis_item, "activate", G_CALLBACK (Disconnect), 0); + gtk_widget_set_sensitive(dis_item, TRUE); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (dis_item), discmenu); + + cfg_item = gtk_menu_item_new_with_label ("Setup"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (cfg_item), cfgmenu); + + enbel = gtk_check_menu_item_new_with_label ("Enable Bells"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)enbel, Bells); + g_signal_connect (enbel, "toggled", G_CALLBACK(Toggled), (void *) &Bells); + + logmon_item = gtk_menu_item_new_with_label ("Log Monitor"); + logout_item = gtk_menu_item_new_with_label ("Log Output"); + + chat_term = gtk_check_menu_item_new_with_label ("Chat Terminal Mode"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *) chat_term, ChatMode); + g_signal_connect (chat_term, ("toggled"), G_CALLBACK (Toggled), (void *) &ChatMode); + + propitem = gtk_menu_item_new_with_label ("Properties"); + // g_signal_connect (Prop, "activate", G_CALLBACK (property), (void *) i); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (propitem), propmenu); + + + tcp_item = gtk_menu_item_new_with_label ("TCP Hosts"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (tcp_item), tcpmenu); + + mon_item = gtk_menu_item_new_with_label ("Monitor"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (mon_item), monmenu); + + montx = gtk_check_menu_item_new_with_label ("Monitor TX"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)montx, mtxparam); + g_signal_connect (montx, "toggled", G_CALLBACK (Toggled), (void *) &mtxparam); + + monsup = gtk_check_menu_item_new_with_label ("Monitor Supervisor"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)monsup, MCOM); + g_signal_connect (monsup, "toggled", G_CALLBACK (Toggled), (void *) &MCOM); + + monnode = gtk_check_menu_item_new_with_label ("Monitor Nodes"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)monnode, MonNODES); + g_signal_connect (monnode, "toggled", G_CALLBACK (Toggled), (void *) &MonNODES); + + mui = gtk_check_menu_item_new_with_label ("Monitor UI Only"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)mui, muionly); + g_signal_connect (mui, "toggled", G_CALLBACK (Toggled), (void *) &muionly); + + encol = gtk_check_menu_item_new_with_label ("Enable Colour"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)encol, MONColour); + g_signal_connect (encol, "toggled", G_CALLBACK (Toggled), (void *) &MONColour); + + addpor = gtk_menu_item_new_with_label ("Add Port"); + g_signal_connect (addpor, "activate", G_CALLBACK (AddPortItem), (void *) 0); + + + /* Add them to the menu */ + + gtk_menu_shell_append ((GtkMenuShell *)menubar, conn_item); + gtk_menu_shell_append ((GtkMenuShell *)menubar, dis_item); + gtk_menu_shell_append ((GtkMenuShell *)menubar, cfg_item); + gtk_menu_shell_append ((GtkMenuShell *)menubar, mon_item); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, montx); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, monsup); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, monnode); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, mui); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, encol); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, addpor); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, tcp_item); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, propitem); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, enbel); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, logmon_item); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, logout_item); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, chat_term); + + for (i = 0; i < MonPorts; i++) + + { + + char Port[10]; + sprintf(Port, "Port %d", i + 1); + mon[i] = gtk_check_menu_item_new_with_label (Port); + + // Set the Checked flag from the corresponding bit of PortMask + gtk_check_menu_item_set_active((GtkCheckMenuItem *)mon[i], (PortMask >> i) & 1); + + // Call PToggled() when menu is selected. Data to PToggled is Port Number + g_signal_connect (mon[i], "toggled", G_CALLBACK (PToggled), (void *) i); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, mon[i]); + + } + + gtk_widget_show_all (menubar); + + SendTraceOptions(); + + return menubar; + +} + +gint ScrollTimer(gpointer data) +{ + GtkTextIter iter; + + gtk_text_buffer_get_end_iter(text, &iter); + gtk_text_view_scroll_to_iter ((GtkTextView *)view, &iter, 0.0, FALSE, 0.0, 0.0); + + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_view_scroll_to_iter ((GtkTextView *)view2, &iter, 0.0, FALSE, 0.0, 0.0); + + return FALSE; +} + +static fd_set readfs; +static fd_set writefs; +static fd_set errorfs; +static struct timeval timeout; + +int MonData = FALSE; + + +//int Connecting = FALSE; +//int Disconnecting = FALSE; +//int Connected = FALSE; +//int SocketActive = FALSE; + +int ProcessReceivedData(); + +gint PollTimer(gpointer data) +{ + FD_ZERO(&readfs); + + if (Connecting ||Connected) + FD_SET(sock,&errorfs); + else + return TRUE; + + if (Connected) FD_SET(sock,&readfs); + + FD_ZERO(&writefs); + + if (Connecting) FD_SET(sock,&writefs); // Need notification of Connect + + FD_ZERO(&errorfs); + + if (Connecting ||Connected) FD_SET(sock,&errorfs); + + if (select(sock + 1, &readfs, &writefs, &errorfs, &timeout) > 0) + { + // See what happened + + if (FD_ISSET(sock, &readfs)) + { + // data available + + ProcessReceivedData(); + + } + + if (FD_ISSET(sock, &writefs)) + { + // Connect success + + Connecting = FALSE; + Connected = TRUE; + + } + + if (FD_ISSET(sock, &errorfs)) + { + // if connecting, then failed, if connected then has just disconnected + + if (Connecting) + { + // Falied + + Connecting = FALSE; + Connected = FALSE; + } + else + { + if (SocketActive) + closesocket(sock); + else + return TRUE; + + sprintf(Title,"BPQTermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + Disconnecting = FALSE; + MonData = FALSE; + return TRUE; + + } + } + } + + return TRUE; +} + +static GtkWidget *create_monitor ( void ) +{ + //GtkWidget *tree_view; +// GtkTreeIter *iter; +// GtkCellRender *cell; +// GtkTreeViewColumn *column; + + + view = gtk_text_view_new (); + text = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); + //gtk_widget_set_size_request (view, width, height); + gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE); + gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE); + + scrolledwin = gtk_scrolled_window_new(NULL,NULL); + gtk_container_set_border_width(GTK_CONTAINER(scrolledwin), 3); + gtk_widget_set_size_request(scrolledwin, 500, 100); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN); + gtk_container_add(GTK_CONTAINER (scrolledwin), view); + + gtk_widget_show(scrolledwin); + return scrolledwin; + +} + +static GtkWidget *create_output ( void ) +{ + view2 = gtk_text_view_new (); + text2 = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view2)); + gtk_text_view_set_editable (GTK_TEXT_VIEW(view2), FALSE); + gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW(view2), FALSE); + scrolledwin2 = gtk_scrolled_window_new(NULL,NULL); + gtk_container_set_border_width(GTK_CONTAINER(scrolledwin2), 3); + gtk_widget_set_size_request(scrolledwin2, 500, 100); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin2),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin2), GTK_SHADOW_IN); + gtk_container_add(GTK_CONTAINER(scrolledwin2), view2); + + gtk_widget_show(scrolledwin2); + return scrolledwin2; +} + +void frame_callback(GtkWindow *window, + GdkEvent *event, gpointer data) + { + //int x, y; + char buf[10]; + x = event->configure.x; + y = event->configure.y; + sprintf(buf, "%d, %d", x, y); + // gtk_window_set_title(window, buf); + } + + +gint delete_event( GtkWidget *widget, + GdkEvent *event, + gpointer data ) +{ + /* If you return FALSE in the "delete_event" signal handler, + * GTK will emit the "destroy" signal. Returning TRUE means + * you don't want the window to be destroyed. + * This is useful for popping up 'are you sure you want to quit?' + * type dialogs. */ + + g_print ("delete event occurred\n"); + gtk_window_get_size(GTK_WINDOW(widget), &width, &height); + printf("%d %d\n", width, height); + + + /* Change TRUE to FALSE and the main window will be destroyed with + * a "delete_event". */ + + return(FALSE); +} + + + +int main(int argc, char *argv[]) +{ + //PangoFontDescription *font_desc; +// ReadConfig(); + + int i; + + + + gtk_init (&argc, &argv); + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC (gtk_main_quit), NULL); + gtk_container_set_border_width (GTK_CONTAINER (window), 10); + //gtk_widget_set_usize (GTK_WIDGET(window), x, y); + + ReadConfig(); + + gtk_window_set_default_size(GTK_WINDOW (window), width, height); + gtk_widget_set_uposition(GTK_WIDGET(window),gx, gy); + //gtk_window_move(GTK_WINDOW(window), x, y); + gtk_window_set_resizable (GTK_WINDOW (window), TRUE); + g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (close_application), NULL); + gtk_window_set_title (GTK_WINDOW (window), "BPQTermTCP"); + gtk_container_set_border_width (GTK_CONTAINER (window), 0); + gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("/usr/share/pixmaps/bpqicon.png")); + //gtk_window_get_frame_dimensions(GTK_WINDOW(window),&left,&top,&right,&bottom); + g_signal_connect(G_OBJECT(window), "configure-event", + G_CALLBACK(frame_callback), NULL); + + + gtk_signal_connect (GTK_OBJECT (window), "delete_event", + GTK_SIGNAL_FUNC (delete_event), NULL); + + // Create a box for the menu + + box1 = gtk_vbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (window), box1); + box10 = gtk_vbox_new (FALSE, 0); + + menubar = get_menubar_menu (window); + + gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 1); + gtk_container_add (GTK_CONTAINER (box1), box10); + gtk_widget_show (window); + + vpaned = gtk_vpaned_new (); + gtk_container_add (GTK_CONTAINER (box10), vpaned); + gtk_widget_show (vpaned); + + /* Now create the contents of the two halves of the window */ + + frame1 = create_monitor (); + gtk_paned_add1 (GTK_PANED (vpaned), frame1); + gtk_widget_show (frame1); + + frame2 = create_output (); + gtk_paned_add2 (GTK_PANED (vpaned), frame2); + gtk_widget_show (frame2); + + + /* Separator */ + separator = gtk_hseparator_new (); + gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); + + box2 = gtk_vbox_new (FALSE, 10); + gtk_container_set_border_width (GTK_CONTAINER (box2), 1); + gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); + + // set up the text entry line + + entry = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry), width/6.50); + gtk_entry_set_activates_default(GTK_ENTRY (entry), TRUE); + g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (enter_callback), (gpointer) entry); + gtk_box_pack_start (GTK_BOX (box2), entry, FALSE, FALSE, 0); + gtk_widget_grab_focus(entry); + + /* Change default font throughout the widget */ + +// font_desc = pango_font_description_from_string ("sans 9"); +// gtk_widget_modify_font (entry, font_desc); +// gtk_widget_modify_font (view, font_desc); +// gtk_widget_modify_font (view2, font_desc);dfgd +// pango_font_description_free (font_desc); +// gtk_widget_get_size_request(scrolledwin, &xx, &yy); +// gtk_widget_get_size_request(scrolledwin2, &xxx, &yyy); + + gtk_widget_show_all (window); + + rtag = gtk_text_buffer_create_tag (text, NULL, "foreground", "red", NULL); + btag = gtk_text_buffer_create_tag (text, NULL, "foreground", "blue", NULL); + + for (i = 0; i < 100; i++) + { + tag[i] = gtk_text_buffer_create_tag (text2, NULL, "foreground", "red", NULL); + tag[i]->values->appearance.fg_color.red = (Colours[i] & 0xff) << 8; + tag[i]->values->appearance.fg_color.green = (Colours[i] & 0xff00); + tag[i]->values->appearance.fg_color.blue = (Colours[i] & 0xff0000) >> 8; + } + + for (i = 0; i < 100; i++) + { + tagm[i] = gtk_text_buffer_create_tag (text, NULL, "foreground", "red", NULL); + tagm[i]->values->appearance.fg_color.red = (Colours[i] & 0xff) << 8; + tagm[i]->values->appearance.fg_color.green = (Colours[i] & 0xff00); + tagm[i]->values->appearance.fg_color.blue = (Colours[i] & 0xff0000) >> 8; + } + + g_timeout_add (200, PollTimer, 0); + + gtk_main (); + + { + + GKeyFile * KF; + gchar * Value; + GError *error = NULL; + gsize length; + FILE *outfile; + + char path[PATH_MAX]; + char *fname = ".BPQTermTCP.ini"; + snprintf(path, PATH_MAX, "%s/%s", getenv("HOME"), fname); + + KF = g_key_file_new(); + g_key_file_load_from_file(KF, path, 0, NULL); + + + printf("%d %d\n", width, height); + + //g_key_file_set_integer(KF, "Session 1", "Width", width); + //g_key_file_set_integer(KF, "Session 1", "Height", height); + g_key_file_set_integer(KF, "Session 1", "MTX", mtxparam); + g_key_file_set_integer(KF, "Session 1", "MCOM", MCOM); + g_key_file_set_integer(KF, "Session 1", "MonNODES", MonNODES); + g_key_file_set_integer(KF, "Session 1", "ChatMode", ChatMode); + g_key_file_set_integer(KF, "Session 1", "Bells", Bells); + g_key_file_set_integer(KF, "Session 1", "CurrentHost", CurrentHost); + g_key_file_set_integer(KF, "Session 1", "MONColour", MONColour); + g_key_file_set_integer(KF, "Session 1", "MonPorts", MonPorts); + g_key_file_set_integer(KF, "Session 1", "PortMask", PortMask); + g_key_file_set_integer(KF, "Session 1", "MUIONLY", muionly); + sprintf(Position, "%d,%d,%d,%d", x, y, width, height); + g_key_file_set_string(KF, "Session 1", "Position", Position); + + sprintf(monitormon, "%d,%d", xx, yy); + g_key_file_set_string(KF, "Session 1", "Scrollwin", monitormon); + Value = g_key_file_to_data(KF, &length, &error); + + outfile = fopen ( path, "w"); + fputs(Value, outfile); + fclose(outfile); + + g_free(Value); + + g_key_file_free(KF); + } + + return 0; +} + +void SendTraceOptions() +{ + char Buffer[80]; + + int Len = sprintf(Buffer,"\\\\\\\\%x %x %x %x %x %x\r", PortMask, mtxparam, MCOM, MonNODES, MONColour, muionly); + + send(sock, Buffer, Len, 0); + +} +void WritetoOutputWindow(const char * Msg, int len) +{ + const char * ptr1 = Msg; + char * ptr2; + GtkTextIter iter; + GtkTextIter enditer; + int start, end; + GtkTextTag *mtag; + + if (SaveLen) + { + // Have part line - append to it + memcpy(&Save[SaveLen], Msg, len); + SaveLen += len; + ptr1 = Save; + len = SaveLen; + SaveLen = 0; + } + +lineloop: + + if (len <= 0) + { + g_timeout_add (100, ScrollTimer, 0); + return; + } + + // copy text to control a line at a time + + ptr2 = memchr(ptr1, 13, len); + + if (ptr2 == 0) // No CR + { + memmove(Save, ptr1, len); + SaveLen = len; + return; + } + +// *(ptr2++) = 0; + + if (ptr1[0] == 0x1b) + { + mtag = tag[ptr1[1] - 10]; + + gtk_text_buffer_get_end_iter(text2, &iter); + start = gtk_text_buffer_get_char_count(text2); + gtk_text_buffer_insert(text2, &iter, ptr1 + 2, (ptr2 - ptr1) - 2); + end = gtk_text_buffer_get_char_count(text2); + + gtk_text_buffer_get_iter_at_offset (text2, &iter, start); + gtk_text_buffer_get_iter_at_offset (text2, &enditer, end); + gtk_text_buffer_apply_tag (text2, mtag, &iter, &enditer); + + } + else + { +// gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL, ptr1, -1); + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_buffer_insert(text2, &iter, ptr1, ptr2 - ptr1); + + } + +// gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL, "\n", -1); + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_buffer_insert(text2, &iter, "\n", -1); +// gtk_text_view_place_cursor_onscreen (view2); + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_view_scroll_to_iter ((GtkTextView *)view2, &iter, 0.0, FALSE, 0.0, 0.0); + + +// if (LogMonitor) WriteMonitorLine(ptr1, ptr2 - ptr1); + + len -= (++ptr2 - ptr1); + ptr1 = ptr2; + + goto lineloop; + +} + +char MonSave[1000]; +int MonSaveLen; + +void WritetoMonWindow(char * Msg, int len) +{ + char * ptr1 = Msg, * ptr2; + GtkTextIter iter; + GtkTextIter enditer; + int start, end; + GtkTextTag *mtag; + + if (MonSaveLen) + { + // Have part line - append to it + memcpy(&MonSave[MonSaveLen], Msg, len); + MonSaveLen += len; + ptr1 = MonSave; + len = MonSaveLen; + MonSaveLen = 0; + } + if (enbel) + { + do { + ptr2=memchr(ptr1,7,len); + + if (ptr2) + { + *(ptr2)=32; + gdk_beep(); + } + } while (ptr2); + } + + +lineloop: + + if (len <= 0) + { + g_timeout_add (100, ScrollTimer, 0); + return; + } + // copy text to control a line at a time + + ptr2 = memchr(ptr1, 13, len); + + if (ptr2 == 0) // No CR + { + memmove(MonSave, ptr1, len); + MonSaveLen = len; + return; + } + + if (ptr1[0] == 0x1b) + { + mtag = tagm[ptr1[1] - 10]; + + gtk_text_buffer_get_end_iter(text, &iter); + start = gtk_text_buffer_get_char_count(text); + gtk_text_buffer_insert(text, &iter, ptr1 + 2, (ptr2 - ptr1) - 2); + end = gtk_text_buffer_get_char_count(text); + + gtk_text_buffer_get_iter_at_offset (text, &iter, start); + gtk_text_buffer_get_iter_at_offset (text, &enditer, end); + gtk_text_buffer_apply_tag (text, mtag, &iter, &enditer); + } + else + { + gtk_text_buffer_get_end_iter(text, &iter); + gtk_text_buffer_insert(text, &iter, ptr1, (ptr2 - ptr1)); + + } + + gtk_text_buffer_get_end_iter(text, &iter); + gtk_text_buffer_insert(text, &iter, "\n", 1); + + gtk_text_view_scroll_to_iter ((GtkTextView *)view, &iter, 0.0, FALSE, 0.0, 0.0); + +// if (LogMonitor) WriteMonitorLine(ptr1, ptr2 - ptr1); + + len -= (++ptr2 - ptr1); + ptr1 = ptr2; + + goto lineloop; +} + + +int SendMsg(const char * msg, int len) +{ + send(sock, msg, len, 0); + return 0; +} + +int TCPConnect(char * Host, char * Port) +{ + + int err = 0; +// u_long param=1; +// int bcopt=TRUE; +// struct sockaddr_in sinx; +// int addrlen=sizeof(sinx); + char Title[80]; + + struct addrinfo hints, *res = NULL; + + Disconnecting = FALSE; + + // get host info, make socket, and connect it + + memset(&hints, 0, sizeof hints); + hints.ai_family = AF_UNSPEC; // use IPv4 or IPv6, whichever + hints.ai_socktype = SOCK_STREAM; + getaddrinfo(Host, Port, &hints, &res); + + if (!res) + { + dialog = gtk_message_dialog_new ((GtkWindow *)window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "Resolve HostName Failed"); + + gtk_window_set_title (GTK_WINDOW (dialog), "TermTCP"); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + + sprintf(Title,"TermTCP Version %s - Disconnected", VersionString); + + gtk_window_set_title (GTK_WINDOW (window), Title); + + return FALSE; // Resolve failed + + } + + sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol); + + if (connect(sock, res->ai_addr, res->ai_addrlen) == 0) + { + // + // Connected successful + // + + Telnet_Connected(sock, 0); + + return TRUE; + } + else + { + err=errno; + + if (err == 10035) + { + // Connect in Progress + + sprintf(Title,"BPQTermTCP Version %s - Connecting to %s", VersionString, Host); + gtk_window_set_title (GTK_WINDOW (window), Title); + + EnableDisconnectMenu(); + DisableConnectMenu(); + + return TRUE; + } + else + { + // Connect failed + + closesocket(sock); + dialog = gtk_message_dialog_new ((GtkWindow *)window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Connect Failed"); + + gtk_window_set_title (GTK_WINDOW (dialog), "BPQTermTCP"); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + return FALSE; + } + } + + return FALSE; +} + +#define MAX_MSG_LEN 512 + + +int ProcessReceivedData() +{ + char message[MAX_MSG_LEN + 10]; + gchar * ptr; + char * Buffptr; + char * FEptr = 0; + int len = 0, MonLen; + + len = recv(sock, message, MAX_MSG_LEN, 0); + + if (len <= 0) + { + if (Disconnecting == FALSE) + { + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; + } + else + if (SocketActive) + closesocket(sock); + + sprintf(Title,"BPQTermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + MonData = FALSE; + return TRUE; + } + + if (len == 0) + { + printf("recv - len = 0\r\n"); + if (Disconnecting == FALSE) + { + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; + } + else + closesocket(sock); + + return TRUE; + } + + message[len] = 0; + + // Look for MON delimiters (FF/FE) + + Buffptr = message; + + if (MonData) + { + // Already in MON State + + FEptr = memchr(Buffptr, 0xfe, len); + + if (!FEptr) + { + // no FE - so send all to monitor + + WritetoMonWindow(Buffptr, len); + return TRUE; + } + + MonData = FALSE; + + MonLen = FEptr - Buffptr; // Mon Data, Excluding the FE + + WritetoMonWindow(Buffptr, MonLen); + + Buffptr = ++FEptr; // Char following FE + + if (++MonLen < len) + { + len -= MonLen; + goto MonLoop; // See if next in MON or Data + } + + // Nothing Left + + return TRUE; + } + +MonLoop: + + ptr = memchr(Buffptr, 0xff, len); + + if (ptr) + { + // Buffer contains Mon Data + + if (ptr > Buffptr) + { + // Some Normal Data before the FF + + int NormLen = ptr - Buffptr; // Before the FF + WritetoOutputWindow(Buffptr, NormLen); + + len -= NormLen; + Buffptr = ptr; + goto MonLoop; + } + + MonData = TRUE; + + FEptr = memchr(Buffptr, 0xfe, len); + + if (FEptr) + { + MonData = FALSE; + + MonLen = FEptr + 1 - Buffptr; // MonLen includes FF and FE + WritetoMonWindow(Buffptr+1, MonLen - 2); + + len -= MonLen; + Buffptr += MonLen; // Char Following FE + + if (len <= 0) + { + return TRUE; + } + goto MonLoop; + } + else + { + // No FE, so rest of buffer is MON Data + + WritetoMonWindow(Buffptr+1, len -1); // Exclude FF +// dorefresh(); + return TRUE; + } + } + + // No FF, so must be session data + + WritetoOutputWindow(Buffptr, len); +// SlowTimer = 0; + + return TRUE; +} +/* +gboolean GtkMsg_ShowMessage(GIOChannel *channel, GIOCondition condition, gpointer data) +{ + gchar message[MAX_MSG_LEN + 10]; +// GtkTextMark* MarkEnd; + gchar * ptr; + char * Buffptr; + char * FEptr = 0; + int len = 0, MonLen; + + +// GtkWidget *widgetMsgList = lookup_widget(MainWindow, "textview1"); +// GtkTextBuffer *textMsgList = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widgetMsgList)); + + if (condition & G_IO_HUP) + { + if (SocketActive) + closesocket(sock); + else + return 0; + + sprintf(Title,"BPQTermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + Disconnecting = FALSE; + MonData = FALSE; + return TRUE; + } + + if ((condition & G_IO_IN) == 0) + return TRUE; + + g_io_channel_read_chars (channel, message, MAX_MSG_LEN, &len, NULL); + + if (len == 0) + { + if (Disconnecting == FALSE) + { + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; + } + return TRUE; + } + + message[len] = 0; + + // Look for MON delimiters (FF/FE) + + Buffptr = message; + + if (MonData) + { + // Already in MON State + + FEptr = memchr(Buffptr, 0xfe, len); + + if (!FEptr) + { + // no FE - so send all to monitor + + WritetoMonWindow(Buffptr, len); + return TRUE; + } + + MonData = FALSE; + + MonLen = FEptr - Buffptr; // Mon Data, Excluding the FE + + WritetoMonWindow(Buffptr, MonLen); + + Buffptr = ++FEptr; // Char following FE + + if (++MonLen < len) + { + len -= MonLen; + goto MonLoop; // See if next in MON or Data + } + + // Nothing Left + + return TRUE; + } + +MonLoop: + + ptr = memchr(Buffptr, 0xff, len); + + if (ptr) + { + // Buffer contains Mon Data + + if (ptr > Buffptr) + { + // Some Normal Data before the FF + + int NormLen = ptr - Buffptr; // Before the FF + WritetoOutputWindow(Buffptr, NormLen); + + len -= NormLen; + Buffptr = ptr; + goto MonLoop; + } + + MonData = TRUE; + + FEptr = memchr(Buffptr, 0xfe, len); + + if (FEptr) + { + MonData = FALSE; + + MonLen = FEptr + 1 - Buffptr; // MonLen includes FF and FE + WritetoMonWindow(Buffptr+1, MonLen - 2); + + len -= MonLen; + Buffptr += MonLen; // Char Following FE + + if (len <= 0) + { + return TRUE; + } + goto MonLoop; + } + else + { + // No FE, so rest of buffer is MON Data + + WritetoMonWindow(Buffptr+1, len -1); // Exclude FF +// DoRefresh(); + return TRUE; + } + } + + // No FF, so must be session data + + WritetoOutputWindow(Buffptr, len); +// SlowTimer = 0; + + return TRUE; +} + +*/ + +int Telnet_Connected(SOCKET sock, int Error) +{ + char Msg[80]; + int Len; + + // Connect Complete + + if (Error) + { + dialog = gtk_message_dialog_new ((GtkWindow *)window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Connect Failed"); + + gtk_window_set_title (GTK_WINDOW (dialog), "TermTCP"); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + closesocket(sock); + Connecting = FALSE; + SocketActive = FALSE; + + sprintf(Title,"TermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + return 0; + + } + +// RecvChannel = g_io_channel_unix_new((gint)sock); +// RecvChannel = g_io_channel_win32_new_socket((gint)sock); +// g_io_channel_set_encoding (RecvChannel, NULL, NULL); +// g_io_channel_set_flags(RecvChannel, G_IO_FLAG_APPEND| G_IO_FLAG_NONBLOCK, NULL); +// g_io_add_watch(RecvChannel, G_IO_IN | G_IO_HUP, GtkMsg_ShowMessage, 0); + + SocketActive = TRUE; + Connecting = FALSE; + Connected = TRUE; + + Len = sprintf(Msg, "%s\r%s\rBPQTermTCP\r", UserName[CurrentHost], Password[CurrentHost]); + + SendMsg(Msg, Len); + + SendTraceOptions(); + +// SlowTimer = 0; + + sprintf(Title,"TermTCP Version %s - Connected to %s", VersionString, Host[CurrentHost]); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableConnectMenu(); + EnableDisconnectMenu(); + + return 0; +} + + +void EnableDisconnectMenu() +{ + gtk_widget_set_sensitive(dis_item, TRUE); +} +void DisableConnectMenu() +{ + gtk_widget_set_sensitive(conn_item, FALSE); +} +void EnableConnectMenu() +{ + gtk_widget_set_sensitive(conn_item, TRUE); +} +void DisableDisconnectMenu() +{ + gtk_widget_set_sensitive(dis_item, FALSE); + +} + diff --git a/bpqicon.ico b/bpqicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..a57a91c59bd54e8495e9660264d515bf0313a242 GIT binary patch literal 766 zcmc(bF%kkH3`PGsb~IMjlpbS`mLt*Aa2#)ek1#ue>x|A?82BMSpOEZI3oFKpn%z&* zmGcH7Sizz*UNW@zW{4Qv5Fjgy1uceSCJ%!AE+ArK2 z4gH)C?WRF!x#PRh=PTTwN(RpV3r*Z~4?WpGZIC?ikslwWzyDI-r})}4`Csh;*C<;s literal 0 HcmV?d00001 diff --git a/bpqicon.png b/bpqicon.png new file mode 100644 index 0000000000000000000000000000000000000000..75b2b3450e902bf5133edc175f0aa8b38ba73f58 GIT binary patch literal 253 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnL3?x0byx0z;*aCb)T>t+EvKYFLU+o7{oCO|{ z#X#BvjNMLV+W{HYo-U3d9M_W*99X~cIvjeyz}4t`=D{E41up%J6HYdJeXwWPDDi+r zdBXX_Jd+Y9A8-v};M^c|Og`fsBf|UO_QmvAUQh^kMk%6I+ zu7RgTe~DWM4f DupdZd literal 0 HcmV?d00001 diff --git a/oldTermTCP.c b/oldTermTCP.c new file mode 100644 index 0000000..fb6a76e --- /dev/null +++ b/oldTermTCP.c @@ -0,0 +1,1650 @@ +#define GTK_ENABLE_BROKEN +#define _CRT_SECURE_NO_DEPRECATE + +#include +#include +#include + +GdkPixbuf *create_pixbuf(const gchar * filename) +{ + GdkPixbuf *pixbuf; + GError *error = NULL; + pixbuf = gdk_pixbuf_new_from_file(filename, &error); + if(!pixbuf) { + fprintf(stderr, "%s\n", error->message); + g_error_free(error); + } + + return pixbuf; +} + +#ifdef WIN32 +#include "winsock2.h" +#include "WS2tcpip.h" + +#else +#include +#include +#include +#include +#include +#include +#include +#include + +#define SOCKET int +#define closesocket close +typedef gint32 COLORREF; +#define RGB(r,g,b) ((COLORREF)(((guint8)(r)|((guint16)((guint8)(g))<<8))|(((guint32)(guint8)(b))<<16))) + +#endif + +char Host[5][100]; +char Port[5][10]; +char UserName[5][80]; +char Password[5][80]; +char Path[5][100]; +char Test1[5][100]; +char Test2[5][100]; +char Pass[5][100]; +char path[5][100]; + +char HN[5][6] = {"Host1", "Host2", "Host3", "Host4"}; +char PN[5][6] = {"Port1", "Port2", "Port3", "Port4"}; +char PASSN[5][6] = {"Pass1", "Pass2", "Pass3", "Pass4"}; +char UN[5][6] = {"User1", "User2", "User3", "User4"}; +char pn[5][6] = {"Path"}; +int CurrentHost = 0; +char VersionString[80] = "0.0.1.26"; + +char DisMsg[] = "*** Disconnected\r"; + +int PortMask=65535; +int mtxparam=1; +int MCOM=1; +int Split; +int x,y; +int Bells = FALSE; +int StripLF = FALSE; +int LogMonitor = FALSE; +int LogOutput = FALSE; +int SendDisconnected = TRUE; +int MonNODES = FALSE; +int MONColour = TRUE; +int ChatMode = FALSE; +int MonPorts = 1; +int muionly = 1; + +int position; +int left = 100, top = 100, right = 500, bottom = 500; +int height; +int width; +char Position[50]; +gint gx, gy; +gint xx, yy; +gint xxx, yyy; +int size; +int Size; + +int Connecting = FALSE; +int Disconnecting = FALSE; +int Connected = FALSE; +int SocketActive = FALSE; + +char Title[80]; + +void ReadConfig(); +void SendTraceOptions(); + +int TCPConnect(char * Host, char * Port); +void WritetoOutputWindow(const char * Text, int Len); +void WritetoMonWindow(char * Text, int Len); +int Telnet_Connected(SOCKET sock, int Error); +int SendMsg(const char * msg, int len); + +#ifdef WIN32 + +void __cdecl Debugprintf(const char * format, ...) +{ + char Mess[1000]; + va_list(arglist); + + va_start(arglist, format); + vsprintf(Mess, format, arglist); + strcat(Mess, "\r\n"); + OutputDebugString(Mess); + + return; +} +#endif + +COLORREF Colours[256] = {0, + RGB(0,0,0), RGB(0,0,128), RGB(0,0,192), RGB(0,0,255), // 1 - 4 + RGB(0,64,0), RGB(0,64,128), RGB(0,64,192), RGB(0,64,255), // 5 - 8 + RGB(0,128,0), RGB(0,128,128), RGB(0,128,192), RGB(0,128,255), // 9 - 12 + RGB(0,192,0), RGB(0,192,128), RGB(0,192,192), RGB(0,192,255), // 13 - 16 + RGB(0,255,0), RGB(0,255,128), RGB(0,255,192), RGB(0,255,255), // 17 - 20 + + RGB(64,0,0), RGB(64,0,128), RGB(64,0,192), RGB(0,0,255), // 21 + RGB(64,64,0), RGB(64,64,128), RGB(64,64,192), RGB(64,64,255), + RGB(64,128,0), RGB(64,128,128), RGB(64,128,192), RGB(64,128,255), + RGB(64,192,0), RGB(64,192,128), RGB(64,192,192), RGB(64,192,255), + RGB(64,255,0), RGB(64,255,128), RGB(64,255,192), RGB(64,255,255), + + RGB(128,0,0), RGB(128,0,128), RGB(128,0,192), RGB(128,0,255), // 41 + RGB(128,64,0), RGB(128,64,128), RGB(128,64,192), RGB(128,64,255), + RGB(128,128,0), RGB(128,128,128), RGB(128,128,192), RGB(128,128,255), + RGB(128,192,0), RGB(128,192,128), RGB(128,192,192), RGB(128,192,255), + RGB(128,255,0), RGB(128,255,128), RGB(128,255,192), RGB(128,255,255), + + RGB(192,0,0), RGB(192,0,128), RGB(192,0,192), RGB(192,0,255), // 61 + RGB(192,64,0), RGB(192,64,128), RGB(192,64,192), RGB(192,64,255), + RGB(192,128,0), RGB(192,128,128), RGB(192,128,192), RGB(192,128,255), + RGB(192,192,0), RGB(192,192,128), RGB(192,192,192), RGB(192,192,255), + RGB(192,255,0), RGB(192,255,128), RGB(192,255,192), RGB(192,2552,255), + + RGB(255,0,0), RGB(255,0,128), RGB(255,0,192), RGB(255,0,255), // 81 + RGB(255,64,0), RGB(255,64,128), RGB(255,64,192), RGB(255,64,255), + RGB(255,128,0), RGB(255,128,128), RGB(255,128,192), RGB(255,128,255), + RGB(255,192,0), RGB(255,192,128), RGB(255,192,192), RGB(255,192,255), + RGB(255,255,0), RGB(255,255,128), RGB(255,255,192), RGB(255,2552,255) +}; + + +SOCKET RecvSocket; +SOCKET sock; + +GtkWidget *dialog; +GtkWidget *window; +GtkWidget *box1; +GtkWidget *box2; +GtkWidget *box3; +GtkWidget *box10; +GtkWidget *hbox; +GtkWidget *button; +GtkWidget *check; +GtkWidget *separator; +GtkWidget *table; +GtkWidget *vscrollbar; +GtkWidget *vscrollbar2; +GtkTextBuffer *text; +GtkTextBuffer *text2; +GtkWidget *entry; +GtkWidget *vpaned; +GtkWidget *frame1; +GtkWidget *frame2; +GIOChannel *RecvChannel; +GtkWidget *menubar; +GtkWidget *view; +GtkWidget* scrolledwin; +GtkWidget *view2; +GtkWidget* scrolledwin2; +GtkWidget *montx; +GtkWidget *monsup; +GtkWidget *monnode; +GtkWidget *encol; +GtkWidget *mui; +GtkWidget *addpor; +GtkWidget *menubar; +GtkWidget *conmenu, *conn_item, *Conn[4], *Conn2, *Conn3, *Conn4; +GtkWidget *discmenu, *dis_item, sid_item; +GtkWidget *cfgmenu, *tcp_item, *font_item, *strip_item, *logmon_item, *logout_item, *cfg_item, *chat_term, *Cfg[4], *Cfg2, *Cfg3, *Cfg4; +GtkWidget *monmenu, *mon_item, *mon[32]; +GtkWidget *tcpmenu; +GtkWidget *enbel, *enbel_item; +GtkWidget *propmenu,*propitem; + +GtkTextTag *rtag, *btag, *tag[256], *tagm[256]; + +void EnableDisconnectMenu(); +void DisableConnectMenu(); +void EnableConnectMenu(); +void DisableDisconnectMenu(); + +void close_application(GtkWidget *widget, gpointer data) +{ + gtk_main_quit (); + return 0; +} + +void enter_callback( GtkWidget *widget, + GtkWidget *entry ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (entry)); + + if (!Connected && ! Connecting) + { + TCPConnect(Host[CurrentHost], Port[CurrentHost]); + gtk_entry_set_text (GTK_ENTRY (entry), ""); + return ; + } + + SendMsg(entry_text, strlen(entry_text)); + SendMsg("\r", 1); + WritetoOutputWindow(entry_text, strlen(entry_text)); + WritetoOutputWindow("\r ", 1); + gtk_entry_set_text (GTK_ENTRY (entry), ""); +} + + +static void Disconnect(GtkWidget *w, gpointer data); +static void Toggled(GtkWidget *w, int * data ) +{ + int NewVal = gtk_check_menu_item_get_active((GtkCheckMenuItem *)w); + *(data) = NewVal; + + SendTraceOptions(); + + return; +} +static void property(GtkWidget *w, gpointer data) +{ + GtkWidget * dialog = gtk_dialog_new_with_buttons("Properties", + GTK_WINDOW(window), + GTK_DIALOG_MODAL, + GTK_STOCK_OK, + GTK_STOCK_CANCEL, 2, + NULL ); + + GtkWidget *path; + GtkWidget *label5, *content_area1; + GtkWidget *entry5; + content_area1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); + + label5 = gtk_label_new("Path"); + + gtk_container_add (GTK_CONTAINER (content_area1), label5); + + entry5 = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry5), 100); + gtk_widget_show_all (dialog); +} +static void Configure(GtkWidget *w, gpointer data) +{ + GtkWidget * dialog = gtk_dialog_new_with_buttons( "Configuration", + GTK_WINDOW(window), + GTK_DIALOG_MODAL, + GTK_STOCK_OK, 1, + GTK_STOCK_CANCEL, 2, + NULL ); + + GtkWidget *entry1; + GtkWidget *entry2; + GtkWidget *entry3; + GtkWidget *entry4; + + GtkWidget *label, *content_area; + GtkWidget *label2, *label3, *label4; + + int HostNum = (int)data; + const gchar *entry_text; + gint result; + char Key[10]; + + content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); + + label = gtk_label_new ("Host"); + label2 = gtk_label_new ("Port"); + label3 = gtk_label_new ("Username"); + label4 = gtk_label_new ("Password"); + + /* Add the label, and show everything we've added to the dialog. */ + + gtk_container_add (GTK_CONTAINER (content_area), label); + + entry1 = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry1), 100); + gtk_entry_set_text (GTK_ENTRY (entry1), &Host[HostNum][0]); + + gtk_container_add (GTK_CONTAINER (content_area), entry1); + + gtk_container_add (GTK_CONTAINER (content_area), label2); + entry2 = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry2), 10); + gtk_entry_set_text (GTK_ENTRY (entry2), &Port[HostNum][0]); + + gtk_container_add (GTK_CONTAINER (content_area), entry2); + + gtk_container_add (GTK_CONTAINER (content_area), label3); + + entry3 = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry3), 100); + gtk_entry_set_text (GTK_ENTRY (entry3), &UserName[HostNum][0]); + gtk_container_add (GTK_CONTAINER (content_area), entry3); + + gtk_container_add (GTK_CONTAINER (content_area), label4); + + entry4 = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry4), 100); + gtk_entry_set_text (GTK_ENTRY (entry4), &Password[HostNum][0]); + gtk_container_add (GTK_CONTAINER (content_area), entry4); + + gtk_widget_show_all (dialog); + + result = gtk_dialog_run (GTK_DIALOG (dialog)); + + if (result == 1) + { + GKeyFile * KF; + gchar * Value; + GError *error = NULL; + gsize length; + FILE *outfile; + char path[PATH_MAX]; + char *fname = ".BPQTermTCP.ini"; + snprintf(path, PATH_MAX, "%s/%s", getenv("HOME"), fname); + + + entry_text = gtk_entry_get_text (GTK_ENTRY (entry1)); + strcpy(&Host[HostNum][0], entry_text); + + entry_text = gtk_entry_get_text (GTK_ENTRY (entry2)); + strcpy(&Port[HostNum][0], entry_text); + + entry_text = gtk_entry_get_text (GTK_ENTRY (entry3)); + strcpy(&UserName[HostNum][0], entry_text); + + entry_text = gtk_entry_get_text (GTK_ENTRY (entry4)); + strcpy(&Password[HostNum][0], entry_text); + + KF = g_key_file_new(); + g_key_file_load_from_file(KF, "BPQTermTCP.ini", 0, NULL); + + sprintf(Key, "Host%d", HostNum + 1); + g_key_file_set_string(KF, "Session 1", Key, &Host[HostNum][0]); + + sprintf(Key, "Port%d", HostNum + 1); + g_key_file_set_string(KF, "Session 1", Key, &Port[HostNum][0]); + + sprintf(Key, "User%d", HostNum + 1); + g_key_file_set_string(KF, "Session 1", Key, &UserName[HostNum][0]); + + sprintf(Key, "Pass%d", HostNum + 1); + g_key_file_set_string(KF, "Session 1", Key, &Password[HostNum][0]); + + + Value = g_key_file_to_data(KF, &length, &error); + + outfile = fopen ("BPQTermTCP.ini", "w"); + fputs(Value, outfile); + fclose(outfile); + + g_free(Value); + + g_key_file_free(KF); + } + + gtk_widget_destroy (dialog); +} + +static void Connect( GtkWidget *w, gpointer data ) +{ + CurrentHost = (int)data; + TCPConnect(Host[CurrentHost], Port[CurrentHost]); +} + + + // Port Line Callback. data Param is Port Number +static void PToggled( GtkWidget *w, int data ) +{ + // Create Port Mask bit from Port Number + int Mask = 1 << data; + + // Get current state of Item + int NewVal = gtk_check_menu_item_get_active((GtkCheckMenuItem *)w); + PortMask &= ~Mask; // Clear portmask bit for this port + + // Shift the new bit to the right place in the mask + NewVal = NewVal << data; + + // OR into Mask + PortMask |= NewVal; + + SendTraceOptions(); + + return; + +} + +static void AddPortItem( GtkWidget *w, int * data ) +{ + char Port[10]; + sprintf(Port, "Port %d", MonPorts + 1); + mon[MonPorts] = gtk_check_menu_item_new_with_label (Port); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)mon[MonPorts], (PortMask >> MonPorts) & MonPorts); + + // Set Callback to PToggled. Parameter is Port Number + g_signal_connect (mon[MonPorts], "toggled", G_CALLBACK (PToggled), (void *) MonPorts); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, mon[MonPorts]); + + MonPorts++; + + gtk_widget_show_all (menubar); + + return; +} + +GtkWidget *get_menubar_menu(GtkWidget *window) +{ + int i; + + menubar = gtk_menu_bar_new(); + conmenu = gtk_menu_new(); + cfgmenu = gtk_menu_new(); + discmenu = gtk_menu_new(); + monmenu = gtk_menu_new(); + montx = gtk_menu_new(); + monsup = gtk_menu_new(); + monnode = gtk_menu_new(); + encol = gtk_menu_new(); + addpor = gtk_menu_new(); + tcpmenu = gtk_menu_new(); + enbel = gtk_menu_new(); + mui = gtk_menu_new(); + propmenu = gtk_menu_new(); + + /* Create the menu items */ + + for (i = 0; i < 4; i++) + { + Conn[i] = gtk_check_menu_item_new_with_label (Host[i]); + gtk_menu_shell_append (GTK_MENU_SHELL (conmenu), Conn[i]); + gtk_check_menu_item_set_active((GtkCheckMenuItem *) Conn[i], CurrentHost == i); + g_signal_connect (Conn[i], ("toggled"), G_CALLBACK (Toggled), (void *) &CurrentHost); + + Cfg[i] = gtk_menu_item_new_with_label (Host[i]); + gtk_menu_shell_append (GTK_MENU_SHELL (tcpmenu), Cfg[i]); + + + /* Attach the callback functions to the activate signal */ + + g_signal_connect (Conn[i], "activate", G_CALLBACK (Connect), (void *) i); + g_signal_connect (Cfg[i], "activate", G_CALLBACK (Configure), (void *) i); + + } + + conn_item = gtk_menu_item_new_with_label ("Connect"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (conn_item), conmenu); + + dis_item = gtk_menu_item_new_with_label ("Disconnect"); + g_signal_connect (dis_item, "activate", G_CALLBACK (Disconnect), 0); + gtk_widget_set_sensitive(dis_item, TRUE); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (dis_item), discmenu); + + cfg_item = gtk_menu_item_new_with_label ("Setup"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (cfg_item), cfgmenu); + + enbel = gtk_check_menu_item_new_with_label ("Enable Bells"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)enbel, Bells); + g_signal_connect (enbel, "toggled", G_CALLBACK(Toggled), (void *) &Bells); + + logmon_item = gtk_menu_item_new_with_label ("Log Monitor"); + logout_item = gtk_menu_item_new_with_label ("Log Output"); + + chat_term = gtk_check_menu_item_new_with_label ("Chat Terminal Mode"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *) chat_term, ChatMode); + g_signal_connect (chat_term, ("toggled"), G_CALLBACK (Toggled), (void *) &ChatMode); + + propitem = gtk_menu_item_new_with_label ("Properties"); +// g_signal_connect (Prop[i], "activate", G_CALLBACK (property), (void *) i); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (propitem), propmenu); + + + tcp_item = gtk_menu_item_new_with_label ("TCP Hosts"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (tcp_item), tcpmenu); + + mon_item = gtk_menu_item_new_with_label ("Monitor"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (mon_item), monmenu); + + montx = gtk_check_menu_item_new_with_label ("Monitor TX"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)montx, mtxparam); + g_signal_connect (montx, "toggled", G_CALLBACK (Toggled), (void *) &mtxparam); + + monsup = gtk_check_menu_item_new_with_label ("Monitor Supervisor"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)monsup, MCOM); + g_signal_connect (monsup, "toggled", G_CALLBACK (Toggled), (void *) &MCOM); + + monnode = gtk_check_menu_item_new_with_label ("Monitor Nodes"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)monnode, MonNODES); + g_signal_connect (monnode, "toggled", G_CALLBACK (Toggled), (void *) &MonNODES); + + mui = gtk_check_menu_item_new_with_label ("Monitor UI Only"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)mui, muionly); + g_signal_connect (mui, "toggled", G_CALLBACK (Toggled), (void *) &muionly); + + encol = gtk_check_menu_item_new_with_label ("Enable Colour"); + gtk_check_menu_item_set_active((GtkCheckMenuItem *)encol, MONColour); + g_signal_connect (encol, "toggled", G_CALLBACK (Toggled), (void *) &MONColour); + + addpor = gtk_menu_item_new_with_label ("Add Port"); + g_signal_connect (addpor, "activate", G_CALLBACK (AddPortItem), (void *) 0); + + + /* Add them to the menu */ + + gtk_menu_shell_append ((GtkMenuShell *)menubar, conn_item); + gtk_menu_shell_append ((GtkMenuShell *)menubar, dis_item); + gtk_menu_shell_append ((GtkMenuShell *)menubar, cfg_item); + gtk_menu_shell_append ((GtkMenuShell *)menubar, mon_item); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, montx); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, monsup); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, monnode); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, mui); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, encol); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, addpor); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, tcp_item); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, propitem); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, enbel); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, logmon_item); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, logout_item); + gtk_menu_shell_append ((GtkMenuShell *)cfgmenu, chat_term); + + for (i = 0; i < MonPorts; i++) + + { + + char Port[10]; + sprintf(Port, "Port %d", i + 1); + mon[i] = gtk_check_menu_item_new_with_label (Port); + + // Set the Checked flag from the corresponding bit of PortMask + gtk_check_menu_item_set_active((GtkCheckMenuItem *)mon[i], (PortMask >> i) & 1); + + // Call PToggled() when menu is selected. Data to PToggled is Port Number + g_signal_connect (mon[i], "toggled", G_CALLBACK (PToggled), (void *) i); + gtk_menu_shell_append ((GtkMenuShell *)monmenu, mon[i]); + + } + + gtk_widget_show_all (menubar); + + SendTraceOptions(); + + return menubar; + +} + +gint ScrollTimer(gpointer data) +{ + GtkTextIter iter; + + gtk_text_buffer_get_end_iter(text, &iter); + gtk_text_view_scroll_to_iter ((GtkTextView *)view, &iter, 0.0, FALSE, 0.0, 0.0); + + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_view_scroll_to_iter ((GtkTextView *)view2, &iter, 0.0, FALSE, 0.0, 0.0); + + return FALSE; +} + +static fd_set readfs; +static fd_set writefs; +static fd_set errorfs; +static struct timeval timeout; + +int MonData = FALSE; + + +//int Connecting = FALSE; +//int Disconnecting = FALSE; +//int Connected = FALSE; +//int SocketActive = FALSE; + +int ProcessReceivedData(); + +gint PollTimer(gpointer data) +{ + FD_ZERO(&readfs); + + if (Connecting ||Connected) + FD_SET(sock,&errorfs); + else + return TRUE; + + if (Connected) FD_SET(sock,&readfs); + + FD_ZERO(&writefs); + + if (Connecting) FD_SET(sock,&writefs); // Need notification of Connect + + FD_ZERO(&errorfs); + + if (Connecting ||Connected) FD_SET(sock,&errorfs); + + if (select(sock + 1, &readfs, &writefs, &errorfs, &timeout) > 0) + { + // See what happened + + if (FD_ISSET(sock, &readfs)) + { + // data available + + ProcessReceivedData(); + + } + + if (FD_ISSET(sock, &writefs)) + { + // Connect success + + Connecting = FALSE; + Connected = TRUE; + + } + + if (FD_ISSET(sock, &errorfs)) + { + // if connecting, then failed, if connected then has just disconnected + + if (Connecting) + { + // Falied + + Connecting = FALSE; + Connected = FALSE; + } + else + { + if (SocketActive) + closesocket(sock); + else + return TRUE; + + sprintf(Title,"BPQTermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + Disconnecting = FALSE; + MonData = FALSE; + return TRUE; + + } + } + } + + return TRUE; +} + +static GtkWidget *create_monitor ( void ) +{ + GtkWidget *tree_view; + + view = gtk_text_view_new (); + text = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); + gtk_widget_set_size_request (view, 600, 100); + gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE); + gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE); + + scrolledwin = gtk_scrolled_window_new(NULL,NULL); + //gtk_container_set_border_width(GTK_CONTAINER(scrolledwin), 1); + gtk_widget_set_size_request(scrolledwin, 600, 100); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN); + gtk_container_add(GTK_CONTAINER (scrolledwin), view); + + gtk_widget_show(scrolledwin); + return scrolledwin; + +} + +static GtkWidget *create_output ( void ) +{ + view2 = gtk_text_view_new (); + text2 = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view2)); + gtk_text_view_set_editable (GTK_TEXT_VIEW(view2), FALSE); + gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW(view2), FALSE); + scrolledwin2 = gtk_scrolled_window_new(NULL,NULL); + //gtk_container_set_border_width(GTK_CONTAINER(box2), 2); + gtk_widget_set_size_request(scrolledwin2, 100, 100); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin2),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin2), GTK_SHADOW_IN); + gtk_container_add(GTK_CONTAINER(scrolledwin2), view2); + + gtk_widget_show(scrolledwin2); + return scrolledwin2; +} + +void frame_callback(GtkWindow *window, + GdkEvent *event, gpointer data) + { + //int x, y; + char buf[10]; + x = event->configure.x; + y = event->configure.y; + sprintf(buf, "%d, %d", x, y); + // gtk_window_set_title(window, buf); + } + + +//gint delete_event( GtkWidget *widget, +// GdkEvent *event, +// gpointer data ) +//{ + /* If you return FALSE in the "delete_event" signal handler, + * GTK will emit the "destroy" signal. Returning TRUE means + * you don't want the window to be destroyed. + * This is useful for popping up 'are you sure you want to quit?' + * type dialogs. */ + + // g_print ("delete event occurred\n"); + // gtk_window_get_size(GTK_WINDOW(widget), &width, &height); +// printf("%d %d\n", width, height); + + + /* Change TRUE to FALSE and the main window will be destroyed with + * a "delete_event". */ + +// return(FALSE); +//} + +int main(int argc, char *argv[]) +{ + //PangoFontDescription *font_desc; + int i; + + gtk_init (&argc, &argv); + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Paned Windows"); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC (gtk_main_quit), NULL); + gtk_container_set_border_width (GTK_CONTAINER (window), 10); + gtk_widget_set_usize (GTK_WIDGET(window), 450, 400); + + ReadConfig(); + +// window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + //gtk_window_set_default_size(GTK_WINDOW (window),left - right, top - bottom); + gtk_widget_set_uposition(window, left, top); + gtk_window_set_resizable (GTK_WINDOW (window), TRUE); + g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (close_application), NULL); + gtk_window_set_title (GTK_WINDOW (window), "BPQTermTCP"); + gtk_container_set_border_width (GTK_CONTAINER (window), 0); + gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("bpqicon.png")); + + // Create a box for the menu + +// g_signal_connect(G_OBJECT(window), "configure-event", +// G_CALLBACK(frame_callback), NULL); + + +// gtk_signal_connect (GTK_OBJECT (window), "delete_event", +// GTK_SIGNAL_FUNC (delete_event), NULL); + + + box1 = gtk_vbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (window), box1); + box10 = gtk_vbox_new (FALSE, 0); + + menubar = get_menubar_menu (window); + gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 1); + gtk_container_add (GTK_CONTAINER (box1), box10); + + gtk_widget_show (window); + vpaned = gtk_vpaned_new (); + gtk_container_add (GTK_CONTAINER (box10), vpaned); + gtk_widget_show (vpaned); + + /* Now create the contents of the two halves of the window */ + + frame1 = create_monitor (); + gtk_paned_add1 (GTK_PANED (vpaned), frame1); + gtk_widget_show (frame1); + + frame2 = create_output (); + gtk_paned_add2 (GTK_PANED (vpaned), frame2); + gtk_widget_show (frame2); + // gtk_widget_show(box2); + + /* Separator */ + separator = gtk_hseparator_new (); + gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); + + box2 = gtk_vbox_new (FALSE, 10); + gtk_container_set_border_width (GTK_CONTAINER (box2), 1); + gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); + + // set up the text entry line + + entry = gtk_entry_new(); + gtk_entry_set_max_length (GTK_ENTRY (entry), 300); + gtk_entry_set_activates_default(GTK_ENTRY (entry), TRUE); + g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (enter_callback), (gpointer) entry); + gtk_box_pack_start (GTK_BOX (box2), entry, FALSE, FALSE, 0); + + /* Change default font throughout the widget */ + +// font_desc = pango_font_description_from_string ("sans 9"); +// gtk_widget_modify_font (entry, font_desc); +// gtk_widget_modify_font (view, font_desc); +// gtk_widget_modify_font (view2, font_desc); +// pango_font_description_free (font_desc); + + gtk_widget_show_all (window); + + rtag = gtk_text_buffer_create_tag (text, NULL, "foreground", "red", NULL); + btag = gtk_text_buffer_create_tag (text, NULL, "foreground", "blue", NULL); + + for (i = 0; i < 100; i++) + { + tag[i] = gtk_text_buffer_create_tag (text2, NULL, "foreground", "red", NULL); + tag[i]->values->appearance.fg_color.red = (Colours[i] & 0xff) << 8; + tag[i]->values->appearance.fg_color.green = (Colours[i] & 0xff00); + tag[i]->values->appearance.fg_color.blue = (Colours[i] & 0xff0000) >> 8; + } + + for (i = 0; i < 100; i++) + { + tagm[i] = gtk_text_buffer_create_tag (text, NULL, "foreground", "red", NULL); + tagm[i]->values->appearance.fg_color.red = (Colours[i] & 0xff) << 8; + tagm[i]->values->appearance.fg_color.green = (Colours[i] & 0xff00); + tagm[i]->values->appearance.fg_color.blue = (Colours[i] & 0xff0000) >> 8; + } + + g_timeout_add (200, PollTimer, 0); + + gtk_main (); + + { + GKeyFile * KF; + gchar * Value; + GError *error = NULL; + gsize length; + FILE *outfile; + + KF = g_key_file_new(); + g_key_file_load_from_file(KF, "BPQTermTCP.ini", 0, NULL); + + g_key_file_set_integer(KF, "Session 1", "MTX", mtxparam); + g_key_file_set_integer(KF, "Session 1", "MCOM", MCOM); + g_key_file_set_integer(KF, "Session 1", "MonNODES", MonNODES); + g_key_file_set_integer(KF, "Session 1", "ChatMode", ChatMode); + g_key_file_set_integer(KF, "Session 1", "Bells", Bells); + g_key_file_set_integer(KF, "Session 1", "CurrentHost", CurrentHost); + g_key_file_set_integer(KF, "Session 1", "MONColour", MONColour); + g_key_file_set_integer(KF, "Session 1", "MonPorts", MonPorts); + g_key_file_set_integer(KF, "Session 1", "PortMask", PortMask); + g_key_file_set_integer(KF, "Session 1", "MUIONLY", muionly); +// g_key_file_set_string(KF, "Session 1", "Path", &path); +// printf(Size, "%d,%d,%d,%d", left,top,right,bottom); + Value = g_key_file_to_data(KF, &length, &error); +// sprintf(Value, "%d,%d,%d,%d", &left,&top,&right,&bottom); +// g_key_file_set_string(KF, "Session 1", "Size", &Value); + outfile = fopen ("BPQTermTCP.ini", "w"); + fputs(Value, outfile); + fclose(outfile); + + g_free(Value); + + g_key_file_free(KF); + } + + return 0; +} + +void SendTraceOptions() +{ + char Buffer[80]; + + int Len = sprintf(Buffer,"\\\\\\\\%x %x %x %x %x %x %x\r", PortMask, mtxparam, MCOM, MonNODES, MONColour, muionly,1); + + send(sock, Buffer, Len, 0); + +} + +char Save[1000]; +int SaveLen; + +void WritetoOutputWindow(const char * Msg, int len) +{ + const char * ptr1 = Msg; + char * ptr2; + GtkTextIter iter; + GtkTextIter enditer; + int start, end; + GtkTextTag *mtag; + + if (SaveLen) + { + // Have part line - append to it + memcpy(&Save[SaveLen], Msg, len); + SaveLen += len; + ptr1 = Save; + len = SaveLen; + SaveLen = 0; + } + +lineloop: + + if (len <= 0) + { + g_timeout_add (100, ScrollTimer, 0); + return; + } + + // copy text to control a line at a time + + ptr2 = memchr(ptr1, 13, len); + + if (ptr2 == 0) // No CR + { + memmove(Save, ptr1, len); + SaveLen = len; + return; + } + +// *(ptr2++) = 0; + + if (ptr1[0] == 0x1b) + { + mtag = tag[ptr1[1] - 10]; + + gtk_text_buffer_get_end_iter(text2, &iter); + start = gtk_text_buffer_get_char_count(text2); + gtk_text_buffer_insert(text2, &iter, ptr1 + 2, (ptr2 - ptr1) - 2); + end = gtk_text_buffer_get_char_count(text2); + + gtk_text_buffer_get_iter_at_offset (text2, &iter, start); + gtk_text_buffer_get_iter_at_offset (text2, &enditer, end); + gtk_text_buffer_apply_tag (text2, mtag, &iter, &enditer); + + } + else + { +// gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL, ptr1, -1); + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_buffer_insert(text2, &iter, ptr1, ptr2 - ptr1); + + } + +// gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL, "\n", -1); + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_buffer_insert(text2, &iter, "\n", -1); +// gtk_text_view_place_cursor_onscreen (view2); + gtk_text_buffer_get_end_iter(text2, &iter); + gtk_text_view_scroll_to_iter ((GtkTextView *)view2, &iter, 0.0, FALSE, 0.0, 0.0); + + +// if (LogMonitor) WriteMonitorLine(ptr1, ptr2 - ptr1); + + len -= (++ptr2 - ptr1); + ptr1 = ptr2; + + goto lineloop; + +} + +char MonSave[1000]; +int MonSaveLen; + +void WritetoMonWindow(char * Msg, int len) +{ + char * ptr1 = Msg, * ptr2; + GtkTextIter iter; + GtkTextIter enditer; + int start, end; + GtkTextTag *mtag; + + if (MonSaveLen) + { + // Have part line - append to it + memcpy(&MonSave[MonSaveLen], Msg, len); + MonSaveLen += len; + ptr1 = MonSave; + len = MonSaveLen; + MonSaveLen = 0; + } + if (enbel) + { + do { + ptr2=memchr(ptr1,7,len); + + if (ptr2) + { + *(ptr2)=32; + gdk_beep(); + } + } while (ptr2); + } + + +lineloop: + + if (len <= 0) + { + g_timeout_add (100, ScrollTimer, 0); + return; + } + // copy text to control a line at a time + + ptr2 = memchr(ptr1, 13, len); + + if (ptr2 == 0) // No CR + { + memmove(MonSave, ptr1, len); + MonSaveLen = len; + return; + } + + if (ptr1[0] == 0x1b) + { + mtag = tagm[ptr1[1] - 10]; + + gtk_text_buffer_get_end_iter(text, &iter); + start = gtk_text_buffer_get_char_count(text); + gtk_text_buffer_insert(text, &iter, ptr1 + 2, (ptr2 - ptr1) - 2); + end = gtk_text_buffer_get_char_count(text); + + gtk_text_buffer_get_iter_at_offset (text, &iter, start); + gtk_text_buffer_get_iter_at_offset (text, &enditer, end); + gtk_text_buffer_apply_tag (text, mtag, &iter, &enditer); + } + else + { + gtk_text_buffer_get_end_iter(text, &iter); + gtk_text_buffer_insert(text, &iter, ptr1, (ptr2 - ptr1)); + + } + + gtk_text_buffer_get_end_iter(text, &iter); + gtk_text_buffer_insert(text, &iter, "\n", 1); + + gtk_text_view_scroll_to_iter ((GtkTextView *)view, &iter, 0.0, FALSE, 0.0, 0.0); + +// if (LogMonitor) WriteMonitorLine(ptr1, ptr2 - ptr1); + + len -= (++ptr2 - ptr1); + ptr1 = ptr2; + + goto lineloop; +} + + +int SendMsg(const char * msg, int len) +{ + send(sock, msg, len, 0); + return 0; +} + +int TCPConnect(char * Host, char * Port) +{ + + int err = 0; +// u_long param=1; +// int bcopt=TRUE; +// struct sockaddr_in sinx; +// int addrlen=sizeof(sinx); + char Title[80]; + + struct addrinfo hints, *res = NULL; + + Disconnecting = FALSE; + + // get host info, make socket, and connect it + + memset(&hints, 0, sizeof hints); + hints.ai_family = AF_UNSPEC; // use IPv4 or IPv6, whichever + hints.ai_socktype = SOCK_STREAM; + getaddrinfo(Host, Port, &hints, &res); + + if (!res) + { + dialog = gtk_message_dialog_new ((GtkWindow *)window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "Resolve HostName Failed"); + + gtk_window_set_title (GTK_WINDOW (dialog), "TermTCP"); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + + sprintf(Title,"TermTCP Version %s - Disconnected", VersionString); + + gtk_window_set_title (GTK_WINDOW (window), Title); + + return FALSE; // Resolve failed + + } + + sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol); + + if (connect(sock, res->ai_addr, res->ai_addrlen) == 0) + { + // + // Connected successful + // + + Telnet_Connected(sock, 0); + + return TRUE; + } + else + { + err=errno; + + if (err == 10035) + { + // Connect in Progress + + sprintf(Title,"BPQTermTCP Version %s - Connecting to %s", VersionString, Host); + gtk_window_set_title (GTK_WINDOW (window), Title); + + EnableDisconnectMenu(); + DisableConnectMenu(); + + return TRUE; + } + else + { + // Connect failed + + closesocket(sock); + dialog = gtk_message_dialog_new ((GtkWindow *)window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Connect Failed"); + + gtk_window_set_title (GTK_WINDOW (dialog), "BPQTermTCP"); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + return FALSE; + } + } + + return FALSE; +} + +#define MAX_MSG_LEN 512 + + +int ProcessReceivedData() +{ + char message[MAX_MSG_LEN + 10]; + gchar * ptr; + char * Buffptr; + char * FEptr = 0; + int len = 0, MonLen; + + len = recv(sock, message, MAX_MSG_LEN, 0); + + if (len <= 0) + { + if (Disconnecting == FALSE) + { + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; + } + else + if (SocketActive) + closesocket(sock); + + sprintf(Title,"BPQTermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + MonData = FALSE; + return TRUE; + } + + if (len == 0) + { + printf("recv - len = 0\r\n"); + if (Disconnecting == FALSE) + { + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; + } + else + closesocket(sock); + + return TRUE; + } + + message[len] = 0; + + // Look for MON delimiters (FF/FE) + + Buffptr = message; + + if (MonData) + { + // Already in MON State + + FEptr = memchr(Buffptr, 0xfe, len); + + if (!FEptr) + { + // no FE - so send all to monitor + + WritetoMonWindow(Buffptr, len); + return TRUE; + } + + MonData = FALSE; + + MonLen = FEptr - Buffptr; // Mon Data, Excluding the FE + + WritetoMonWindow(Buffptr, MonLen); + + Buffptr = ++FEptr; // Char following FE + + if (++MonLen < len) + { + len -= MonLen; + goto MonLoop; // See if next in MON or Data + } + + // Nothing Left + + return TRUE; + } + +MonLoop: + + ptr = memchr(Buffptr, 0xff, len); + + if (ptr) + { + // Buffer contains Mon Data + + if (ptr > Buffptr) + { + // Some Normal Data before the FF + + int NormLen = ptr - Buffptr; // Before the FF + WritetoOutputWindow(Buffptr, NormLen); + + len -= NormLen; + Buffptr = ptr; + goto MonLoop; + } + + MonData = TRUE; + + FEptr = memchr(Buffptr, 0xfe, len); + + if (FEptr) + { + MonData = FALSE; + + MonLen = FEptr + 1 - Buffptr; // MonLen includes FF and FE + WritetoMonWindow(Buffptr+1, MonLen - 2); + + len -= MonLen; + Buffptr += MonLen; // Char Following FE + + if (len <= 0) + { + return TRUE; + } + goto MonLoop; + } + else + { + // No FE, so rest of buffer is MON Data + + WritetoMonWindow(Buffptr+1, len -1); // Exclude FF +// dorefresh(); + return TRUE; + } + } + + // No FF, so must be session data + + WritetoOutputWindow(Buffptr, len); +// SlowTimer = 0; + + return TRUE; +} +/* +gboolean GtkMsg_ShowMessage(GIOChannel *channel, GIOCondition condition, gpointer data) +{ + gchar message[MAX_MSG_LEN + 10]; +// GtkTextMark* MarkEnd; + gchar * ptr; + char * Buffptr; + char * FEptr = 0; + int len = 0, MonLen; + + +// GtkWidget *widgetMsgList = lookup_widget(MainWindow, "textview1"); +// GtkTextBuffer *textMsgList = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widgetMsgList)); + + if (condition & G_IO_HUP) + { + if (SocketActive) + closesocket(sock); + else + return 0; + + sprintf(Title,"BPQTermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + Disconnecting = FALSE; + MonData = FALSE; + return TRUE; + } + + if ((condition & G_IO_IN) == 0) + return TRUE; + + g_io_channel_read_chars (channel, message, MAX_MSG_LEN, &len, NULL); + + if (len == 0) + { + if (Disconnecting == FALSE) + { + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; + } + return TRUE; + } + + message[len] = 0; + + // Look for MON delimiters (FF/FE) + + Buffptr = message; + + if (MonData) + { + // Already in MON State + + FEptr = memchr(Buffptr, 0xfe, len); + + if (!FEptr) + { + // no FE - so send all to monitor + + WritetoMonWindow(Buffptr, len); + return TRUE; + } + + MonData = FALSE; + + MonLen = FEptr - Buffptr; // Mon Data, Excluding the FE + + WritetoMonWindow(Buffptr, MonLen); + + Buffptr = ++FEptr; // Char following FE + + if (++MonLen < len) + { + len -= MonLen; + goto MonLoop; // See if next in MON or Data + } + + // Nothing Left + + return TRUE; + } + +MonLoop: + + ptr = memchr(Buffptr, 0xff, len); + + if (ptr) + { + // Buffer contains Mon Data + + if (ptr > Buffptr) + { + // Some Normal Data before the FF + + int NormLen = ptr - Buffptr; // Before the FF + WritetoOutputWindow(Buffptr, NormLen); + + len -= NormLen; + Buffptr = ptr; + goto MonLoop; + } + + MonData = TRUE; + + FEptr = memchr(Buffptr, 0xfe, len); + + if (FEptr) + { + MonData = FALSE; + + MonLen = FEptr + 1 - Buffptr; // MonLen includes FF and FE + WritetoMonWindow(Buffptr+1, MonLen - 2); + + len -= MonLen; + Buffptr += MonLen; // Char Following FE + + if (len <= 0) + { + return TRUE; + } + goto MonLoop; + } + else + { + // No FE, so rest of buffer is MON Data + + WritetoMonWindow(Buffptr+1, len -1); // Exclude FF +// DoRefresh(); + return TRUE; + } + } + + // No FF, so must be session data + + WritetoOutputWindow(Buffptr, len); +// SlowTimer = 0; + + return TRUE; +} + +*/ + +int Telnet_Connected(SOCKET sock, int Error) +{ + char Msg[80]; + int Len; + + // Connect Complete + + if (Error) + { + dialog = gtk_message_dialog_new ((GtkWindow *)window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Connect Failed"); + + gtk_window_set_title (GTK_WINDOW (dialog), "TermTCP"); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + closesocket(sock); + Connecting = FALSE; + SocketActive = FALSE; + + sprintf(Title,"TermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableDisconnectMenu(); + EnableConnectMenu(); + + return 0; + + } + +// RecvChannel = g_io_channel_unix_new((gint)sock); +// RecvChannel = g_io_channel_win32_new_socket((gint)sock); +// g_io_channel_set_encoding (RecvChannel, NULL, NULL); +// g_io_channel_set_flags(RecvChannel, G_IO_FLAG_APPEND| G_IO_FLAG_NONBLOCK, NULL); +// g_io_add_watch(RecvChannel, G_IO_IN | G_IO_HUP, GtkMsg_ShowMessage, 0); + + SocketActive = TRUE; + Connecting = FALSE; + Connected = TRUE; + + Len = sprintf(Msg, "%s\r%s\rBPQTermTCP\r", UserName[CurrentHost], Password[CurrentHost]); + + SendMsg(Msg, Len); + + SendTraceOptions(); + +// SlowTimer = 0; + + sprintf(Title,"TermTCP Version %s - Connected to %s", VersionString, Host[CurrentHost]); + gtk_window_set_title (GTK_WINDOW (window), Title); + DisableConnectMenu(); + EnableDisconnectMenu(); + + return 0; +} + +static void Disconnect(GtkWidget *w, gpointer data) +{ + if (Disconnecting) + { + // Force close + + if (SocketActive) + closesocket(sock); + + sprintf(Title,"TermTCP Version %s - Disconnected", VersionString); + gtk_window_set_title (GTK_WINDOW (window), Title); + + DisableDisconnectMenu(); + EnableConnectMenu(); + + + WritetoOutputWindow(DisMsg, strlen(DisMsg)); + SocketActive = FALSE; + Connected = FALSE; + Disconnecting = FALSE; + return; + } + shutdown(sock, 2); // SD_BOTH + Disconnecting = TRUE; +} + +void EnableDisconnectMenu() +{ + gtk_widget_set_sensitive(dis_item, TRUE); +} +void DisableConnectMenu() +{ + gtk_widget_set_sensitive(conn_item, FALSE); +} +void EnableConnectMenu() +{ + gtk_widget_set_sensitive(conn_item, TRUE); +} +void DisableDisconnectMenu() +{ + gtk_widget_set_sensitive(dis_item, FALSE); + +} + +void ReadConfig() +{ + FILE *infile; + GKeyFile * KF; + gchar * Value; + gchar * Posn; + + GError *error = NULL; + char path[PATH_MAX]; + char *fname = ".BPQTermTCP.ini"; + snprintf(path, PATH_MAX, "%s/%s", getenv("HOME"), fname); + + KF = g_key_file_new(); + g_key_file_load_from_file(KF, path, 0, NULL); + + Posn = g_key_file_get_string (KF, "Session 1", "Position", &error); + if (Posn) + sscanf(Posn,"%d,%d,%d,%d",&gx,&gy, &width, &height); + + printf("%s %d %d %d %d\n", Posn, gx, gy, width, height); + + PortMask = g_key_file_get_integer(KF, "Session 1", "PortMask", &error); + Bells = g_key_file_get_integer(KF, "Session 1", "Bells", &error); +// StripLF = g_key_file_get_integer(KF, "Session 1", "StripLF", &error); + MCOM = g_key_file_get_integer(KF, "Session 1", "MCOM", &error); + MONColour = g_key_file_get_integer(KF, "Session 1", "MONColour", &error); + MonNODES= g_key_file_get_integer(KF, "Session 1", "MonNODES", &error); + MonPorts= g_key_file_get_integer(KF, "Session 1", "MonPorts", &error); + ChatMode= g_key_file_get_integer(KF, "Session 1", "ChatMode", &error); + CurrentHost = g_key_file_get_integer (KF, "Session 1", "CurrentHost", &error); + mtxparam = g_key_file_get_integer (KF, "Session 1", "MTX", &error); +// fontname = g_key_file_intger (KF, "Session 1", "FontName", &error); +// charset = g_key_file_intger (KF, "Session 1", "CharSet", &error); +// codepage = g_key_file_intger (KF, "Session 1", "CodePage", &error); +// fontsize = g_key_file_intger (KF, "Session 1", "FontSize", &error); +// fontwidth = g_key_file_intger (KF, "Session 1", "FontWidth", &error); + muionly = g_key_file_get_integer (KF, "Session 1", "MUIONLY", &error); + + g_key_file_free(KF); + + infile = fopen ("BPQTermTCP.ini", "r"); + + if (infile) + { + char buffer[1024]; + char * ret; + char * ptr; + + while (1) + { + ret = fgets(buffer, 1024, infile); + + if (ret == 0) + { + fclose (infile); + return; + } + + ptr = strchr(buffer, 10); + + if (ptr) + *ptr = 0; + + if (memcmp(buffer, "Host", 4) == 0) + { + int port = atoi(&buffer[4]) - 1; + strcpy(&Host[port][0], &buffer[6]); + continue; + } + if (memcmp(buffer, "Port", 4) == 0) + { + int port = atoi(&buffer[4]) - 1; + strcpy(&Port[port][0], &buffer[6]); + continue; + } + if (memcmp(buffer, "User", 4) == 0) + { + int port = atoi(&buffer[4]) - 1; + strcpy(&UserName[port][0], &buffer[6]); + continue; + } + if (memcmp(buffer, "Pass", 4) == 0) + { + int port = atoi(&buffer[4]) - 1; + strcpy(&Password[port][0], &buffer[6]); + continue; + } + } + } +// return 0 +}