Mercurial > pidgin

comparison src/conversation.c @ 3790:12b29552f1d7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 3930] Better than cheddar, it's i18n input... committer: Tailor Script <tailor@pidgin.im>
author Rob Flynn <gaim@robflynn.com>
date Wed, 23 Oct 2002 00:12:49 +0000
parents fb519383a058
children 3163a8825063
comparison
equal deleted inserted replaced
3789:fb519383a058 3790:12b29552f1d7
77 77
78 int fontsize = 3; 78 int fontsize = 3;
79 extern GdkColor bgcolor; 79 extern GdkColor bgcolor;
80 extern GdkColor fgcolor; 80 extern GdkColor fgcolor;
81 81
82 void check_everything(GtkWidget *entry); 82 void check_everything(GtkTextBuffer *buffer);
83 gboolean keypress_callback(GtkWidget *entry, GdkEventKey * event, struct conversation *c); 83 gboolean keypress_callback(GtkWidget *entry, GdkEventKey * event, struct conversation *c);
84 gboolean stop_rclick_callback(GtkWidget *widget, GdkEventButton *event, gpointer data);
84 85
85 static void update_icon(struct conversation *); 86 static void update_icon(struct conversation *);
86 static void remove_icon(struct conversation *); 87 static void remove_icon(struct conversation *);
87 88
88 static void update_checkbox(struct conversation *); 89 static void update_checkbox(struct conversation *);
438 static void do_insert_image(GtkObject *obj, GtkWidget *wid) 439 static void do_insert_image(GtkObject *obj, GtkWidget *wid)
439 { 440 {
440 struct conversation *c = gtk_object_get_user_data(obj); 441 struct conversation *c = gtk_object_get_user_data(obj);
441 const char *name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(wid)); 442 const char *name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(wid));
442 const char *filename; 443 const char *filename;
443 int pos;
444 char *buf; 444 char *buf;
445 struct stat st; 445 struct stat st;
446 int id = g_slist_length(c->images) + 1; 446 int id = g_slist_length(c->images) + 1;
447 447
448 if (file_is_dir(name, wid)) 448 if (file_is_dir(name, wid))
463 filename = strchr(filename, '/') + 1; 463 filename = strchr(filename, '/') + 1;
464 464
465 buf = g_strdup_printf ("<IMG SRC=\"file://%s\" ID=\"%d\" DATASIZE=\"%d\">", 465 buf = g_strdup_printf ("<IMG SRC=\"file://%s\" ID=\"%d\" DATASIZE=\"%d\">",
466 filename, id, (int)st.st_size); 466 filename, id, (int)st.st_size);
467 c->images = g_slist_append(c->images, g_strdup(name)); 467 c->images = g_slist_append(c->images, g_strdup(name));
468 468 gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(c->entry_buffer),
469 if (GTK_OLD_EDITABLE(c->entry)->has_selection) { 469 buf, -1);
470 int finish = GTK_OLD_EDITABLE(c->entry)->selection_end_pos;
471 gtk_editable_insert_text(GTK_EDITABLE(c->entry),
472 buf, strlen(buf), &finish);
473 } else {
474 pos = GTK_OLD_EDITABLE(c->entry)->current_pos;
475 gtk_editable_insert_text(GTK_EDITABLE(c->entry),
476 buf, strlen(buf), &pos);
477 }
478 g_free(buf); 470 g_free(buf);
479 } 471 }
480 472
481 void insert_image(GtkWidget *save, struct conversation *c) 473 void insert_image(GtkWidget *save, struct conversation *c)
482 { 474 {
518 return FALSE; 510 return FALSE;
519 } 511 }
520 512
521 debug_printf("conversation close callback\n"); 513 debug_printf("conversation close callback\n");
522 514
523 if (convo_options & OPT_CONVO_CHECK_SPELLING) 515 /* if (convo_options & OPT_CONVO_CHECK_SPELLING)
524 gtkspell_detach(GTK_TEXT(c->entry)); 516 gtkspell_detach(GTK_TEXT(c->entry));*/
525 517
526 if (!c->is_chat) { 518 if (!c->is_chat) {
527 GSList *cn = connections; 519 GSList *cn = connections;
528 if (!(misc_options & OPT_MISC_STEALTH_TYPING)) 520 if (!(misc_options & OPT_MISC_STEALTH_TYPING))
529 serv_send_typing(c->gc, c->name, NOT_TYPING); 521 serv_send_typing(c->gc, c->name, NOT_TYPING);
623 615
624 sprintf(c->fontface, "%s", newfont && *newfont ? newfont : DEFAULT_FONT_FACE); 616 sprintf(c->fontface, "%s", newfont && *newfont ? newfont : DEFAULT_FONT_FACE);
625 c->hasfont = 1; 617 c->hasfont = 1;
626 618
627 pre_fontface = g_strconcat("<FONT FACE=\"", c->fontface, "\">", NULL); 619 pre_fontface = g_strconcat("<FONT FACE=\"", c->fontface, "\">", NULL);
628 surround(c->entry, pre_fontface, "</FONT>"); 620 surround(c, pre_fontface, "</FONT>");
629 gtk_widget_grab_focus(c->entry); 621 gtk_widget_grab_focus(c->entry);
630 g_free(pre_fontface); 622 g_free(pre_fontface);
631 } 623 }
632 624
633 gint delete_all_convo(GtkWidget *w, GdkEventAny *e, gpointer d) 625 gint delete_all_convo(GtkWidget *w, GdkEventAny *e, gpointer d)
819 { 811 {
820 struct conversation *c = (struct conversation*)data; 812 struct conversation *c = (struct conversation*)data;
821 if (c && c->gc && c->name) { 813 if (c && c->gc && c->name) {
822 c->type_again = 1; 814 c->type_again = 1;
823 serv_send_typing(c->gc, c->name, TYPED); 815 serv_send_typing(c->gc, c->name, TYPED);
816 debug_printf("typed...\n");
824 } 817 }
825 return FALSE; 818 return FALSE;
826 } 819 }
827 820
828 gboolean keypress_callback(GtkWidget *entry, GdkEventKey * event, struct conversation *c) 821 gboolean keypress_callback(GtkWidget *entry, GdkEventKey *event, struct conversation *c)
829 { 822 {
830 int pos;
831
832 if (event->keyval == GDK_Escape) { 823 if (event->keyval == GDK_Escape) {
833 if (convo_options & OPT_CONVO_ESC_CAN_CLOSE) { 824 if (convo_options & OPT_CONVO_ESC_CAN_CLOSE) {
834 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 825 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
835 close_callback(c->close, c); 826 close_callback(c->close, c);
836 c = NULL; 827 c = NULL;
845 gtk_imhtml_page_down(GTK_IMHTML(c->text)); 836 gtk_imhtml_page_down(GTK_IMHTML(c->text));
846 } else if ((event->keyval == GDK_F2) && (convo_options & OPT_CONVO_F2_TOGGLES)) { 837 } else if ((event->keyval == GDK_F2) && (convo_options & OPT_CONVO_F2_TOGGLES)) {
847 gtk_imhtml_show_comments(GTK_IMHTML(c->text), !GTK_IMHTML(c->text)->comments); 838 gtk_imhtml_show_comments(GTK_IMHTML(c->text), !GTK_IMHTML(c->text)->comments);
848 } else if ((event->keyval == GDK_Return) || (event->keyval == GDK_KP_Enter)) { 839 } else if ((event->keyval == GDK_Return) || (event->keyval == GDK_KP_Enter)) {
849 if ((event->state & GDK_CONTROL_MASK) && (convo_options & OPT_CONVO_CTL_ENTER)) { 840 if ((event->state & GDK_CONTROL_MASK) && (convo_options & OPT_CONVO_CTL_ENTER)) {
850 gtk_signal_emit_by_name(GTK_OBJECT(entry), "activate", c); 841 send_callback(NULL, c);
851 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 842 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
852 return TRUE; 843 return TRUE;
853 } else if (!(event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) && (convo_options & OPT_CONVO_ENTER_SENDS)) { 844 } else if (!(event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) && (convo_options & OPT_CONVO_ENTER_SENDS)) {
854 gtk_signal_emit_by_name(GTK_OBJECT(entry), "activate", c); 845 send_callback(NULL, c);
855 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 846 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
856 return TRUE; 847 return TRUE;
857 } else { 848 } else {
858 int oldpos; 849 return FALSE;
859 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
860 oldpos = pos = gtk_editable_get_position(GTK_EDITABLE(entry));
861 gtk_editable_insert_text(GTK_EDITABLE(entry), "\n", 1, &pos);
862 if (oldpos == pos)
863 gtk_editable_set_position(GTK_EDITABLE(entry), pos + 1);
864 return TRUE;
865 } 850 }
866 } else if ((event->state & GDK_CONTROL_MASK) && (event->keyval == 'm')) { 851 } else if ((event->state & GDK_CONTROL_MASK) && (event->keyval == 'm')) {
867 int oldpos;
868 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 852 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
869 oldpos = pos = gtk_editable_get_position(GTK_EDITABLE(entry)); 853 gtk_text_buffer_insert_at_cursor(c->entry_buffer, "\n", 1);
870 gtk_editable_insert_text(GTK_EDITABLE(entry), "\n", 1, &pos);
871 if (oldpos == pos)
872 gtk_editable_set_position(GTK_EDITABLE(entry), pos + 1);
873 } else if (event->state & GDK_CONTROL_MASK) { 854 } else if (event->state & GDK_CONTROL_MASK) {
874 int pos = 0;
875 switch (event->keyval) { 855 switch (event->keyval) {
876 case GDK_Up: 856 case GDK_Up:
877 if (!c->send_history) 857 if (!c->send_history)
878 break; 858 break;
879 if (!c->send_history->prev) { 859 if (!c->send_history->prev) {
860 GtkTextIter start, end;
880 if (c->send_history->data) 861 if (c->send_history->data)
881 g_free(c->send_history->data); 862 g_free(c->send_history->data);
882 c->send_history->data = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); 863 gtk_text_buffer_get_start_iter(c->entry_buffer, &start);
864 gtk_text_buffer_get_end_iter(c->entry_buffer, &end);
865 c->send_history->data = gtk_text_buffer_get_text(c->entry_buffer,
866 &start, &end, FALSE);
883 } 867 }
884 if (c->send_history->next && c->send_history->next->data) { 868 if (c->send_history->next && c->send_history->next->data) {
885 c->send_history = c->send_history->next; 869 c->send_history = c->send_history->next;
886 gtk_editable_delete_text (GTK_EDITABLE(entry),0,-1); 870 gtk_text_buffer_set_text(c->entry_buffer, c->send_history->data, -1);
887 gtk_editable_insert_text(GTK_EDITABLE(entry),
888 c->send_history->data,
889 strlen(c->send_history->data),
890 &pos);
891 } 871 }
892 872
893 break; 873 break;
894 case GDK_Down: 874 case GDK_Down:
895 if (!c->send_history) 875 if (!c->send_history)
896 break; 876 break;
897 if (c->send_history->prev) { 877 if (c->send_history->prev) {
898 c->send_history = c->send_history->prev; 878 c->send_history = c->send_history->prev;
899 if (c->send_history->data) { 879 if (c->send_history->data) {
900 gtk_editable_delete_text (GTK_EDITABLE(entry),0,-1); 880 gtk_text_buffer_set_text(c->entry_buffer, c->send_history->data, -1);
901 gtk_editable_insert_text (GTK_EDITABLE(entry), c->send_history->data,
902 strlen(c->send_history->data), &pos);
903
904 } 881 }
905 } 882 }
906 break; 883 break;
907 } 884 }
908 if (convo_options & OPT_CONVO_CTL_CHARS) { 885 if (convo_options & OPT_CONVO_CTL_CHARS) {
909 switch (event->keyval) { 886 switch (event->keyval) {
910 case 'i': 887 case 'i':
911 case 'I': 888 case 'I':
912 quiet_set(c->italic, 889 quiet_set(c->italic,
913 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(c->italic))); 890 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(c->italic)));
914 do_italic(c->italic, c->entry); 891 do_italic(c->italic, c);
915 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 892 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
916 break; 893 break;
917 case 'u': /* ctl-u is GDK_Clear, which clears the line */ 894 case 'u': /* ctl-u is GDK_Clear, which clears the line */
918 case 'U': 895 case 'U':
919 quiet_set(c->underline, 896 quiet_set(c->underline,
920 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON 897 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
921 (c->underline))); 898 (c->underline)));
922 do_underline(c->underline, c->entry); 899 do_underline(c->underline, c);
923 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 900 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
924 break; 901 break;
925 case 'b': /* ctl-b is GDK_Left, which moves backwards */ 902 case 'b': /* ctl-b is GDK_Left, which moves backwards */
926 case 'B': 903 case 'B':
927 quiet_set(c->bold, 904 quiet_set(c->bold,
928 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(c->bold))); 905 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(c->bold)));
929 do_bold(c->bold, c->entry); 906 do_bold(c->bold, c);
930 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 907 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
931 break; 908 break;
932 case '-': 909 case '-':
933 do_small(NULL, c->entry); 910 do_small(NULL, c);
934 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 911 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
935 break; 912 break;
936 case '=': 913 case '=':
937 case '+': 914 case '+':
938 do_big(NULL, c->entry); 915 do_big(NULL, c);
939 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 916 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
940 break; 917 break;
941 case '0': 918 case '0':
942 do_normal(NULL, c->entry); 919 do_normal(NULL, c);
943 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 920 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
944 break; 921 break;
945 case 'f': 922 case 'f':
946 case 'F': 923 case 'F':
947 quiet_set(c->font, 924 quiet_set(c->font,
1003 case '*': 980 case '*':
1004 sprintf(buf, ":-D"); 981 sprintf(buf, ":-D");
1005 break; 982 break;
1006 } 983 }
1007 if (buf[0]) { 984 if (buf[0]) {
1008 if (GTK_OLD_EDITABLE(c->entry)->has_selection) { 985 gtk_text_buffer_insert_at_cursor(c->entry_buffer, buf, -1);
1009 int finish = GTK_OLD_EDITABLE(c->entry)->selection_end_pos;
1010 gtk_editable_insert_text(GTK_EDITABLE(c->entry),
1011 buf, strlen(buf), &finish);
1012 } else {
1013 pos = GTK_OLD_EDITABLE(c->entry)->current_pos;
1014 gtk_editable_insert_text(GTK_EDITABLE(c->entry),
1015 buf, strlen(buf), &pos);
1016 }
1017 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event"); 986 gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key_press_event");
1018 } 987 }
1019 } 988 }
1020 if (event->keyval == 'l') { 989 if (event->keyval == 'l') {
1021 gtk_imhtml_clear(GTK_IMHTML(c->text)); 990 gtk_imhtml_clear(GTK_IMHTML(c->text));
1068 } 1037 }
1069 1038
1070 return FALSE; 1039 return FALSE;
1071 } 1040 }
1072 1041
1042 /* This guy just kills a single right click from being propagated any
1043 * further. I have no idea *why* we need this, but we do ... It
1044 * prevents right clicks on the GtkTextView in a convo dialog from
1045 * going all the way down to the notebook. I suspect a bug in
1046 * GtkTextView, but I'm not ready to point any fingers yet. */
1047 gboolean stop_rclick_callback(GtkWidget *widget, GdkEventButton *event, gpointer data)
1048 {
1049 if (event->button == 3 && event->type == GDK_BUTTON_PRESS) {
1050 /* right single click */
1051 g_signal_stop_emission_by_name(G_OBJECT(widget), "button_press_event");
1052 return TRUE;
1053 }
1054 }
1055
1073 static void got_typing_keypress(struct conversation *c, gboolean first) { 1056 static void got_typing_keypress(struct conversation *c, gboolean first) {
1074 /* we know we got something, so we at least have to make sure we don't send 1057 /* we know we got something, so we at least have to make sure we don't send
1075 * TYPED any time soon */ 1058 * TYPED any time soon */
1076 if(c->type_again_timeout) 1059 if(c->type_again_timeout)
1077 gtk_timeout_remove(c->type_again_timeout); 1060 gtk_timeout_remove(c->type_again_timeout);
1086 else 1069 else
1087 c->type_again = 0; 1070 c->type_again = 0;
1088 } 1071 }
1089 } 1072 }
1090 1073
1091 void delete_text_callback(GtkEditable *editable, gint start_pos, gint end_pos, gpointer user_data) { 1074 void delete_text_callback(GtkTextBuffer *textbuffer, GtkTextIter *start_pos, GtkTextIter *end_pos, gpointer user_data) {
1092 struct conversation *c = user_data; 1075 struct conversation *c = user_data;
1093 gchar *contents;
1094 1076
1095 if(!c) 1077 if(!c)
1096 return; 1078 return;
1097 1079
1098 if (misc_options & OPT_MISC_STEALTH_TYPING) 1080 if (misc_options & OPT_MISC_STEALTH_TYPING)
1099 return; 1081 return;
1100 1082
1101 contents = gtk_editable_get_chars(editable, 0, -1); 1083 if(gtk_text_iter_is_start(start_pos) && gtk_text_iter_is_end(end_pos)) {
1102 if(start_pos == 0 && (end_pos == strlen(contents) || end_pos == -1)) {
1103 if(c->type_again_timeout) 1084 if(c->type_again_timeout)
1104 gtk_timeout_remove(c->type_again_timeout); 1085 gtk_timeout_remove(c->type_again_timeout);
1105 serv_send_typing(c->gc, c->name, NOT_TYPING); 1086 serv_send_typing(c->gc, c->name, NOT_TYPING);
1106 } else { 1087 } else {
1107 /* we're deleting, but not all of it, so it counts as typing */ 1088 /* we're deleting, but not all of it, so it counts as typing */
1108 got_typing_keypress(c, FALSE); 1089 got_typing_keypress(c, FALSE);
1109 } 1090 }
1110 g_free(contents); 1091 }
1111 } 1092
1112 1093 void insert_text_callback(GtkTextBuffer *textbuffer, GtkTextIter *position, gchar *new_text, gint new_text_length, gpointer user_data) {
1113 void insert_text_callback(GtkEditable *editable, gchar *new_text, gint new_text_length, gint *position, gpointer user_data) {
1114 struct conversation *c = user_data; 1094 struct conversation *c = user_data;
1115 gchar *contents;
1116 1095
1117 if(!c) 1096 if(!c)
1118 return; 1097 return;
1119 1098
1120 if (misc_options & OPT_MISC_STEALTH_TYPING) 1099 if (misc_options & OPT_MISC_STEALTH_TYPING)
1121 return; 1100 return;
1122 1101
1123 contents = gtk_editable_get_chars(editable, 0, -1); 1102 got_typing_keypress(c, (gtk_text_iter_is_start(position) && gtk_text_iter_is_end(position)));
1124 got_typing_keypress(c, (*position == 0 && strlen(contents) == 0));
1125 g_free(contents);
1126 } 1103 }
1127 1104
1128 void send_callback(GtkWidget *widget, struct conversation *c) 1105 void send_callback(GtkWidget *widget, struct conversation *c)
1129 { 1106 {
1130 char *buf, *buf2; 1107 char *buf, *buf2;
1131 int limit; 1108 int limit;
1132 gulong length=0; 1109 gulong length=0;
1133 int err = 0; 1110 int err = 0;
1134 GList *first; 1111 GList *first;
1112 GtkTextIter start_iter, end_iter;
1135 1113
1136 if (!c->gc) 1114 if (!c->gc)
1137 return; 1115 return;
1138 1116
1139 1117 gtk_text_buffer_get_start_iter(c->entry_buffer, &start_iter);
1140 buf2 = gtk_editable_get_chars(GTK_EDITABLE(c->entry), 0, -1); 1118 gtk_text_buffer_get_end_iter(c->entry_buffer, &end_iter);
1119 buf2 = gtk_text_buffer_get_text(c->entry_buffer, &start_iter, &end_iter, FALSE);
1141 limit = 32 * 1024; /* you shouldn't be sending more than 32k in your messages. that's a book. */ 1120 limit = 32 * 1024; /* you shouldn't be sending more than 32k in your messages. that's a book. */
1142 buf = g_malloc(limit); 1121 buf = g_malloc(limit);
1143 g_snprintf(buf, limit, "%s", buf2); 1122 g_snprintf(buf, limit, "%s", buf2);
1144 g_free(buf2); 1123 g_free(buf2);
1145 if (!strlen(buf)) { 1124 if (!strlen(buf)) {
1221 g_free(buf2); 1200 g_free(buf2);
1222 g_free(buf); 1201 g_free(buf);
1223 return; 1202 return;
1224 } 1203 }
1225 if (plugin_return) { 1204 if (plugin_return) {
1226 gtk_editable_delete_text(GTK_EDITABLE(c->entry), 0, -1); 1205 gtk_text_buffer_set_text(c->entry_buffer, "", -1);
1227 g_free(buffy); 1206 g_free(buffy);
1228 g_free(buf2); 1207 g_free(buf2);
1229 g_free(buf); 1208 g_free(buf);
1230 return; 1209 return;
1231 } 1210 }
1360 else if (err == -ENOTCONN) 1339 else if (err == -ENOTCONN)
1361 debug_printf("Not yet connected\n"); 1340 debug_printf("Not yet connected\n");
1362 else 1341 else
1363 do_error_dialog(_("Unable to send message"), NULL, GAIM_ERROR); 1342 do_error_dialog(_("Unable to send message"), NULL, GAIM_ERROR);
1364 } else { 1343 } else {
1365 gtk_editable_delete_text(GTK_EDITABLE(c->entry), 0, -1); 1344 gtk_text_buffer_set_text(c->entry_buffer, "", -1);
1366 1345
1367 if ((err > 0) && (away_options & OPT_AWAY_BACK_ON_IM)) { 1346 if ((err > 0) && (away_options & OPT_AWAY_BACK_ON_IM)) {
1368 if (awaymessage != NULL) { 1347 if (awaymessage != NULL) {
1369 do_im_back(); 1348 do_im_back();
1370 } else if (c->gc->away) { 1349 } else if (c->gc->away) {
1372 } 1351 }
1373 } 1352 }
1374 } 1353 }
1375 } 1354 }
1376 1355
1377 int entry_key_pressed(GtkWidget *w, GtkWidget *entry) 1356 gboolean entry_key_pressed(GtkTextBuffer *buffer)
1378 { 1357 {
1379 check_everything(w); 1358 check_everything(buffer);
1380 return FALSE; 1359 return FALSE;
1381 } 1360 }
1382 1361
1383 /*------------------------------------------------------------------------*/ 1362 /*------------------------------------------------------------------------*/
1384 /* HTML-type stuff */ 1363 /* HTML-type stuff */
1385 /*------------------------------------------------------------------------*/ 1364 /*------------------------------------------------------------------------*/
1386 1365
1387 int count_tag(GtkWidget *entry, char *s1, char *s2) 1366 int count_tag(GtkTextBuffer *buffer, char *s1, char *s2)
1388 { 1367 {
1389 char *p1, *p2; 1368 char *p1, *p2;
1390 int res = 0; 1369 int res = 0;
1391 char *tmp, *tmpo, h; 1370 GtkTextIter start, end;
1392 tmpo = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); 1371 char *tmp, *tmpo;
1393 h = tmpo[GTK_OLD_EDITABLE(entry)->current_pos]; 1372
1394 tmpo[GTK_OLD_EDITABLE(entry)->current_pos] = '\0'; 1373 gtk_text_buffer_get_start_iter(buffer, &start);
1395 tmp = tmpo; 1374 gtk_text_buffer_get_iter_at_mark(buffer, &end,
1375 gtk_text_buffer_get_insert(buffer));
1376
1377 tmp = tmpo = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
1396 do { 1378 do {
1397 p1 = strstr(tmp, s1); 1379 p1 = strstr(tmp, s1);
1398 p2 = strstr(tmp, s2); 1380 p2 = strstr(tmp, s2);
1399 if (p1 && p2) { 1381 if (p1 && p2) {
1400 if (p1 < p2) { 1382 if (p1 < p2) {
1412 res = 0; 1394 res = 0;
1413 tmp = p2 + strlen(s2); 1395 tmp = p2 + strlen(s2);
1414 } 1396 }
1415 } 1397 }
1416 } while (p1 || p2); 1398 } while (p1 || p2);
1417 tmpo[GTK_OLD_EDITABLE(entry)->current_pos] = h;
1418 g_free(tmpo); 1399 g_free(tmpo);
1419 return res; 1400 return res;
1420 } 1401 }
1421 1402
1422 1403
1423 int invert_tags(GtkWidget *entry, char *s1, char *s2, int really) 1404 gboolean invert_tags(GtkTextBuffer *buffer, char *s1, char *s2, gboolean really)
1424 { 1405 {
1425 int start = GTK_OLD_EDITABLE(entry)->selection_start_pos; 1406 GtkTextIter start1, start2, end1, end2;
1426 int finish = GTK_OLD_EDITABLE(entry)->selection_end_pos; 1407 char *b1, *b2;
1427 char *s; 1408
1428 1409 if (gtk_text_buffer_get_selection_bounds(buffer, &start1, &end2)) {
1429 s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); 1410 start2 = start1; end1 = end2;
1430 if (!g_strncasecmp(&s[start], s1, strlen(s1)) && 1411 if (!gtk_text_iter_forward_chars(&start2, strlen(s1)))
1431 !g_strncasecmp(&s[finish - strlen(s2)], s2, strlen(s2))) { 1412 return FALSE;
1432 if (really) { 1413 if (!gtk_text_iter_backward_chars(&end1, strlen(s2)))
1433 gtk_editable_delete_text(GTK_EDITABLE(entry), start, start + strlen(s1)); 1414 return FALSE;
1434 gtk_editable_delete_text(GTK_EDITABLE(entry), finish - strlen(s2) - strlen(s1), 1415 b1 = gtk_text_buffer_get_text(buffer, &start1, &start2, FALSE);
1435 finish - strlen(s1)); 1416 b2 = gtk_text_buffer_get_text(buffer, &end1, &end2, FALSE);
1436 } 1417 if (!g_strncasecmp(b1, s1, strlen(s1)) &&
1437 g_free(s); 1418 !g_strncasecmp(b2, s2, strlen(s2))) {
1438 return 1; 1419 if (really) {
1439 } 1420 GtkTextMark *m_end1, *m_end2;
1440 g_free(s); 1421
1441 return 0; 1422 m_end1= gtk_text_buffer_create_mark(buffer, "m1", &end1, TRUE);
1442 } 1423 m_end2= gtk_text_buffer_create_mark(buffer, "m2", &end2, TRUE);
1443 1424
1444 1425 gtk_text_buffer_delete(buffer, &start1, &start2);
1445 void remove_tags(GtkWidget *entry, char *tag) 1426 gtk_text_buffer_get_iter_at_mark(buffer, &end1, m_end1);
1446 { 1427 gtk_text_buffer_get_iter_at_mark(buffer, &end2, m_end2);
1447 char *s, *t; 1428 gtk_text_buffer_delete(buffer, &end1, &end2);
1448 int start = GTK_OLD_EDITABLE(entry)->selection_start_pos; 1429 gtk_text_buffer_delete_mark(buffer, m_end1);
1449 int finish = GTK_OLD_EDITABLE(entry)->selection_end_pos; 1430 gtk_text_buffer_delete_mark(buffer, m_end2);
1450 int temp; 1431 }
1451 s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); 1432 g_free(b1); g_free(b2);
1452 t = s; 1433 return TRUE;
1453 1434 }
1454 if (start > finish) { 1435 g_free(b1);g_free(b2);
1455 temp = start; 1436 }
1456 start = finish; 1437 return FALSE;
1457 finish = temp; 1438 }
1458 } 1439
1459 1440
1460 if (strstr(tag, "<FONT SIZE=")) { 1441 void remove_tags(struct conversation *c, char *tag)
1442 {
1443 GtkTextIter start, end, m_start, m_end;
1444
1445 if (!gtk_text_buffer_get_selection_bounds(c->entry_buffer,
1446 &start, &end))
1447 return;
1448
1449 /* FIXMEif (strstr(tag, "<FONT SIZE=")) {
1461 while ((t = strstr(t, "<FONT SIZE="))) { 1450 while ((t = strstr(t, "<FONT SIZE="))) {
1462 if (((t - s) < finish) && ((t - s) >= start)) { 1451 if (((t - s) < finish) && ((t - s) >= start)) {
1463 gtk_editable_delete_text(GTK_EDITABLE(entry), (t - s), 1452 gtk_editable_delete_text(GTK_EDITABLE(entry), (t - s),
1464 (t - s) + strlen(tag)); 1453 (t - s) + strlen(tag));
1465 g_free(s); 1454 g_free(s);
1466 s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); 1455 s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
1467 t = s; 1456 t = s;
1468 } else 1457 } else
1469 t++; 1458 t++;
1470 } 1459 }
1471 } else { 1460 } else*/ {
1472 while ((t = strstr(t, tag))) { 1461 while (gtk_text_iter_forward_search(&start, tag, 0, &m_start, &m_end, &end)) {
1473 if (((t - s) < finish) && ((t - s) >= start)) { 1462 gtk_text_buffer_delete(c->entry_buffer, &m_start, &m_end);
1474 gtk_editable_delete_text(GTK_EDITABLE(entry), (t - s), 1463 gtk_text_buffer_get_selection_bounds(c->entry_buffer, &start, &end);
1475 (t - s) + strlen(tag)); 1464 }
1476 g_free(s); 1465 }
1477 s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
1478 t = s;
1479 } else
1480 t++;
1481 }
1482 }
1483 g_free(s);
1484 } 1466 }
1485 1467
1486 static char *html_logize(char *p) 1468 static char *html_logize(char *p)
1487 { 1469 {
1488 1470
1522 *buffer_p = '\0'; 1504 *buffer_p = '\0';
1523 1505
1524 return buffer_start; 1506 return buffer_start;
1525 } 1507 }
1526 1508
1527 void surround(GtkWidget *entry, char *pre, char *post) 1509 void surround(struct conversation *c, char *pre, char *post)
1528 { 1510 {
1529 int temp, pos = GTK_OLD_EDITABLE(entry)->current_pos; 1511 GtkTextIter start, end;
1530 int dummy; 1512 GtkTextMark *mark_start, *mark_end;
1531 int start, finish; 1513
1532 1514 /* if (convo_options & OPT_CONVO_CHECK_SPELLING) {
1533 if (convo_options & OPT_CONVO_CHECK_SPELLING) {
1534 gtkspell_detach(GTK_TEXT(entry)); 1515 gtkspell_detach(GTK_TEXT(entry));
1535 } 1516 }*/
1536 1517
1537 if (GTK_OLD_EDITABLE(entry)->has_selection) { 1518 if (gtk_text_buffer_get_selection_bounds(c->entry_buffer, &start, &end)) {
1538 remove_tags(entry, pre); 1519 remove_tags(c, pre);
1539 remove_tags(entry, post); 1520 remove_tags(c, post);
1540 start = GTK_OLD_EDITABLE(entry)->selection_start_pos; 1521
1541 finish = GTK_OLD_EDITABLE(entry)->selection_end_pos; 1522 mark_start = gtk_text_buffer_create_mark(c->entry_buffer, "m1", &start, TRUE);
1542 if (start > finish) { 1523 mark_end = gtk_text_buffer_create_mark(c->entry_buffer, "m2", &end, FALSE);
1543 dummy = finish; 1524 gtk_text_buffer_insert(c->entry_buffer, &start, pre, -1);
1544 finish = start; 1525 gtk_text_buffer_get_selection_bounds(c->entry_buffer, &start, &end);
1545 start = dummy; 1526 gtk_text_buffer_insert(c->entry_buffer, &end, post, -1);
1546 } 1527 gtk_text_buffer_get_iter_at_mark(c->entry_buffer, &start, mark_start);
1547 dummy = start; 1528 gtk_text_buffer_move_mark_by_name(c->entry_buffer, "selection_bound", &start);
1548 gtk_editable_insert_text(GTK_EDITABLE(entry), pre, strlen(pre), &dummy);
1549 dummy = finish + strlen(pre);
1550 gtk_editable_insert_text(GTK_EDITABLE(entry), post, strlen(post), &dummy);
1551 gtk_editable_select_region(GTK_EDITABLE(entry), start,
1552 finish + strlen(pre) + strlen(post));
1553 } else { 1529 } else {
1554 temp = pos; 1530 gtk_text_buffer_insert(c->entry_buffer, &start, pre, -1);
1555 gtk_editable_insert_text(GTK_EDITABLE(entry), pre, strlen(pre), &pos); 1531 gtk_text_buffer_insert(c->entry_buffer, &start, post, -1);
1556 if (temp == pos) { 1532 mark_start = gtk_text_buffer_get_insert(c->entry_buffer);
1557 dummy = pos + strlen(pre); 1533 gtk_text_buffer_get_iter_at_mark(c->entry_buffer, &start, mark_start);
1558 gtk_editable_insert_text(GTK_EDITABLE(entry), post, strlen(post), &dummy); 1534 gtk_text_iter_backward_chars(&start, strlen(post));
1559 gtk_editable_set_position(GTK_EDITABLE(entry), dummy); 1535 gtk_text_buffer_place_cursor(c->entry_buffer, &start);
1560 } else { 1536 }
1561 dummy = pos; 1537
1562 gtk_editable_insert_text(GTK_EDITABLE(entry), post, strlen(post), &dummy); 1538 /* if (convo_options & OPT_CONVO_CHECK_SPELLING) {
1563 gtk_editable_set_position(GTK_EDITABLE(entry), pos);
1564 }
1565 }
1566
1567 if (convo_options & OPT_CONVO_CHECK_SPELLING) {
1568 gtkspell_attach(GTK_TEXT(entry)); 1539 gtkspell_attach(GTK_TEXT(entry));
1569 } 1540 }*/
1570 1541
1571 gtk_widget_grab_focus(entry); 1542 gtk_widget_grab_focus(c->entry);
1572 } 1543 }
1573 1544
1574 void advance_past(GtkWidget *entry, char *pre, char *post) 1545 void advance_past(struct conversation *c, char *pre, char *post)
1575 { 1546 {
1576 char *s, *s2; 1547 GtkTextIter current_pos, start, end;
1577 int pos; 1548
1578 if (invert_tags(entry, pre, post, 1)) 1549 if (invert_tags(c->entry_buffer, pre, post, 1))
1579 return; 1550 return;
1580 s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); 1551
1581 pos = GTK_OLD_EDITABLE(entry)->current_pos; 1552 gtk_text_buffer_get_iter_at_mark(c->entry_buffer, &current_pos,
1582 debug_printf(_("Currently at %d, "), pos); 1553 gtk_text_buffer_get_insert(c->entry_buffer));
1583 s2 = strstr(&s[pos], post); 1554 if (gtk_text_iter_forward_search(&current_pos, post, 0, &start, &end, NULL))
1584 if (s2) { 1555 gtk_text_buffer_place_cursor(c->entry_buffer, &end);
1585 pos = s2 - s + strlen(post); 1556 else
1586 } else { 1557 gtk_text_buffer_insert_at_cursor(c->entry_buffer, post, -1);
1587 gtk_editable_insert_text(GTK_EDITABLE(entry), post, strlen(post), &pos); 1558
1588 } 1559 gtk_widget_grab_focus(c->entry);
1589 g_free(s);
1590 debug_printf(_("Setting position to %d\n"), pos);
1591 gtk_editable_set_position(GTK_EDITABLE(entry), pos);
1592 gtk_widget_grab_focus(entry);
1593 } 1560 }
1594 1561
1595 void toggle_fg_color(GtkWidget *color, struct conversation *c) 1562 void toggle_fg_color(GtkWidget *color, struct conversation *c)
1596 { 1563 {
1597 if (state_lock) 1564 if (state_lock)
1599 if (GTK_TOGGLE_BUTTON(color)->active) 1566 if (GTK_TOGGLE_BUTTON(color)->active)
1600 show_fgcolor_dialog(c, color); 1567 show_fgcolor_dialog(c, color);
1601 else if (c->fg_color_dialog) 1568 else if (c->fg_color_dialog)
1602 cancel_fgcolor(color, c); 1569 cancel_fgcolor(color, c);
1603 else 1570 else
1604 advance_past(c->entry, "<FONT COLOR>", "</FONT>"); 1571 advance_past(c, "<FONT COLOR>", "</FONT>");
1605 } 1572 }
1606 1573
1607 void toggle_bg_color(GtkWidget *color, struct conversation *c) 1574 void toggle_bg_color(GtkWidget *color, struct conversation *c)
1608 { 1575 {
1609 if (state_lock) 1576 if (state_lock)
1611 if (GTK_TOGGLE_BUTTON(color)->active) 1578 if (GTK_TOGGLE_BUTTON(color)->active)
1612 show_bgcolor_dialog(c, color); 1579 show_bgcolor_dialog(c, color);
1613 else if (c->bg_color_dialog) 1580 else if (c->bg_color_dialog)
1614 cancel_bgcolor(color, c); 1581 cancel_bgcolor(color, c);
1615 else 1582 else
1616 advance_past(c->entry, "<BODY BGCOLOR>", "</BODY>"); 1583 advance_past(c, "<BODY BGCOLOR>", "</BODY>");
1617 } 1584 }
1618 1585
1619 void toggle_font(GtkWidget *font, struct conversation *c) 1586 void toggle_font(GtkWidget *font, struct conversation *c)
1620 { 1587 {
1621 if (state_lock) 1588 if (state_lock)
1623 if (GTK_TOGGLE_BUTTON(font)->active) 1590 if (GTK_TOGGLE_BUTTON(font)->active)
1624 show_font_dialog(c, font); 1591 show_font_dialog(c, font);
1625 else if (c->font_dialog) 1592 else if (c->font_dialog)
1626 cancel_font(font, c); 1593 cancel_font(font, c);
1627 else 1594 else
1628 advance_past(c->entry, "<FONT FACE>", "</FONT>"); 1595 advance_past(c, "<FONT FACE>", "</FONT>");
1629 } 1596 }
1630 1597
1631 void insert_link_cb(GtkWidget *w, struct conversation *c) 1598 void insert_link_cb(GtkWidget *w, struct conversation *c)
1632 { 1599 {
1633 show_add_link(c->link, c); 1600 show_add_link(c->link, c);
1642 show_add_link(c->link, c); 1609 show_add_link(c->link, c);
1643 1610
1644 else if (c->link_dialog) 1611 else if (c->link_dialog)
1645 cancel_link(c->link, c); 1612 cancel_link(c->link, c);
1646 else 1613 else
1647 advance_past(c->entry, "<A HREF>", "</A>"); 1614 advance_past(c, "<A HREF>", "</A>");
1648 1615
1649 gtk_widget_grab_focus(c->entry); 1616 gtk_widget_grab_focus(c->entry);
1650 } 1617 }
1651 1618
1652 void do_strike(GtkWidget *strike, GtkWidget *entry) 1619 void do_strike(GtkWidget *strike, struct conversation *c)
1653 { 1620 {
1654 if (state_lock) 1621 if (state_lock)
1655 return; 1622 return;
1656 1623
1657 if (GTK_TOGGLE_BUTTON(strike)->active) 1624 if (GTK_TOGGLE_BUTTON(strike)->active)
1658 surround(entry, "<STRIKE>", "</STRIKE>"); 1625 surround(c, "<STRIKE>", "</STRIKE>");
1659 else 1626 else
1660 advance_past(entry, "<STRIKE>", "</STRIKE>"); 1627 advance_past(c, "<STRIKE>", "</STRIKE>");
1661 1628
1662 } 1629 gtk_widget_grab_focus(c->entry);
1663 1630 }
1664 void do_bold(GtkWidget *bold, GtkWidget *entry) 1631
1632 void do_bold(GtkWidget *bold, struct conversation *c)
1665 { 1633 {
1666 if (state_lock) 1634 if (state_lock)
1667 return; 1635 return;
1668 if (GTK_TOGGLE_BUTTON(bold)->active) 1636 if (GTK_TOGGLE_BUTTON(bold)->active)
1669 surround(entry, "<B>", "</B>"); 1637 surround(c, "<B>", "</B>");
1670 else 1638 else
1671 advance_past(entry, "<B>", "</B>"); 1639 advance_past(c, "<B>", "</B>");
1672 1640
1673 gtk_widget_grab_focus(entry); 1641 gtk_widget_grab_focus(c->entry);
1674 } 1642 }
1675 1643
1676 void do_underline(GtkWidget *underline, GtkWidget *entry) 1644 void do_underline(GtkWidget *underline, struct conversation *c)
1677 { 1645 {
1678 if (state_lock) 1646 if (state_lock)
1679 return; 1647 return;
1680 if (GTK_TOGGLE_BUTTON(underline)->active) 1648 if (GTK_TOGGLE_BUTTON(underline)->active)
1681 surround(entry, "<U>", "</U>"); 1649 surround(c, "<U>", "</U>");
1682 else 1650 else
1683 advance_past(entry, "<U>", "</U>"); 1651 advance_past(c, "<U>", "</U>");
1684 1652
1685 gtk_widget_grab_focus(entry); 1653 gtk_widget_grab_focus(c->entry);
1686 } 1654 }
1687 1655
1688 void do_italic(GtkWidget *italic, GtkWidget *entry) 1656 void do_italic(GtkWidget *italic, struct conversation *c)
1689 { 1657 {
1690 if (state_lock) 1658 if (state_lock)
1691 return; 1659 return;
1692 if (GTK_TOGGLE_BUTTON(italic)->active) 1660 if (GTK_TOGGLE_BUTTON(italic)->active)
1693 surround(entry, "<I>", "</I>"); 1661 surround(c, "<I>", "</I>");
1694 else 1662 else
1695 advance_past(entry, "<I>", "</I>"); 1663 advance_past(c, "<I>", "</I>");
1696 1664
1697 gtk_widget_grab_focus(entry); 1665 gtk_widget_grab_focus(c->entry);
1698 } 1666 }
1699 1667
1700 /* html code to modify font sizes must all be the same length, */ 1668 /* html code to modify font sizes must all be the same length, */
1701 /* currently set to 15 chars */ 1669 /* currently set to 15 chars */
1702 1670
1703 void do_small(GtkWidget *small, GtkWidget *entry) 1671 void do_small(GtkWidget *small, struct conversation *c)
1704 { 1672 {
1705 if (state_lock) 1673 if (state_lock)
1706 return; 1674 return;
1707 1675
1708 surround(entry, "<FONT SIZE=\"1\">", "</FONT>"); 1676 surround(c, "<FONT SIZE=\"1\">", "</FONT>");
1709 1677
1710 gtk_widget_grab_focus(entry); 1678 gtk_widget_grab_focus(c->entry);
1711 } 1679 }
1712 1680
1713 void do_normal(GtkWidget *normal, GtkWidget *entry) 1681 void do_normal(GtkWidget *normal, struct conversation *c)
1714 { 1682 {
1715 if (state_lock) 1683 if (state_lock)
1716 return; 1684 return;
1717 1685
1718 surround(entry, "<FONT SIZE=\"3\">", "</FONT>"); 1686 surround(c, "<FONT SIZE=\"3\">", "</FONT>");
1719 1687
1720 gtk_widget_grab_focus(entry); 1688 gtk_widget_grab_focus(c->entry);
1721 } 1689 }
1722 1690
1723 void do_big(GtkWidget *big, GtkWidget *entry) 1691 void do_big(GtkWidget *big, struct conversation *c)
1724 { 1692 {
1725 if (state_lock) 1693 if (state_lock)
1726 return; 1694 return;
1727 1695
1728 surround(entry, "<FONT SIZE=\"5\">", "</FONT>"); 1696 surround(c, "<FONT SIZE=\"5\">", "</FONT>");
1729 1697
1730 gtk_widget_grab_focus(entry); 1698 gtk_widget_grab_focus(c->entry);
1731 } 1699 }
1732 1700
1733 void check_everything(GtkWidget *entry) 1701 void check_everything(GtkTextBuffer *buffer)
1734 { 1702 {
1735 struct conversation *c; 1703 struct conversation *c;
1736 1704
1737 c = (struct conversation *)gtk_object_get_user_data(GTK_OBJECT(entry)); 1705 c = (struct conversation *)g_object_get_data(G_OBJECT(buffer), "user_data");
1738 if (!c) 1706 if (!c)
1739 return; 1707 return;
1740 if (invert_tags(entry, "<B>", "</B>", 0)) 1708 if (invert_tags(c->entry_buffer, "<B>", "</B>", 0))
1741 quiet_set(c->bold, TRUE); 1709 quiet_set(c->bold, TRUE);
1742 else if (count_tag(entry, "<B>", "</B>")) 1710 else if (count_tag(c->entry_buffer, "<B>", "</B>"))
1743 quiet_set(c->bold, TRUE); 1711 quiet_set(c->bold, TRUE);
1744 else 1712 else
1745 quiet_set(c->bold, FALSE); 1713 quiet_set(c->bold, FALSE);
1746 if (invert_tags(entry, "<I>", "</I>", 0)) 1714 if (invert_tags(c->entry_buffer, "<I>", "</I>", 0))
1747 quiet_set(c->italic, TRUE); 1715 quiet_set(c->italic, TRUE);
1748 else if (count_tag(entry, "<I>", "</I>")) 1716 else if (count_tag(c->entry_buffer, "<I>", "</I>"))
1749 quiet_set(c->italic, TRUE); 1717 quiet_set(c->italic, TRUE);
1750 else 1718 else
1751 quiet_set(c->italic, FALSE); 1719 quiet_set(c->italic, FALSE);
1752 1720
1753 if (invert_tags(entry, "<FONT COLOR", "</FONT>", 0)) 1721 if (invert_tags(c->entry_buffer, "<FONT COLOR", "</FONT>", 0))
1754 quiet_set(c->fgcolorbtn, TRUE); 1722 quiet_set(c->fgcolorbtn, TRUE);
1755 else if (count_tag(entry, "<FONT COLOR", "</FONT>")) 1723 else if (count_tag(c->entry_buffer, "<FONT COLOR", "</FONT>"))
1756 quiet_set(c->fgcolorbtn, TRUE); 1724 quiet_set(c->fgcolorbtn, TRUE);
1757 else 1725 else
1758 quiet_set(c->fgcolorbtn, FALSE); 1726 quiet_set(c->fgcolorbtn, FALSE);
1759 1727
1760 if (invert_tags(entry, "<BODY BGCOLOR", "</BODY>", 0)) 1728 if (invert_tags(c->entry_buffer, "<BODY BGCOLOR", "</BODY>", 0))
1761 quiet_set(c->bgcolorbtn, TRUE); 1729 quiet_set(c->bgcolorbtn, TRUE);
1762 else if (count_tag(entry, "<BODY BGCOLOR", "</BODY>")) 1730 else if (count_tag(c->entry_buffer, "<BODY BGCOLOR", "</BODY>"))
1763 quiet_set(c->bgcolorbtn, TRUE); 1731 quiet_set(c->bgcolorbtn, TRUE);
1764 else 1732 else
1765 quiet_set(c->bgcolorbtn, FALSE); 1733 quiet_set(c->bgcolorbtn, FALSE);
1766 1734
1767 if (invert_tags(entry, "<FONT FACE", "</FONT>", 0)) 1735 if (invert_tags(c->entry_buffer, "<FONT FACE", "</FONT>", 0))
1768 quiet_set(c->font, TRUE); 1736 quiet_set(c->font, TRUE);
1769 else if (count_tag(entry, "<FONT FACE", "</FONT>")) 1737 else if (count_tag(c->entry_buffer, "<FONT FACE", "</FONT>"))
1770 quiet_set(c->font, TRUE); 1738 quiet_set(c->font, TRUE);
1771 else 1739 else
1772 quiet_set(c->font, FALSE); 1740 quiet_set(c->font, FALSE);
1773 1741
1774 if (invert_tags(entry, "<A HREF", "</A>", 0)) 1742 if (invert_tags(c->entry_buffer, "<A HREF", "</A>", 0))
1775 quiet_set(c->link, TRUE); 1743 quiet_set(c->link, TRUE);
1776 else if (count_tag(entry, "<A HREF", "</A>")) 1744 else if (count_tag(c->entry_buffer, "<A HREF", "</A>"))
1777 quiet_set(c->link, TRUE); 1745 quiet_set(c->link, TRUE);
1778 else 1746 else
1779 quiet_set(c->link, FALSE); 1747 quiet_set(c->link, FALSE);
1780 1748
1781 if (invert_tags(entry, "<U>", "</U>", 0)) 1749 if (invert_tags(c->entry_buffer, "<U>", "</U>", 0))
1782 quiet_set(c->underline, TRUE); 1750 quiet_set(c->underline, TRUE);
1783 else if (count_tag(entry, "<U>", "</U>")) 1751 else if (count_tag(c->entry_buffer, "<U>", "</U>"))
1784 quiet_set(c->underline, TRUE); 1752 quiet_set(c->underline, TRUE);
1785 else 1753 else
1786 quiet_set(c->underline, FALSE); 1754 quiet_set(c->underline, FALSE);
1787 } 1755 }
1788 1756
2247 2215
2248 /* Bold */ 2216 /* Bold */
2249 button = gaim_pixbuf_toolbar_button_from_stock("gtk-bold"); 2217 button = gaim_pixbuf_toolbar_button_from_stock("gtk-bold");
2250 gtk_size_group_add_widget(sg, button); 2218 gtk_size_group_add_widget(sg, button);
2251 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 2219 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2252 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_bold), c->entry); 2220 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_bold), c);
2253 c->bold = button; /* We should remember this */ 2221 c->bold = button; /* We should remember this */
2254 2222
2255 /* Italic */ 2223 /* Italic */
2256 button = gaim_pixbuf_toolbar_button_from_stock("gtk-italic"); 2224 button = gaim_pixbuf_toolbar_button_from_stock("gtk-italic");
2257 gtk_size_group_add_widget(sg, button); 2225 gtk_size_group_add_widget(sg, button);
2258 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 2226 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2259 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_italic), c->entry); 2227 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_italic), c);
2260 c->italic = button; /* We should remember this */ 2228 c->italic = button; /* We should remember this */
2261 2229
2262 /* Underline */ 2230 /* Underline */
2263 button = gaim_pixbuf_toolbar_button_from_stock("gtk-underline"); 2231 button = gaim_pixbuf_toolbar_button_from_stock("gtk-underline");
2264 gtk_size_group_add_widget(sg, button); 2232 gtk_size_group_add_widget(sg, button);
2265 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 2233 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2266 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_underline), c->entry); 2234 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_underline), c);
2267 c->underline = button; /* We should remember this */ 2235 c->underline = button; /* We should remember this */
2268 2236
2269 /* Sep */ 2237 /* Sep */
2270 sep = gtk_vseparator_new(); 2238 sep = gtk_vseparator_new();
2271 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0); 2239 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
2272 2240
2273 /* Increase font size */ 2241 /* Increase font size */
2274 button = gaim_pixbuf_toolbar_button_from_file("text_bigger.png"); 2242 button = gaim_pixbuf_toolbar_button_from_file("text_bigger.png");
2275 gtk_size_group_add_widget(sg, button); 2243 gtk_size_group_add_widget(sg, button);
2276 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 2244 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2277 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_big), c->entry); 2245 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_big), c);
2278 2246
2279 /* Normal Font Size */ 2247 /* Normal Font Size */
2280 button = gaim_pixbuf_toolbar_button_from_file("text_normal.png"); 2248 button = gaim_pixbuf_toolbar_button_from_file("text_normal.png");
2281 gtk_size_group_add_widget(sg, button); 2249 gtk_size_group_add_widget(sg, button);
2282 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 2250 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2283 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_normal), c->entry); 2251 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_normal), c);
2284 c->font = button; /* We should remember this */ 2252 c->font = button; /* We should remember this */
2285 2253
2286 /* Decrease font size */ 2254 /* Decrease font size */
2287 button = gaim_pixbuf_toolbar_button_from_file("text_smaller.png"); 2255 button = gaim_pixbuf_toolbar_button_from_file("text_smaller.png");
2288 gtk_size_group_add_widget(sg, button); 2256 gtk_size_group_add_widget(sg, button);
2289 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 2257 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2290 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_small), c->entry); 2258 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(do_small), c);
2291 2259
2292 /* Sep */ 2260 /* Sep */
2293 sep = gtk_vseparator_new(); 2261 sep = gtk_vseparator_new();
2294 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0); 2262 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
2295 2263
2751 GtkWidget *send; 2719 GtkWidget *send;
2752 GtkWidget *info; 2720 GtkWidget *info;
2753 GtkWidget *warn; 2721 GtkWidget *warn;
2754 GtkWidget *block; 2722 GtkWidget *block;
2755 /*GtkWidget *close;*/ 2723 /*GtkWidget *close;*/
2724 GtkWidget *frame;
2756 GtkWidget *entry; 2725 GtkWidget *entry;
2757 GtkWidget *bbox; 2726 GtkWidget *bbox;
2758 GtkWidget *vbox; 2727 GtkWidget *vbox;
2759 GtkWidget *vbox2; 2728 GtkWidget *vbox2;
2760 GtkWidget *paned; 2729 GtkWidget *paned;
2902 2871
2903 c->lbox = gtk_hbox_new(FALSE, 0); 2872 c->lbox = gtk_hbox_new(FALSE, 0);
2904 gtk_box_pack_start(GTK_BOX(vbox2), c->lbox, FALSE, FALSE, 0); 2873 gtk_box_pack_start(GTK_BOX(vbox2), c->lbox, FALSE, FALSE, 0);
2905 gtk_widget_show(c->lbox); 2874 gtk_widget_show(c->lbox);
2906 2875
2907 entry = gtk_text_new(NULL, NULL); 2876 toolbar = build_conv_toolbar(c);
2877 gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, FALSE, 0);
2878
2879 frame = gtk_frame_new(NULL);
2880 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
2881 gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0);
2882 gtk_widget_show(frame);
2883
2884 c->entry_buffer = gtk_text_buffer_new(NULL);
2885 g_object_set_data(G_OBJECT(c->entry_buffer), "user_data", c);
2886 entry = gtk_text_view_new_with_buffer(c->entry_buffer);
2908 c->entry = entry; 2887 c->entry = entry;
2909 if (!(im_options & OPT_IM_ONE_WINDOW)) 2888 if (!(im_options & OPT_IM_ONE_WINDOW))
2910 gtk_window_set_focus(GTK_WINDOW(c->window), c->entry); 2889 gtk_window_set_focus(GTK_WINDOW(c->window), c->entry);
2911 2890
2912 toolbar = build_conv_toolbar(c); 2891 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(c->entry), GTK_WRAP_WORD);
2913 gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, FALSE, 0);
2914
2915 gtk_object_set_user_data(GTK_OBJECT(entry), c);
2916 gtk_text_set_editable(GTK_TEXT(entry), TRUE);
2917 gtk_text_set_word_wrap(GTK_TEXT(entry), TRUE);
2918 2892
2919 gtk_widget_set_usize(entry, conv_size.width - 20, MAX(conv_size.entry_height, 25)); 2893 gtk_widget_set_usize(entry, conv_size.width - 20, MAX(conv_size.entry_height, 25));
2920 2894
2921 gtk_signal_connect(GTK_OBJECT(entry), "activate", GTK_SIGNAL_FUNC(send_callback), c); 2895 g_signal_connect_swapped(G_OBJECT(c->entry), "key_press_event",
2922 gtk_signal_connect(GTK_OBJECT(entry), "key_press_event", GTK_SIGNAL_FUNC(keypress_callback), c); 2896 G_CALLBACK(entry_key_pressed), c->entry_buffer);
2923 gtk_signal_connect(GTK_OBJECT(entry), "insert-text", GTK_SIGNAL_FUNC(insert_text_callback), c); 2897 g_signal_connect(G_OBJECT(c->entry), "key_press_event", G_CALLBACK(keypress_callback), c);
2924 gtk_signal_connect(GTK_OBJECT(entry), "delete-text", GTK_SIGNAL_FUNC(delete_text_callback), c); 2898 g_signal_connect_after(G_OBJECT(c->entry), "button_press_event",
2925 gtk_signal_connect(GTK_OBJECT(entry), "key_press_event", GTK_SIGNAL_FUNC(entry_key_pressed), 2899 G_CALLBACK(stop_rclick_callback), NULL);
2926 entry); 2900 g_signal_connect(G_OBJECT(c->entry_buffer), "insert_text",
2927 if (convo_options & OPT_CONVO_CHECK_SPELLING) 2901 G_CALLBACK(insert_text_callback), c);
2928 gtkspell_attach(GTK_TEXT(c->entry)); 2902 g_signal_connect(G_OBJECT(c->entry_buffer), "delete_range",
2929 gtk_box_pack_start(GTK_BOX(vbox2), entry, TRUE, TRUE, 0); 2903 G_CALLBACK(delete_text_callback), c);
2904
2905 /* if (convo_options & OPT_CONVO_CHECK_SPELLING)
2906 gtkspell_attach(GTK_TEXT(c->entry));*/
2907 gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(entry));
2930 gtk_widget_show(entry); 2908 gtk_widget_show(entry);
2931 2909
2932 c->bbox = bbox = gtk_hbox_new(FALSE, 5); 2910 c->bbox = bbox = gtk_hbox_new(FALSE, 5);
2933 gtk_box_pack_start(GTK_BOX(vbox2), bbox, FALSE, FALSE, 0); 2911 gtk_box_pack_start(GTK_BOX(vbox2), bbox, FALSE, FALSE, 0);
2934 gtk_widget_show(bbox); 2912 gtk_widget_show(bbox);
3043 } 3021 }
3044 } 3022 }
3045 3023
3046 while (cnv) { 3024 while (cnv) {
3047 c = (struct conversation *)cnv->data; 3025 c = (struct conversation *)cnv->data;
3048 if (convo_options & OPT_CONVO_CHECK_SPELLING) 3026 /* if (convo_options & OPT_CONVO_CHECK_SPELLING)
3049 gtkspell_attach(GTK_TEXT(c->entry)); 3027 gtkspell_attach(GTK_TEXT(c->entry));
3050 else 3028 else
3051 gtkspell_detach(GTK_TEXT(c->entry)); 3029 gtkspell_detach(GTK_TEXT(c->entry));*/
3052 cnv = cnv->next; 3030 cnv = cnv->next;
3053 } 3031 }
3054 3032
3055 while (con) { 3033 while (con) {
3056 gc = (struct gaim_connection *)con->data; 3034 gc = (struct gaim_connection *)con->data;
3057 cht = gc->buddy_chats; 3035 cht = gc->buddy_chats;
3058 while (cht) { 3036 while (cht) {
3059 c = (struct conversation *)cht->data; 3037 c = (struct conversation *)cht->data;
3060 if (convo_options & OPT_CONVO_CHECK_SPELLING) 3038 /* if (convo_options & OPT_CONVO_CHECK_SPELLING)
3061 gtkspell_attach(GTK_TEXT(c->entry)); 3039 gtkspell_attach(GTK_TEXT(c->entry));
3062 else 3040 else
3063 gtkspell_detach(GTK_TEXT(c->entry)); 3041 gtkspell_detach(GTK_TEXT(c->entry));*/
3064 cht = cht->next; 3042 cht = cht->next;
3065 } 3043 }
3066 con = con->next; 3044 con = con->next;
3067 } 3045 }
3068 3046