Context Navigation

← Previous Change
Next Change →

Changeset 3324 for trunk/jons-gtk2-gui

Timestamp:

03/02/03 04:12:08 (6 years ago)

Author:

bostjanlah

Message:

Localized definitions and move them out licq_gtk.h

Location:

trunk/jons-gtk2-gui/src

Files:

: 29 modified

add_user_window.cpp (modified) (4 diffs)
auth_user_window.cpp (modified) (4 diffs)
away_window.cpp (modified) (6 diffs)
chat_window.cpp (modified) (4 diffs)
contact_list.cpp (modified) (3 diffs)
convo.cpp (modified) (2 diffs)
extras.cpp (modified) (7 diffs)
file_window.cpp (modified) (7 diffs)
history_window.cpp (modified) (2 diffs)
key_request.cpp (modified) (2 diffs)
licq_gtk.h (modified) (6 diffs)
log_window.cpp (modified) (2 diffs)
main.cpp (modified) (2 diffs)
main_window.cpp (modified) (3 diffs)
menu.cpp (modified) (1 diff)
more_window.cpp (modified) (3 diffs)
option_window.cpp (modified) (2 diffs)
pipe.cpp (modified) (1 diff)
plugin_window.cpp (modified) (1 diff)
random_chat.cpp (modified) (3 diffs)
register_user.cpp (modified) (4 diffs)
search_user_window.cpp (modified) (2 diffs)
security_window.cpp (modified) (1 diff)
stats_window.cpp (modified) (4 diffs)
status.cpp (modified) (1 diff)
system_message.cpp (modified) (2 diffs)
system_status.cpp (modified) (1 diff)
user_info_window.cpp (modified) (3 diffs)
user_menu.cpp (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/jons-gtk2-gui/src/add_user_window.cpp

r3164	r3324
20	20
21	21
	22	#include "licq_gtk.h"
	23	#include "utilities.h"
	24
22	25	#include <stdlib.h>
23	26	#include <gtk/gtk.h>
24	27
25		#include "licq_icqd.h"
26		#include "licq_gtk.h"
	28	struct add_user {
	29	GtkWidget *window;
	30	GtkWidget *entry;
	31	GtkWidget *check_box;
	32	};
27	33
28		void menu_system_add_user(GtkWidget *window, gpointer data)
	34	void
	35	window_close(GtkWidget widget, GtkWidget destroy)
29	36	{
30		GtkWidget *ok;
31		GtkWidget *cancel;
32		GtkWidget *label;
33		GtkWidget *h_box;
34		GtkWidget *v_box;
35		struct add_user *a = g_new0(struct add_user, 1);
	37	gtk_widget_destroy(destroy);
	38	}
	39
	40	void
	41	destroy_cb(GtkWidget widget, gpointer *p)
	42	{
	43	if (p != NULL && *p != NULL) {
	44	g_free(*p);
	45	*p = NULL;
	46	}
	47	}
	48
	49	static void
	50	add_user_callback(GtkWidget widget, struct add_user au)
	51	{
	52	unsigned long uin = strtoul(entry_get_chars(au->entry).c_str(), NULL, 10);
	53
	54	if (uin != 0) {
	55	icq_daemon->AddUserToList(uin);
	56
	57	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(au->check_box)))
	58	icq_daemon->icqAlertUser(uin);
	59	}
	60
	61	window_close(NULL, au->window);
	62	}
	63
	64	void
	65	menu_system_add_user(GtkWidget *window, gpointer data)
	66	{
	67	static struct add_user *au = NULL;
	68
	69	if (au == NULL)
	70	au = g_new0(struct add_user, 1);
	71	else {
	72	gtk_widget_show(au->window);
	73	return;
	74	}
36	75
37	76	/* Make up the window for adding users */
38		a->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	77	au->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
39	78
40		gtk_window_set_title(GTK_WINDOW(a->window), "Licq - Add User");
41		gtk_window_set_position(GTK_WINDOW(a->window), GTK_WIN_POS_CENTER);
	79	gtk_window_set_title(GTK_WINDOW(au->window), "Licq - Add User");
	80	gtk_window_set_position(GTK_WINDOW(au->window), GTK_WIN_POS_CENTER);
42	81
43	82	/* The main box */
44		v_box = gtk_vbox_new(FALSE, 5);
	83	GtkWidget *v_box = gtk_vbox_new(FALSE, 5);
45	84
46	85	/* Work on the first hbox */
47		h_box = gtk_hbox_new(FALSE, 5);
48		label = gtk_label_new("Add Uin: ");
49		a->entry = gtk_entry_new();
50		gtk_entry_set_max_length(GTK_ENTRY(a->entry), MAX_LENGTH_UIN);
51		gtk_box_pack_start(GTK_BOX(h_box), label, TRUE, TRUE, 0);
52		gtk_box_pack_start(GTK_BOX(h_box), a->entry, TRUE, TRUE, 0);
	86	GtkWidget *h_box = gtk_hbox_new(FALSE, 5);
	87	au->entry = gtk_entry_new();
	88	gtk_entry_set_max_length(GTK_ENTRY(au->entry), MAX_LENGTH_UIN);
	89	gtk_box_pack_start(GTK_BOX(h_box), gtk_label_new("Add Uin: "), TRUE, TRUE, 0);
	90	gtk_box_pack_start(GTK_BOX(h_box), au->entry, TRUE, TRUE, 0);
53	91
54		/* Accept only numbers in the a->entry */
55		g_signal_connect(G_OBJECT(a->entry), "insert-text",
56		G_CALLBACK(verify_numbers), 0);
	92	/* Accept only numbers in the au->entry */
	93	g_signal_connect(G_OBJECT(au->entry), "insert-text",
	94	G_CALLBACK(verify_numbers), 0);
57	95
58	96	/* Add the first hbox to the top of the vbox */
…	…
61	99	/* Work on the send hbox */
62	100	h_box = gtk_hbox_new(FALSE, 0);
63		a->check_box = gtk_check_button_new_with_label("Alert User");
64		gtk_box_pack_start(GTK_BOX(h_box), a->check_box, TRUE, TRUE, 0);
	101	au->check_box = gtk_check_button_new_with_label("Alert User");
	102	gtk_box_pack_start(GTK_BOX(h_box), au->check_box, TRUE, TRUE, 0);
65	103
66	104	/* Add the second hbox to the vbox */
…	…
69	107	/* Work on the third hbox, with the buttons */
70	108	h_box = gtk_hbox_new(FALSE, 5);
71		ok = gtk_button_new_with_mnemonic("_Add");
	109	GtkWidget *ok = gtk_button_new_with_mnemonic("_Add");
72	110	gtk_box_pack_start(GTK_BOX(h_box), ok, TRUE, TRUE, 10);
73		cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
	111	GtkWidget *cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
74	112	gtk_box_pack_start(GTK_BOX(h_box), cancel, TRUE, TRUE, 10);
75	113
…	…
79	117	/* Connect all the signals to functions */
80	118	g_signal_connect(G_OBJECT(cancel), "clicked",
81		G_CALLBACK(~~dialog_close), a->window~~);
82		g_signal_connect(G_OBJECT(a->window), "destroy",
83		G_CALLBACK(d~~ialog_close), a->window~~);
	119	G_CALLBACK(window_close), NULL);
	120	g_signal_connect(G_OBJECT(au->window), "destroy",
	121	G_CALLBACK(destroy_cb), &au);
