fsched.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 "fsched.h"
#include "../schedule.h"
#include "../var.h"
#include "../ntlocale.h"
#include "misc.h"
#include "mywidget.h"
#include "edit.h"

GtkWidget *d4x_scheduler_window=(GtkWidget *)NULL;
GtkTreeView *d4x_scheduler_view=(GtkTreeView *)NULL;
GtkListStore *d4x_scheduler_store=(GtkListStore *)NULL;

/*
static void d4x_scheduler_select(GtkWidget *clist, gint row, gint column,
				 GdkEventButton *event) {
	if (event && event->type==GDK_2BUTTON_PRESS && event->button==1)
};
*/

static char *action_names[]={
	N_("limit speed"),
	N_("popup main window"),
	N_("exit"),
	N_("remove completed"),
	N_("remove failed"),
	N_("restart download"),
	N_("stop download"),
	N_("remove download"),
	N_("remove download if completed"),
	N_("add download"),
	N_("save list"),
	N_("execute command")
};

void d4x_scheduler_insert(d4xSchedAction *act,d4xSchedAction *prev){
	if (d4x_scheduler_window==NULL) return;
	char *text[3];
	char buf[MAX_LEN];
	char buf2[MAX_LEN];
	struct tm tm_time;
	*buf2=0;
	localtime_r(&(act->start_time),&tm_time);
	strftime(buf,MAX_LEN,"%T %d %b %Y",&tm_time);
	text[0]=buf;
	text[1]=_(action_names[act->type()]);
	text[2]=buf2;
	switch(act->type()){
	case SACT_EXECUTE:{
		d4xSAExecute *a=(d4xSAExecute *)act;
		g_snprintf(buf2,MAX_LEN,"%s",a->command.get());
		break;
	};
	case SACT_SAVE_LIST:{
		d4xSASaveList *a=(d4xSASaveList *)act;
		g_snprintf(buf2,MAX_LEN,"%s",a->path.get());
		break;
	};
	case SACT_SET_SPEED:{
		d4xSASpeed *a=(d4xSASpeed *)act;
		sprintf(buf2,"%s",_(SPEED_LIMITATIONS_NAMES[a->speed]));
		break;
	};
	case SACT_ADD_DOWNLOAD:{
		d4xSAAddDownload *a=(d4xSAAddDownload *)act;
		if (a->dwn && a->dwn->info){
			char *url=a->dwn->info->url();
			g_snprintf(buf2,MAX_LEN,"%s",url);
			delete[] url;
		};
		break;
	};
	case SACT_DEL_IF_COMPLETED:
	case SACT_DELETE_DOWNLOAD:
	case SACT_RUN_DOWNLOAD:
	case SACT_PAUSE_DOWNLOAD:{
		d4xSAUrl *a=(d4xSAUrl *)act;
		if (a->url){
			char *url=a->url->url();
			g_snprintf(buf2,MAX_LEN,"%s",url);
			delete[] url;
		};
		break;
	};
	};
	GtkTreeIter iter;
	if (prev)
		gtk_list_store_insert_after(d4x_scheduler_store,&iter,prev->iter);
	else
		gtk_list_store_insert_after(d4x_scheduler_store,&iter,NULL);
	gtk_list_store_set(d4x_scheduler_store, &iter,
			   0,text[0],
			   1,text[1],
			   2,text[2],
			   3,act,
			   -1);
	if (act->iter) gtk_tree_iter_free(act->iter);
	act->iter=gtk_tree_iter_copy(&iter);
};

void d4x_scheduler_remove(d4xSchedAction *act){
	if (d4x_scheduler_window==NULL) return;
	gtk_list_store_remove(d4x_scheduler_store,act->iter);
};

static gint compare_nodes2(gconstpointer a,gconstpointer b){
    gint aa=GPOINTER_TO_INT(a);
    gint bb=GPOINTER_TO_INT(b);
    if (aa>bb) return -1;
    if (aa==bb) return 0;
    return 1;
};

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

