iptuxsetup.cpp

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

	gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);

	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_resizable(column, TRUE);
	gtk_tree_view_column_set_expand(column, TRUE);
	gtk_tree_view_column_set_title(column, _("end IPv4"));
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column, renderer, "text", 1, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);

	return view;
}

bool IptuxSetup::CheckExist()
{
	if (!setup)
		return false;
	gtk_window_present(GTK_WINDOW(setup));
	return true;
}

//头像 2,0 pixbuf,1 iconfile
GtkTreeModel *IptuxSetup::CreateIconModel()
{
	extern Control ctr;
	GtkListStore *model;
	GdkPixbuf *pixbuf;
	GtkTreeIter iter;
	GSList *tmp;

	model = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
	pthread_mutex_lock(&ctr.mutex);
	tmp = ctr.iconlist;
	while (tmp) {
		pixbuf = gdk_pixbuf_new_from_file_at_size((char *)tmp->data,
							  MAX_ICONSIZE,
							  MAX_ICONSIZE, NULL);
		if (pixbuf) {
			gtk_list_store_append(model, &iter);
			gtk_list_store_set(model, &iter, 0, pixbuf, 1,
					   (char *)tmp->data, -1);
			g_object_unref(pixbuf);
		}
		tmp = tmp->next;
	}
	pthread_mutex_unlock(&ctr.mutex);

	return GTK_TREE_MODEL(model);
}

GtkWidget *IptuxSetup::CreateComboBoxWithModel(GtkTreeModel * model,
					       gchar * iconfile)
{
	GtkWidget *combo;
	GtkCellRenderer *renderer;
	gint active;

	combo = gtk_combo_box_new_with_model(model);
	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, FALSE);
	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer,
				       "pixbuf", 0, NULL);
	gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 6);
	active = FileGetItemPos(iconfile, model);
	gtk_combo_box_set_active(GTK_COMBO_BOX(combo), active);
	gtk_widget_show(combo);

	return combo;
}

gint IptuxSetup::FileGetItemPos(const char *filename, GtkTreeModel * model)
{
	GdkPixbuf *pixbuf;
	GtkTreeIter iter;
	gchar *tmp;
	gint pos;

	pos = 0;
	if (gtk_tree_model_get_iter_first(model, &iter)) {
		do {
			gtk_tree_model_get(model, &iter, 1, &tmp, -1);
			if (strcmp(filename, tmp) == 0) {
				g_free(tmp);
				return pos;
			}
			g_free(tmp);
			pos++;
		} while (gtk_tree_model_iter_next(model, &iter));
	}
	if (access(filename, F_OK) != 0 ||
	    !(pixbuf =
	      gdk_pixbuf_new_from_file_at_size(filename, MAX_ICONSIZE,
					       MAX_ICONSIZE, NULL)))
		return -1;
	gtk_list_store_append(GTK_LIST_STORE(model), &iter);
	gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, pixbuf, 1, filename,
			   -1);
	g_object_unref(pixbuf);

	return pos;
}

void IptuxSetup::ObtainPerson(gpointer data)
{
	extern Control ctr;
	GtkTextIter start, end;
	GtkTextBuffer *buffer;
	GdkPixbuf *pixbuf;
	GtkTreeIter iter;
	IptuxSetup *ipst;
	char buf[MAX_PATHBUF];
	const char *text;
	gint active;

	ipst = (IptuxSetup *) data;
	text = gtk_entry_get_text(GTK_ENTRY(ipst->myname));
	free(ctr.myname);
	ctr.myname = Strdup(text);

	active = gtk_combo_box_get_active(GTK_COMBO_BOX(ipst->myicon));
	snprintf(buf, MAX_PATHBUF, "%d", active);
	gtk_tree_model_get_iter_from_string(ipst->icon_model, &iter, buf);
	free(ctr.myicon);
	gtk_tree_model_get(ipst->icon_model, &iter, 1, &ctr.myicon, -1);
	if (strncmp(ctr.myicon, __ICON_DIR, strlen(__ICON_DIR))) {
		snprintf(buf, MAX_PATHBUF, "%s/.iptux/myicon", getenv("HOME"));
		pixbuf =
		    gdk_pixbuf_new_from_file_at_size(ctr.myicon, MAX_ICONSIZE,
						     MAX_ICONSIZE, NULL);
		gdk_pixbuf_save(pixbuf, buf, "png", NULL, NULL);
		g_object_unref(pixbuf);
	}

	free(ctr.path);
	ctr.path =
	    gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(ipst->save_path));

	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ipst->sign));
	gtk_text_buffer_get_bounds(buffer, &start, &end);
	free(ctr.sign);
	ctr.sign = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
}