84	122	g_signal_connect(G_OBJECT(ok), "clicked",
85		G_CALLBACK(add_user_callback), a);
	123	G_CALLBACK(add_user_callback), au);
86	124
87	125	/* Show the widgets and grab the focus */
88		gtk_container_add(GTK_CONTAINER(a->window), v_box);
89		gtk_widget_show_all(a->window);
90		gtk_window_set_focus(GTK_WINDOW(a~~->window), a~~->entry);
	126	gtk_container_add(GTK_CONTAINER(au->window), v_box);
	127	gtk_widget_show_all(au->window);
	128	gtk_window_set_focus(GTK_WINDOW(au->window), au->entry);
91	129	}
92
93		~~void add_user_callback(GtkWidget widget, struct add_user a)~~
94		{
95		~~unsigned long uin =~~
96		~~atol((const char *)gtk_entry_get_text(GTK_ENTRY(a->entry)));~~
97
98		~~icq_daemon->AddUserToList(uin);~~
99
100		~~if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(a->check_box)))~~
101		~~icq_daemon->icqAlertUser(uin);~~
102
103		~~gtk_widget_destroy(a->window);~~
104		}
105
106		~~void dialog_close(GtkWidget widget, GtkWidget destroy)~~
107		{
108		~~gtk_widget_destroy(destroy);~~
109		}

