qtree.cc

一个功能比较强的下载软件

/*	WebDownloader for X-Window
 *	Copyright (C) 1999-2002 Koshelev Maxim
 *	This Program is free but not GPL!!! You can't modify it
 *	without agreement with author. You can't distribute modified
 *	program but you can distribute unmodified program.
 *
 *	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.
 */

#include "qtree.h"
#include "list.h"
#include "misc.h"
#include "colors.h"
#include "../ntlocale.h"
#include "../main.h"
#include "../var.h"
#include "mywidget.h"
#include "buttons.h"

enum {
	QROW_NAME,
	QROW_TOTAL,
	QROW_WAIT,
	QROW_RUN,
	QROW_QUEUE,
	QROW_LAST
};

extern tMain aa;

static gint _event_queue_(GtkWidget *widget,GdkEventButton *event,d4xQsTree *q){
	if (event->type==GDK_BUTTON_PRESS && event->button==3) {
		GtkTreeSelection *sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
		GtkTreePath *path=NULL;
		if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
						  gint(event->x),
						  gint(event->y),
						  &path,
						  NULL,NULL,NULL)){
			gtk_tree_selection_select_path(sel,path);
			gtk_tree_path_free(path);
			q->popup_menu((GdkEvent*)event,1);
		}else{
			q->popup_menu((GdkEvent*)event,0);
			gtk_tree_selection_unselect_all(sel);
		};
		return TRUE;
	};
	return FALSE;
};

static void _menu_event_(d4xQsTree *qt,guint action,GtkWidget *widget){
	switch(action){
	case 0:
		qt->create_init();
		break;
	case 1:
		qt->create_init(1);
		break;
	case 2:
		qt->delete_queue();
		break;
	case 3:
		qt->prefs_init();
		break;
	};
};

static void _create_cancel_(GtkButton *button,d4xQsTree *qt){
	qt->create_cancel();
};

static void _create_ok_(GtkWidget *widget,d4xQsTree *qt){
	qt->create_ok();
};

static void _create_delete_(GtkWidget *window,GdkEvent *event,d4xQsTree *qt){
	qt->create_cancel();
};

static void _create_changed_(GtkWidget *entry,GtkWidget *ok_button){
	if (strlen(text_from_combo(entry)))
		gtk_widget_set_sensitive(ok_button,TRUE);
	else
		gtk_widget_set_sensitive(ok_button,FALSE);
};

void d4xQsTree::create_ok(){
	d4xDownloadQueue *papa=NULL;
	if (create_mode)
		papa=selected();
	char *name=text_from_combo(dialog_entry);
	create_new_queue(name,papa);
	create_cancel();
};

void d4xQsTree::create_cancel(){
	gtk_widget_destroy(dialog);
	dialog=NULL;
};

void d4xQsTree::create_init(int mode){
	if (dialog){
		gdk_window_show(dialog->window);
		return;
	};
	create_mode=mode;
	dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_wmclass(GTK_WINDOW(dialog),
			       "D4X_CreateQueueDialog","D4X");
	gtk_window_set_title(GTK_WINDOW (dialog),
			     _("Create new queue"));
	gtk_window_set_position(GTK_WINDOW(dialog),
				GTK_WIN_POS_CENTER);
	gtk_container_set_border_width(GTK_CONTAINER(dialog),5);
	GtkWidget *vbox=gtk_vbox_new(FALSE,0);
	GtkWidget *hbox=gtk_hbutton_box_new();
	gtk_box_set_spacing(GTK_BOX(vbox),5);
	dialog_entry=gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(vbox),dialog_entry,FALSE,FALSE,0);
	gtk_box_set_spacing(GTK_BOX(hbox),5);
	GtkWidget *ok_button=gtk_button_new_with_label(_("Ok"));
	GtkWidget *cancel_button=gtk_button_new_with_label(_("Cancel"));
	GTK_WIDGET_SET_FLAGS(ok_button,GTK_CAN_DEFAULT);
	GTK_WIDGET_SET_FLAGS(cancel_button,GTK_CAN_DEFAULT);
	gtk_widget_set_sensitive(ok_button,FALSE);
	gtk_box_pack_start(GTK_BOX(hbox),ok_button,FALSE,FALSE,0);
	gtk_box_pack_start(GTK_BOX(hbox),cancel_button,FALSE,FALSE,0);
	gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
	g_signal_connect(G_OBJECT (dialog_entry),"changed",
			   (GtkSignalFunc)_create_changed_, ok_button);
	g_signal_connect(G_OBJECT(ok_button),"clicked",
			   G_CALLBACK(_create_ok_),this);
	g_signal_connect(G_OBJECT(cancel_button),"clicked",
			   G_CALLBACK(_create_cancel_),this);
	g_signal_connect(G_OBJECT(dialog),"delete_event",
			   G_CALLBACK(_create_delete_),this);
	g_signal_connect(G_OBJECT(dialog_entry), "activate",
			   G_CALLBACK (_create_ok_), this);
	d4x_eschandler_init(dialog,this);
	gtk_container_add(GTK_CONTAINER(dialog),vbox);
	gtk_widget_show_all(dialog);
	gtk_window_set_default(GTK_WINDOW(dialog),ok_button);
	gtk_widget_grab_focus(dialog_entry);
	gtk_window_set_modal (GTK_WINDOW(dialog),TRUE);
	gtk_window_set_transient_for (GTK_WINDOW (dialog),
				      GTK_WINDOW (MainWindow));
};