void IptuxSetup::ObtainSystem(gpointer data)
{
	extern Control ctr;
	GtkTreeIter iter;
	IptuxSetup *ipst;
	char buf[MAX_BUF];
	const char *text;
	gint active;

	ipst = (IptuxSetup *) data;
	text = gtk_entry_get_text(GTK_ENTRY(ipst->encode));
	free(ctr.encode);
	ctr.encode = Strdup(text);

	active = gtk_combo_box_get_active(GTK_COMBO_BOX(ipst->palicon));
	snprintf(buf, MAX_BUF, "%d", active);
	gtk_tree_model_get_iter_from_string(ipst->icon_model, &iter, buf);
	free(ctr.palicon);
	gtk_tree_model_get(ipst->icon_model, &iter, 1, &ctr.palicon, -1);

	text = gtk_font_button_get_font_name(GTK_FONT_BUTTON(ipst->font));
	free(ctr.font);
	ctr.font = Strdup(text);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ipst->tidy)))
		FLAG_SET(ctr.flags, 3);
	else
		FLAG_CLR(ctr.flags, 3);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ipst->log)))
		FLAG_SET(ctr.flags, 2);
	else
		FLAG_CLR(ctr.flags, 2);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ipst->black)))
		FLAG_SET(ctr.flags, 1);
	else
		FLAG_CLR(ctr.flags, 1);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ipst->proof)))
		FLAG_SET(ctr.flags, 0);
	else
		FLAG_CLR(ctr.flags, 0);
}

void IptuxSetup::ObtainIpseg(gpointer data)
{
	extern Control ctr;
	GtkTreeIter iter;
	IptuxSetup *ipst;
	gchar *ipstr1, *ipstr2;

	ipst = (IptuxSetup *) data;
	pthread_mutex_lock(&ctr.mutex);
	g_slist_foreach(ctr.ipseg, remove_foreach, GINT_TO_POINTER(UNKNOWN));
	g_slist_free(ctr.ipseg), ctr.ipseg = NULL;
	if (gtk_tree_model_get_iter_first(ipst->ip_model, &iter)) {
		do {
			gtk_tree_model_get(ipst->ip_model, &iter,
					   0, &ipstr1, 1, &ipstr2, -1);
			ctr.ipseg = g_slist_append(ctr.ipseg, ipstr1);
			ctr.ipseg = g_slist_append(ctr.ipseg, ipstr2);
		} while (gtk_tree_model_iter_next(ipst->ip_model, &iter));
	}
	pthread_mutex_unlock(&ctr.mutex);
}

void IptuxSetup::UpdateMyInfo()
{
	extern struct interactive inter;
	extern UdpData udt;
	Command cmd;
	GSList *tmp;

	pthread_mutex_lock(&udt.mutex);
	tmp = udt.pallist;
	while (tmp) {
		cmd.SendAbsence(inter.udpsock, tmp->data);
		if (FLAG_ISSET(((Pal*)tmp->data)->flags, 0))
			thread_create(ThreadFunc(Pal::SendFeature), tmp->data, false);
		tmp = tmp->next;
	}
	pthread_mutex_unlock(&udt.mutex);
}