trunk/jons-gtk2-gui/src/auth_user_window.cpp

r3164	r3324
23	23	#include "licq_icqd.h"
24	24	#include "licq_gtk.h"
	25	#include "utilities.h"
	26
	27	struct auth_user
	28	{
	29	GtkWidget *window;
	30	GtkWidget *entry;
	31	GtkWidget *text;
	32	GtkWidget *grant;
	33	GtkWidget *refuse;
	34	};
	35
	36	static void
	37	auth_user_cb(GtkWidget widget, struct auth_user au)
	38	{
	39	gulong uin = strtoul(entry_get_chars(au->entry).c_str(),
	40	NULL,
	41	10);
	42	std::string reason = entry_get_chars(au->text);
	43
	44	if (widget == au->grant)
	45	icq_daemon->icqAuthorizeGrant(uin, reason.c_str());
	46	else
	47	icq_daemon->icqAuthorizeRefuse(uin, reason.c_str());
	48
	49	window_close(NULL, au->window);
	50	}
25	51
26	52	void menu_system_auth_user(GtkWidget *widget, const unsigned long uin)
27	53	{
	54	static struct auth_user *au = NULL;
	55
	56	if (au == NULL)
	57	au = g_new0(struct auth_user, 1);
	58	else {
	59	gtk_widget_show(au->window);
	60	return;
	61	}
	62
28	63	GtkWidget *label;
29	64	GtkWidget *scroll;
30		~~GtkWidget *ok;~~
31	65	GtkWidget *cancel;
32		~~GtkWidget *refuse;~~
33	66	GtkWidget *h_box;
34	67	GtkWidget *v_box;
35		struct auth_user *au = g_new0(struct auth_user, 1);
36
	68
37	69	/* Create the window */
38	70	au->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
…	…
68	100	/* Make the buttons and pack them */
69	101	h_box = gtk_hbox_new(FALSE, 5);
70		ok = gtk_button_new_from_stock(GTK_STOCK_OK);
71		refuse = gtk_button_new_with_mnemonic("_Refuse");
	102	au->grant = gtk_button_new_from_stock(GTK_STOCK_OK);
	103	au->refuse = gtk_button_new_with_mnemonic("_Refuse");
72	104	cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
73		gtk_box_pack_start(GTK_BOX(h_box), ok, TRUE, TRUE, 15);
74		gtk_box_pack_start(GTK_BOX(h_box), refuse, TRUE, TRUE, 15);
	105	gtk_box_pack_start(GTK_BOX(h_box), au->grant, TRUE, TRUE, 15);
	106	gtk_box_pack_start(GTK_BOX(h_box), au->refuse, TRUE, TRUE, 15);
75	107	gtk_box_pack_start(GTK_BOX(h_box), cancel, TRUE, TRUE, 15);
76	108	gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 5);
…	…
78	110	/* Connect the signals */
79	111	g_signal_connect(G_OBJECT(cancel), "clicked",
80		G_CALLBACK(~~dialog~~_close), au->window);
	112	G_CALLBACK(window_close), au->window);
81	113	g_signal_connect(G_OBJECT(au->window), "destroy",
82		G_CALLBACK(d~~ialog_close), au->window~~);
83		g_signal_connect(G_OBJECT(ok), "clicked",
84		G_CALLBACK(auth_user_~~grant~~), au);
85		g_signal_connect(G_OBJECT(refuse), "clicked",
86		G_CALLBACK(auth_user_~~refuse~~), au);
	114	G_CALLBACK(destroy_cb), &au);
	115	g_signal_connect(G_OBJECT(au->grant), "clicked",
	116	G_CALLBACK(auth_user_cb), au);
	117	g_signal_connect(G_OBJECT(au->refuse), "clicked",
	118	G_CALLBACK(auth_user_cb), au);
