mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/gtk/tr_core.c

461 lines
12 KiB
C
Raw Blame History

/******************************************************************************
* $Id$
*
* Copyright (c) 2007 Transmission authors and contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include <string.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include "bencode.h"
#include "transmission.h"
/* XXX */
#define TR_WANT_TORRENT_PRIVATE
#include "conf.h"
#include "tr_core.h"
#include "tr_torrent.h"
#include "util.h"
static void
tr_core_init( GTypeInstance * instance, gpointer g_class );
static void
tr_core_class_init( gpointer g_class, gpointer g_class_data );
static void
tr_core_dispose( GObject * obj );
static void
tr_core_torrent_finalized( gpointer gdata, GObject * tor );
static int
tr_core_check_torrents( TrCore * self, gboolean timeout );
static void
tr_core_insert( TrCore * self, TrTorrent * tor );
GType
tr_core_get_type( void )
{
static GType type = 0;
if( 0 == type )
{
static const GTypeInfo info =
{
sizeof( TrCoreClass ),
NULL, /* base_init */
NULL, /* base_finalize */
tr_core_class_init, /* class_init */
NULL, /* class_finalize */
NULL, /* class_data */
sizeof( TrCore ),
0, /* n_preallocs */
tr_core_init, /* instance_init */
NULL,
};
type = g_type_register_static( G_TYPE_OBJECT, "TrCore", &info, 0 );
}
return type;
}
void
tr_core_class_init( gpointer g_class, gpointer g_class_data SHUTUP )
{
GObjectClass * gobject_class;
gobject_class = G_OBJECT_CLASS( g_class );
gobject_class->dispose = tr_core_dispose;
}
void
tr_core_init( GTypeInstance * instance, gpointer g_class SHUTUP )
{
TrCore * self = (TrCore *) instance;
GtkListStore * store;
/* column types for the model used to store torrent information */
/* keep this in sync with the enum near the bottom of tr_core.h */
GType types[] =
{
/* info->name, info->totalSize, status, error, errorString, */
G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING,
/* progress, rateDownload, rateUpload, eta, peersTotal, */
G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT,
/* peersUploading, peersDownloading, seeders, leechers */
G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT,
/* completedFromTracker, downloaded, uploaded left */
G_TYPE_INT, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64,
/* tracker, the TrTorrent object */
TR_TRACKER_BOXED_TYPE, TR_TORRENT_TYPE,
};
/* create the model used to store torrent data */
g_assert( ALEN( types ) == MC_ROW_COUNT );
store = gtk_list_store_newv( MC_ROW_COUNT, types );
self->model = GTK_TREE_MODEL( store );
self->handle = tr_init( "gtk" );
self->torrents = NULL;
self->quitting = FALSE;
self->disposed = FALSE;
}
void
tr_core_dispose( GObject * obj )
{
TrCore * self = (TrCore *) obj;
GObjectClass * parent;
GList * ii;
if( self->disposed )
{
return;
}
self->disposed = TRUE;
if( NULL != self->model )
{
g_object_unref( self->model );
self->model = NULL;
}
if( NULL != self->torrents )
{
for( ii = g_list_first( self->torrents ); NULL != ii; ii = ii->next )
{
g_object_weak_unref( ii->data, tr_core_torrent_finalized, self );
}
g_list_free( self->torrents );
self->torrents = NULL;
}
tr_close( self->handle );
/* Chain up to the parent class */
parent = g_type_class_peek( g_type_parent( TR_CORE_TYPE ) );
parent->dispose( obj );
}
void
tr_core_torrent_finalized( gpointer gdata, GObject * tor )
{
TrCore * self = gdata;
TR_IS_CORE( self );
self->torrents = g_list_remove( self->torrents, tor );
}
TrCore *
tr_core_new( void )
{
return g_object_new( TR_CORE_TYPE, NULL );
}
GtkTreeModel *
tr_core_model( TrCore * self )
{
TR_IS_CORE( self );
return self->model;
}
tr_handle_t *
tr_core_handle( TrCore * self )
{
TR_IS_CORE( self );
return self->handle;
}
void
tr_core_quit( TrCore * self )
{
GtkTreeIter iter;
TrTorrent * tor;
GList * ii;
TR_IS_CORE( self );
g_assert( !self->quitting );
self->quitting = TRUE;
/*
Add a reference to all torrents in the list, which will be
removed when the politely-stopped signal is emitted. This is
necessary because a reference is added when a torrent is removed
from the model and tr_torrent_stop_polite() is called on it.
*/
if( gtk_tree_model_get_iter_first( self->model, &iter) )
{
do
{
gtk_tree_model_get( self->model, &iter, MC_TORRENT, &tor, -1 );
}
while( gtk_tree_model_iter_next( self->model, &iter ) );
}
/* try to politely stop all the torrents */
for( ii = g_list_first( self->torrents ); NULL != ii; ii = ii->next )
{
tr_torrent_stop_politely( ii->data );
}
/* shut down nat traversal */
tr_natTraversalEnable( self->handle, 0 );
}
gboolean
tr_core_did_quit( TrCore * self )
{
tr_handle_status_t * hstat;
TR_IS_CORE( self );
g_assert( self->quitting );
hstat = tr_handleStatus( self->handle );
return ( 0 == tr_core_check_torrents( self, FALSE ) &&
TR_NAT_TRAVERSAL_DISABLED == hstat->natTraversalStatus );
}
void
tr_core_force_quit( TrCore * self )
{
TR_IS_CORE( self );
g_assert( self->quitting );
/* time the remaining torrents out so they signal politely-stopped */
tr_core_check_torrents( self, TRUE );
}
void
tr_core_clear( TrCore * self )
{
TR_IS_CORE( self );
if( NULL != self->model )
{
g_object_unref( self->model );
self->model = NULL;
}
}
void
tr_core_reap( TrCore * self )
{
TR_IS_CORE( self );
tr_core_check_torrents( self, FALSE );
}
int
tr_core_check_torrents( TrCore * self, gboolean timeout )
{
tr_stat_t * st;
GList * ii, * list;
int count;
count = 0;
list = g_list_copy( self->torrents );
for( ii = g_list_first( list ); NULL != ii; ii = ii->next )
{
st = tr_torrent_stat_polite( ii->data, timeout );
if( NULL == st || !( TR_STATUS_PAUSE & st->status ) )
{
count++;
}
}
g_list_free( list );
return count;
}
void
tr_core_save( TrCore * self, char ** error )
{
benc_val_t state;
GList * ii;
TR_IS_CORE( self );
tr_bencInit( &state, TYPE_LIST );
if( tr_bencListReserve( &state, g_list_length( self->torrents ) ) )
{
if( NULL != error )
{
*error = g_strdup( "malloc failure" );
}
return;
}
for( ii = g_list_first( self->torrents ); NULL != ii; ii = ii->next )
{
tr_torrent_get_state( ii->data, tr_bencListAdd( &state ) );
}
cf_savestate( &state, error );
tr_bencFree( &state );
for( ii = g_list_first( self->torrents ); NULL != ii; ii = ii->next )
{
tr_torrent_state_saved( ii->data );
}
}
int
tr_core_load( TrCore * self, benc_val_t * state, GList ** errors )
{
int ii, count;
char * errstr;
TrTorrent * tor;
TR_IS_CORE( self );
if( TYPE_LIST != state->type )
{
return 0;
}
count = 0;
for( ii = 0; ii < state->val.l.count; ii++ )
{
errstr = NULL;
tor = tr_torrent_new_with_state( G_OBJECT( self ),
state->val.l.vals + ii, 0, &errstr );
if( NULL != errstr )
{
*errors = g_list_append( *errors, errstr );
}
if( NULL != tor )
{
tr_core_insert( self, tor );
count++;
}
}
return count;
}
gboolean
tr_core_add_torrent( TrCore * self, const char * torrent, const char * dir,
guint flags, char ** err )
{
TrTorrent * tor;
TR_IS_CORE( self );
tor = tr_torrent_new( G_OBJECT( self ), torrent, dir, flags, err );
if( NULL == tor )
{
return FALSE;
}
tr_core_insert( self, tor );
return TRUE;
}
void
tr_core_delete_torrent( TrCore * self, void * torrent,
GtkTreeIter * iter )
{
TR_IS_CORE( self );
/* tor will be unref'd in the politely_stopped handler */
g_object_ref( torrent );
tr_torrent_stop_politely( torrent );
if( TR_FLAG_SAVE & tr_torrent_info( torrent )->flags )
{
tr_torrentRemoveSaved( tr_torrent_handle( torrent ) );
}
gtk_list_store_remove( GTK_LIST_STORE( self->model ), iter );
}
void
tr_core_insert( TrCore * self, TrTorrent * tor )
{
GtkTreeIter iter;
tr_info_t * inf;
g_object_weak_ref( G_OBJECT( tor ), tr_core_torrent_finalized, self );
self->torrents = g_list_append( self->torrents, tor );
gtk_list_store_append( GTK_LIST_STORE( self->model ), &iter );
inf = tr_torrent_info( tor );
/* inserting the torrent into the model adds a reference */
gtk_list_store_set( GTK_LIST_STORE( self->model ), &iter,
MC_NAME, inf->name,
MC_SIZE, inf->totalSize,
MC_TORRENT, tor,
-1);
/* we will always ref a torrent before politely stopping it */
g_signal_connect( tor, "politely_stopped",
G_CALLBACK( g_object_unref ), NULL );
g_object_unref( tor );
}
void
tr_core_update( TrCore * self )
{
GtkTreeIter iter;
TrTorrent * tor;
tr_stat_t * st;
TR_IS_CORE( self );
if( gtk_tree_model_get_iter_first( self->model, &iter ) )
{
do
{
gtk_tree_model_get( self->model, &iter, MC_TORRENT, &tor, -1 );
st = tr_torrent_stat( tor );
g_object_unref( tor );
/* XXX find out if setting the same data emits changed signal */
gtk_list_store_set( GTK_LIST_STORE( self->model ), &iter,
MC_STAT, st->status,
MC_ERR, st->error,
MC_TERR, st->errorString,
MC_PROG, st->progress,
MC_DRATE, st->rateDownload,
MC_URATE, st->rateUpload,
MC_ETA, st->eta,
MC_PEERS, st->peersTotal,
MC_UPEERS, st->peersUploading,
MC_DPEERS, st->peersDownloading,
MC_SEED, st->seeders,
MC_LEECH, st->leechers,
MC_DONE, st->completedFromTracker,
MC_TRACKER, st->tracker,
MC_DOWN, st->downloaded,
MC_UP, st->uploaded,
MC_LEFT, st->left,
-1 );
}
while( gtk_tree_model_iter_next( self->model, &iter ) );
}
}
Reference in New Issue View Git Blame Copy Permalink