dld_ui.c

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

	}
	
	
	
	if(needlock)	
	{
		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview_info), iter, 0.0, FALSE, 0.0, 0.0);
		os_lock_unlock(infolock);
	}
	
}



VOID dld_gtkui_draw_window_drop(INT newspeed)  /* -1 == RefreshOnly  */
{
	GdkColor color;
	static GdkGC *gc_blue = NULL;
	//static GdkGC *gc_red = NULL;
	
	GtkWidget *widget;
	
	//LIST *l;
	
	
//	gint width, height;
	gint x,y, w, h, i, y1, y2;

	static INT speeds[100];
	x = 2;
	y = 2;
	w = 38;
	h = 38;
	if (w > 100) 
	{
		dprintf("[dld_gtkui_draw_window_drop] ERROR! window_drop is TOO BIG!\n");
		return;
	}
	
	widget = window_drop;
	if(!widget) return;
	

		
	if(!gc_blue)
	{
		memset(speeds, 0, sizeof(speeds));
		
		gc_blue = gdk_gc_new(widget->window);
		gdk_color_parse("#58a8ff", &color);
		gdk_color_alloc(gtk_widget_get_colormap(widget),&color);
		gdk_gc_set_foreground(gc_blue, &color);
		
		
		gdk_color_parse("#555555", &color);
		gdk_color_alloc(gtk_widget_get_colormap(widget),&color);
		
		//FIXEME!!!!
		gdk_gc_set_background(gc_blue, &color);
	}
	
	if(newspeed != -1)
	{
		for(i=1;i<w;i++)
			speeds[i-1] = speeds[i];
		speeds[w - 1] = newspeed;
		//dprintf("[dld_gtkui_draw_window_drop] Add Speed\n");
	}
	
	//gdk_window_clear(widget->window);
	gdk_draw_drawable(widget->window, gc_blue, pixmap_window_drop, 0, 0, 0, 0, 42, 42);
	
	
	if(dld_taskmgr_get_active_tasknumber() != 0)
	{
		for(i=0;i<w;i++)
		{
			y1 = y + h * (1.0 - (float)speeds[i]/(float)g_config.speedrate);
			y2 = y + h;
			
			if(y1 <= y) y1 = y;
				
			if(y1 != y2)
				gdk_draw_line(widget->window, gc_blue, x + i, y1, x + i, y2);
		}
	}
	else
	{
		gdk_draw_drawable(widget->window, gc_blue, pixmap_logo, 0, 0, 2, 2, 38, 38);		
	}
}

VOID dld_gtkui_draw_blocks(DldTask *task)
{
	GdkColor color;
	static GdkGC *gc = NULL;
	static GdkGC *gc_red = NULL;
	
	GtkWidget *widget;
	
	LIST *l;
	DldDataBlock *block;
	
	gint width, height;
	gint x,y, w, h, x1, w1;

		
	widget = canvas_graph;
	if(!widget)
	{
		dprintf("[dld_gtkui_draw_blocks] Can't find CANVAS_GRAPH!\r\n");
		return;
	}
	

	if(!widget->window)
	{
		dprintf("[dld_gtkui_draw_blocks] Canvas is not ready!\r\n");
		return;
	}
	
	gdk_window_get_geometry (widget->window, NULL, NULL, &width, &height, NULL);

	if(!gc)
	{
		gc = gdk_gc_new(widget->window);
		gdk_color_parse("#0000ff", &color);
		gdk_color_alloc(gtk_widget_get_colormap(widget),&color);
		gdk_gc_set_foreground(gc, &color);
		
		gc_red = gdk_gc_new(widget->window);
		gdk_color_parse("#ff0000", &color);
		gdk_color_alloc(gtk_widget_get_colormap(widget),&color);
		gdk_gc_set_foreground(gc_red, &color);

		gdk_color_parse("black", &color);
		gdk_color_alloc(gtk_widget_get_colormap(widget),&color);
		gdk_gc_set_background(gc, &color);
	}
	
	gdk_window_clear(widget->window);
	
	x = 5;
	y = 5;
	w = width - x - 5;
	h = 60;
	
	gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE, x - 1, y - 1, w + 1, h + 1);
	
	if(task)
	{
		if(task->filesize)
		{
			for(l = task->finishedblocks; l != NULL; l = l->next)
			{
				block = (DldDataBlock *)l->data;
				x1 = (gint)((float)block->start * (float)w / (float)task->filesize);
				w1 = (gint)((float)(block->end - (float)block->start + 1.0) * (float)w / (float)task->filesize);
				gdk_draw_rectangle(widget->window, gc, TRUE, x + x1, y, w1, h);
				
				gdk_draw_line(widget->window, gc_red, x + x1 + w1, y, x + x1 + w1, y + h);
			}
		}
	}		
	gdk_draw_rectangle(widget->window, widget->style->black_gc, FALSE, x - 1, y - 1, w + 1, h + 1);
}