void d4x_scheduler_remove_selected(){
	if (d4x_scheduler_window==NULL) return;
	GtkTreeSelection *s=gtk_tree_view_get_selection(d4x_scheduler_view);
	tQueue q;
	gtk_tree_selection_selected_foreach(s,
					    _foreach_remove_prepare_,
					    &q);
	tNode *t=q.last();
	while(t){
		GValue val={0,};
		gtk_tree_model_get_value(GTK_TREE_MODEL(d4x_scheduler_store),((tmpIterNode*)t)->iter,3,&val);
		d4xSchedAction *act=(d4xSchedAction *)g_value_get_pointer(&val);
		g_value_unset(&val);
		MainScheduler->del_action(act);
		t=t->next;
	};
};

gint d4x_scheduler_close() {
	if (!d4x_scheduler_window) return(FALSE);
	gtk_widget_destroy(d4x_scheduler_window);
	d4x_scheduler_window=(GtkWidget *)NULL;
	return(TRUE);
};

void d4x_scheduler_init_editor(){
	GtkWidget *tmp=my_gtk_aeditor_new();
//	MyGtkAEditor *editor=MY_GTK_AEDITOR(tmp);

	gtk_widget_show_all(tmp);
	gtk_window_set_modal (GTK_WINDOW(tmp),TRUE);
	gtk_window_set_transient_for (GTK_WINDOW (tmp), GTK_WINDOW (d4x_scheduler_window));
};

static GtkTreeIter *_sel_iter_=(GtkTreeIter *)NULL;

static void _foreach_edit_prepare_(GtkTreeModel *model,GtkTreePath *path,
				   GtkTreeIter *iter,gpointer p){
	if (_sel_iter_) gtk_tree_iter_free(_sel_iter_);
	_sel_iter_=gtk_tree_iter_copy(iter);
};

void d4x_scheduler_edit(){
	if (d4x_scheduler_window==NULL) return;
	GtkTreeSelection *s=gtk_tree_view_get_selection(d4x_scheduler_view);
	gtk_tree_selection_selected_foreach(s,
					    _foreach_edit_prepare_,
					    NULL);
	if (_sel_iter_){
		GValue val={0,};
		gtk_tree_model_get_value(GTK_TREE_MODEL(d4x_scheduler_store),_sel_iter_,3,&val);
		d4xSchedAction *act=(d4xSchedAction *)g_value_get_pointer(&val);
		g_value_unset(&val);
		if (act && act->lock==0){
			act->lock=1;
			GtkWidget *tmp=my_gtk_aeditor_new(act);
			gtk_widget_show_all(tmp);
			gtk_window_set_modal (GTK_WINDOW(tmp),TRUE);
			gtk_window_set_transient_for (GTK_WINDOW (tmp), GTK_WINDOW (d4x_scheduler_window));
		};
		gtk_tree_iter_free(_sel_iter_);
	};
	_sel_iter_=(GtkTreeIter *)NULL;
};

gint d4x_scheduler_select(GtkWidget *widget, gint row, gint column,
			  GdkEventButton *event, gpointer data,
			  gpointer nothing){
	if (event && event->type==GDK_2BUTTON_PRESS && event->button==1){
		d4x_scheduler_edit();
	};
	return(TRUE);
};

void d4x_scheduler_init(){
	if (d4x_scheduler_window) {
		gdk_window_show(d4x_scheduler_window->window);
		return;
	};
	d4x_scheduler_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW (d4x_scheduler_window),
			     _("Scheduler"));
	gtk_window_set_wmclass(GTK_WINDOW(d4x_scheduler_window),
			       "D4X_Scheduler","D4X");
	gtk_window_set_position(GTK_WINDOW(d4x_scheduler_window),GTK_WIN_POS_CENTER);
	gtk_widget_set_size_request(d4x_scheduler_window,-1,400);
	gtk_container_set_border_width(GTK_CONTAINER(d4x_scheduler_window),5);
	gchar *titles[]={_("Time"),_("Action"),_("Info")};
	GtkListStore *list_store = gtk_list_store_new(4,
						      G_TYPE_STRING,
						      G_TYPE_STRING,
						      G_TYPE_STRING,
						      G_TYPE_POINTER);
	d4x_scheduler_store=list_store;
	d4x_scheduler_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)));
	gtk_tree_view_set_headers_visible(d4x_scheduler_view,TRUE);
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *col;
	for (int i=0;i<3;i++){
		renderer = gtk_cell_renderer_text_new();
		col=gtk_tree_view_column_new_with_attributes(_(titles[i]),
							     renderer,
							     "text",i,
							     NULL);
		gtk_tree_view_column_set_visible(col,TRUE);
		gtk_tree_view_append_column(d4x_scheduler_view,col);
	};