void IptuxSetup::AddPalIcon(GtkWidget *combo)
{
	GtkWidget *chooser;
	GtkTreeModel *model;
	gchar *filename;
	gint active;

	chooser =
	    my_chooser::create_chooser(_("Please choose a head portrait"),
				       setup);
	filename = my_chooser::run_chooser(chooser);
	if (!filename)
		return;
	model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
	active = FileGetItemPos(filename, model);
	gtk_combo_box_set_active(GTK_COMBO_BOX(combo), active);
	g_free(filename);
}

void IptuxSetup::ClickAddIpseg(gpointer data)
{
	const gchar *text1, *text2, *text;
	IptuxSetup *ipst;
	in_addr_t ip1, ip2;
	GtkTreeIter iter;
	int status;

	ipst = (IptuxSetup *) data;
	text1 = gtk_entry_get_text(GTK_ENTRY(ipst->entry1));
	status = inet_pton(AF_INET, text1, &ip1);
	if (status <= 0) {
		pop_warning(setup, NULL, _("\nThe address %s is illegal!"),
			    text1);
		return;
	}
	text2 = gtk_entry_get_text(GTK_ENTRY(ipst->entry2));
	status = inet_pton(AF_INET, text2, &ip2);
	if (status <= 0) {
		pop_warning(setup, NULL, _("\nThe address %s is illegal!"),
			    text2);
		return;
	}

	ip1 = ntohl(ip1), ip2 = ntohl(ip2);
	if (ip1 > ip2) {
		text = text1;
		text1 = text2;
		text2 = text;
	}

	gtk_list_store_append(GTK_LIST_STORE(ipst->ip_model), &iter);
	gtk_list_store_set(GTK_LIST_STORE(ipst->ip_model), &iter,
			   0, text1, 1, text2, -1);
	gtk_entry_set_text(GTK_ENTRY(ipst->entry1), "\0");
	gtk_entry_set_text(GTK_ENTRY(ipst->entry2), "\0");
}

void IptuxSetup::ClickDelIpseg(gpointer data)
{
	gchar *ipstr1, *ipstr2;
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	IptuxSetup *ipst;

	ipst = (IptuxSetup *) data;
	selection =
	    gtk_tree_view_get_selection(GTK_TREE_VIEW(ipst->ipseg_view));
	if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
		return;
	gtk_tree_model_get(ipst->ip_model, &iter, 0, &ipstr1, 1, &ipstr2, -1);
	gtk_entry_set_text(GTK_ENTRY(ipst->entry1), ipstr1);
	gtk_entry_set_text(GTK_ENTRY(ipst->entry2), ipstr2);
	gtk_list_store_remove(GTK_LIST_STORE(ipst->ip_model), &iter);
}

void IptuxSetup::ClickOk(gpointer data)
{
	IptuxSetup::ClickApply(data);
	gtk_widget_destroy(setup);
}

void IptuxSetup::ClickApply(gpointer data)
{
	extern Control ctr;

	ObtainPerson(data);
	ObtainSystem(data);
	ObtainIpseg(data);
	ctr.dirty = true;
	IptuxSetup::UpdateMyInfo();
}

void IptuxSetup::SetupDestroy(gpointer data)
{
	setup = NULL;
	delete(IptuxSetup *) data;
}

void IptuxSetup::ChoosePortrait(GtkWidget *image)
{
	gchar path[MAX_PATHBUF], *filename;
	GtkWidget *chooser;
	GdkPixbuf *pixbuf;

	chooser = my_chooser::create_chooser(
			     _("Please choose a personal portrait"), setup);
	filename = my_chooser::run_chooser(chooser);
	if (!filename)
		return;
	pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
	g_free(filename);
	if (pixbuf) {
		snprintf(path, MAX_PATHBUF, "%s/.iptux/myad", getenv("HOME"));
		pixbuf_shrink_scale_1(&pixbuf, MAX_ADSIZE, MAX_ADSIZE);
		gdk_pixbuf_save(pixbuf, path, "png", NULL, NULL);	//命中率极高，不妨直接保存
		pixbuf_shrink_scale_1(&pixbuf, MAX_PREVIEWSIZE, MAX_PREVIEWSIZE);
		gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
		g_object_unref(pixbuf);
	}
}