INT dld_gtkui_callback(INT uicmd, ...)
{
	DldTask *task;
	DldTaskDir *taskdir;
	DldProxy *proxy;	
	DldTaskThread *dldthread;
	DldLogMsg *logmsg;
	INT start, end;
	BOOL blockfinished;
	INT ret;	
	BOOL can_refresh = FALSE;
	
	va_list ap;
	
	//if(pthread_self() != global_main_thread.thread && !dld_gtkui_is_in_gtk_action())
	if(pthread_self() != global_main_thread.thread)
	{
		//if(g_mutex_trylock (gdk_threads_mutex))
		g_mutex_lock (gdk_threads_mutex);
		can_refresh = TRUE;
	}
	
	va_start (ap, uicmd);
	ret = DLD_ERR_OK;
	//DO NOT return here!!!!
	switch(uicmd)
	{
		case DLD_UICMD_TASKTHREAD_LOG:	 		// thread, log
			dldthread = va_arg(ap, DldTaskThread *);
			logmsg = va_arg(ap, DldLogMsg *);
			if(g_ui_curtaskthread == dldthread)
				dld_gtkui_add_log(NULL,NULL,logmsg);
			break;
			
		case DLD_UICMD_TASKTHREAD_STATUS:  		// thread, status
			break;
	
		case DLD_UICMD_TASK_DATA_FINISH:   // task, start, end, blockfinished
			task = va_arg(ap, DldTask *);
			start = va_arg(ap, INT);
			end = va_arg(ap, INT);
			blockfinished = va_arg(ap, BOOL);
			
			ret = dld_gtkuicmd_task_data_finish(can_refresh, task, start, end, blockfinished);
			break;
			
		case DLD_UICMD_TASK_LOG:        // task, log
			task = va_arg(ap, DldTask *);
			logmsg = va_arg(ap, DldLogMsg *);
			if(g_ui_curtask == task && g_ui_curtaskthread == NULL)
				dld_gtkui_add_log(NULL,NULL,logmsg);

			break;
		case DLD_UICMD_TASK_STATUS:     // task, status
			task = va_arg(ap, DldTask *);
			dld_gtkuicmd_modify_task(can_refresh, task);
			break;

		case DLD_UICMD_ADD_TASKTHREAD: 	   //thread
			dldthread = va_arg(ap, DldTaskThread *);
			dld_gtkuicmd_add_taskthread(can_refresh, dldthread);			
			break;
		case DLD_UICMD_REMOVE_TASKTHREAD: 	   //thread
			dldthread = va_arg(ap, DldTaskThread *);
			if(dldthread == g_ui_curtaskthread) 
				g_ui_curtaskthread = NULL;
			
			dld_gtkuicmd_remove_taskthread(can_refresh, dldthread);
			break;
		
		
		case DLD_UICMD_ADD_TASK:          // task
			task = va_arg(ap, DldTask *);
			ret = dld_gtkuicmd_add_task(can_refresh, task);
			break;
			
		case DLD_UICMD_REMOVE_TASK:        // task
			task = va_arg(ap, DldTask *);
			if(task == g_ui_curtask)
				g_ui_curtask = NULL;
			ret = dld_gtkuicmd_remove_task(can_refresh, task);
			break;
			
		case DLD_UICMD_START_TASK:        // task
			task = va_arg(ap, DldTask *);
			ret = dld_gtkuicmd_start_task(can_refresh, task);
			break;
			
		case DLD_UICMD_MODIFY_TASK:
			task = va_arg(ap, DldTask *);
			ret = dld_gtkuicmd_modify_task(can_refresh, task);
			break;			
		
		case DLD_UICMD_STOP_TASK:        // task			
			task = va_arg(ap, DldTask *);
			ret = dld_gtkuicmd_stop_task(can_refresh, task);
			break;
		
		
		case DLD_UICMD_ADD_TASKDIR:			//taskdir
			taskdir = va_arg(ap, DldTaskDir *);
			ret = dld_gtkuicmd_add_taskdir(can_refresh, taskdir);			
			break;
		case DLD_UICMD_REMOVE_TASKDIR:		//taskdir
			taskdir = va_arg(ap, DldTaskDir *);
			if(taskdir == g_ui_curtaskdir)
				g_ui_curtaskdir = (DldTaskDir *)g_taskdirs->data;
			
			ret = dld_gtkuicmd_remove_taskdir(can_refresh, taskdir);			
			break;
		case DLD_UICMD_MODIFY_TASKDIR:		//taskdir !!!!!!!!  MODIFYING!!!!!!!
			taskdir = va_arg(ap, DldTaskDir *);
			ret = dld_gtkuicmd_modify_taskdir(can_refresh, taskdir);						
			break;
		
		
		case DLD_UICMD_ADD_PROXY:
			proxy = va_arg(ap, DldProxy *);
			ret = dld_gtkuicmd_add_proxy(can_refresh, proxy);
			break;

		case DLD_UICMD_REMOVE_PROXY:
			proxy = va_arg(ap, DldProxy *);
			ret = dld_gtkuicmd_remove_proxy(can_refresh, proxy);
			break;
		
		case DLD_UICMD_MODIFY_PROXY:
			proxy = va_arg(ap, DldProxy *);
			ret = dld_gtkuicmd_modify_proxy(can_refresh, proxy);
			break;
		
		default:
			dprintf("[dld_gtkui_callback] Unknown UICMD = %d\r\n", uicmd);
			break;
	}
	
	va_end (ap);
	
	if(can_refresh)
		gdk_threads_leave();

	return ret;
}





