dialogpeer.cpp

iptux是linux下面能实现类似windows里面飞鸽传书的功能

	Pal *pal;

	pal = (Pal *) data;
	if (pal->dialog) {
		gtk_window_present(GTK_WINDOW
				   (((DialogPeer *) pal->dialog)->dialog));
		return true;
	}
	tmp = (GList *) udt.PalGetMsgPos(data);
	if (tmp) {
		pthread_mutex_lock(&udt.mutex);
		g_queue_delete_link(udt.msgqueue, tmp);
		pthread_mutex_unlock(&udt.mutex);
	}

	return false;
}

void DialogPeer::FillPalInfoToBuffer(gpointer data, GtkTextBuffer * buffer, bool sad)
{
	extern Control ctr;
	char buf[MAX_BUF], ipstr[INET_ADDRSTRLEN];
	GdkPixbuf *pixbuf;
	GtkTextIter iter;
	Pal *pal;

	pal = (Pal*)data;
	snprintf(buf, MAX_BUF, _("Version: %s\n"), pal->version);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	snprintf(buf, MAX_BUF, _("Nickname: %s\n"), pal->name);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	snprintf(buf, MAX_BUF, _("User: %s\n"), pal->user);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	snprintf(buf, MAX_BUF, _("Host: %s\n"), pal->host);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	inet_ntop(AF_INET, &pal->ipv4, ipstr, INET_ADDRSTRLEN);
	snprintf(buf, MAX_BUF, _("Host IP: %s\n"), ipstr);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	if (!FLAG_ISSET(pal->flags, 0))
		snprintf(buf, MAX_BUF, _("Compatibility: Microsoft\n"));
	else
		snprintf(buf, MAX_BUF, _("Compatibility: GNU/Linux\n"));
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	snprintf(buf, MAX_BUF, _("System Encode: %s\n"), pal->encode);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);

	snprintf(buf, MAX_BUF, _("Personal Signature:\n"));
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
			pal->sign?pal->sign:_("(lazy)"), -1, "sign", NULL);

	if (!sad || !pal->ad ||
		    !(pixbuf = gdk_pixbuf_new_from_file(pal->ad, NULL)))
		return;
	snprintf(buf, MAX_BUF, _("\nAdvertisement: \n"));
	gtk_text_buffer_get_end_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, buf, -1);
	pixbuf_shrink_scale_1(&pixbuf, GINT(ctr.pix*51), -1);
	gtk_text_buffer_insert_pixbuf(buffer, &iter, pixbuf);
	g_object_unref(pixbuf);
}

void DialogPeer::DragDataReceived(gpointer data, GdkDragContext * context,
				  gint x, gint y, GtkSelectionData * select,
				  guint info, guint time)
{
	extern SendFile sfl;
	extern struct interactive inter;
	const char *prl = "file://";
	char ipstr[INET_ADDRSTRLEN], *tmp, *file;
	GSList *list;
	Pal *pal;

	if (select->length <= 0 || select->format != 8 ||
	    strcasestr((char *)select->data, prl) == NULL) {
		gtk_drag_finish(context, FALSE, FALSE, time);
		return;
	}

	list = NULL, tmp = (char *)select->data;
	while (tmp = strcasestr(tmp, prl)) {
		file = my_getline(tmp + strlen(prl));
		list = g_slist_append(list, file);
		tmp += strlen(prl) + strlen(file);
	}
	pal = (Pal *) data;
	sfl.SendFileInfo(list, pal);
	g_slist_free(list);	//他处释放

	inet_ntop(AF_INET, &pal->ipv4, ipstr, INET_ADDRSTRLEN);
	pop_info(pal->dialog ? ((DialogPeer *) pal->dialog)->dialog :
		 inter.window,
		 pal->dialog ? ((DialogPeer *) pal->dialog)->focus : NULL,
		 _("Sending the files' infomation to \n%s[%s] is done!"),
		 pal->name, ipstr);

	gtk_drag_finish(context, TRUE, FALSE, time);
}

void DialogPeer::DragPicReceived(GtkWidget *view, GdkDragContext * context,
				 gint x, gint y, GtkSelectionData * select,
				 guint info, guint time, GtkTextBuffer *buffer)
{
	const char *prl = "file://";
	GdkPixbuf *pixbuf;
	GtkTextIter iter;
	char *tmp, *file;
	gboolean flag;
	gint position;

	if (select->length <= 0 || select->format != 8 ||
	    strcasestr((char *)select->data, prl) == NULL) {
		gtk_drag_finish(context, FALSE, FALSE, time);
		return;
	}

	flag = FALSE, tmp = (char *)select->data;
	while (tmp = strcasestr(tmp, prl)) {
		file = my_getline(tmp + strlen(prl));
		pixbuf = gdk_pixbuf_new_from_file(file, NULL);
		if (pixbuf) {
			g_object_get(buffer, "cursor-position", &position, NULL);
			gtk_text_buffer_get_iter_at_offset(buffer, &iter, position);
			gtk_text_buffer_insert_pixbuf(buffer, &iter, pixbuf);
			g_object_unref(pixbuf);
			flag = TRUE;
		}
		tmp += strlen(prl) + strlen(file);
		free(file);
	}

	gtk_drag_finish(context, flag, FALSE, time);
	if (flag)
		g_signal_stop_emission_by_name(view, "drag-data-received");
}

