Linux QQ之客户端

客户端之登录UI

//client.c 客户端主函数

#include "const_global.h"
#include <signal.h>
#include "gui.h"

void mem_error(){
format_record("Read or write memory error.");
exit(0);
}

int main(int argc, char *argv[]) {
gtk_init(&argc, &argv);
signal(SIGSEGV, mem_error);
land_interface();
return EXIT_SUCCESS;
}

//gui.h 前台UI实现的头文件

#ifndef GUI_H
#define GUI_H

#include <gtk/gtk.h>

void close_window(GtkWidget *, gpointer);
void close_app(GtkWidget *, gpointer);
void on_logout_event(GtkWidget *window, gpointer data);
void on_login_event(GtkWidget *, gpointer);
void on_clear_entry_event(GtkWidget *, gpointer);
void on_changed_event(GtkWidget * , gpointer);
void on_send_event(GtkWidget *, gpointer );
gboolean on_2click_record_event(GtkWidget *, GdkEventButton *, gpointer);

static void init_chat_window(char *,char *);
static void destroy_all_chat_window();
guint get_chat_thread_index(char *);
void *receive_msg_thread();

void add_list_item(GtkWidget *,char *, int);
static GtkTreeModel *create_and_fill_model(void);
static GtkWidget *create_view_and_model(void);

void chat_1to1_ui(char *);
void land_ok_ui();
void land_interface();

void show_login_status(GtkWidget *, gpointer);
void set_widget_bg(GtkWidget *, const gchar *);

typedef struct {
GtkWidget *username_entry; // uname input entry in land ui
GtkWidget *password_entry; // passwd input entry in land ui
} UserInfoGtk;

typedef struct{
guint      status;	// chat window status, 1:opened / 0:closed
//	int		 clientfd;  // connect server file describor
char peer_uid[10];  // peer userid
char peer_uname[20];// peer username
GtkWidget *window;	// chat window
GtkWidget  *input;	// send msg entry obj
GtkWidget *output;	// show msg treeview obj
//	GtkStatusIcon *trayIcon; // chat window status icon
char  address[25];
}ChatThread;

void show_msg(ChatThread *, char *, int);

static ChatThread *chat_thread[MAXFRIENDS];

static GtkWidget *window;
//static GtkStatusIcon *trayIcon;
static GtkStatusIcon *trayIcon;

//according user level to modify
static guint CURRENT_UID=0;

static pthread_t recv_msg_tid;

static int CLIENT_FD = -1;

#endif

//gui.c 前台UI的具体实现

#include "const_global.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include "gui.h"
#include "pub.h"

#define INIT 	0
#define REFRESH 1

void set_widget_bg(GtkWidget *widget, const gchar *img_file) {
GtkStyle *style;
GdkPixbuf *pixbuf;
GdkPixmap *pixmap;
gint width, height;

pixbuf = gdk_pixbuf_new_from_file(img_file, NULL );
width = gdk_pixbuf_get_width(pixbuf);
height = gdk_pixbuf_get_height(pixbuf);
pixmap = gdk_pixmap_new(NULL, width, height, 24);
gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, NULL, 0);
style = gtk_style_copy(GTK_WIDGET(widget)->style);

if (style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]);

style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_ACTIVE] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_PRELIGHT] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_SELECTED] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_INSENSITIVE] = g_object_ref(pixmap);
gtk_widget_set_style(GTK_WIDGET(widget), style);
g_object_unref(style);
}

void close_window(GtkWidget *window, gpointer data) {
gtk_widget_destroy(window);

if (data != NULL) {
((ChatThread *) data)->status = 0;
((ChatThread *) data)->address[0] = '\0';
}
}

void close_app(GtkWidget *window, gpointer data) {
gtk_main_quit();
}