INT dld_gtkui_taskprop(GtkWidget *taskdialog)
{
	DldTask *task;	
	//GValue value={0,};
	
	CHAR *url, *newname, *localdir, *username, *password, *dir, *reference, *comment, *proxy;
	gchar localfile[1024];
	gint threadnumber;
	BOOL allowrename, start;
	
	url = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_url")));
	reference = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_reference")));
	localdir = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_localdir")));
	newname = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_rename")));
	username = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_username")));
	password = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_password")));
	dir = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "combo_category_text")));
	proxy = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "combo_proxy_text")));
	comment = (CHAR *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(taskdialog, "text_comment")));
	
	threadnumber = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(taskdialog, "spin_threads")));
	allowrename = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(taskdialog, "check_force_rename")));
	start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(taskdialog, "check_immediately")));
	
	if(localdir == NULL || strlen(localdir) == 0)
		localdir = os_get_home_dir();
	
	snprintf(localfile, sizeof(localfile), "%s/%s", localdir, newname);
	
	//g_object_get_property(G_OBJECT(taskdialog), "task", &value);
	task = g_ui_curmodifytask;
	if(!task)
	{
		//we need to add a new task
		task = dld_task_new(url, reference, localfile, username, password, dir, threadnumber, allowrename);
		
		dld_task_set_proxy(task, proxy);
		dld_task_set_comment(task, comment);
	
		dld_taskmgr_add_task(task);
		
		dld_config_write(NULL, "lastproxy", proxy);
		dld_config_write(NULL, "lastusername", username);
		dld_config_write(NULL, "lastpassword", password);
		dld_config_write(NULL, "lastcategory", dir);
		
		dld_config_write_int(NULL, "lastthreadnumber", threadnumber);
		dld_config_write_int(NULL, "lastallowrename", allowrename);
		dld_config_write_int(NULL, "lastimmediately", start);		
		
		if(start)
			dld_task_start(task);
		else
			dld_task_stop(task);
	}
	else
	{
		//we should modify the existed task
		dld_task_set_localfile(task, localfile);
		
		dld_task_set_dir(task, dir);
		dld_task_set_allowrename(task, allowrename);
		dld_task_set_username(task, username);
		dld_task_set_password(task, password);
		dld_task_set_url(task, url, TRUE);  //allow rename now (once)
		dld_task_set_reference(task, reference);
		dld_task_set_threadnumber(task, threadnumber);
		
		dld_task_set_proxy(task, proxy);
		dld_task_set_comment(task, comment);
		
		dld_gtkuicmd_modify_task(FALSE, task);
		
		if(start)
			dld_task_start(task);
		else
			dld_task_stop(task);

	}
	return DLD_ERR_OK;
}


INT dld_gtkui_new_dir(GtkWidget *dirdialog)
{
	//G_CONST_RETURN 
	gchar *name, *path;
	name = (gchar *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(dirdialog, "text_name")));	
	path = (gchar *)gtk_entry_get_text(GTK_ENTRY(lookup_widget(dirdialog, "text_path")));	
	
	
	dld_taskdir_add_dir(name, path);
	
	return DLD_ERR_OK;
}