//	gtk_clist_set_selection_mode(GTK_CLIST(d4x_scheduler_clist),GTK_SELECTION_EXTENDED);
//	g_signal_connect(G_OBJECT(d4x_scheduler_clist), "select_row",
//	                   G_CALLBACK(d4x_scheduler_select),NULL);

	GtkWidget *scroll_window=gtk_scrolled_window_new((GtkAdjustment *)NULL,(GtkAdjustment *)NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
	                                GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(scroll_window),GTK_WIDGET(d4x_scheduler_view));
	GtkWidget *button=gtk_button_new_with_label(_("Ok"));
	GtkWidget *add_button=gtk_button_new_with_label(_("New"));
	GtkWidget *edit_button=gtk_button_new_with_label(_("Edit"));
	GtkWidget *del_button=gtk_button_new_with_label(_("Remove"));
	GTK_WIDGET_SET_FLAGS(button,GTK_CAN_DEFAULT);
	GTK_WIDGET_SET_FLAGS(edit_button,GTK_CAN_DEFAULT);
	GTK_WIDGET_SET_FLAGS(add_button,GTK_CAN_DEFAULT);
	GTK_WIDGET_SET_FLAGS(del_button,GTK_CAN_DEFAULT);
	GtkWidget *vbox=gtk_vbox_new(FALSE,0);
	GtkWidget *hbox=gtk_hbutton_box_new();
	gtk_box_set_spacing(GTK_BOX(vbox),5);
	gtk_box_set_spacing(GTK_BOX(hbox),3);
	gtk_box_pack_start(GTK_BOX(vbox),scroll_window,TRUE,TRUE,0);
	gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
	gtk_box_pack_end(GTK_BOX(hbox),add_button,FALSE,FALSE,0);
	gtk_box_pack_end(GTK_BOX(hbox),del_button,FALSE,FALSE,0);
	gtk_box_pack_end(GTK_BOX(hbox),edit_button,FALSE,FALSE,0);
	gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,0);
	gtk_container_add(GTK_CONTAINER(d4x_scheduler_window),vbox);
	gtk_window_set_default(GTK_WINDOW(d4x_scheduler_window),button);
	MainScheduler->redraw();
	gtk_widget_show_all(d4x_scheduler_window);

	g_signal_connect(G_OBJECT(d4x_scheduler_window),"delete_event",G_CALLBACK(d4x_scheduler_close), NULL);
	g_signal_connect(G_OBJECT(add_button),"clicked",G_CALLBACK(d4x_scheduler_init_editor),NULL);
	g_signal_connect(G_OBJECT(del_button),"clicked",G_CALLBACK(d4x_scheduler_remove_selected),NULL);
	g_signal_connect(G_OBJECT(edit_button),"clicked",G_CALLBACK(d4x_scheduler_edit),NULL);
	g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(d4x_scheduler_close),NULL);
	d4x_eschandler_init(d4x_scheduler_window,NULL);
};

/*********************************************************************/

static GtkWidgetClass *parent_class = (GtkWidgetClass *)NULL;

static void my_gtk_aeditor_edit_ok(GtkWidget *widget,MyGtkAEditor *editor){
	tDownload *what=editor->dwn;
	what->editor->apply_changes();
	what->delete_editor();
	char *url=what->info->url();
	text_to_combo(editor->url_entry,url);
	delete[] url;
};

static void my_gtk_aeditor_edit_download(GtkWidget *widget,MyGtkAEditor *editor){
	tDownload *what;
	int flag=0;
	if (editor->dwn==NULL){
		editor->dwn=new tDownload;
		char *url_entry_cont=text_from_combo(editor->url_entry);
		editor->dwn->info=new tAddr(url_entry_cont);
		if (url_entry_cont==NULL || *url_entry_cont==0)
			flag=1;
	};
	if (editor->dwn->config==NULL){
		editor->dwn->config=new tCfg;
		editor->dwn->set_default_cfg();
		editor->dwn->config->save_path.set(CFG.GLOBAL_SAVE_PATH);
	};
	what=editor->dwn;
	init_edit_window_without_ok(what,1);
	what->editor->disable_time();