Return to callbacks.c CVS log

Up to [Synchronet] / sbbs / src / sbbs3 / gtkchat

Annotation of sbbs/src/sbbs3/gtkchat/callbacks.c, revision 1.1

1.1     ! root        1: #include <gtk/gtk.h>
        !             2: #include <gdk/gdkkeysyms.h>
        !             3: 
        !             4: #include "chatfuncs.h"
        !             5: #include "callbacks.h"
        !             6: #include "interface.h"
        !             7: #include "support.h"
        !             8: 
        !             9: gint
        !            10: get_from_remote(gpointer data)
        !            11: {
        !            12:        int             ch;
        !            13:        gchar   *outstr;
        !            14:        gchar   instr[2];
        !            15:        int             inbytes;
        !            16:        int             outbytes;
        !            17: 
        !            18:        instr[1]=0;
        !            19:        switch(chat_check_remote()) {
        !            20:                case 2:         /* Chat active */
        !            21:                        while(ch=chat_read_byte()) {
        !            22:                                if(ch==-1) {
        !            23:                                        chat_close();
        !            24:                                        gtk_main_quit();
        !            25:                                        return(FALSE);
        !            26:                                }
        !            27:                                if(ch==8 || ch==127) {
        !            28:                                        GtkTextIter             start;
        !            29:                                        GtkTextIter             end;
        !            30: 
        !            31:                                        gtk_text_buffer_get_iter_at_mark(
        !            32:                                                         gtk_text_view_get_buffer(GTK_TEXT_VIEW(data))
        !            33:                                                        ,&start
        !            34:                                                        ,gtk_text_buffer_get_insert(
        !            35:                                                                        gtk_text_view_get_buffer(GTK_TEXT_VIEW(data))
        !            36:                                                        )
        !            37:                                        );
        !            38:                                        end=start;
        !            39:                                        gtk_text_iter_backward_cursor_position(&end);
        !            40:                                        gtk_text_buffer_delete(
        !            41:                                                         gtk_text_view_get_buffer(GTK_TEXT_VIEW(data))
        !            42:                                                        ,&start
        !            43:                                                        ,&end
        !            44:                                        );
        !            45:                                }
        !            46:                                else {
        !            47:                                        instr[0]=ch;
        !            48:                                        outstr=g_convert(instr, 1, "UTF-8", "CP437", &inbytes, &outbytes, NULL);
        !            49:                                        gtk_text_buffer_insert_at_cursor(
        !            50:                                                         gtk_text_view_get_buffer(GTK_TEXT_VIEW(data))
        !            51:                                                        ,outstr
        !            52:                                                        ,1
        !            53:                                        );
        !            54:                                        g_free(outstr);
        !            55:                                }
        !            56:                        }
        !            57:                        return(TRUE);
        !            58:        }
        !            59:        chat_close();
        !            60:        return(FALSE);
        !            61: }
        !            62: 
        !            63: 
        !            64: gint
        !            65: connect_wait(gpointer data)
        !            66: {
        !            67:        GtkWidget *MainWindow;
        !            68: 
        !            69:        switch(chat_check_remote()) {
        !            70:                case -1:        /* Error */
        !            71:                case 0:         /* Remote has gone away */
        !            72:                        chat_close();
        !            73:                        return(FALSE);
        !            74:                case 1:         /* Waiting for remote */
        !            75:                        return(TRUE);
        !            76:                case 2:         /* Chat active */
        !            77:                        MainWindow = create_MainWindow ();
        !            78:                        gtk_widget_hide (GTK_WIDGET(data));
        !            79:                        gtk_widget_show (MainWindow);
        !            80:                        return(FALSE);
        !            81:        }
        !            82:        return(TRUE);
        !            83: }
        !            84: 
        !            85: 
        !            86: void
        !            87: on_MainWindow_destroy                  (GtkObject       *object,
        !            88:                                         gpointer         user_data)
        !            89: {
        !            90:        chat_close();
        !            91:        gtk_main_quit();
        !            92: }
        !            93: 
        !            94: 
        !            95: gboolean
        !            96: on_LocalText_key_press_event           (GtkWidget       *widget,
        !            97:                                         GdkEventKey     *event,
        !            98:                                         gpointer         user_data)
        !            99: {
        !           100:        gchar   *outstr;
        !           101:        gchar   instr[2];
        !           102:        int             inbytes;
        !           103:        int             outbytes;
        !           104: 
        !           105:        if(event->keyval==GDK_BackSpace || event->keyval==GDK_Delete) {
        !           106:                GtkTextIter             start;
        !           107:                GtkTextIter             end;
        !           108: 
        !           109:                chat_write_byte('\b');
        !           110:                gtk_text_buffer_get_iter_at_mark(
        !           111:                                 gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget))
        !           112:                                ,&start
        !           113:                                ,gtk_text_buffer_get_insert(
        !           114:                                                gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget))
        !           115:                                )
        !           116:                );
        !           117:                end=start;
        !           118:                gtk_text_iter_backward_cursor_position(&end);
        !           119:                gtk_text_buffer_delete(
        !           120:                                 gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget))
        !           121:                                ,&start
        !           122:                                ,&end
        !           123:                );
        !           124:        }
        !           125:        if(event->keyval >= 32 && event->keyval < 127) {
        !           126:                instr[1]=0;
        !           127:                instr[0]=event->keyval;
        !           128:                chat_write_byte(event->keyval);
        !           129:                outstr=g_convert(instr, 1, "UTF-8", "CP437", &inbytes, &outbytes, NULL);
        !           130:                gtk_text_buffer_insert_at_cursor(
        !           131:                                 gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget))
        !           132:                                ,outstr
        !           133:                                ,1
        !           134:                );
        !           135:                g_free(outstr);
        !           136:        }
        !           137:        if(event->keyval == GDK_Return || event->keyval == GDK_KP_Enter) {
        !           138:                instr[1]=0;
        !           139:                instr[0]='\n';
        !           140:                chat_write_byte('\r');
        !           141:                outstr=g_convert(instr, 1, "UTF-8", "CP437", &inbytes, &outbytes, NULL);
        !           142:                gtk_text_buffer_insert_at_cursor(
        !           143:                                 gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget))
        !           144:                                ,outstr
        !           145:                                ,1
        !           146:                );
        !           147:                g_free(outstr);
        !           148:        }
        !           149:        
        !           150:        return FALSE;
        !           151: }
        !           152: 
        !           153: 
        !           154: void
        !           155: on_CancelButton_clicked                (GtkButton       *button,
        !           156:                                         gpointer         user_data)
        !           157: {
        !           158:        chat_close();
        !           159:        gtk_main_quit();
        !           160: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.