lod.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 <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "lod.h"
#include "log.h"
#include "buttons.h"
#include "list.h"
#include "lmenu.h"
#include "addd.h"
#include "misc.h"
#include "about.h"
#include "dndtrash.h"
#include "../ntlocale.h"
#include "../locstr.h"
#include "../main.h"
#include "../var.h"
#include "../xml.h"
#include "colors.h"
#include <gdk-pixbuf/gdk-pixbuf.h>

tConfirmedDialog *AskOpening=(tConfirmedDialog *)NULL;

//GdkPixmap *list_of_downloads_pixmaps[PIX_UNKNOWN];
//GdkBitmap *list_of_downloads_bitmaps[PIX_UNKNOWN];
GdkPixbuf *list_of_downloads_pixbufs[PIX_UNKNOWN];

GdkBitmap *wait_mask,*stop_mask,*pause_mask,*complete_mask,*run_mask,*part_run_mask,*run_bad_mask,*stop_wait_mask;
GdkPixmap *wait_pixmap=(GdkPixmap *)NULL,*stop_pixmap=(GdkPixmap *)NULL,*pause_pixmap=(GdkPixmap *)NULL,*complete_pixmap=(GdkPixmap *)NULL;
GdkPixmap *run_pixmap=(GdkPixmap *)NULL,*part_run_pixmap=(GdkPixmap *)NULL,*run_bad_pixmap=(GdkPixmap *)NULL,*stop_wait_pixmap=(GdkPixmap *)NULL;

static gchar *ListTitles[]={
	" ",
	N_("File"),
	N_("Type"),
	N_("Full Size"),
	N_("Downloaded"),
	N_("Rest"),
	"%",
	N_("Speed"),
	N_("Time"),
	N_("Remaining"),
	N_("Pause"),
	N_("Attempt"),
	N_("Description"),
	N_("URL"),
	" "
};

static GtkWidget *LoDSelectWindow=(GtkWidget *)NULL;
static GtkWidget *LoDSelectEntry;
static int LoDSelectType=0;

/* functions to store list ordering when run without interface */

#define _INIT_QVP_(arg,arg1) cols[arg].type=arg;cols[arg].size=arg1;cols[arg].visible=1;

d4xQVPrefs::d4xQVPrefs(){
	_INIT_QVP_(STATUS_COL,25);
	_INIT_QVP_(FILE_COL,100);
	_INIT_QVP_(FILE_TYPE_COL,40);
	_INIT_QVP_(FULL_SIZE_COL,70);
	_INIT_QVP_(DOWNLOADED_SIZE_COL,70);
	_INIT_QVP_(REMAIN_SIZE_COL,70);
	_INIT_QVP_(PERCENT_COL,30);
	_INIT_QVP_(SPEED_COL,60);
	_INIT_QVP_(TIME_COL,60);
	_INIT_QVP_(ELAPSED_TIME_COL,60);
	_INIT_QVP_(PAUSE_COL,40);
	_INIT_QVP_(TREAT_COL,40);
	_INIT_QVP_(DESCRIPTION_COL,100);
	_INIT_QVP_(URL_COL,500);
	_INIT_QVP_(NOTHING_COL,0);
};

extern d4xQVPrefs QV_PREFS;

d4xQueueView::d4xQueueView(){
	LoDSortFlag=NOTHING_COL;
/*
	for (int i=0;i<=NOTHING_COL;i++){
		prefs.cols[i].size=QV_PREFS.cols[i].size;
		prefs.cols[i].type=QV_PREFS.cols[i].type;
		prefs.cols[i].enum_index=QV_PREFS.cols[i].enum_index;
	};
*/
	ListOfDownloads=NULL;
};

d4xQueueView::~d4xQueueView(){
	if (ListOfDownloads)
		g_object_unref(G_OBJECT(ListOfDownloads));
};

void d4xQueueView::remove_wf(tDownload *what){
	d4xWFNode *node=(d4xWFNode *)(what->WFP);
	if (last_selected==what) last_selected=NULL;
	if (node){
		ALL_DOWNLOADS->lock();
		ListOfDownloadsWF.del(node);
		ALL_DOWNLOADS->unlock();
		delete(node);
	};
	what->WFP=(tNode*)NULL;
};

void d4xQueueView::add_wf(tDownload *what){
	d4xWFNode *node=new d4xWFNode;
	node->dwn=what;
	what->WFP=node;
	ALL_DOWNLOADS->lock();
	ListOfDownloadsWF.insert(node);
	ALL_DOWNLOADS->unlock();
};

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

struct GtkCellRendererProgress{
	GtkCellRenderer parent;
	gfloat percent;
	tDownload *dwn;
};

struct GtkCellRendererProgressClass{
	GtkCellRendererClass parent_class;
};

GtkType          gtk_cell_renderer_progress_get_type (void);
GtkCellRenderer *gtk_cell_renderer_progress_new      (void);

static void gtk_cell_renderer_progress_init (GtkCellRendererProgress *cellpixbuf){
};