static gboolean target_drag_drop (GtkTreeView        *view,
				  GdkDragContext     *context,
				  gint                x,
				  gint                y,
				  guint               time,
				  d4xQsTree *qt){
	GtkTreePath *path=NULL;
	if (context->targets &&
	    gtk_tree_view_get_path_at_pos(view,x,y,&path,NULL,NULL,NULL)){
		GtkTreeModel *model=gtk_tree_view_get_model(view);
		GtkTreeIter iter;
		if (gtk_tree_model_get_iter(model,&iter,path))
			if (qt->drop_to_row) gtk_tree_iter_free(qt->drop_to_row);
			qt->drop_to_row=gtk_tree_iter_copy(&iter);
			gtk_drag_get_data (GTK_WIDGET(view), context,
					   GDK_POINTER_TO_ATOM (context->targets->data),
					   time);
		gtk_tree_path_free(path);
		return TRUE;
	};
	if (qt->drop_to_row) gtk_tree_iter_free(qt->drop_to_row);
	qt->drop_to_row=NULL;
	return FALSE;
};

static void _foreach_move_prepare_(GtkTreeModel *model,GtkTreePath *path,
				   GtkTreeIter *iter,gpointer p){
	tQueue *q=(tQueue*)p;
	tmpIterNode *i=new tmpIterNode(iter);
	q->insert(i);
};

tDownload * d4xQsTree::get_download(GtkTreeView *view,GtkTreeIter *iter){
	GtkListStore *list_store=GTK_LIST_STORE(gtk_tree_view_get_model(view));
	GValue val={0,};
	gtk_tree_model_get_value(GTK_TREE_MODEL(list_store),iter,
				 NOTHING_COL,&val);
	tDownload *what=(tDownload *)g_value_get_pointer(&val);
	g_value_unset(&val);
	return (what);
};

void d4xQsTree::drop_from(GtkTreeView *src_view){
	drag_motion(NULL);
	if (drop_to_row==NULL) return;

	tQueue q;
	GtkTreeSelection *sel=gtk_tree_view_get_selection(src_view);
	gtk_tree_selection_selected_foreach(sel,
					    _foreach_move_prepare_,
					    &q);
	tNode *t=q.last();
	if (t==NULL) return;
	tDownload *temp=get_download(src_view,((tmpIterNode*)t)->iter);
	d4xDownloadQueue *src=temp->myowner->PAPA;
	if (src==NULL) return;
	GValue val={0,};
	gtk_tree_model_get_value(GTK_TREE_MODEL(store),drop_to_row,
				 QROW_QUEUE,&val);
	d4xDownloadQueue *dst=(d4xDownloadQueue *)g_value_get_pointer(&val);
	g_value_unset(&val);
	
	if (dst && dst!=src){
		while(t){
			tDownload *temp=get_download(src_view,((tmpIterNode*)t)->iter);
			int type=temp->owner();
			src->del(temp);
			src->qv.remove(temp);
			dst->add(temp,type);
			dst->qv.add(temp);
			t=t->next;
		};
		aa.try_to_run_wait(dst);
		aa.try_to_run_wait(src);
		prepare_buttons();
	};
};

void d4xQsTree::drag_motion(GtkTreeIter *iter){
	if (row_to_color){
		gtk_tree_store_set(store,row_to_color,
				   QROW_LAST,FALSE,
				   -1);
		gtk_tree_iter_free(row_to_color);
	};
	if (iter==NULL){
		row_to_color=NULL;
	}else{
		row_to_color=gtk_tree_iter_copy(iter);
		gtk_tree_store_set(store,row_to_color,
				   QROW_LAST,TRUE,
				   -1);
	};
};