INT dld_gtkui_set_global_config(GtkWidget *optdialog)
{
	g_config.timeout = 1000 * atoi(gtk_entry_get_text(GTK_ENTRY(lookup_widget(optdialog, "text_timeout"))));	
	g_config.speedrate = 1024 * atoi(gtk_entry_get_text(GTK_ENTRY(lookup_widget(optdialog, "text_speedrate"))));		
	g_config.maxtasks = atoi(gtk_entry_get_text(GTK_ENTRY(lookup_widget(optdialog, "text_maxtasks"))));	
	g_config.maxretries = atoi(gtk_entry_get_text(GTK_ENTRY(lookup_widget(optdialog, "text_maxretries"))));	
	g_config.retrydelay = 1000 * atoi(gtk_entry_get_text(GTK_ENTRY(lookup_widget(optdialog, "text_retrydelay"))));	
	g_config.tellme = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(optdialog, "check_tellme")));	
	
	dld_taskmgr_save_global_config();
	
	return DLD_ERR_OK;
}

INT dld_gtkui_select_taskdir(DldTaskDir *taskdir)
{
	LIST *l;
	DldTask *task;
	
	//dprintf("[dld_gtkui_select_taskdir] UNFINISHED!!!!!!\r\n");
	gtk_list_store_clear(treeview_tasks_store);
	for(l=g_tasks; l != NULL; l = list_next(l))
	{
		task = (DldTask *)l->data;
		dld_gtkuicmd_add_task(FALSE, task);
	}
	//dld_gtkui_redraw(treeview_dirs);
	
	return DLD_ERR_OK;
}

INT dld_gtkui_select_task(DldTask *task)
{
	LIST *l;
	DldTaskThread *dldthread;
	GtkTreeIter iter;
	
	//dld_task_lock(task);
	g_ui_curtaskthread = NULL;
	g_ui_curtask = task;
	
	gtk_list_store_clear(treeview_infos_store);
	
	if(g_ui_curtask)
	{
		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, NULL,
							TREEVIEW_INFOS_COL_TITLE, _("Main Log"),
							-1);
		
		for(l = task->taskthreads; l != NULL; l = list_next(l))
		{
			dldthread = (DldTaskThread *)l->data;
			dld_gtkuicmd_add_taskthread(FALSE, dldthread);
		}
		
	}
	
	dld_gtkui_draw_blocks(task);
	dld_gtkui_select_taskthread(NULL);
	
	//dld_task_unlock(task);
	return DLD_ERR_OK;
}


INT dld_gtkui_select_taskthread(DldTaskThread *dldthread)
{
	GtkTextBuffer *textbuffer;
	GtkTextIter startiter, enditer;
	LIST *l;
	DldLogMsg *logmsg;
	DldTask *task;
	DldLog *log;
	
	g_ui_curtaskthread = dldthread;
	
	if(dldthread)
		task = dldthread->parenttask;
	else
		task = g_ui_curtask;
	
	
	//dld_task_lock(task);
	//os_lock_lock(infolock);
	
	textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(textview_info));
	gtk_text_buffer_get_start_iter (textbuffer, &startiter);
	gtk_text_buffer_get_end_iter (textbuffer, &enditer);
	
	gtk_text_buffer_delete(textbuffer, &startiter, &enditer);
	
	gtk_text_buffer_get_start_iter (textbuffer, &startiter);
	gtk_text_buffer_get_end_iter (textbuffer, &enditer);

	if(!task) return DLD_ERR_NULLPOINTER;	
		
	if(dldthread) 
	{
		log = dldthread->log;
		dld_log_lock(log);
		
		l = dldthread->log->logs;
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, &enditer, _("Thread Log :\r\n"), -1,
												"info",
												NULL);		
	}
	else
	{
		log = task->log;
		dld_log_lock(log);
		
		l = task->log->logs;
		gtk_text_buffer_insert_with_tags_by_name(textbuffer, &enditer, _("Main Log :\r\n"), -1,
												"info",
												NULL);
	}
	for(; l!=NULL; l = list_next(l))
	{
		logmsg = (DldLogMsg *)l->data;
		dld_gtkui_add_log(textbuffer, &enditer, logmsg);
	}
	
	gtk_text_buffer_get_end_iter (textbuffer, &enditer);
	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview_info), &enditer, 0.0, FALSE, 0.0, 1.0);
	
	dld_log_unlock(log);
	
	return DLD_ERR_OK;

}