dld_ui.c

linux的多线程下载工具。基于gtk界面。

/* dld_ui.c (for interface)
 *
 * Copyright (C) 2004-2004 Wang Xiaoguang (Chice) <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 *
 * Authors: Wang Xiaoguang (Chice) <[e-mail]>
 */

#include "dld_ui.h"
#include "support.h"
#include "../dld_task.h"
#include "../dld_log.h"
#include "../dld_taskmgr.h"
#include "../dld_language.h"
#include "../dld_proxy.h"
#include "../dld_taskdir.h"
#include "../dld_taskmgr.h"


DldTaskDir 		*g_ui_curtaskdir = NULL;
DldTask 		*g_ui_curtask = NULL;
DldTask 		*g_ui_curmodifytask = NULL;
DldTaskThread 	*g_ui_curtaskthread = NULL;

static TICK *drawblockstick = NULL;
static TICK *drawwindowdroptick = NULL;
static LOCK *infolock = NULL;





INT dld_gtkui_init()
{
	drawblockstick = os_tick_new(200, TRUE);
	drawwindowdroptick = os_tick_new(2000, TRUE);
	infolock = os_lock_create();

	return DLD_ERR_OK;
}
INT dld_gtkui_cleanup()
{
	drawblockstick = os_tick_free(drawblockstick);
	drawwindowdroptick = os_tick_free(drawwindowdroptick);
	infolock = os_lock_free(infolock);
	
	
	return DLD_ERR_OK;
}


VOID dld_gtkui_redraw(GtkWidget *w)
{
	gtk_widget_queue_draw(GTK_WIDGET(w));
	while (g_main_iteration(FALSE));
}

BOOL dld_gtkui_get_iter_by_ptr(GtkTreeView *tv, POINTER ptr, GtkTreeIter *iter)
{
	GtkTreeModel *model;
	//gchar *str;
	gpointer p = NULL;
	
	model = gtk_tree_view_get_model(GTK_TREE_VIEW(tv));
	
	if( !gtk_tree_model_get_iter_first(model, iter) ) return FALSE; //no iters
	
	do
	{
		gtk_tree_model_get(model, iter, 0, &p, -1);
		if(p == ptr) return TRUE;
		
	}while(gtk_tree_model_iter_next(model, iter));
	return FALSE;
}

BOOL dld_gtkui_get_iter_by_taskdir(DldTaskDir *taskdir , GtkTreeIter *iter)
{
	return dld_gtkui_get_iter_by_ptr(GTK_TREE_VIEW(treeview_dirs), (POINTER)taskdir, iter);
}

BOOL dld_gtkui_get_iter_by_task(DldTask *task , GtkTreeIter *iter)
{
	return dld_gtkui_get_iter_by_ptr(GTK_TREE_VIEW(treeview_tasks), (POINTER)task, iter);
}

BOOL dld_gtkui_get_iter_by_taskthread(DldTaskThread *taskthread , GtkTreeIter *iter)
{
	return dld_gtkui_get_iter_by_ptr(GTK_TREE_VIEW(treeview_infos), taskthread, iter);
}

BOOL dld_gtkui_get_iter_by_proxy(DldProxy *proxy , GtkTreeIter *iter)
{
	if(!treeview_proxys) return FALSE;
	return dld_gtkui_get_iter_by_ptr(GTK_TREE_VIEW(treeview_proxys), proxy, iter);
}