87	119
88	120	/* Show the window */
…	…
91	123	gtk_window_set_focus(GTK_WINDOW(au->window), au->entry);
92	124
93		if(uin != 0)
94		{
	125	if (uin != 0) {
95	126	const gchar *s_uin = g_strdup_printf("%ld", uin);
96	127	gtk_entry_set_text(GTK_ENTRY(au->entry), s_uin);
97	128	}
98	129	}
99
100		~~void auth_user_grant(GtkWidget widget, struct auth_user au)~~
101		{
102		~~gulong uin = atol((const char *)gtk_editable_get_chars(GTK_EDITABLE(~~
103		~~au->entry), 0, -1));~~
104		~~gchar *reason = gtk_editable_get_chars(GTK_EDITABLE(au->text), 0, -1);~~
105
106		~~icq_daemon->icqAuthorizeGrant(uin, reason);~~
107
108		~~dialog_close(au->window, au->window);~~
109		}
110
111		~~void auth_user_refuse(GtkWidget widget, struct auth_user au)~~
112		{
113		~~gulong uin = atol((const char *)gtk_editable_get_chars(GTK_EDITABLE(~~
114		~~au->entry), 0, -1));~~
115		~~gchar *reason = gtk_editable_get_chars(GTK_EDITABLE(au->text), 0, -1);~~
116
117		~~/* Refuse it */~~
118		~~icq_daemon->icqAuthorizeRefuse(uin, reason);~~
119
120		~~dialog_close(au->window, au->window);~~
121		}

trunk/jons-gtk2-gui/src/away_window.cpp

r3164	r3324
26	26	GSList *uaw_list;
27	27
28		void away_msg_window(gushort status)
29		{
30		struct away_dialog *away_d = g_new0(struct away_dialog, 1);
31
32		GtkWidget *ok;
33		GtkWidget *cancel;
34		GtkWidget *h_box;
35		GtkWidget *v_box;
36		const gchar *title =
37		g_strdup_printf("Set %s Response",
38		ICQUser::StatusToStatusStr(status, FALSE));
39
40		/* Make the main window */
41		away_d->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
42		gtk_window_set_title(GTK_WINDOW(away_d->window), title);
43		gtk_window_set_position(GTK_WINDOW(away_d->window), GTK_WIN_POS_CENTER);
44
45		/* The text box */
46		away_d->text = gtk_text_view_new();
47		gtk_text_view_set_editable(GTK_TEXT_VIEW(away_d->text), TRUE);
48		gtk_widget_set_size_request(GTK_WIDGET(away_d->text), 300, 100);
49
50		/* The boxes */
51		h_box = gtk_hbox_new(TRUE, 5);
52		v_box = gtk_vbox_new(FALSE, 5);
53
54		/* Pack the text box into the v_box */
55		gtk_box_pack_start(GTK_BOX(v_box), away_d->text, TRUE, TRUE, 0);
56
57		/* Make the buttons now */
58		ok = gtk_button_new_from_stock(GTK_STOCK_OK);
59		cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
60
61		/* Pack the buttons */
62		gtk_box_pack_start(GTK_BOX(h_box), ok, TRUE, TRUE, 5);
63		gtk_box_pack_start(GTK_BOX(h_box), cancel, TRUE, TRUE, 5);
64		gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);
65
66		/* Connect the signals now */
67		g_signal_connect(G_OBJECT(cancel), "clicked",
68		G_CALLBACK(away_close), away_d->window);
69		g_signal_connect(G_OBJECT(away_d->window), "destroy",
70		G_CALLBACK(away_close), away_d->window);
71		g_signal_connect(G_OBJECT(ok), "clicked",
72		G_CALLBACK(set_away_msg), away_d);
73
74		/* Get the window ready to be shown, show it, and set is_shown */
75		gtk_container_add(GTK_CONTAINER(away_d->window), v_box);
76		gtk_widget_show_all(away_d->window);
77		gtk_window_set_focus(GTK_WINDOW(away_d->window), away_d->text);
78		gtk_grab_add(away_d->window);
79		}
	28	struct away_dialog
	29	{
	30	GtkWidget *window;
	31	GtkWidget *text;
	32	};
	33
	34	struct user_away_window
	35	{
	36	GtkWidget *window;
	37	GtkWidget *show_again;
	38	GtkWidget *text_box;
	39	ICQUser *user;
	40	GtkWidget *progress;
	41	gchar buffer[30];
	42	struct e_tag_data *etag;
	43	};