void on_login_event(GtkWidget *button, gpointer data) {
const char *username_text = gtk_entry_get_text(
GTK_ENTRY(((UserInfoGtk *) data)->username_entry));
const char *passwd_text = gtk_entry_get_text(
GTK_ENTRY(((UserInfoGtk *) data)->password_entry));
char buf[MAXLINE], *login_result, *user_pet_name, *ip_port;
#ifndef DEBUG
if(strlen(username_text) == 0 || strlen(passwd_text) == 0) {
LOGIN_STATUS = LOGIN_FAILED;
goto End;
}
memset(buf,'\0',MAXLINE);

login_user(username_text, passwd_text, buf);
if(!strlen(buf)) {
LOGIN_STATUS = LOGIN_FAILED;
goto End;
}
strtok(buf, split); 				// action type [LOGIN|FRESH]
login_result = strtok(NULL, split); // login status [SUCCESS|FAILED] and USER_NAME
user_pet_name = strtok(NULL, split);
ip_port = strtok(NULL, split);

LOGIN_STATUS = strcmp(login_result,"SUCCESS") == 0 ? LOGIN_SUCCESS : LOGIN_FAILED;

if (LOGIN_STATUS == LOGIN_SUCCESS) {
memset(USER_ID, '\0', sizeof(USER_ID));
memset(USER_NAME,'\0',sizeof(USER_NAME));
memset(ADDRESS,'\0',sizeof(ADDRESS));
strcpy(USER_ID, username_text);
strcpy(USER_NAME, user_pet_name);
strcpy(ADDRESS, ip_port);
CLIENT_FD = open_tcp_connection();
}
#else
LOGIN_STATUS = LOGIN_SUCCESS;
strcpy(USER_ID, "00001");
strcpy(USER_NAME, "debug");
strcpy(ADDRESS, "127.0.0.1:8000");
#endif
End:
return;
}

void on_logout_event(GtkWidget *window, gpointer data) {
int clientfd;
char buf[50], *logout_result;

//	clientfd = open_tcp_connection();
clientfd = CLIENT_FD;
if( -1 == clientfd) {
format_record("ERROR: Can not connect to server, quit failed.");
return;
}
sprintf(buf, "LOGOUT%s%s%sNULL%sNULL", split, USER_ID, split, split);

if (Write(clientfd, buf, sizeof(buf)) < 0) {
format_record("ERROR: Write request to server to logout failed.");
goto End;
}
memset(buf, '\0', sizeof(buf));
if (Read(clientfd, buf, sizeof(buf)) < 0) {
format_record("ERROR: Read return result from server of login failed.");
goto End;
}

strtok(buf, split); 				 	// action type [LOGIN|REFRESH|LOGOUT]
logout_result = strtok(NULL, split); 	// login status [SUCCESS|FAILED] and USER_NAME

LOGIN_STATUS = strcmp(logout_result, "SUCCESS") == 0 ? LOGIN_OFF : LOGIN_SUCCESS;

if (LOGIN_STATUS != LOGIN_OFF) {
format_record("There is something wrong to read return result from server of logout.");
goto End;
}

memset(USER_ID, '\0', sizeof(USER_ID));
memset(USER_NAME,'\0',sizeof(USER_NAME));
memset(ADDRESS,'\0',sizeof(ADDRESS));
destroy_all_chat_window();
close_app(window, data);

End:
Close(clientfd);
CLIENT_FD = -1;
}

void on_clear_entry_event(GtkWidget *button, gpointer data) {
//	GtkTextBuffer *buffer;
//	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW( data));
//	gtk_text_buffer_set_text(buffer, "", -1);
gtk_entry_set_text((GtkEntry *) data, "");
}

void on_changed_event(GtkWidget * widget, gpointer statusbar) {
GtkTreeIter iter;
GtkTreeModel *model;
char *value = NULL;

if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(widget), &model,
&iter)) {
gtk_tree_model_get(model, &iter, COL_NAME, &value, -1);
if (value == NULL )
return;
gtk_statusbar_push(GTK_STATUSBAR(statusbar),
gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), value),
value);
g_free(value);
}
}