INT dld_gtkuicmd_modify_task(BOOL can_refresh, DldTask *task)
{
	GtkTreeIter iter;
	GdkPixbuf *pixbuf_show;
	
	CHAR tnstr[20], fsstr[20], ratestr[20], speedstr[20];
	
	if(!dld_gtkui_get_iter_by_task(task, &iter))
	{
		return DLD_ERR_OK;
	}
	
	//sprintf(taskstr, "%u", (guint)task);
	sprintf(tnstr, "%u", (guint)task->threadnumber);
	sprintf(fsstr, "%u", (guint)task->filesize);
	sprintf(speedstr, "%u kb/s", (guint)task->speed / 1024);
	
	if( task->filesize != 0)
		sprintf(ratestr, "%d%% (%u)", (INT)((float)task->finishedsize / (float)task->filesize * 100.0), task->finishedsize);
	else
		strcpy(ratestr, "0% (0)");
	
	
	pixbuf_show = pixbuf_stop;
	
	if(task->finishedsize >= task->filesize && task->filesize != 0)
		pixbuf_show = pixbuf_finished;
	
	if(task->status == DLD_TASK_RUNNING || task->status == DLD_TASK_RESET)
		pixbuf_show = pixbuf_start;
	
	if(task->status == DLD_TASK_ERROR)
		pixbuf_show = pixbuf_error;
	
	if(task->status == DLD_TASK_WAITING)
		pixbuf_show = pixbuf_queue;
	

		
	gtk_list_store_set (GTK_LIST_STORE (treeview_tasks_store), 
					&iter,
					TREEVIEW_TASKS_COL_STATUS, pixbuf_show,
					TREEVIEW_TASKS_COL_FILENAME, task->localfile->str,
					TREEVIEW_TASKS_COL_SIZE, fsstr,
					TREEVIEW_TASKS_COL_RATE, ratestr,
					TREEVIEW_TASKS_COL_SPEED, speedstr,
					TREEVIEW_TASKS_COL_TIME, "00:00:00",
					TREEVIEW_TASKS_COL_REMAINING, "??:??:??",
					TREEVIEW_TASKS_COL_THREADNUMBER, tnstr,
					TREEVIEW_TASKS_COL_URL, task->url->str,
					TREEVIEW_TASKS_COL_COMMENT, task->comment->str,
					-1);
	
	if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_tasks));
	
	if(task->status != DLD_TASK_RUNNING) gtk_widget_queue_draw(GTK_WIDGET(window_drop));
	
	return DLD_ERR_OK;
}

INT dld_gtkuicmd_add_task(BOOL can_refresh, DldTask *task)
{
	GtkTreeIter iter;
	//CHAR taskstr[20];
	
	if(g_ui_curtaskdir != NULL)
	{
		if(strcmpi(g_ui_curtaskdir->dir->str, task->dir->str) != 0)
			return DLD_ERR_OK;
	}
	
	//sprintf(taskstr, "%u", (guint)task);
	
	gtk_list_store_append (GTK_LIST_STORE (treeview_tasks_store), &iter);
	gtk_list_store_set (GTK_LIST_STORE (treeview_tasks_store), 
					&iter,
					TREEVIEW_TASKS_COL_TASK, task,
					-1);
	
	dld_gtkuicmd_modify_task(can_refresh, task);
	
	return DLD_ERR_OK;
}


INT dld_gtkuicmd_remove_task(BOOL can_refresh, DldTask *task)
{
	GtkTreeIter iter;
	if(dld_gtkui_get_iter_by_task(task , &iter))
	{
		gtk_list_store_clear(treeview_infos_store);
		gtk_list_store_remove(GTK_LIST_STORE (treeview_tasks_store), &iter);
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_tasks));
	}
	return DLD_ERR_OK;

}

INT dld_gtkuicmd_start_task(BOOL can_refresh, DldTask *task)
{
	GtkTreeIter iter;
	
	if(dld_gtkui_get_iter_by_task(task , &iter))
	{
		gtk_list_store_set (GTK_LIST_STORE (treeview_tasks_store), 
			&iter,
			TREEVIEW_TASKS_COL_STATUS, pixbuf_start,
			-1);
		
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_tasks));
	}
	return DLD_ERR_OK;
}

INT dld_gtkuicmd_stop_task(BOOL can_refresh, DldTask *task)
{
	GtkTreeIter iter;
	
	if(dld_gtkui_get_iter_by_task(task , &iter))
	{
		gtk_list_store_set (GTK_LIST_STORE (treeview_tasks_store), 
			&iter,
			TREEVIEW_TASKS_COL_STATUS, pixbuf_stop,
			-1);
		
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_tasks));
	}
	
	//if a task is stopped , the speed diagram should be refreshed
	gtk_widget_queue_draw(GTK_WIDGET(window_drop));
	
	return DLD_ERR_OK;
}