80	44
81	45	void set_away_msg(GtkWidget widget, struct away_dialog away_d)
82	46	{
83		~~ICQOwner *owner = gUserManager.FetchOwner(LOCK_W);~~
84	47	GtkTextIter s, e;
85	48	GtkTextBuffer *tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(away_d->text));
…	…
87	50	gtk_text_buffer_get_end_iter(tb, &e);
88	51	gchar *txt = gtk_text_buffer_get_text(tb, &s, &e, FALSE);
	52	ICQOwner *owner = gUserManager.FetchOwner(LOCK_W);
89	53	owner->SetAutoResponse(txt);
	54	gUserManager.DropOwner();
90	55	g_free(txt);
	56
	57	window_close(NULL, away_d->window);
	58	}
	59
	60	void away_msg_window(gushort status)
	61	{
	62
	63	static struct away_dialog *away_d = NULL;
	64
	65	if (away_d == NULL)
	66	away_d = g_new0(struct away_dialog, 1);
	67	else {
	68	gtk_widget_show(away_d->window);
	69	return;
	70	}
	71
	72	gchar *title = g_strdup_printf("Set %s Response",
	73	ICQUser::StatusToStatusStr(status, FALSE));
	74
	75	/* Make the main window */
	76	away_d->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	77	gtk_window_set_title(GTK_WINDOW(away_d->window), title);
	78	gtk_window_set_position(GTK_WINDOW(away_d->window), GTK_WIN_POS_CENTER);
	79	g_free(title);
	80
	81	/* The text box */
	82	away_d->text = gtk_text_view_new();
	83	gtk_text_view_set_editable(GTK_TEXT_VIEW(away_d->text), TRUE);
	84	gtk_widget_set_size_request(GTK_WIDGET(away_d->text), 300, 100);
	85
	86	// Insert the current away message
	87	ICQOwner *owner = gUserManager.FetchOwner(LOCK_R);
	88	GtkTextBuffer *tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(away_d->text));
	89	gtk_text_buffer_set_text(tb, owner->AutoResponse(), -1);