void on_send_event(GtkWidget *widget, gpointer data) {
char *peer_ip, *peer_port, *address;
char words[130];
if (strlen(gtk_entry_get_text(GTK_ENTRY(((ChatThread *) data)->input)))) {
sprintf(words, "%s%s%s%s%s", USER_ID, split, USER_NAME, split, gtk_entry_get_text(GTK_ENTRY(((ChatThread *) data)->input)));
//begin: send msg to peer user
address = (char *)malloc(25);
strcpy(address,((ChatThread *) data)->address);
peer_ip = strtok(address,":");
peer_port = strtok(NULL,":");
send_udp_msg(peer_ip, atoi(peer_port), words);
free(address);
//	end: send msg to peer user

//	begin: save msg to server
memset(words,'\0',sizeof(words));
sprintf(words, "SAVE_MSG%s%s%s%s%s%s",
split,USER_ID,
split,gtk_entry_get_text(GTK_ENTRY(((ChatThread *) data)->input)),
split,((ChatThread *) data)->peer_uid);
save_tcp_msg(words);
//		save_tcp_msg(CLIENT_FD,words);
//	end: save msg to server

//  begin: show msg in chat window
memset(words,'\0',sizeof(words));
sprintf(words,"%s :[%s]",gtk_entry_get_text(GTK_ENTRY(((ChatThread *) data)->input)), USER_NAME);
on_clear_entry_event(widget, GTK_ENTRY(((ChatThread *) data)->input));
show_msg((ChatThread *) data, words, SELF_ALIGN);
//	end: show msg in chat window
} else {
format_record("Can not send null character.");
}
}

void add_list_item(GtkWidget *list, char *item_text, int alignment) {
GtkWidget *list_item, *label;
if (strlen(item_text)) {
//		gtk_container_add(GTK_CONTAINER(list),gtk_list_item_new_with_label(item_text));
label = gtk_label_new(item_text);
list_item = gtk_list_item_new();
gtk_misc_set_alignment(GTK_MISC(label),alignment,0);
// left/up alignment
//		gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
// right/up alignment
//		gtk_misc_set_alignment(GTK_MISC(label),1,0);
gtk_container_add(GTK_CONTAINER(list_item), label);
gtk_container_add(GTK_CONTAINER(list), list_item);
} else {
format_record("No data!");
}
}

static void destroy_all_chat_window(){
int index = 0;
for (index=CURRENT_UID-1; index >= 0; index--)
free(chat_thread[index]);
CURRENT_UID = 0;
}

static void init_chat_window(char *peer_uid, char *peer_uname){
chat_thread[CURRENT_UID] = (ChatThread *) malloc(sizeof(ChatThread));
memset(chat_thread[CURRENT_UID], '\0', sizeof(ChatThread));
strcpy(chat_thread[CURRENT_UID]->peer_uid, peer_uid);
strcpy(chat_thread[CURRENT_UID]->peer_uname, peer_uname);
chat_thread[CURRENT_UID]->status = 0;
//	chat_thread[CURRENT_UID]->clientfd = -1;
//	chat_thread[CURRENT_UID]->trayIcon = gtk_status_icon_new_from_file("ico/qq2.ico");
CURRENT_UID++;
}

guint get_chat_thread_index(char *uid) {
int index;
for(index=0; index < MAXFRIENDS; index++){
if(!strcmp(chat_thread[index]->peer_uid, uid)) break;
}
if (index >= MAXFRIENDS){
format_record("ERROR: Can not find proper uid for chat_thread.");
}
return index;
}

void show_msg(ChatThread *chat_thread, char *msg, int alignment){
add_list_item(GTK_WIDGET(chat_thread->output), msg, alignment);
gtk_widget_show_all(GTK_WIDGET(chat_thread->output));
}

void show_dialog(char *msgtip){
GtkWidget *dialog;
dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,"%s",msgtip);
gtk_window_set_title(GTK_WINDOW(dialog), "Information");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}

/*icon******代码**********开始*/