INT dld_gtkuicmd_task_data_finish(BOOL can_refresh, DldTask *task, INT start, INT end, BOOL blockfinished)
{
	GtkTreeIter iter;
	CHAR ratestr[20], fsstr[20], speedstr[20], remainingstr[20];
	INT t;
	CHAR msg[1000];
	
	if(dld_gtkui_get_iter_by_task(task , &iter))
	{
		sprintf(ratestr, "%d%% (%u)", (INT)((float)task->finishedsize / (float)task->filesize * 100.0), task->finishedsize);
		sprintf(fsstr, "%u", (guint)task->filesize);
		sprintf(speedstr, "%u kb/s", (guint)task->speed / 1024);
		if(task->speed == 0)
		{
			strcpy(remainingstr, "??:??:??");
		}
		else
		{
			t = (task->filesize - task->finishedsize) / task->speed;
			sprintf(remainingstr, "%d:%d:%d",  t / 3600 ,(t / 60) % 60  ,t % 60);
		}
		
		gtk_list_store_set (GTK_LIST_STORE (treeview_tasks_store), 
			&iter,
			TREEVIEW_TASKS_COL_SIZE, fsstr,
			TREEVIEW_TASKS_COL_RATE, ratestr,
			TREEVIEW_TASKS_COL_SPEED, speedstr,
			TREEVIEW_TASKS_COL_REMAINING, remainingstr,
			-1);

		if(task->finishedsize >= task->filesize)
		{
			gtk_list_store_set (GTK_LIST_STORE (treeview_tasks_store), 
				&iter,
				TREEVIEW_TASKS_COL_STATUS, pixbuf_finished,
				-1);
			
			if(g_config.tellme)
			{
				snprintf(msg, sizeof(msg), _("DLD has finished: %s"), task->url->str);
				quick_toptip(msg);
			}
		}	
	}
	
	if(can_refresh)
	{	
		if(os_tick_check(drawblockstick) || blockfinished)
		{
			if(g_ui_curtask == task)
			{
				dld_gtkui_draw_blocks(task);
				dld_gtkui_redraw(GTK_WIDGET(treeview_tasks));
			}
		}
		
		
		if(os_tick_check(drawwindowdroptick))  
		{
			dld_gtkui_draw_window_drop(dld_taskmgr_get_total_speed());
			dld_gtkui_redraw(GTK_WIDGET(window_drop));
		}	
	}
	else
	{
		gtk_widget_queue_draw(GTK_WIDGET(window_drop));
		gtk_widget_queue_draw(GTK_WIDGET(canvas_graph));
	}
	
	return DLD_ERR_OK;
}




INT dld_gtkuicmd_add_taskthread(BOOL can_refresh, DldTaskThread *dldthread)
{
	GtkTreeIter iter;
	DldTask *task;
//	gchar threadstr[20];
	gchar title[100];
	
	if(!dldthread) return DLD_ERR_NULLPOINTER;
	task = dldthread->parenttask;
	
	if(g_ui_curtask == task)
	{
		//sprintf(threadstr, "%u", (guint)dldthread);
		sprintf(title, _("Thread(0x%x)"), (guint)dldthread);
		gtk_list_store_append (GTK_LIST_STORE (treeview_infos_store), &iter);
		gtk_list_store_set (GTK_LIST_STORE (treeview_infos_store), &iter,
							TREEVIEW_INFOS_COL_TASKTHREAD, dldthread,
							TREEVIEW_INFOS_COL_TITLE, title,
							-1);
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_infos));
	}
	return DLD_ERR_OK;
}

INT dld_gtkuicmd_remove_taskthread(BOOL can_refresh, DldTaskThread *dldthread)
{
	GtkTreeIter iter;
	DldTask *task;
	
	if(!dldthread) return DLD_ERR_NULLPOINTER;
	task = dldthread->parenttask;
	
	if(g_ui_curtask == task)
	{
		if(dld_gtkui_get_iter_by_taskthread(dldthread, &iter))
		{
			gtk_list_store_remove(GTK_LIST_STORE (treeview_infos_store), &iter);
			if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_infos));
		}
	}
	return DLD_ERR_OK;
}



INT dld_gtkuicmd_add_taskdir(BOOL can_refresh, DldTaskDir *taskdir)
{
	GtkTreeIter iter;
//	CHAR taskdirstr[20];
	
	//sprintf(taskdirstr, "%u", (guint)taskdir);
	
	gtk_list_store_append (GTK_LIST_STORE (treeview_dirs_store), &iter);
	gtk_list_store_set (GTK_LIST_STORE (treeview_dirs_store), 
					&iter,
					TREEVIEW_DIRS_COL_TASKDIR, taskdir,
					TREEVIEW_DIRS_COL_TITLE, taskdir->dir->str,
					TREEVIEW_DIRS_COL_PATH, taskdir->path->str,
					-1);
	
	if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_dirs));
		
	return DLD_ERR_OK;
}


INT dld_gtkuicmd_remove_taskdir(BOOL can_refresh, DldTaskDir *taskdir)
{
	GtkTreeIter iter;
	if(dld_gtkui_get_iter_by_taskdir(taskdir , &iter))
	{
		gtk_list_store_remove(GTK_LIST_STORE (treeview_dirs_store), &iter);
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_dirs));
	}
	return DLD_ERR_OK;

}