static void
gtk_cell_renderer_progress_get_size (GtkCellRenderer *cell,
				     GtkWidget       *widget,
				     GdkRectangle    *cell_area,
				     gint            *x_offset,
				     gint            *y_offset,
				     gint            *width,
				     gint            *height){
	if (x_offset) *x_offset = 0;
	if (y_offset) *y_offset = 0;
	if (cell_area){
		if (width) *width = cell_area->width-1;
		if (height) *height = cell_area->height-1;
	};
};

static void
gtk_cell_renderer_progress_get_property (GObject        *object,
					 guint           param_id,
					 GValue         *value,
					 GParamSpec     *pspec){
//	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
};

static void
gtk_cell_renderer_progress_set_property (GObject      *object,
					 guint         param_id,
					 const GValue *value,
					 GParamSpec   *pspec){
	GtkCellRendererProgress *renderer = (GtkCellRendererProgress *)object;
	switch (param_id){
	case 1:
		renderer->percent=g_value_get_float(value);
		break;
	case 2:
		renderer->dwn=(tDownload *)g_value_get_pointer(value);
		break;
	default:
//		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
		break;
	};
};

static void
gtk_cell_renderer_progress_render (GtkCellRenderer    *cell,
				   GdkWindow          *window,
				   GtkWidget          *widget,
				   GdkRectangle       *background_area,
				   GdkRectangle       *cell_area,
				   GdkRectangle       *expose_area,
				   GtkCellRendererState flags){
	char tmpc[100];
	float p=((GtkCellRendererProgress*)cell)->percent;

	if (p>99.0 && p<100.0)
		sprintf(tmpc,"%.1f",p);
	else
		sprintf(tmpc,"%.0f",p);
	PangoRectangle rect;
	PangoLayout *layout=gtk_widget_create_pango_layout (widget, tmpc);
	pango_layout_get_pixel_extents (layout, NULL, &rect);
	gint x=0,y=0;
	if (rect.width<cell_area->width)
		x=(cell_area->width-rect.width)/2;
	if (rect.height<cell_area->height)
		y=(cell_area->height-rect.height)/2;
	pango_layout_set_width (layout, -1);
	GtkStyle *style=gtk_widget_get_style(widget);
	if (CFG.PROGRESS_MODE==1 || CFG.PROGRESS_MODE==2){
		gtk_paint_box(style,window,
			      GTK_STATE_NORMAL,GTK_SHADOW_NONE,
			      cell_area,
			      widget,
			      "trough",
			      cell_area->x,cell_area->y,
			      cell_area->width,cell_area->height);
	};
	switch (CFG.PROGRESS_MODE){
	case 2:{
		if (p<=0) break;
		tDownload *temp=((GtkCellRendererProgress*)cell)->dwn;;
		if (temp && temp->segments && temp->finfo.size>0){
			temp->segments->lock_public();
			tSegment *tmp=temp->segments->get_first();
			while(tmp){
				gint start=int(float(tmp->begin)*float(cell_area->width)/float(temp->finfo.size));
				gint end=int(float(tmp->end)*float(cell_area->width)/float(temp->finfo.size));
				if (end-start>=2) //most themes is buggy to draw boxes with width less than 2 pixels!!!
					gtk_paint_box(style,window,
						      GTK_STATE_PRELIGHT,GTK_SHADOW_OUT,
						      cell_area,
						      widget,
						      "bar",
						      cell_area->x+start,cell_area->y,
						      end-start,cell_area->height);
				tmp=tmp->next;
			};
			temp->segments->unlock_public();
			break;
		};
	};
	case 1:
		if (p<=0) break;
		gtk_paint_box(style,window,
			      GTK_STATE_PRELIGHT,GTK_SHADOW_OUT,
			      cell_area,
			      widget,
			      "bar",
			      cell_area->x,cell_area->y,
			      int((cell_area->width*p)/100),cell_area->height);
	default:
		break;
	};
	gtk_paint_layout (widget->style,
			  window,
			  GTK_STATE_NORMAL,
			  TRUE,
			  cell_area,
			  widget,
			  "cellrenderertext",
			  cell_area->x +x + cell->xpad,
			  cell_area->y +y + cell->ypad,
			  layout);
	g_object_unref(G_OBJECT (layout));
//	printf("render: %f\n",);
};


static void gtk_cell_renderer_progress_class_init (GtkCellRendererProgressClass *klass){
	GObjectClass *object_class = G_OBJECT_CLASS (klass);
	GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);

	cell_class->get_size = gtk_cell_renderer_progress_get_size;
	cell_class->render = gtk_cell_renderer_progress_render;
	object_class->set_property = gtk_cell_renderer_progress_set_property;
	object_class->get_property = gtk_cell_renderer_progress_get_property;

	g_object_class_install_property (object_class, 1,
					 g_param_spec_float ("percent",
							     _("Percent"),
							     _("Percentage to render"),
							     0,100,0,
							     G_PARAM_READABLE));
	g_object_class_install_property (object_class, 2,
					 g_param_spec_pointer ("download",
							       _("Download"),
							       _("Link to tDownload"),
							       G_PARAM_READABLE));
};