guint change_icon(gpointer data) {
char text[10];
strcpy(text, gtk_status_icon_get_tooltip_text(trayIcon));
if (strcmp(text, USER_NAME) != 0) {
gtk_status_icon_set_from_file(trayIcon, "ico/qq.ico");
gtk_status_icon_set_tooltip(trayIcon, USER_NAME);
} else {
gtk_status_icon_set_from_file(trayIcon, "ico/qq2.ico");
gtk_status_icon_set_tooltip(trayIcon, (((ChatThread *)data)->peer_uid));
}
return 1;
}

guint change_self_icon() {
gtk_status_icon_set_from_file(trayIcon, "ico/qq.ico");
gtk_status_icon_set_tooltip(trayIcon, USER_NAME);
return 1;
}

void trayView(GtkMenuItem *item, gpointer window){
gtk_window_present(GTK_WINDOW(window));
}

void show_about(GtkMenuItem *item, gpointer window){
show_dialog("Personal chat software.\nProblems call QQ:393608596.\nThank you!");
}

void trayIconActivated(GObject *trayIcon, gpointer data){
char peer_uid[10];
strcpy(peer_uid, gtk_status_icon_get_tooltip_text(GTK_STATUS_ICON(trayIcon)));
if(strcmp(peer_uid,USER_NAME) != 0){
chat_1to1_ui(peer_uid);
gtk_status_icon_set_blinking(GTK_STATUS_ICON(trayIcon), FALSE);
change_self_icon(GTK_STATUS_ICON(trayIcon));
}else{
gtk_window_present(GTK_WINDOW(data));
}
}

void trayIconPopup(GtkStatusIcon *status_icon, guint button, guint32 activate_time, gpointer popUpMenu){
gtk_menu_popup(GTK_MENU(popUpMenu), NULL, NULL, gtk_status_icon_position_menu, status_icon, button, activate_time);
}

gboolean delete_event(GtkWidget *window, GdkEvent *event, gpointer data){
return FALSE;
}

gboolean window_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer trayIcon) {
if (event->changed_mask == GDK_WINDOW_STATE_ICONIFIED
&& (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED
|| event->new_window_state
== (GDK_WINDOW_STATE_ICONIFIED
| GDK_WINDOW_STATE_MAXIMIZED))) {
gtk_widget_hide(GTK_WIDGET(widget));
} else if (event->changed_mask == GDK_WINDOW_STATE_WITHDRAWN
&& (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED
|| event->new_window_state
== (GDK_WINDOW_STATE_ICONIFIED
| GDK_WINDOW_STATE_MAXIMIZED))) {
}
return TRUE;
}

guint show_trayicon(GtkWidget *window) {
GtkWidget *menu, *menuItemView, *menuItemExit, *about;

trayIcon = gtk_status_icon_new_from_file("ico/qq.ico");
menu = gtk_menu_new();

menuItemView = gtk_menu_item_new_with_label("Window");
about = gtk_menu_item_new_with_label("About");
menuItemExit = gtk_menu_item_new_with_label("Exit");

g_signal_connect(G_OBJECT(menuItemView), "activate", G_CALLBACK(trayView), window);
g_signal_connect(G_OBJECT(about), "activate", G_CALLBACK(show_about), window);
g_signal_connect(G_OBJECT(menuItemExit), "activate", G_CALLBACK(close_app), NULL);

gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItemView);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), about);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItemExit);
gtk_widget_show_all(menu);

gtk_status_icon_set_tooltip(trayIcon, USER_NAME);
gtk_status_icon_set_visible(trayIcon, TRUE);
g_signal_connect(GTK_STATUS_ICON(trayIcon), "activate",
GTK_SIGNAL_FUNC(trayIconActivated), window);
g_signal_connect(GTK_STATUS_ICON(trayIcon), "popup_menu",
GTK_SIGNAL_FUNC(trayIconPopup), menu);

g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(close_app), NULL);
g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete_event), trayIcon);
g_signal_connect(G_OBJECT(window), "window_state_event", G_CALLBACK(window_state_event), trayIcon);