91	90	gUserManager.DropOwner();
92	91
93		gtk_grab_remove(away_d->window);
94		gtk_widget_destroy(away_d->window);
95		}
96
97		void away_close(GtkWidget widget, GtkWidget window)
98		{
99		gtk_grab_remove(window);
100		gtk_widget_destroy(window);
	92	/* The boxes */
	93	GtkWidget *h_box = gtk_hbox_new(TRUE, 5);
	94	GtkWidget *v_box = gtk_vbox_new(FALSE, 5);
	95
	96	/* Pack the text box into the v_box */
	97	gtk_box_pack_start(GTK_BOX(v_box), away_d->text, TRUE, TRUE, 0);
	98
	99	/* Make the buttons now */
	100	GtkWidget *ok = gtk_button_new_from_stock(GTK_STOCK_OK);
	101	GtkWidget *cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
	102
	103	/* Pack the buttons */
	104	gtk_box_pack_start(GTK_BOX(h_box), ok, TRUE, TRUE, 5);
	105	gtk_box_pack_start(GTK_BOX(h_box), cancel, TRUE, TRUE, 5);
	106	gtk_box_pack_start(GTK_BOX(v_box), h_box, FALSE, FALSE, 0);
	107
	108	/* Connect the signals now */
	109	g_signal_connect(G_OBJECT(cancel), "clicked",
	110	G_CALLBACK(window_close), away_d->window);
	111	g_signal_connect(G_OBJECT(away_d->window), "destroy",
	112	G_CALLBACK(destroy_cb), &away_d);
	113	g_signal_connect(G_OBJECT(ok), "clicked",
	114	G_CALLBACK(set_away_msg), away_d);
	115
	116	/* Get the window ready to be shown, show it, and set is_shown */
	117	gtk_container_add(GTK_CONTAINER(away_d->window), v_box);
	118	gtk_widget_show_all(away_d->window);
	119	gtk_window_set_focus(GTK_WINDOW(away_d->window), away_d->text);
	120	gtk_window_set_modal(GTK_WINDOW(away_d->window), TRUE);
	121	}
	122
	123	/* The following will ensure only one window is open and that when the *
	124	** Auto Response is received, it pops up in the box there. Now the *
	125	** status of the connection will be brought back to this window */
	126
	127	void
	128	destroy_away_window(GtkWidget widget, struct user_away_window uaw)
	129	{
	130	uaw->user->SetShowAwayMsg(gtk_toggle_button_get_active(
	131	GTK_TOGGLE_BUTTON(uaw->show_again)));
	132	uaw_list = g_slist_remove(uaw_list, uaw);
	133	catcher = g_slist_remove(catcher, uaw->etag);
	134	g_free(uaw->etag);
	135	g_free(uaw);
	136	}
	137
	138	struct user_away_window *uaw_find(unsigned long uin)
	139	{
	140	struct user_away_window *uaw;
	141	GSList *temp_uaw_list = uaw_list;
	142
	143	while (temp_uaw_list) {
	144	uaw = (struct user_away_window *)temp_uaw_list->data;
	145	if (uaw->user->Uin() == uin)
	146	return uaw;
	147	temp_uaw_list = temp_uaw_list->next;
	148	}
	149
	150	/* It wasn't found, return null */
	151	return 0;
	152	}
	153
	154	struct user_away_window uaw_new(ICQUser u)
	155	{
	156	/* Does it exist already? */
	157	struct user_away_window *uaw = uaw_find(u->Uin());
	158
	159	/* If it does, return it, if not, make one */
	160	if (uaw != 0)
	161	return uaw;
	162
	163	uaw = g_new0(struct user_away_window, 1);
	164
	165	uaw->user = u;
	166
	167	uaw_list = g_slist_append(uaw_list, uaw);
	168
	169	// list_read_message(0, uaw->user);
	170
	171	return uaw;
101	172	}
102	173
…	…
105	176	struct user_away_window *uaw = uaw_find(user->Uin());
106	177
107		if(uaw != 0)
	178	// we're in the process of retrieving the message (or it's displayed already)
	179	if (uaw != NULL)
108	180	return;
109	181
110	182	uaw = uaw_new(user);
111
112		GtkWidget *h_box;
113		GtkWidget *v_box;
114		GtkWidget *scroll;
115		GtkWidget *close;
116		const gchar *title = g_strdup_printf("Auto Response for %s", user->GetAlias());
117
118		struct e_tag_data *etd = g_new0(struct e_tag_data, 1);
119
	183	uaw->etag = g_new0(struct e_tag_data, 1);
120	184	uaw->user = user;
121		uaw->etag = etd;
122
	185
	186	gchar *title = g_strdup_printf("Auto Response for %s", user->GetAlias());
123	187
124	188	/* Make the window */
…	…
126	190	gtk_window_set_title(GTK_WINDOW(uaw->window), title);
127	191	gtk_window_set_position(GTK_WINDOW(uaw->window), GTK_WIN_POS_CENTER);
	192	g_free(title);
128	193
129	194	g_signal_connect(G_OBJECT(uaw->window), "destroy",
130		G_CALLBACK(~~close~~_away_window), uaw);
	195	G_CALLBACK(destroy_away_window), uaw);