GtkType gtk_cell_renderer_progress_get_type (void){
	static GtkType cell_progress_type = 0;

	if (!cell_progress_type)
	{
		static const GTypeInfo cell_progress_info =
		{
			sizeof (GtkCellRendererProgressClass),
			NULL,		/* base_init */
			NULL,		/* base_finalize */
			(GClassInitFunc) gtk_cell_renderer_progress_class_init,
			NULL,		/* class_finalize */
			NULL,		/* class_data */
			sizeof (GtkCellRendererProgress),
			0,              /* n_preallocs */
			(GInstanceInitFunc) gtk_cell_renderer_progress_init,
		};

		cell_progress_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
							     "GtkCellRendererProgress",
							     &cell_progress_info,
							     GTypeFlags(0));
	}

	return cell_progress_type;
}


GtkCellRenderer *gtk_cell_renderer_progress_new (void){
  return GTK_CELL_RENDERER (g_object_new (gtk_cell_renderer_progress_get_type (),NULL));
}

/***************************************************************/
gint lod_get_height() {
	if (!MAIN_PANED) return FALSE;
	CFG.WINDOW_CLIST_HEIGHT=GTK_PANED(MAIN_PANED)->child1_size;
	if (!MAIN_PANED1) return FALSE;
	CFG.WINDOW_TREE_WIDTH=GTK_PANED(MAIN_PANED1)->child1_size;
	return FALSE;
};

void lod_set_height() {
//	gtk_widget_set_size_request(ListOfDownloads,-1,gint(CFG.WINDOW_CLIST_HEIGHT));
	gtk_paned_set_position(GTK_PANED(MAIN_PANED),gint(CFG.WINDOW_CLIST_HEIGHT));
	gtk_paned_set_position(GTK_PANED(MAIN_PANED1),gint(CFG.WINDOW_TREE_WIDTH));
};


void lod_init_pixmaps(){
#include "pixmaps/wait_xpm.xpm"
#include "pixmaps/run_xpm.xpm"
#include "pixmaps/run1.xpm"
#include "pixmaps/run2.xpm"
#include "pixmaps/run3.xpm"
#include "pixmaps/run4.xpm"
#include "pixmaps/run5.xpm"
#include "pixmaps/run6.xpm"
#include "pixmaps/run7.xpm"
#include "pixmaps/run8.xpm"
#include "pixmaps/run_bad.xpm"
#include "pixmaps/run_bad1.xpm"
#include "pixmaps/run_bad2.xpm"
#include "pixmaps/run_bad3.xpm"
#include "pixmaps/run_bad4.xpm"
#include "pixmaps/run_bad5.xpm"
#include "pixmaps/run_bad6.xpm"
#include "pixmaps/run_bad7.xpm"
#include "pixmaps/run_bad8.xpm"
#include "pixmaps/run_part.xpm"
#include "pixmaps/run_part1.xpm"
#include "pixmaps/run_part2.xpm"
#include "pixmaps/run_part3.xpm"
#include "pixmaps/run_part4.xpm"
#include "pixmaps/run_part5.xpm"
#include "pixmaps/run_part6.xpm"
#include "pixmaps/run_part7.xpm"
#include "pixmaps/run_part8.xpm"
#include "pixmaps/stop_xpm.xpm"
#include "pixmaps/stop_wait.xpm"
#include "pixmaps/paused.xpm"
#include "pixmaps/complete.xpm"
	char *xml_names[]={
		"waitpix",
		"failedpix",
		"stopwaitpix",
		"runpix",
		"runpix1",
		"runpix2",
		"runpix3",
		"runpix4",
		"runpix5",
		"runpix6",
		"runpix7",
		"runpix8",
		"runbadpix",
		"runbadpix1",
		"runbadpix2",
		"runbadpix3",
		"runbadpix4",
		"runbadpix5",
		"runbadpix6",
		"runbadpix7",
		"runbadpix8",
		"runpartpix",
		"runpartpix1",
		"runpartpix2",
		"runpartpix3",
		"runpartpix4",
		"runpartpix5",
		"runpartpix6",
		"runpartpix7",
		"runpartpix8",
		"completepix",
		"pausedpix"
	};
	char **xpm_table[]={
		wait_xpm,
		stop_xpm,
		stop_wait_xpm,
		run_xpm,
		run1_xpm,
		run2_xpm,
		run3_xpm,
		run4_xpm,
		run5_xpm,
		run6_xpm,
		run7_xpm,
		run8_xpm,
		run_bad_xpm,
		run_bad1_xpm,
		run_bad2_xpm,
		run_bad3_xpm,
		run_bad4_xpm,
		run_bad5_xpm,
		run_bad6_xpm,
		run_bad7_xpm,
		run_bad8_xpm,
		run_part_xpm,
		run_part1_xpm,
		run_part2_xpm,
		run_part3_xpm,
		run_part4_xpm,
		run_part5_xpm,
		run_part6_xpm,
		run_part7_xpm,
		run_part8_xpm,