return 0;
}

void *receive_msg_thread(){
int socketfd;
guint uindex;
char *buf_return, *peer_uid, *peer_uname, *buf_stream;
socketfd = open_udp_server_running(ADDRESS);
buf_return = (char *) malloc(MAXLINE);
buf_stream = (char *) malloc(MAXLINE);
while (1) {
memset(buf_return, '\0', MAXLINE);
memset(buf_stream, '\0', MAXLINE);
receive_udp_msg(socketfd, buf_return);
if (strlen(buf_return) <= 0) break;
peer_uid = strtok(buf_return, split);
peer_uname = strtok(NULL, split);
sprintf(buf_stream, "[%s]: ", peer_uname);
strcat(buf_stream, strtok(NULL, split));
/*
* show the offline msg about save msg of db
* read one record one by one
* do connect db server then get records by recycling output
*/
uindex = get_chat_thread_index(peer_uid);
//		check peer user chat window status[0:closed 1:opened]
if (chat_thread[uindex]->status == 0) {
change_icon(chat_thread[uindex]);
gtk_status_icon_set_blinking(GTK_STATUS_ICON(trayIcon), TRUE);
} else {
show_msg(chat_thread[uindex], buf_stream, PEER_ALIGN);
}
}
free(buf_return);
free(buf_stream);
Close(socketfd);
pthread_exit(0);
}

void fill_model_data(GtkTreeStore *treestore, int opt) {
GtkTreeIter toplevel, child;
int clientfd;
char buf[MAXLINE], *action_type, *role_type, *group_name,
*friend_id, *friend_name, *friend_status;

clientfd = open_tcp_connection();
if (-1 == clientfd) {
return ;
}
sprintf(buf, "FRESH%s%s%sNULL%sNULL", split, USER_ID, split, split);

if (Write(clientfd, buf, sizeof(buf)) < 0) {
format_record(
"ERROR: Write request to server to fresh friend list failed.");
return ;
}
memset(buf, 0, sizeof(buf));
action_type = (char *) malloc(10);
role_type = (char *) malloc(10);
group_name = (char *) malloc(10);
friend_id = (char *) malloc(10);
friend_name = (char *) malloc(20);
friend_status = (char *) malloc(2);

while (1) {
if (Read(clientfd, buf, sizeof(buf)) > 0) {
strcpy(action_type, strtok(buf, split));
strcpy(role_type, strtok(NULL, split));
if (strcmp(role_type, "GROUP") == 0) {
strcpy(group_name, strtok(NULL, split));
gtk_tree_store_append(treestore, &toplevel, NULL );
gtk_tree_store_set(treestore, &toplevel, 0, group_name, -1);
} else if (strcmp(role_type, "FRIEND") == 0) {
gtk_tree_store_append(treestore, &child, &toplevel);

strcpy(friend_id, strtok(NULL, split));
gtk_tree_store_set(treestore, &child, COL_ID, friend_id, -1);
strcpy(friend_name, strtok(NULL, split));
gtk_tree_store_set(treestore, &child, COL_NAME, friend_name, -1);
strcpy(friend_status, strtok(NULL, split));
gtk_tree_store_set(treestore, &child, COL_STATUS,
(atoi(friend_status) == 1) ? "Online" : "Offline", -1);

if(INIT == opt) init_chat_window(friend_id, friend_name);

} else if (strcmp(role_type, "NULL") == 0) {
break;
} else {
// do else
break;
}
} else
break;
}
free(action_type);
free(role_type);
free(group_name);
free(friend_id);
free(friend_name);
free(friend_status);
Close(clientfd);
}

guint refresh_tree_store(GtkWidget *view) {
GtkTreeStore *treestore;
treestore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(view)));
gtk_tree_store_clear(treestore);
fill_model_data(treestore, REFRESH);
return 1;
}