131	196
132	197	/* Make the boxes */
133		h_box = gtk_hbox_new(FALSE, 5);
134		v_box = gtk_vbox_new(FALSE, 5);
	198	GtkWidget *h_box = gtk_hbox_new(FALSE, 5);
	199	GtkWidget *v_box = gtk_vbox_new(FALSE, 5);
135	200
136	201	/* The scrolling window */
137		scroll = gtk_scrolled_window_new(0, 0);
	202	GtkWidget *scroll = gtk_scrolled_window_new(0, 0);
138	203	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
139	204	GTK_POLICY_NEVER,
…	…
158	223
159	224	/* The close button */
160		close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
	225	GtkWidget *close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
161	226	g_signal_connect(G_OBJECT(close), "clicked",
162		G_CALLBACK(~~close_away_window), ua~~w);
	227	G_CALLBACK(window_close), uaw->window);
163	228
164	229	/* Pack everything */
…	…
190	255	/* Append it to gslist */
191	256	catcher = g_slist_append(catcher, uaw->etag);
192
193		g_free(const_cast<char *>(title));
194		}
195
196		void close_away_window(GtkWidget widget, struct user_away_window uaw)
197		{
198		uaw->user->SetShowAwayMsg(gtk_toggle_button_get_active(
199		GTK_TOGGLE_BUTTON(uaw->show_again)));
200		uaw_list = g_slist_remove(uaw_list, uaw);
201		catcher = g_slist_remove(catcher, uaw->etag);
202		dialog_close(0, uaw->window);
203		}
204
205		/* The following will ensure only one window is open and that when the *
206		** Auto Response is received, it pops up in the box there. Now the *
207		** status of the connection will be brought back to this window */
208
209		struct user_away_window uaw_new(ICQUser u)
210		{
211		struct user_away_window *uaw;
212
213		/* Does it exist already? */
214		uaw = uaw_find(u->Uin());
215
216		/* If it does, return it, if not, make one */
217		if(uaw != 0)
218		return uaw;
219
220		uaw = g_new0(struct user_away_window, 1);
221
222		uaw->user = u;
223
224		uaw_list = g_slist_append(uaw_list, uaw);
225
226		// list_read_message(0, uaw->user);
227
228		return uaw;
229		}
230
231		struct user_away_window *uaw_find(unsigned long uin)
232		{
233		struct user_away_window *uaw;
234		GSList *temp_uaw_list = uaw_list;
235
236		while(temp_uaw_list)
237		{
238		uaw = (struct user_away_window *)temp_uaw_list->data;
239		if(uaw->user->Uin() == uin)
240		return uaw;
241
242		temp_uaw_list = temp_uaw_list->next;
243		}
244
245		/* It wasn't found, return null */
246		return 0;
247		}
	257	}
	258
	259	void finish_away(ICQEvent *event)
	260	{
	261	struct user_away_window *uaw = uaw_find(event->Uin());
	262
	263	/* If the window isn't open, don't bother */
	264	if (uaw == 0)
	265	return;
	266
	267	GtkTextBuffer *tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(uaw->text_box));
	268	GtkTextIter iter;
	269	gtk_text_buffer_get_end_iter(tb, &iter);
	270	gtk_text_buffer_insert(tb, &iter, uaw->user->AutoResponse(), -1);
	271	}
	272

trunk/jons-gtk2-gui/src/chat_window.cpp

r3207	r3324
23	23	#include <list>
24	24
25		~~#include "licq_icq.h"~~
26	25	#include "licq_gtk.h"
	26	#include "licq_chat.h"
	27	#include "licq_log.h"
	28
	29	struct request_chat
	30	{
	31	GtkWidget *window;
	32	GtkWidget *text_box;
	33	GtkWidget *send_norm;
	34	GtkWidget *send_urg;
	35	GtkWidget *send_list;
	36	GtkWidget *chat_list;
	37	ICQUser *user;
	38	struct e_tag_data *etd;
	39	};
	40
	41	struct remote_chat_request
	42	{
	43	GtkWidget *dialog;
	44	gulong uin;
	45	CEventChat *c_event;
	46	};
	47
	48	struct kick_window
	49	{
	50	GtkWidget *winKick;
	51	GtkWid