Changeset 6687


Ignore:
Timestamp:
Sep 2, 2008, 8:59:00 PM (13 years ago)
Author:
charles
Message:

(gtk) #989: add a checkbox to auto-update the blocklist once a week

Location:
trunk
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/Makefile.am

    r6567 r6687  
    2424    actions.h \
    2525    add-dialog.h \
     26    blocklist.h \
    2627    conf.h \
    2728    details.h \
     
    5556    actions.c \
    5657    add-dialog.c \
     58    blocklist.c \
    5759    conf.c \
    5860    details.c \
  • trunk/gtk/conf.c

    r6559 r6687  
    161161***/
    162162
    163 int
     163int64_t
    164164pref_int_get( const char * key )
    165165{
    166     int64_t i;
     166    int64_t i = 0;
    167167    tr_bencDictFindInt( getPrefs( ), key, &i );
    168168    return i;
    169169}
    170170void
    171 pref_int_set( const char * key, int value )
     171pref_int_set( const char * key, int64_t value )
    172172{
    173173    tr_benc * d = getPrefs( );
     
    176176}
    177177void
    178 pref_int_set_default( const char * key, int value )
     178pref_int_set_default( const char * key, int64_t value )
    179179{
    180180    if( !tr_bencDictFind( getPrefs( ), key ) )
  • trunk/gtk/conf.h

    r6559 r6687  
    3030#define TG_CONF_H
    3131
    32 int          pref_int_get            ( const char * key );
    33 void         pref_int_set            ( const char * key, int value );
    34 void         pref_int_set_default    ( const char * key, int value );
     32int64_t      pref_int_get            ( const char * key );
     33void         pref_int_set            ( const char * key, int64_t value );
     34void         pref_int_set_default    ( const char * key, int64_t value );
    3535
    3636gboolean     pref_flag_get           ( const char * key );
  • trunk/gtk/main.c

    r6686 r6687  
    4848#include "actions.h"
    4949#include "add-dialog.h"
     50#include "blocklist.h"
    5051#include "conf.h"
    5152#include "details.h"
     
    465466        appsetup( win, argfiles, cbdata, startpaused, startminimized );
    466467        tr_sessionSetRPCCallback( h, onRPCChanged, cbdata );
     468        gtr_blocklist_maybe_autoupdate( cbdata->core );
    467469
    468470        gtk_main();
  • trunk/gtk/tr-core.c

    r6624 r6687  
    9393
    9494static void
     95tr_core_marshal_blocklist( GClosure * closure, GValue * ret UNUSED,
     96                           guint count, const GValue * vals,
     97                           gpointer hint UNUSED, gpointer marshal )
     98{
     99    typedef void (*TRMarshalErr)
     100        ( gpointer, enum tr_core_err, const char *, gpointer );
     101    TRMarshalErr     callback;
     102    GCClosure      * cclosure = (GCClosure*) closure;
     103    gboolean         flag;
     104    const char     * str;
     105    gpointer         inst, gdata;
     106
     107    g_return_if_fail( count == 3 );
     108
     109    inst    = g_value_peek_pointer( vals );
     110    flag    = g_value_get_boolean( vals + 1 );
     111    str     = g_value_get_string( vals + 2 );
     112    gdata   = closure->data;
     113
     114    callback = (TRMarshalErr)( marshal ? marshal : cclosure->callback );
     115    callback( inst, flag, str, gdata );
     116}
     117
     118static void
    95119tr_core_marshal_prompt( GClosure * closure, GValue * ret UNUSED,
    96120                        guint count, const GValue * vals,
     
    149173
    150174    core_class = TR_CORE_CLASS( g_class );
     175    core_class->blocksig = g_signal_new( "blocklist-status",
     176                                         G_TYPE_FROM_CLASS( g_class ),
     177                                         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
     178                                         tr_core_marshal_blocklist, G_TYPE_NONE,
     179                                         2, G_TYPE_BOOLEAN, G_TYPE_STRING );
    151180    core_class->errsig = g_signal_new( "error", G_TYPE_FROM_CLASS( g_class ),
    152181                                       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
     
    743772
    744773    return count;
     774}
     775
     776void
     777tr_core_blocksig( TrCore * core, gboolean isDone, const char * status )
     778{
     779    g_signal_emit( core, TR_CORE_GET_CLASS(core)->blocksig, 0, isDone, status );
    745780}
    746781
  • trunk/gtk/tr-core.h

    r6559 r6687  
    6060{
    6161    GObjectClass parent;
     62
     63    /* "blocklist" signal:
     64       void  handler( TrCore *, const char *, gpointer userData ); */
     65    int blocksig;
    6266
    6367    /* "error" signal:
     
    160164void tr_core_quit( TrCore * self );
    161165
     166/* emit the "blocklist changed" signal */
     167void tr_core_blocksig( TrCore * core, gboolean isDone, const char * status );
     168
    162169/* Set a preference value, save the prefs file, and emit the
    163170   "prefs-changed" signal */
     
    171178   "prefs-changed" signal */
    172179void tr_core_set_pref_int( TrCore * self, const char * key, int val );
     180
    173181
    174182/**
  • trunk/gtk/tr-prefs.c

    r6686 r6687  
    2222#include <libtransmission/version.h>
    2323#include <libtransmission/web.h>
     24#include "blocklist.h"
    2425#include "conf.h"
    2526#include "hig.h"
     
    5556    pref_int_set_default    ( PREF_KEY_PEER_SOCKET_TOS, TR_DEFAULT_PEER_SOCKET_TOS );
    5657    pref_flag_set_default   ( PREF_KEY_ALLOW_HIBERNATION, FALSE );
    57     pref_flag_set_default   ( PREF_KEY_BLOCKLIST_ENABLED, TR_DEFAULT_BLOCKLIST_ENABLED );
     58    pref_flag_set_default   ( PREF_KEY_BLOCKLIST_ENABLED, TRUE );
     59    pref_flag_set_default   ( PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
    5860
    5961    pref_string_set_default ( PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
     
    350352    GtkWidget * dialog;
    351353    TrCore * core;
     354    gulong id;
    352355    int abortFlag;
    353356    char secondary[256];
     
    364367    gtk_button_set_label( GTK_BUTTON( w ), buf );
    365368}
    366 static gboolean
    367 updateBlocklistTextFromData( gpointer gdata )
     369
     370static void
     371onBlocklistDialogResponse( GtkDialog * d, int response UNUSED, gpointer gdata )
    368372{
    369373    struct blocklist_data * data = gdata;
    370     updateBlocklistText( data->check, data->core );
    371     return FALSE;
    372 }
    373 
    374 static gboolean
    375 blocklistDialogSetSecondary( gpointer gdata )
     374    g_signal_handler_disconnect( data->core, data->id );
     375    gtk_widget_destroy( GTK_WIDGET( d ) );
     376}
     377
     378static void
     379onBlocklistStatus( TrCore * core UNUSED, gboolean isDone, const char * status, gpointer gdata )
    376380{
    377381    struct blocklist_data * data = gdata;
    378     GtkMessageDialog * md = GTK_MESSAGE_DIALOG( data->dialog );
    379     gtk_message_dialog_format_secondary_text( md, data->secondary );
    380     return FALSE;
    381 }
    382 
    383 static gboolean
    384 blocklistDialogAllowClose( gpointer dialog )
    385 {
    386     GtkDialog * d = GTK_DIALOG( dialog );
    387     gtk_dialog_set_response_sensitive( GTK_DIALOG( d ), GTK_RESPONSE_CANCEL, FALSE );
    388     gtk_dialog_set_response_sensitive( GTK_DIALOG( d ), GTK_RESPONSE_CLOSE, TRUE );
    389     return FALSE;
    390 }
    391 
    392 static void
    393 got_blocklist( tr_handle   * handle         UNUSED,
    394                long          response_code  UNUSED,
    395                const void  * response,
    396                size_t        response_len,
    397                void        * gdata )
    398 {
    399     struct blocklist_data * data = gdata;
    400     const char * text = response;
    401     int size = response_len;
    402     int rules = 0;
    403     gchar * filename = NULL;
    404     gchar * filename2 = NULL;
    405     int fd = -1;
    406     int ok = 1;
    407 
    408     if( !data->abortFlag && ( !text || !size ) )
    409     {
    410         ok = FALSE;
    411         g_snprintf( data->secondary, sizeof( data->secondary ),
    412                     _( "Unable to get blocklist." ) );
    413         g_message( data->secondary );
    414         g_idle_add( blocklistDialogSetSecondary, data );
    415     }     
    416 
    417     if( ok && !data->abortFlag )
    418     {
    419         GError * err = NULL;
    420         fd = g_file_open_tmp( "transmission-blockfile-XXXXXX", &filename, &err );
    421         if( err ) {
    422             g_snprintf( data->secondary, sizeof( data->secondary ),
    423                         _( "Unable to get blocklist: %s" ), err->message );
    424             g_warning( data->secondary );
    425             g_idle_add( blocklistDialogSetSecondary, data );
    426             g_clear_error( &err );
    427             ok = FALSE;
    428         } else {
    429             write( fd, text, size );
    430             close( fd );
    431         }
    432     }
    433     if( ok && !data->abortFlag )
    434     {
    435         char * cmd;
    436         filename2 = g_strdup_printf( "%s.txt", filename );
    437         g_snprintf( data->secondary, sizeof( data->secondary ),
    438                     _( "Uncompressing blocklist..." ) );
    439         g_idle_add( blocklistDialogSetSecondary, data );
    440         cmd = g_strdup_printf( "zcat %s > %s ", filename, filename2 );
    441         tr_dbg( "%s", cmd );
    442         system( cmd );
    443         g_free( cmd );
    444     }
    445     if( ok && !data->abortFlag )
    446     {
    447         g_snprintf( data->secondary, sizeof( data->secondary ),
    448                     _( "Parsing blocklist..." ) );
    449         g_idle_add( blocklistDialogSetSecondary, data );
    450         rules = tr_blocklistSetContent( tr_core_handle( data->core ), filename2 );
    451     }
    452     if( ok && !data->abortFlag )
    453     {
    454         g_snprintf( data->secondary, sizeof( data->secondary ),
    455                     _( "Blocklist updated with %'d entries" ), rules );
    456         g_idle_add( blocklistDialogSetSecondary, data );
    457         g_idle_add( blocklistDialogAllowClose, data->dialog );
    458         g_idle_add( updateBlocklistTextFromData, data );
    459     }
    460 
    461     /* g_free( data ); */
    462     if( filename2 ) {
    463         unlink( filename2 );
    464         g_free( filename2 );
    465     }
    466     if( filename ) {
    467         unlink( filename );
    468         g_free( filename );
    469     }
    470 }
    471 
    472 static void
    473 onUpdateBlocklistResponseCB( GtkDialog * dialog, int response, gpointer vdata )
    474 {
    475     struct blocklist_data * data = vdata;
    476 
    477     if( response == GTK_RESPONSE_CANCEL )
    478         data->abortFlag = 1;
    479 
    480     data->dialog = NULL;
    481     gtk_widget_destroy( GTK_WIDGET( dialog ) );
     382
     383    gdk_threads_enter( );
     384    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( data->dialog ), status );
     385    gtk_dialog_set_response_sensitive( GTK_DIALOG( data->dialog ), GTK_RESPONSE_CANCEL, !isDone );
     386    gtk_dialog_set_response_sensitive( GTK_DIALOG( data->dialog ), GTK_RESPONSE_CLOSE, isDone );
     387    if( isDone )
     388        updateBlocklistText( data->check, core );
     389    gdk_threads_leave( );
    482390}
    483391
     
    487395    GtkWidget * d;
    488396    struct blocklist_data * data = gdata;
    489     tr_handle * handle = g_object_get_data( G_OBJECT( w ), "handle" );
    490     const char * url = "http://download.m0k.org/transmission/files/level1.gz";
    491397   
    492398    d = gtk_message_dialog_new( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( w ) ) ),
     
    495401                                GTK_BUTTONS_NONE,
    496402                                _( "Updating Blocklist" ) );
    497     gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( d ),
    498                                               _( "Retrieving blocklist..." ) );
     403
     404    data->dialog = d;
     405    data->id = g_signal_connect( data->core, "blocklist-status", G_CALLBACK( onBlocklistStatus ), data );
     406
    499407    gtk_dialog_add_buttons( GTK_DIALOG( d ),
    500408                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     
    503411    gtk_dialog_set_response_sensitive( GTK_DIALOG( d ), GTK_RESPONSE_CLOSE, FALSE );
    504412
    505     data->dialog = d;
    506 
    507     g_signal_connect( d, "response", G_CALLBACK(onUpdateBlocklistResponseCB), data );
     413    g_signal_connect( d, "response", G_CALLBACK(onBlocklistDialogResponse), data );
    508414    gtk_widget_show( d );
    509415
    510     tr_webRun( handle, url, NULL, got_blocklist, data );
     416    gtr_blocklist_update( data->core );
    511417}
    512418
     
    533439    struct blocklist_data * data;
    534440
     441    data = g_new0( struct blocklist_data, 1 );
     442    data->core = TR_CORE( core );
     443
    535444    t = hig_workarea_create( );
    536445    hig_workarea_add_section_title (t, &row, _("Options"));
     446
     447        s = _("_Ignore unencrypted peers");
     448        w = gtk_check_button_new_with_mnemonic( s );
     449        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
     450                                      pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
     451        g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
     452        hig_workarea_add_wide_control( t, &row, w );
     453
     454        s = _("Use peer e_xchange");
     455        w = new_check_button( s, PREF_KEY_PEX, core );
     456        hig_workarea_add_wide_control( t, &row, w );
     457
     458        h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
     459        w2 = new_spin_button( PREF_KEY_PORT, core, 1, INT_MAX, 1 );
     460        gtk_box_pack_start( GTK_BOX(h), w2, FALSE, FALSE, 0 );
     461        l = gtk_label_new( NULL );
     462        gtk_misc_set_alignment( GTK_MISC(l), 0.0f, 0.5f );
     463        gtk_box_pack_start( GTK_BOX(h), l, FALSE, FALSE, 0 );
     464        hig_workarea_add_row( t, &row, _("Listening _port:"), h, w2 );
     465
     466        g_object_set_data( G_OBJECT(l), "tr-port-spin", w2 );
     467        g_object_set_data( G_OBJECT(l), "alive", alive );
     468        g_object_set_data( G_OBJECT(l), "handle", tr_core_handle( TR_CORE( core ) ) );
     469        testing_port_cb( NULL, l );
     470        g_signal_connect( w2, "value-changed", G_CALLBACK(testing_port_cb), l );
     471       
     472    hig_workarea_add_section_divider( t, &row );
     473    hig_workarea_add_section_title( t, &row, _( "Blocklist" ) );
    537474
    538475        w = new_check_button( "", PREF_KEY_BLOCKLIST_ENABLED, core );
     
    541478        gtk_box_pack_start_defaults( GTK_BOX(h), w );
    542479        b = gtk_button_new_with_mnemonic( _( "_Update Blocklist" ) );
    543 
    544         data = g_new0( struct blocklist_data, 1 );
    545         data->core = TR_CORE( core );
    546480        data->check = w;
    547 
    548481        g_object_set_data( G_OBJECT( b ), "handle", tr_core_handle( TR_CORE( core ) ) );
    549482        g_signal_connect( b, "clicked", G_CALLBACK(onUpdateBlocklistCB), data );
     
    553486        hig_workarea_add_wide_control( t, &row, h );
    554487       
    555         s = _("_Ignore unencrypted peers");
    556         w = gtk_check_button_new_with_mnemonic( s );
    557         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
    558                                       pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
    559         g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
     488        s = _( "_Enable automatic updates" );
     489        w = new_check_button( s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core );
    560490        hig_workarea_add_wide_control( t, &row, w );
    561 
    562         s = _("Use peer e_xchange");
    563         w = new_check_button( s, PREF_KEY_PEX, core );
    564         hig_workarea_add_wide_control( t, &row, w );
    565 
    566         h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    567         w2 = new_spin_button( PREF_KEY_PORT, core, 1, INT_MAX, 1 );
    568         gtk_box_pack_start( GTK_BOX(h), w2, FALSE, FALSE, 0 );
    569         l = gtk_label_new( NULL );
    570         gtk_misc_set_alignment( GTK_MISC(l), 0.0f, 0.5f );
    571         gtk_box_pack_start( GTK_BOX(h), l, FALSE, FALSE, 0 );
    572         hig_workarea_add_row( t, &row, _("Listening _port:"), h, w2 );
    573 
    574         g_object_set_data( G_OBJECT(l), "tr-port-spin", w2 );
    575         g_object_set_data( G_OBJECT(l), "alive", alive );
    576         g_object_set_data( G_OBJECT(l), "handle", tr_core_handle( TR_CORE( core ) ) );
    577         testing_port_cb( NULL, l );
    578         g_signal_connect( w2, "value-changed", G_CALLBACK(testing_port_cb), l );
     491        g_signal_connect( data->check, "toggled", G_CALLBACK(target_cb), w );
     492        target_cb( data->check, w );
    579493       
    580494    hig_workarea_add_section_divider( t, &row );
  • trunk/gtk/tr-prefs.h

    r6686 r6687  
    5757#define PREF_KEY_MAX_PEERS_PER_TORRENT  "max-peers-per-torrent"
    5858#define PREF_KEY_BLOCKLIST_ENABLED      "blocklist-enabled"
     59#define PREF_KEY_BLOCKLIST_UPDATES_ENABLED  "blocklist-updates-enabled"
    5960#define PREF_KEY_MAIN_WINDOW_HEIGHT     "main-window-height"
    6061#define PREF_KEY_MAIN_WINDOW_WIDTH      "main-window-width"
  • trunk/gtk/util.c

    r6588 r6687  
    173173}
    174174
    175 gboolean
     175int
    176176mkdir_p( const char * path, mode_t mode )
    177177{
  • trunk/gtk/util.h

    r6559 r6687  
    4141
    4242/* return a human-readable string for the size given in bytes. */
    43 char* tr_strlsize( char * buf, guint64 size, size_t buflen );
     43char* tr_strlsize( char * buf, uint64_t size, size_t buflen );
    4444
    4545/* return a human-readable string for the transfer rate given in bytes. */
     
    5555
    5656/* create a directory and any missing parent directories */
    57 gboolean
    58 mkdir_p(const char *name, mode_t mode);
     57int mkdir_p(const char *name, mode_t mode);
    5958
    6059/* create a copy of a GSList of strings, this dups the actual strings too */
  • trunk/po/POTFILES.in

    r5990 r6687  
    22gtk/actions.c
    33gtk/add-dialog.c
     4gtk/blocklist.c
    45gtk/conf.c
    56gtk/details.c
Note: See TracChangeset for help on using the changeset viewer.