static GtkTreeModel *create_and_fill_model(void) {
GtkTreeStore *treestore;
treestore = gtk_tree_store_new(NUM_COLS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING);
fill_model_data(treestore, INIT);
return GTK_TREE_MODEL(treestore);
}

static GtkWidget *create_view_and_model(void) {
GtkTreeViewColumn *col[NUM_COLS];
GtkCellRenderer *renderer;
GtkWidget *view;
GtkTreeModel *model;
int col_index;
view = gtk_tree_view_new();
set_widget_bg(view, "ico/bg.jpg");

renderer = gtk_cell_renderer_text_new();
for (col_index = 0; col_index < NUM_COLS; col_index++) {
col[col_index] = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col[col_index]);
gtk_tree_view_column_pack_start(col[col_index], renderer, TRUE);
gtk_tree_view_column_add_attribute(col[col_index], renderer, "text", col_index);
gtk_tree_view_column_set_reorderable (col[col_index], TRUE);
}
gtk_tree_view_column_set_title(col[0], "Friends List");

model = create_and_fill_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model);

return view;
}

void chat_1to1_ui(char *peer_uid) {
GtkWidget *table, *entry, *cancle;
GtkWidget *send, *scrollwindow, *frame;
GtkTooltips *tooltips;
GtkAdjustment *horizontal, *vertical;
guint id;

#ifndef DEBUG
id = get_chat_thread_index(peer_uid);
if (chat_thread[id]->status) return;
#else
id = 0;
chat_thread[id] = (ChatThread *)malloc(sizeof(ChatThread));
strcpy(chat_thread[id]->peer_uname, "TestPeer");
#endif

chat_thread[id]->status = 1;
chat_thread[id]->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_title(GTK_WINDOW(chat_thread[id]->window), chat_thread[id]->peer_uname);
gtk_window_set_default_size(GTK_WINDOW(chat_thread[id]->window), 450, 450);
gtk_container_set_border_width(GTK_CONTAINER(chat_thread[id]->window), 15);
gtk_window_set_position(GTK_WINDOW(chat_thread[id]->window), GTK_WIN_POS_CENTER);

table = gtk_table_new(CHAT_WINDOW_SIZE, CHAT_WINDOW_SIZE, TRUE);
gtk_container_add(GTK_CONTAINER(chat_thread[id]->window), table);

chat_thread[id]->output = gtk_list_new();
vertical = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 0, 1, 10, 0));
horizontal = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 0, 1, 10, 0));

scrollwindow = gtk_scrolled_window_new(horizontal, vertical);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_table_attach(GTK_TABLE(table), frame, 0, CHAT_WINDOW_SIZE, 0, 6,
GTK_FILL, GTK_FILL, 0, 0);

gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwindow),
chat_thread[id]->output);
gtk_container_add(GTK_CONTAINER(frame), scrollwindow);
gtk_list_scroll_vertical(GTK_LIST(chat_thread[id]->output), GTK_SCROLL_END, 1);

chat_thread[id]->input = gtk_entry_new_with_max_length(100);
gtk_widget_set_size_request(chat_thread[id]->input, 300, 40);
gtk_table_attach_defaults(GTK_TABLE(table), chat_thread[id]->input, 0, 8, 6, 7);
send = gtk_button_new_with_label("send");
gtk_widget_set_size_request(send, 70, 30);
gtk_table_attach(GTK_TABLE(table), send, 7, 8, 7, 8, 0, 0, 0, 0);
cancle = gtk_button_new_with_label("cancle");
gtk_widget_set_size_request(cancle, 70, 30);
gtk_table_attach(GTK_TABLE(table), cancle, 6, 7, 7, 8, 0, 0, 0, 0);

tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips, chat_thread[id]->input, "发送内容不能为空", NULL );

#ifndef DEBUG
request_peer_user_address(peer_uid, chat_thread[id]->address);
#else
strcpy(chat_thread[id]->address, "10.10.10.1:1234");
#endif