static gboolean target_drag_motion (GtkTreeView *view,
				    GdkDragContext *context,
				    gint x,gint y,
				    guint time,
				    d4xQsTree *qt){

	GtkTreeIter iter;
	GtkTreePath *path=NULL;
	if (context->targets &&
	    gtk_tree_view_get_path_at_pos(view,x,y,&path,NULL,NULL,NULL)){
		GtkTreeModel *model=gtk_tree_view_get_model(view);
		if (gtk_tree_model_get_iter(model,&iter,path))
			qt->drag_motion(&iter);
		gtk_tree_path_free(path);
		return TRUE;
	};
	qt->drag_motion(NULL);
	return FALSE;
};

static void target_drag_data_received  (GtkWidget *widget,
					GdkDragContext     *context,
					gint                x,
					gint                y,
					GtkSelectionData   *data,
					guint               info,
					guint               time,
					d4xQsTree *qt){
	if ((data->length == sizeof(GtkWidget *)) && (data->format == 8)){
		GtkTreeView **src_view=NULL;
		src_view=(GtkTreeView **)(data->data);
		if (src_view && *src_view){
			qt->drop_from(*src_view);
		};
		gtk_drag_finish (context, TRUE, FALSE, time);
		return;
	}
	gtk_drag_finish (context, FALSE, FALSE, time);
};

static GtkTargetEntry ltarget_table[] = {
	{ "d4x/dpointer",     0, 0 }
};

static guint ln_targets = sizeof(ltarget_table) / sizeof(ltarget_table[0]);

static void target_drag_leave(GtkWidget *widget,GdkDragContext *context, guint time,d4xQsTree *qt){
	qt->drag_motion(NULL);
}

static gboolean d4x_qstree_select_func(GtkTreeSelection *sel, GtkTreeModel *model,GtkTreePath *path,
				       gboolean is_sel, gpointer data){
	if (!is_sel){
		d4xQsTree *qt=(d4xQsTree*)data;
		GtkTreeIter iter;
		gtk_tree_model_get_iter(model,&iter,path);
		qt->select_row(&iter);
	};
	return(TRUE);
};

void d4xQsTree::init(){
	store=gtk_tree_store_new(QROW_LAST+1,
				 G_TYPE_STRING,  //name
				 G_TYPE_INT,     //Total
				 G_TYPE_INT,     //Wait
				 G_TYPE_STRING,  //Run 
				 G_TYPE_POINTER,
				 G_TYPE_BOOLEAN);//queue
	view=GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)));
	GtkTreeSelection *sel=gtk_tree_view_get_selection(view);
	gtk_tree_selection_set_select_function(sel,d4x_qstree_select_func,this,NULL);
	gtk_tree_view_set_headers_visible(view,FALSE);
	GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
	g_object_set (G_OBJECT (renderer),"background-gdk", &BLUE,NULL);
	g_object_set (G_OBJECT (renderer),"foreground-gdk", &WHITE,NULL);
	GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes ("Name",
									      renderer,
									      "text",QROW_NAME,
									      "background_set", QROW_LAST,
									      "foreground_set", QROW_LAST,
									      NULL);
	gtk_tree_view_append_column(view, column);
	
	renderer = gtk_cell_renderer_text_new ();
	g_object_set (G_OBJECT (renderer),"background-gdk", &BLUE,NULL);
	g_object_set (G_OBJECT (renderer),"foreground-gdk", &WHITE,NULL);
	column = gtk_tree_view_column_new_with_attributes ("Total",
							   renderer,
							   "text",QROW_TOTAL,
							   "background_set", QROW_LAST,
							   "foreground_set", QROW_LAST,
							   NULL);
	gtk_tree_view_append_column(view, column);
	
	renderer = gtk_cell_renderer_text_new ();
	g_object_set (G_OBJECT (renderer),"background-gdk", &BLUE,NULL);
	g_object_set (G_OBJECT (renderer),"foreground-gdk", &WHITE,NULL);
	column = gtk_tree_view_column_new_with_attributes ("Wait",
							   renderer,
							   "text",QROW_WAIT,
							   "background_set", QROW_LAST,
							   "foreground_set", QROW_LAST,
							   NULL);
	gtk_tree_view_append_column(view, column);

	renderer = gtk_cell_renderer_text_new ();
	g_object_set (G_OBJECT (renderer),"background-gdk", &BLUE,NULL);
	g_object_set (G_OBJECT (renderer),"foreground-gdk", &WHITE,NULL);
	column = gtk_tree_view_column_new_with_attributes ("Run",
							   renderer,
							   "text",QROW_RUN,
							   "background_set", QROW_LAST,
							   "foreground_set", QROW_LAST,
							   NULL);
	gtk_tree_view_append_column(view, column);