INT dld_gtkuicmd_modify_taskdir(BOOL can_refresh, DldTaskDir *taskdir)
{
	GtkTreeIter iter;
	if(dld_gtkui_get_iter_by_taskdir(taskdir , &iter))
	{
		//gtk_list_store_remove(GTK_LIST_STORE (treeview_dirs_store), &iter);
		gtk_list_store_set (GTK_LIST_STORE (treeview_dirs_store), &iter,
							TREEVIEW_DIRS_COL_TITLE, taskdir->dir->str,
							TREEVIEW_DIRS_COL_PATH, taskdir->path->str,
							-1);
		
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_dirs));
	}
	return DLD_ERR_OK;

}



INT dld_gtkuicmd_modify_proxy(BOOL can_refresh, DldProxy *proxy)
{
	GtkTreeIter iter;
	if(dld_gtkui_get_iter_by_proxy(proxy , &iter))
	{
		//gtk_list_store_remove(GTK_LIST_STORE (treeview_dirs_store), &iter);
		gtk_list_store_set (GTK_LIST_STORE (treeview_proxys_store), &iter,
							TREEVIEW_PROXYS_COL_NAME, proxy->name->str,
							TREEVIEW_PROXYS_COL_HOST, proxy->host->str,
							TREEVIEW_PROXYS_COL_PORT, proxy->port->str,
							TREEVIEW_PROXYS_COL_TYPE, proxy->type->str,
							TREEVIEW_PROXYS_COL_USERNAME, proxy->username->str,
							TREEVIEW_PROXYS_COL_PASSWORD, proxy->password->str,
							-1);
		
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_dirs));
	}
	return DLD_ERR_OK;
}

INT dld_gtkuicmd_add_proxy(BOOL can_refresh, DldProxy *proxy)
{
	if(!treeview_proxys || ! treeview_proxys_store) return DLD_ERR_OK;
	GtkTreeIter iter;
	
	gtk_list_store_append (GTK_LIST_STORE (treeview_proxys_store), &iter);
	gtk_list_store_set (GTK_LIST_STORE (treeview_proxys_store), 
					&iter,
					TREEVIEW_PROXYS_COL_PROXY, proxy,
					-1);
	
	return dld_gtkuicmd_modify_proxy(can_refresh, proxy);
}
INT dld_gtkuicmd_remove_proxy(BOOL can_refresh, DldProxy *proxy)
{
	GtkTreeIter iter;
	if(dld_gtkui_get_iter_by_proxy(proxy , &iter))
	{
		gtk_list_store_remove(GTK_LIST_STORE (treeview_proxys_store), &iter);
		if(can_refresh) dld_gtkui_redraw(GTK_WIDGET(treeview_proxys));
	}
	return DLD_ERR_OK;
}



VOID dld_gtkui_add_log(GtkTextBuffer *textbuffer,  GtkTextIter *iter, DldLogMsg *logmsg)
{
	GtkTextIter m_iter;
	char timebuf[100];
	char *tag;
	//gchar *localstr = NULL;
	BOOL needlock = FALSE;
	
	if(textbuffer == NULL)
	{
		needlock = TRUE;
		os_lock_lock(infolock);
		textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(textview_info));
	}
	if(iter == NULL)
	{
		iter = &m_iter;
		gtk_text_buffer_get_end_iter (textbuffer, iter);
	}
	
	sprintf(timebuf, "%02d-%02d-%02d %02d:%02d:%02d ",  logmsg->msgtime.year, logmsg->msgtime.month, logmsg->msgtime.day,
											logmsg->msgtime.hour, logmsg->msgtime.minute, logmsg->msgtime.second);

	
	switch(logmsg->msg->str[0])
	{
		case '!':
			tag = "error";
			break;
		case '>':
			tag = "send";
			break;
		case '<':
			tag = "recv";
			break;
		default:
			tag = "info";
			break;
	}
	
	/*
	if(!g_utf8_validate(logmsg->msg->str, -1, NULL))
	{
		dprintf("[dld_gtkui_add_log] WILL USE UTF-8!!!!!!!!\n");
		localstr = dld_gtkui_convert_str(logmsg->msg->str);
	}
	
	
	if(localstr)
	{
		dprintf("[dld_gtkui_add_log] UTF-8 is USED!!!!!!!!\n");
	}
	*/
	if(strcmp(tag, "info") == 0 || strcmp(tag, "error") == 0)
	{
		
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, timebuf, -1,
											tag,
											NULL);
		
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, logmsg->msg->str, -1,
												tag,
												NULL);
		
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, "\r\n", -1,
											NULL);	
	}
	else
	{
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, timebuf, -1,
												tag,
												NULL);
	
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, "\r\n", -1,
											tag,
											NULL);
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, logmsg->msg->str + 1, -1,
												tag,
												NULL);

		gtk_text_buffer_insert_with_tags_by_name(textbuffer, iter, "\r\n", -1,
											tag,
											NULL);