g_signal_connect(G_OBJECT(send), "clicked", G_CALLBACK(on_send_event),
chat_thread[id]);
g_signal_connect(G_OBJECT(cancle), "clicked", G_CALLBACK(on_clear_entry_event),
chat_thread[id]->input);
g_signal_connect(G_OBJECT(chat_thread[id]->input), "activate", G_CALLBACK(on_send_event),
chat_thread[id]);
g_signal_connect(G_OBJECT(chat_thread[id]->window), "destroy", G_CALLBACK(close_window),
chat_thread[id]);

gtk_widget_show_all(chat_thread[id]->window);
}

gboolean on_2click_record_event(GtkWidget *view, GdkEventButton *event, gpointer data) {
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
char *value1 = NULL, *value2 = NULL;

selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
switch (event->type) {
case GDK_2BUTTON_PRESS:
if (event->button != MOUSE_LEFT_CLICK)
break;
if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(selection),
&model, &iter)) {
gtk_tree_model_get(model, &iter, COL_ID, &value1, COL_NAME, &value2, -1);
if (value1 == NULL || value2 == NULL ) break;
//			chat_1to1_ui(value1, value2);
chat_1to1_ui(value1);
g_free(value1);
g_free(value2);
}
break;
case GDK_BUTTON_PRESS:
break;
default:
format_record("No answer for this action.");
break;
}
return FALSE;
}

void land_ok_ui() {
GtkWidget *land_ok_window, *vbox, *statusbar;
GtkWidget *view;
GtkTreeSelection *selection;
GtkWidget *image, *image_box, *name_label;

char ok_ui_title[33];// len(id)[10] + len(name)[20] +'()'[2] +'\0'[1] = 33
#ifndef DEBUG
memset(ok_ui_title,'\0',sizeof(ok_ui_title));
sprintf(ok_ui_title,"%s(%s)",USER_NAME,USER_ID);
#endif

land_ok_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(land_ok_window), GTK_WIN_POS_MOUSE);
gtk_window_set_icon_from_file(GTK_WINDOW(land_ok_window), "ico/qq.ico", NULL);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(land_ok_window), TRUE); // hide taskbar
gtk_widget_set_size_request(land_ok_window, 280, 500);
gtk_window_set_title(GTK_WINDOW(land_ok_window), ok_ui_title);

vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(land_ok_window), vbox);

name_label = gtk_label_new(USER_NAME);
image = gtk_image_new_from_file("ico/qq.ico");
image_box = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(image_box), image, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(image_box), name_label, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), image_box, FALSE, FALSE, 0);
#ifndef DEBUG
view = create_view_and_model();
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 1);

statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 1);

g_signal_connect(selection, "changed", G_CALLBACK(on_changed_event), statusbar);
g_signal_connect(view, "button_press_event", G_CALLBACK(on_2click_record_event),
NULL );
g_signal_connect(G_OBJECT(land_ok_window), "destroy", G_CALLBACK(on_logout_event),
NULL );

g_timeout_add(6000, (GtkFunction)refresh_tree_store, view);
#else
g_signal_connect(G_OBJECT(land_ok_window), "destroy", G_CALLBACK(gtk_main_quit),
NULL);
#endif

show_trayicon(land_ok_window);
#ifndef DEBUG
pthread_create(&recv_msg_tid, NULL, receive_msg_thread, NULL);
#endif
gtk_widget_show_all(land_ok_window);
gtk_main();
}

void show_login_status(GtkWidget *button, gpointer login_info_label) {
const char *error_show =
"<span foreground=\"red\"><b>Access denied!</b></span>";
const char *info_show =
"<span foreground=\"green\"><b>Access granted!</b></span>";
if (LOGIN_STATUS == LOGIN_SUCCESS) {
//		gtk_label_set_markup(GTK_LABEL(login_info_label), info_show);
close_window(window, NULL );
land_ok_ui();
} else {
gtk_label_set_markup(GTK_LABEL(login_info_label), error_show);
}
}