void DialogPeer::DialogDestroy(gpointer data)
{
	delete(DialogPeer *) data;
}

void DialogPeer::InsertPixbuf(gpointer data)
{
	GtkWidget *chooser;
	GdkPixbuf *pixbuf;
	GtkTextBuffer *buffer;
	GtkTextIter iter;
	DialogPeer *peer;
	gchar *filename;
	gint position;

	peer = (DialogPeer*)data;
	chooser = my_chooser::create_chooser(
			     _("Please choose a picture to insert the buffer"), peer->dialog);
	filename = my_chooser::run_chooser(chooser);
	if (!filename)
		return;

	pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
	g_free(filename);
	if (!pixbuf)
		return;
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(peer->focus));
	g_object_get(buffer, "cursor-position", &position, NULL);
	gtk_text_buffer_get_iter_at_offset(buffer, &iter, position);
	gtk_text_buffer_insert_pixbuf(buffer, &iter, pixbuf);
	g_object_unref(pixbuf);
}

void DialogPeer::ClearRecordBuffer(GtkTextBuffer *buffer)
{
	GtkTextIter start, end;

	gtk_text_buffer_get_bounds(buffer, &start, &end);
	if (!gtk_text_iter_equal(&start, &end))
		gtk_text_buffer_delete(buffer, &start, &end);
}

void DialogPeer::SendMessage(gpointer data)
{
	uint8_t count = 0;
	struct sendmsg_para *para;
	DialogPeer *peer;
	GtkTextBuffer *buffer;
	GtkTextIter start, end, iter;
	GdkPixbuf *pixbuf;
	GSList *chiplist;
	gchar *ptr;

	peer = (DialogPeer *) data;
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(peer->focus));
	gtk_text_buffer_get_bounds(buffer, &start, &end);
	if (gtk_text_iter_equal(&start, &end)) {
		pop_warning(peer->dialog, peer->focus,
			    _("<span weight=\"heavy\" underline=\"error\">"
			      "\nCan't send an empty message!!</span>"));
		return;
	}

	chiplist = NULL, iter = start;
	do {
		if (pixbuf = gtk_text_iter_get_pixbuf(&iter)) {
			ptr = g_strdup_printf("%s/.iptux/%x", getenv("HOME"),
					      time(NULL)+(count++));
			gdk_pixbuf_save(pixbuf, ptr, "bmp", NULL, NULL);
			chiplist = g_slist_append(chiplist, new ChipData(PICTURE, ptr));
		}
	} while (gtk_text_iter_forward_find_char(&iter,
			    GtkTextCharPredicate(compare_foreach),
			    GUINT_TO_POINTER(ATOM_OBJECT),
			    &end));
	ptr = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
	if (*ptr)
		chiplist = g_slist_append(chiplist, new ChipData(STRING, ptr));
	else
		g_free(ptr);
	gtk_text_buffer_delete(buffer, &start, &end);

	peer->pal->BufferInsertData(chiplist, SELF);
	gtk_widget_grab_focus(peer->focus);

	para = (struct sendmsg_para*)Malloc(sizeof(struct sendmsg_para));
	para->data = peer->pal, para->chiplist = chiplist;
	thread_create(ThreadFunc(ThreadSendMessage), para, false);
}

void DialogPeer::ThreadSendMessage(gpointer data)
{
	extern struct interactive inter;
	struct sendmsg_para *para;
	Command cmd;
	GSList *tmp;
	char *ptr;
	int sock;

	para = (struct sendmsg_para*)data;
	tmp = para->chiplist;
	while (tmp) {
		ptr = ((ChipData*)tmp->data)->data;
		switch (((ChipData*)tmp->data)->type) {
		case STRING:
			cmd.SendMessage(inter.udpsock, para->data, ptr);
			break;
		case PICTURE:
			sock = Socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
			cmd.SendSublayer(sock, para->data, IPTUX_MSGPICOPT, ptr);
			close(sock), unlink(ptr);
			break;
		default:
			break;
		}
		tmp = tmp->next;
	}

	g_slist_foreach(para->chiplist, remove_foreach, GINT_TO_POINTER(CHIPDATA));
	g_slist_free(para->chiplist);
	free(para);
}