void land_interface() {
GtkWidget *username_label, *password_label;
GtkWidget *username_entry, *password_entry;
GtkWidget *ok_button;
GtkWidget *hbox1, *hbox2, *hbox3, *vbox;
GtkWidget *left_blank_label, *right_blank_label, *login_info_label;
UserInfoGtk user_info;

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkLogin");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 150);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);

g_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(close_app),
NULL );

username_label = gtk_label_new("Username:");
password_label = gtk_label_new("Password:");
user_info.username_entry = username_entry = gtk_entry_new_with_max_length(10);
user_info.password_entry = password_entry = gtk_entry_new_with_max_length(10);
gtk_entry_set_visibility(GTK_ENTRY(password_entry), FALSE);

left_blank_label = gtk_label_new("");
right_blank_label = gtk_label_new("");
ok_button = gtk_button_new_with_label("Login");
login_info_label = gtk_label_new("");

g_signal_connect(GTK_OBJECT(ok_button), "clicked",
GTK_SIGNAL_FUNC(on_login_event), &user_info);
g_signal_connect(G_OBJECT(username_entry), "activate",
G_CALLBACK(on_login_event),&user_info);
g_signal_connect(G_OBJECT(password_entry), "activate",
G_CALLBACK(on_login_event),&user_info);
g_signal_connect(GTK_OBJECT(ok_button), "clicked",
GTK_SIGNAL_FUNC(show_login_status), login_info_label);
g_signal_connect(GTK_OBJECT(ok_button), "clicked",
GTK_SIGNAL_FUNC(on_clear_entry_event), password_entry);

hbox1 = gtk_hbox_new(TRUE, 0);
hbox2 = gtk_hbox_new(TRUE, 0);
hbox3 = gtk_hbox_new(TRUE, 0);
vbox = gtk_vbox_new(FALSE, 0);

gtk_box_pack_start(GTK_BOX(hbox1), username_label, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox1), username_entry, FALSE, FALSE, 5);

gtk_box_pack_start(GTK_BOX(hbox2), password_label, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox2), password_entry, FALSE, FALSE, 5);

gtk_box_pack_start(GTK_BOX(hbox3), left_blank_label, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox3), ok_button, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox3), right_blank_label, FALSE, FALSE, 5);

gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 5);

gtk_box_pack_start(GTK_BOX(vbox), login_info_label, FALSE, FALSE, 3);

gtk_container_add(GTK_CONTAINER(window), vbox);

set_widget_bg(window, "ico/bg.jpg");

gtk_widget_show_all(window);
gtk_main();
}

//const_global.h 全局变量和通用头文件的包含头文件

#ifndef CONST_GLOBAL_H
#define CONST_GLOBAL_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <time.h>
#include <sys/types.h>
#include <regex.h>
#include <memory.h>

#include "xini.h"

#define MOUSE_LEFT_CLICK 0x1
#define MOUSE_MIDDLE_CLICK 0x2
#define MOUSE_RIGHT_CLICK 0x3

#define CHAT_WINDOW_SIZE 8
#define MAXFRIENDS 10
#define MAX_SQL_LEN 180
#define MAXLINE 200

// define show the alignment
#define PEER_ALIGN 0
#define SELF_ALIGN 1
// peer: left
// self: right

#define CLIENT_CFG_FILE "config/client_cfg.ini"
#define SERVER_CFG_FILE "config/server_cfg.ini"

enum {
LOGIN_OFF = 0, LOGIN_ON, LOGIN_SUCCESS, LOGIN_FAILED
};

enum {
COL_ID = 0, COL_NAME, COL_STATUS, NUM_COLS
};

enum {
REGISTER = 0, LOGIN, SEND_MEG, SEND_FILE, EXIT
};

static int LOGIN_STATUS = 0;
static char USER_ID[10];
static char USER_NAME[20];
static char ADDRESS[30]; //such as "IP:PORT"
static char split[10] = "#@@#";

static XINI ini ;

#endif

先发这些吧，通讯相关的（socket、pthread）下次贴出。