Changeset 9130


Ignore:
Timestamp:
Sep 17, 2009, 1:28:45 AM (12 years ago)
Author:
charles
Message:

(trunk gtk) rewrite the 'create torrent' dialog

Location:
trunk/gtk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/main.c

    r9094 r9130  
    13911391    else if( !strcmp( action_name, "new-torrent" ) )
    13921392    {
    1393         GtkWidget * w = make_meta_ui( GTK_WINDOW( data->wind ),
    1394                                      tr_core_session( data->core ) );
     1393        GtkWidget * w = make_meta_ui( GTK_WINDOW( data->wind ), data->core );
    13951394        gtk_widget_show_all( w );
    13961395    }
  • trunk/gtk/makemeta-ui.c

    r8889 r9130  
    2222#include "hig.h"
    2323#include "makemeta-ui.h"
    24 #include "tracker-list.h"
     24#include "tr-core.h"
    2525#include "util.h"
    2626
    27 #define UI_KEY "ui"
    28 #define ANNOUNCE_KEY "recent-announce-url"
     27#define FILE_CHOSEN_KEY "file-is-chosen"
    2928
    3029typedef struct
    3130{
    32     GtkWidget * filename_entry;
    33     GtkWidget * size_lb;
     31    char * target;
     32    guint progress_tag;
     33    GtkWidget * file_chooser;
     34    GtkWidget * folder_chooser;
    3435    GtkWidget * pieces_lb;
    35     GtkWidget * announce_list;
     36    GtkWidget * destination_chooser;
     37    GtkWidget * comment_check;
    3638    GtkWidget * comment_entry;
    37     GtkWidget * progressbar;
    3839    GtkWidget * private_check;
     40    GtkWidget * progress_label;
     41    GtkWidget * progress_bar;
     42    GtkWidget * progress_dialog;
    3943    GtkWidget * dialog;
    40 
    41     tr_metainfo_builder   *  builder;
    42     tr_session            *  session;
    43 
    44     gboolean               isBuilding;
     44    GtkTextBuffer * announce_text_buffer;
     45    TrCore * core;
     46    tr_metainfo_builder *  builder;
    4547}
    4648MakeMetaUI;
     
    5557}
    5658
    57 static void
    58 refreshButtons( MakeMetaUI * ui )
    59 {
    60     GtkDialog * d = GTK_DIALOG( ui->dialog );
    61 
    62     gtk_dialog_set_response_sensitive(
    63          d, GTK_RESPONSE_ACCEPT, !ui->isBuilding && ( ui->builder != NULL ) );
    64     gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CLOSE,
    65                                        !ui->isBuilding );
    66     gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CANCEL,
    67                                        ui->isBuilding );
    68 }
    69 
    70 static void
    71 setIsBuilding( MakeMetaUI * ui,
    72                gboolean     isBuilding )
    73 {
    74     ui->isBuilding = isBuilding;
    75 
    76     if( ui->builder != NULL )
    77         ui->builder->result = TR_MAKEMETA_OK;
    78 
    79     if( !isBuilding )
    80         gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(
    81                                            ui->progressbar ), 0 );
    82 
    83     refreshButtons( ui );
    84 }
    85 
    8659static gboolean
    87 refresh_cb( gpointer user_data )
    88 {
    89     int              denom;
    90     char             buf[1024];
    91     double           fraction;
    92     MakeMetaUI *     ui = user_data;
    93     GtkProgressBar * p = GTK_PROGRESS_BAR( ui->progressbar );
    94 
    95     denom = ui->builder->pieceCount ? ui->builder->pieceCount : 1;
    96     fraction = (double)ui->builder->pieceIndex / denom;
     60onProgressDialogRefresh( gpointer data )
     61{
     62    char * str;
     63    MakeMetaUI * ui = data;
     64    const tr_metainfo_builder * b = ui->builder;
     65    GtkDialog * d = GTK_DIALOG( ui->progress_dialog );
     66    GtkProgressBar * p = GTK_PROGRESS_BAR( ui->progress_bar );
     67    const double fraction = (double)b->pieceIndex / b->pieceCount;
     68        char * base = g_path_get_basename( b->top );
     69
     70    /* progress label */
     71    if( !b->isDone )
     72        str = g_strdup_printf( _( "Creating \"%s\"" ), base );
     73    else if( b->result == TR_MAKEMETA_OK )
     74        str = g_strdup_printf( _( "Created \"%s\"!" ), base );
     75    else if( b->result == TR_MAKEMETA_URL )
     76        str = g_strdup_printf( _( "Error: invalid announce URL \"%s\"" ), b->errfile );
     77    else if( b->result == TR_MAKEMETA_CANCELLED )
     78        str = g_strdup_printf( _( "Cancelled" ) );
     79    else if( b->result == TR_MAKEMETA_IO_READ )
     80        str = g_strdup_printf( _( "Error reading \"%s\": %s" ), b->errfile, g_strerror( b->my_errno ) );
     81    else if( b->result == TR_MAKEMETA_IO_WRITE )
     82        str = g_strdup_printf( _( "Error writing \"%s\": %s" ), b->errfile, g_strerror( b->my_errno ) );
     83    gtk_label_set_text( GTK_LABEL( ui->progress_label ), str );
     84    g_free( str );
     85
     86    /* progress bar */
     87    if( !b->pieceIndex )
     88        str = g_strdup( "" );
     89    else {
     90        char sizebuf[128];
     91        tr_strlsize( sizebuf, (uint64_t)b->pieceIndex *
     92                              (uint64_t)b->pieceSize, sizeof( sizebuf ) );
     93        /* how much data we've scanned through to generate checksums */
     94        str = g_strdup_printf( _( "Scanned %s" ), sizebuf );
     95    }
    9796    gtk_progress_bar_set_fraction( p, fraction );
    98     g_snprintf( buf, sizeof( buf ), "%s.torrent (%d%%)", ui->builder->top,
    99                (int)( fraction * 100 ) );
    100     gtk_progress_bar_set_text( p, buf );
    101 
    102     if( ui->builder->isDone )
    103     {
    104         char * txt = NULL;
    105 
    106         switch( ui->builder->result )
     97    gtk_progress_bar_set_text( p, str );
     98    g_free( str );
     99
     100    /* buttons */
     101    gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CANCEL, !b->isDone );
     102    gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CLOSE, b->isDone );
     103    gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_ACCEPT, b->isDone && !b->result );
     104   
     105    g_free( base );
     106    return TRUE;
     107}
     108
     109static void
     110onProgressDialogDestroyed( gpointer data, GObject * dead UNUSED )
     111{
     112    MakeMetaUI * ui = data;
     113    g_source_remove( ui->progress_tag );
     114}
     115
     116static void
     117addTorrent( MakeMetaUI * ui )
     118{
     119    char * path;
     120    const tr_metainfo_builder * b = ui->builder;
     121    tr_ctor * ctor = tr_ctorNew( tr_core_session( ui->core ) );
     122
     123    tr_ctorSetMetainfoFromFile( ctor, ui->target );
     124
     125    path = g_path_get_dirname( b->top );
     126    tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
     127    g_free( path );
     128
     129    tr_core_add_ctor( ui->core, ctor );
     130}
     131
     132static void
     133onProgressDialogResponse( GtkDialog * d, int response, gpointer data )
     134{
     135    MakeMetaUI * ui = data;
     136
     137    switch( response )
     138    {
     139        case GTK_RESPONSE_CANCEL:
     140            ui->builder->abortFlag = TRUE;
     141            gtk_widget_destroy( GTK_WIDGET( d ) );
     142            break;
     143        case GTK_RESPONSE_ACCEPT:
     144            addTorrent( ui );
     145            /* fall-through */
     146        case GTK_RESPONSE_CLOSE:
     147            gtk_widget_destroy( ui->builder->result ? GTK_WIDGET( d ) : ui->dialog );
     148            break;
     149        default:
     150            g_assert( 0 && "unhandled response" );
     151    }
     152}
     153
     154static void
     155makeProgressDialog( GtkWidget * parent, MakeMetaUI * ui )
     156{
     157    GtkWidget *d, *l, *w, *v, *fr;
     158
     159    d = gtk_dialog_new_with_buttons( _( "New Torrent" ),
     160            GTK_WINDOW( parent ),
     161            GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
     162            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     163            GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
     164            GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
     165            NULL );
     166    ui->progress_dialog = d;
     167    g_signal_connect( d, "response", G_CALLBACK( onProgressDialogResponse ), ui );
     168
     169    fr = gtk_frame_new( NULL );
     170    gtk_container_set_border_width( GTK_CONTAINER( fr ), GUI_PAD_BIG );
     171    gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_NONE );
     172    v = gtk_vbox_new( TRUE, GUI_PAD );
     173    gtk_container_add( GTK_CONTAINER( fr ), v );
     174
     175    l = gtk_label_new( _( "Creating torrent..." ) );
     176    gtk_misc_set_alignment( GTK_MISC( l ), 0.0, 0.5 );
     177    gtk_label_set_justify( GTK_LABEL( l ), GTK_JUSTIFY_LEFT );
     178    ui->progress_label = l;
     179    gtk_box_pack_start( GTK_BOX( v ), l, FALSE, FALSE, 0 );
     180
     181    w = gtk_progress_bar_new( );
     182    ui->progress_bar = w;
     183    gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
     184
     185    ui->progress_tag = g_timeout_add( 1000, onProgressDialogRefresh, ui );
     186    g_object_weak_ref( G_OBJECT( d ), onProgressDialogDestroyed, ui );
     187    onProgressDialogRefresh( ui );
     188
     189    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), fr, TRUE, TRUE, 0 );
     190    gtk_widget_show_all( d );
     191}
     192
     193static void
     194onResponse( GtkDialog* d, int response, gpointer user_data )
     195{
     196    MakeMetaUI * ui = user_data;
     197
     198    if( response == GTK_RESPONSE_ACCEPT )
     199    {
     200        if( ui->builder != NULL )
    107201        {
    108             case TR_MAKEMETA_OK:
    109                 txt = g_strdup( _( "Torrent created!" ) );
    110                 break;
    111 
    112             case TR_MAKEMETA_URL:
    113                 txt = g_strdup_printf( _(
    114                                           "Torrent creation failed: %s" ),
    115                                       _( "Invalid URL" ) );
    116                 break;
    117 
    118             case TR_MAKEMETA_CANCELLED:
    119                 txt = g_strdup_printf( _( "Torrent creation cancelled" ) );
    120                 break;
    121 
    122             case TR_MAKEMETA_IO_READ:
    123             {
    124                 char * tmp =
    125                     g_strdup_printf( _(
    126                                         "Couldn't read \"%1$s\": %2$s" ),
    127                                     ui->builder->errfile,
    128                                     g_strerror( ui->builder->my_errno ) );
    129                 txt = g_strdup_printf( _(
    130                                            "Torrent creation failed: %s" ),
    131                                        tmp );
    132                 g_free( tmp  );
    133                 break;
     202            int i;
     203            int n;
     204            int tier;
     205            GtkTextIter start, end;
     206            char * dir;
     207            char * base;
     208            char * tracker_text;
     209            char ** tracker_strings;
     210            GtkEntry * c_entry = GTK_ENTRY( ui->comment_entry );
     211            GtkToggleButton * p_check = GTK_TOGGLE_BUTTON( ui->private_check );
     212            GtkToggleButton * c_check = GTK_TOGGLE_BUTTON( ui->comment_check );
     213            const char * comment = gtk_entry_get_text( c_entry );
     214            const gboolean isPrivate = gtk_toggle_button_get_active( p_check );
     215            const gboolean useComment = gtk_toggle_button_get_active( c_check );
     216            tr_tracker_info * trackers;
     217
     218            /* destination file */
     219            dir = gtk_file_chooser_get_filename(
     220                      GTK_FILE_CHOOSER( ui->destination_chooser ) );
     221            base = g_path_get_basename( ui->builder->top );
     222            g_free( ui->target );
     223            ui->target = g_strdup_printf( "%s/%s.torrent", dir, base );
     224
     225            /* build the array of trackers */
     226            gtk_text_buffer_get_bounds( ui->announce_text_buffer, &start, &end );
     227            tracker_text = gtk_text_buffer_get_text( ui->announce_text_buffer,
     228                                                     &start, &end, FALSE );
     229            tracker_strings = g_strsplit( tracker_text, "\n", 0 );
     230            for( i=0; tracker_strings[i]; )
     231                ++i;
     232            trackers = g_new0( tr_tracker_info, i );
     233            for( i=n=tier=0; tracker_strings[i]; ++i ) {
     234                const char * str = tracker_strings[i];
     235                if( !*str )
     236                    ++tier;
     237                else {
     238g_message( "tier %d announce %s", tier, tracker_strings[i] );
     239                    trackers[n].tier = tier;
     240                    trackers[n].announce = tracker_strings[i];
     241                    ++n;
     242                }
    134243            }
    135244
    136             case TR_MAKEMETA_IO_WRITE:
    137             {
    138                 char * tmp =
    139                     g_strdup_printf( _(
    140                                         "Couldn't create \"%1$s\": %2$s" ),
    141                                     ui->builder->errfile,
    142                                     g_strerror( ui->builder->my_errno ) );
    143                 txt = g_strdup_printf( _(
    144                                            "Torrent creation failed: %s" ),
    145                                        tmp );
    146                 g_free( tmp  );
    147                 break;
    148             }
     245            /* build the .torrent */
     246            makeProgressDialog( GTK_WIDGET( d ), ui );
     247            tr_makeMetaInfo( ui->builder, ui->target, trackers, n,
     248                             useComment ? comment : NULL, isPrivate );
     249
     250            /* cleanup */
     251            g_free( trackers );
     252            g_strfreev( tracker_strings );
     253            g_free( tracker_text );
     254            g_free( base );
     255            g_free( dir );
    149256        }
    150 
    151         gtk_progress_bar_set_fraction(
    152             p, ui->builder->result == TR_MAKEMETA_OK ? 1.0 : 0.0 );
    153         gtk_progress_bar_set_text( p, txt );
    154         setIsBuilding( ui, FALSE );
    155         g_free( txt );
    156     }
    157 
    158     return !ui->builder->isDone;
    159 }
    160 
    161 static void
    162 remove_tag( gpointer tag )
    163 {
    164     g_source_remove ( GPOINTER_TO_UINT( tag ) ); /* stop the periodic refresh */
    165 }
    166 
    167 static void
    168 response_cb( GtkDialog* d,
    169              int        response,
    170              gpointer   user_data )
    171 {
    172     MakeMetaUI *      ui = user_data;
    173     char *            tmp;
    174     char              buf[1024];
    175     guint             tag;
    176     tr_tracker_info * trackers = NULL;
    177     int               i;
    178     int               trackerCount = 0;
    179 
    180     if( response != GTK_RESPONSE_ACCEPT )
    181     {
    182         if( ui->builder == NULL )
    183         {
    184             gtk_widget_destroy( GTK_WIDGET( d ) );
    185             return;
    186         }
    187 
    188         if( ui->builder->isDone || !ui->isBuilding )
    189         {
    190             gtk_widget_destroy( ui->dialog );
    191         }
    192         else
    193         {
    194             ui->builder->abortFlag = TRUE;
    195         }
    196 
    197         return;
    198     }
    199 
    200     if( ui->builder == NULL || ui->isBuilding )
    201         return;
    202 
    203     setIsBuilding( ui, TRUE );
    204 
    205     tmp = g_path_get_basename ( ui->builder->top );
    206     g_snprintf( buf, sizeof( buf ), "%s.torrent (%d%%)", ui->builder->top,
    207                 0 );
    208 
    209     gtk_progress_bar_set_text( GTK_PROGRESS_BAR( ui->progressbar ), buf );
    210     g_free( tmp );
    211 
    212     trackers = tracker_list_get_trackers( ui->announce_list, &trackerCount );
    213 
    214     pref_int_set( ANNOUNCE_KEY"-count", trackerCount );
    215     for( i=0; i<trackerCount; ++i )
    216     {
    217         char key[512];
    218         g_snprintf( key, sizeof( key ), ANNOUNCE_KEY"-%d-tier", i );
    219         pref_int_set( key, trackers[i].tier );
    220         g_snprintf( key, sizeof( key ), ANNOUNCE_KEY"-%d-announce", i );
    221         pref_string_set( key, trackers[i].announce );
    222     }
    223 
    224     tr_makeMetaInfo( ui->builder,
    225                     NULL,
    226                     trackers, trackerCount,
    227                     gtk_entry_get_text( GTK_ENTRY( ui->comment_entry ) ),
    228                     gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( ui->
    229                                                                      private_check ) ) );
    230 
    231     tag = gtr_timeout_add_seconds( 1, refresh_cb, ui );
    232     g_object_set_data_full ( G_OBJECT( d ), "tag", GUINT_TO_POINTER(
    233                                  tag ), remove_tag );
    234 
    235     /* cleanup */
    236     for( i = 0; i < trackerCount; ++i )
    237         g_free( trackers[i].announce );
    238     g_free( trackers );
     257    }
     258    else if( response == GTK_RESPONSE_CLOSE )
     259    {
     260        gtk_widget_destroy( GTK_WIDGET( d ) );
     261    }
    239262}
    240263
     
    244267
    245268static void
    246 refreshFromBuilder( MakeMetaUI * ui )
    247 {
    248     char                  sizeStr[128];
    249     char                * buf;
    250     tr_metainfo_builder * builder = ui->builder;
    251     const char *          filename = builder ? builder->top : NULL;
    252 
    253 
    254     /* update the progressbar */
     269onSourceToggled( GtkToggleButton * tb, gpointer user_data )
     270{
     271    gtk_widget_set_sensitive( GTK_WIDGET( user_data ),
     272                              gtk_toggle_button_get_active( tb ) );
     273}
     274
     275static void
     276updatePiecesLabel( MakeMetaUI * ui )
     277{
     278    const tr_metainfo_builder * builder = ui->builder;
     279    const char * filename = builder ? builder->top : NULL;
     280    GString * gstr = g_string_new( NULL );
     281
     282    g_string_append( gstr, "<i>" );
    255283    if( !filename )
    256         buf = g_strdup( _( "No source selected" ) );
     284    {
     285        g_string_append( gstr, _( "No source selected" ) );
     286    }
    257287    else
    258         buf = g_strdup_printf( "%s.torrent (%d%%)", filename, 0 );
    259     gtk_progress_bar_set_text( GTK_PROGRESS_BAR( ui->progressbar ), buf );
    260     refreshButtons( ui );
    261     g_free( buf );
    262 
    263     /* update the size label */
    264     if( !filename )
    265         buf = g_strdup( "<i>No source selected</i>" );
    266     else {
    267         tr_strlsize( sizeStr, builder->totalSize, sizeof( sizeStr ) );
    268         buf = g_strdup_printf( /* %1$s is the torrent size
    269                                   %2$'d is its number of files */
    270                                ngettext( "<i>%1$s; %2$'d File</i>",
    271                                          "<i>%1$s; %2$'d Files</i>",
    272                                          builder->fileCount ),
    273                                sizeStr, builder->fileCount );
    274     }
    275     gtk_label_set_markup ( GTK_LABEL( ui->size_lb ), buf );
    276     g_free( buf );
    277 
    278     /* update the pieces label */
    279     if( !filename )
    280         buf = g_strdup( "" );
    281     else {
    282         char * countStr = g_strdup_printf( ngettext( "%'d Piece", "%'d Pieces",
    283                                                      builder->pieceCount ),
    284                                            builder->pieceCount );
    285         tr_strlsize( sizeStr, builder->pieceSize, sizeof( sizeStr ) );
    286         buf = g_strdup_printf( /* %1$s is number of pieces;
    287                                   %2$s is how big each piece is */
    288                                _( "%1$s @ %2$s" ), countStr, sizeStr );
    289         g_free( countStr );
    290     }
    291     gtk_label_set_markup ( GTK_LABEL( ui->pieces_lb ), buf );
    292     g_free( buf );
    293 }
    294 
    295 static void
    296 onSourceActivated( GtkEditable * editable,
    297                    gpointer      gui )
    298 {
    299     const char * filename = gtk_entry_get_text( GTK_ENTRY( editable ) );
    300     MakeMetaUI * ui = gui;
    301 
    302     if( ui->builder )
     288    {
     289        char buf[128];
     290        tr_strlsize( buf, builder->totalSize, sizeof( buf ) );
     291        g_string_append_printf( gstr, ngettext( "%1$s; %2$'d File",
     292                                                "%1$s; %2$'d Files",
     293                                                builder->fileCount ),
     294                                buf, builder->fileCount );
     295        g_string_append( gstr, "; " );
     296        tr_strlsize( buf, builder->pieceSize, sizeof( buf ) );
     297        g_string_append_printf( gstr, ngettext( "%1$'d Piece @ %2$s",
     298                                                "%1$'d Pieces @ %2$s",
     299                                                builder->pieceCount ),
     300                                      builder->pieceCount, buf );
     301    }
     302    g_string_append( gstr, "</i>" );
     303    gtk_label_set_markup ( GTK_LABEL( ui->pieces_lb ), gstr->str );
     304    g_string_free( gstr, TRUE );
     305}
     306
     307static void
     308setFilename( MakeMetaUI * ui, const char * filename )
     309{
     310    if( ui->builder ) {
    303311        tr_metaInfoBuilderFree( ui->builder );
    304     ui->builder = tr_metaInfoBuilderCreate( filename );
    305     refreshFromBuilder( ui );
    306 }
    307 
    308 static gboolean
    309 onSourceLostFocus( GtkWidget *           w,
    310                    GdkEventFocus * focus UNUSED,
    311                    gpointer              gui )
    312 {
    313     onSourceActivated( GTK_EDITABLE( w ), gui );
    314     return FALSE;
    315 }
    316 
    317 static void
    318 onChooseClicked( GtkButton *          button,
    319                  gpointer             gui,
    320                  const char *         title,
    321                  GtkFileChooserAction chooserAction )
    322 {
    323     GtkWidget * top = gtk_widget_get_toplevel( GTK_WIDGET( button ) );
    324     GtkWidget * d = gtk_file_chooser_dialog_new( title,
    325                                                  GTK_WINDOW(
    326                                                      top ),
    327                                                  chooserAction,
    328                                                  GTK_STOCK_CANCEL,
    329                                                  GTK_RESPONSE_CANCEL,
    330                                                  GTK_STOCK_ADD,
    331                                                  GTK_RESPONSE_ACCEPT,
    332                                                  NULL );
    333 
    334     if( gtk_dialog_run( GTK_DIALOG( d ) ) == GTK_RESPONSE_ACCEPT )
    335     {
    336         MakeMetaUI * ui = gui;
    337         char *       filename = gtk_file_chooser_get_filename(
    338              GTK_FILE_CHOOSER( d ) );
    339         gtk_entry_set_text( GTK_ENTRY( ui->filename_entry ), filename );
    340         onSourceActivated( GTK_EDITABLE( ui->filename_entry ), gui );
    341         g_free( filename );
    342     }
    343 
    344     gtk_widget_destroy( d );
    345 }
    346 
    347 static void
    348 onChooseDirectoryClicked( GtkButton * b,
    349                           gpointer    gui )
    350 {
    351     onChooseClicked( b, gui, _(
    352                          "Choose Directory" ),
    353                      GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
    354 }
    355 
    356 static void
    357 onChooseFileClicked( GtkButton * b,
    358                      gpointer    gui )
    359 {
    360     onChooseClicked( b, gui, _(
    361                          "Choose File" ), GTK_FILE_CHOOSER_ACTION_OPEN );
     312        ui->builder = NULL;
     313    }
     314
     315    if( filename )
     316        ui->builder = tr_metaInfoBuilderCreate( filename );
     317
     318    updatePiecesLabel( ui );
     319}
     320
     321static void
     322onChooserChosen( GtkFileChooser * chooser, gpointer user_data )
     323{
     324    char * filename;
     325    MakeMetaUI * ui = user_data;
     326
     327    g_object_set_data( G_OBJECT( chooser ), FILE_CHOSEN_KEY,
     328                       GINT_TO_POINTER( TRUE ) );
     329
     330    filename = gtk_file_chooser_get_filename( chooser );
     331    setFilename( ui, filename );
     332    g_free( filename );
     333}
     334
     335static void
     336onSourceToggled2( GtkToggleButton * tb, GtkWidget * chooser, MakeMetaUI * ui )
     337{
     338    if( gtk_toggle_button_get_active( tb ) )
     339    {
     340        if( g_object_get_data( G_OBJECT( chooser ), FILE_CHOSEN_KEY ) != NULL )
     341            onChooserChosen( GTK_FILE_CHOOSER( chooser ), ui );
     342        else
     343            setFilename( ui, NULL );
     344    }
     345}
     346static void
     347onFolderToggled( GtkToggleButton * tb, gpointer data )
     348{
     349    MakeMetaUI * ui = data;
     350    onSourceToggled2( tb, ui->folder_chooser, ui );
     351}
     352static void
     353onFileToggled( GtkToggleButton * tb, gpointer data )
     354{
     355    MakeMetaUI * ui = data;
     356    onSourceToggled2( tb, ui->file_chooser, ui );
     357}
     358
     359static const char *
     360getDefaultSavePath( void )
     361{
     362    const char * path;
     363#if GLIB_CHECK_VERSION( 2,14,0 )
     364    path = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
     365#else
     366    path = g_get_home_dir( );
     367#endif
     368    return path;
    362369}
    363370
    364371GtkWidget*
    365 make_meta_ui( GtkWindow  * parent,
    366               tr_session * session )
    367 {
    368     int          n;
    369     int          row = 0;
    370     GtkWidget *  d, *t, *w, *h, *h2, *v, *focusMe, *extras;
    371     GtkBox *     main_vbox;
     372make_meta_ui( GtkWindow  * parent, TrCore * core )
     373{
     374    int row = 0;
     375    const char * str;
     376    GtkWidget * d, *t, *w, *l, *fr, *sw;
     377    GSList * slist;
    372378    MakeMetaUI * ui = g_new0 ( MakeMetaUI, 1 );
    373379
    374     ui->session = session;
    375 
    376     d = gtk_dialog_new_with_buttons( _(
    377                                          "New Torrent" ),
     380    ui->core = core;
     381
     382    d = gtk_dialog_new_with_buttons( _( "New Torrent" ),
    378383                                     parent,
    379384                                     GTK_DIALOG_DESTROY_WITH_PARENT |
     
    381386                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
    382387                                     GTK_STOCK_NEW, GTK_RESPONSE_ACCEPT,
    383                                      GTK_STOCK_STOP, GTK_RESPONSE_CANCEL,
    384388                                     NULL );
    385     g_signal_connect( d, "response", G_CALLBACK( response_cb ), ui );
     389    ui->dialog = d;
     390    g_signal_connect( d, "response", G_CALLBACK( onResponse ), ui );
    386391    g_object_set_data_full( G_OBJECT( d ), "ui", ui, freeMetaUI );
    387     ui->dialog = d;
    388     main_vbox = GTK_BOX( GTK_DIALOG( d )->vbox );
    389392
    390393    t = hig_workarea_create ( );
    391394
    392     hig_workarea_add_section_title ( t, &row, _( "Source" ) );
    393 
    394     h = gtk_hbox_new( FALSE, GUI_PAD );
    395     v = gtk_vbox_new( FALSE, GUI_PAD_SMALL );
    396     w = ui->filename_entry = gtk_entry_new( );
    397     g_signal_connect( w, "activate", G_CALLBACK( onSourceActivated ), ui );
    398     g_signal_connect( w, "focus-out-event", G_CALLBACK(
    399                           onSourceLostFocus ), ui );
    400     gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
    401     h2 = gtk_hbox_new( FALSE, GUI_PAD_SMALL );
    402     w = ui->size_lb = gtk_label_new ( NULL );
    403     gtk_label_set_markup ( GTK_LABEL( w ), _( "<i>No source selected</i>" ) );
    404     gtk_box_pack_start( GTK_BOX( h2 ), w, FALSE, FALSE, GUI_PAD_SMALL );
    405     w = ui->pieces_lb = gtk_label_new ( NULL );
    406     gtk_box_pack_end( GTK_BOX( h2 ), w, FALSE, FALSE, GUI_PAD_SMALL );
    407     w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
    408     gtk_widget_set_size_request ( w, 2 * GUI_PAD_BIG, 0 );
    409     gtk_box_pack_start( GTK_BOX( h2 ), w, TRUE, TRUE, 0 );
    410     gtk_box_pack_start( GTK_BOX( v ), h2, FALSE, FALSE, 0 );
    411     gtk_box_pack_start( GTK_BOX( h ), v, TRUE, TRUE, 0 );
    412     v = gtk_vbox_new( FALSE, GUI_PAD_SMALL );
    413     w = gtr_button_new_from_stock( GTK_STOCK_DIRECTORY, _( "F_older" ) );
    414     focusMe = w;
    415     g_signal_connect( w, "clicked", G_CALLBACK(
    416                           onChooseDirectoryClicked ), ui );
    417     gtk_box_pack_start( GTK_BOX( v ), w, TRUE, TRUE, 0 );
    418     w = gtr_button_new_from_stock( GTK_STOCK_FILE, _( "_File" ) );
    419     g_signal_connect( w, "clicked", G_CALLBACK( onChooseFileClicked ), ui );
    420     gtk_box_pack_start( GTK_BOX( v ), w, TRUE, TRUE, 0 );
    421     gtk_box_pack_start( GTK_BOX( h ), v, FALSE, FALSE, 0 );
    422     hig_workarea_add_wide_control( t, &row, h );
     395    hig_workarea_add_section_title ( t, &row, _( "Files" ) );
     396
     397        str = _( "Sa_ve to:" );
     398        w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
     399        gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), getDefaultSavePath( ) );
     400        ui->destination_chooser = w;
     401        hig_workarea_add_row( t, &row, str, w, NULL );
     402
     403        l = gtk_radio_button_new_with_mnemonic( NULL, _( "Source F_older:" ) );
     404        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( l ), FALSE );
     405        w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
     406        g_signal_connect( l, "toggled", G_CALLBACK( onFolderToggled ), ui );
     407        g_signal_connect( l, "toggled", G_CALLBACK( onSourceToggled ), w );
     408        g_signal_connect( w, "selection-changed", G_CALLBACK( onChooserChosen ), ui );
     409        ui->folder_chooser = w;
     410        gtk_widget_set_sensitive( GTK_WIDGET( w ), FALSE );
     411        hig_workarea_add_row_w( t, &row, l, w, NULL );
     412
     413        slist = gtk_radio_button_get_group( GTK_RADIO_BUTTON( l ) ),
     414        l = gtk_radio_button_new_with_mnemonic( slist, _( "Source _File:" ) );
     415        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( l ), TRUE );
     416        w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_OPEN );
     417        g_signal_connect( l, "toggled", G_CALLBACK( onFileToggled ), ui );
     418        g_signal_connect( l, "toggled", G_CALLBACK( onSourceToggled ), w );
     419        g_signal_connect( w, "selection-changed", G_CALLBACK( onChooserChosen ), ui );
     420        ui->file_chooser = w;
     421        hig_workarea_add_row_w( t, &row, l, w, NULL );
     422
     423        w = gtk_label_new( NULL );
     424        ui->pieces_lb = w;
     425        gtk_label_set_markup( GTK_LABEL( w ), _( "<i>No source selected</i>" ) );
     426        hig_workarea_add_row( t, &row, NULL, w, NULL );
    423427
    424428    hig_workarea_add_section_divider( t, &row );
    425     hig_workarea_add_section_title( t, &row, _( "Trackers" ) );
    426 
    427     w = tracker_list_new( session, -1, TRUE );
    428 
    429     n = pref_int_get( ANNOUNCE_KEY"-count" );
    430     if( n > 0 )
    431     {
    432         int i;
    433         int trackerCount = 0;
    434         tr_tracker_info * trackers = g_new0( tr_tracker_info, n );
    435 
    436         for( i=0; i<n; ++i )
    437         {
    438             char key[512];
    439             int tier;
    440             const char * announce;
    441             g_snprintf( key, sizeof( key ), ANNOUNCE_KEY"-%d-tier", i );
    442             tier = pref_int_get( key );
    443             g_snprintf( key, sizeof( key ), ANNOUNCE_KEY"-%d-announce", i );
    444             announce = pref_string_get( key );
    445             if( tier >= 0 && announce && *announce ) {
    446                 trackers[trackerCount].tier = tier;
    447                 trackers[trackerCount++].announce = (char*) announce;
    448             }
    449         }
    450 
    451         if( trackerCount > 0 )
    452             tracker_list_add_trackers( w, trackers, trackerCount );
    453 
    454         g_free( trackers );
    455     }
    456 
    457     ui->announce_list = w;
    458     hig_workarea_add_wide_control( t, &row, w );
    459 
    460     hig_workarea_add_section_divider( t, &row );
    461     w = extras = gtk_expander_new_with_mnemonic( _( "<b>E_xtras</b>" ) );
    462     gtk_expander_set_use_markup( GTK_EXPANDER( w ), TRUE );
    463     hig_workarea_add_section_title_widget( t, &row, w );
    464 
    465     {
    466         int         row2 = 0;
    467         GtkWidget * t2 = hig_workarea_create( );
    468         w = ui->comment_entry = gtk_entry_new( );
    469         hig_workarea_add_row( t2, &row2, _( "Commen_t:" ), w, NULL );
    470         w =
    471             hig_workarea_add_wide_checkbutton( t2, &row2, _(
    472                                                    "_Private torrent" ),
    473                                                FALSE );
     429    hig_workarea_add_section_title ( t, &row, _( "Properties" ) );
     430
     431        str = _( "_Trackers:" );
     432        ui->announce_text_buffer = gtk_text_buffer_new( NULL );
     433        w = gtk_text_view_new_with_buffer( ui->announce_text_buffer );
     434        gtr_widget_set_tooltip_text( w, _( "Transmission supports HTTP and HTTPS (SSL) trackers.  Torrents with multiple trackers are also supported -- trackers from the same server (with similar URLs) must be grouped together and those from different servers separated by a blank line." ) );
     435        gtk_widget_set_size_request( w, -1, 80 );
     436        sw = gtk_scrolled_window_new( NULL, NULL );
     437        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
     438                                        GTK_POLICY_AUTOMATIC,
     439                                        GTK_POLICY_AUTOMATIC );
     440        gtk_container_add( GTK_CONTAINER( sw ), w );
     441        fr = gtk_frame_new( NULL );
     442        gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
     443        gtk_container_add( GTK_CONTAINER( fr ), sw );
     444        hig_workarea_add_tall_row( t, &row, str, fr, NULL );
     445
     446        l = gtk_check_button_new_with_mnemonic( _( "Co_mment:" ) );
     447        ui->comment_check = l;
     448        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( l ), FALSE );
     449        w = gtk_entry_new( );
     450        ui->comment_entry = w;
     451        gtk_widget_set_sensitive( GTK_WIDGET( w ), FALSE );
     452        g_signal_connect( l, "toggled", G_CALLBACK( onSourceToggled ), w );
     453        hig_workarea_add_row_w( t, &row, l, w, NULL );
     454
     455        w = hig_workarea_add_wide_checkbutton( t, &row, _( "_Private torrent" ), FALSE );
    474456        ui->private_check = w;
    475         hig_workarea_finish( t2, &row2 );
    476         gtk_container_add( GTK_CONTAINER( extras ), t2 );
    477     }
    478 
     457 
    479458    hig_workarea_finish( t, &row );
    480     gtk_box_pack_start( main_vbox, t, TRUE, TRUE, 0 );
    481 
    482     w = gtk_frame_new( NULL );
    483     gtk_frame_set_shadow_type( GTK_FRAME( w ), GTK_SHADOW_NONE );
    484     gtk_container_set_border_width( GTK_CONTAINER( w ), GUI_PAD );
    485     gtk_container_add( GTK_CONTAINER( w ), gtk_hseparator_new( ) );
    486     gtk_box_pack_start( main_vbox, w, FALSE, FALSE, 0 );
    487 
    488     w = gtk_frame_new( NULL );
    489     gtk_frame_set_shadow_type( GTK_FRAME( w ), GTK_SHADOW_NONE );
    490     gtk_container_set_border_width( GTK_CONTAINER( w ), GUI_PAD );
    491     ui->progressbar = gtk_progress_bar_new( );
    492     gtk_progress_bar_set_text( GTK_PROGRESS_BAR( ui->progressbar ),
    493                               _( "No source selected" ) );
    494     gtk_container_add( GTK_CONTAINER( w ), ui->progressbar );
    495     gtk_box_pack_start( main_vbox, w, FALSE, FALSE, 0 );
    496 
    497     gtk_window_set_default_size( GTK_WINDOW( d ), 500, 0 );
    498     gtk_widget_show_all( GTK_DIALOG( d )->vbox );
    499     setIsBuilding( ui, FALSE );
    500     gtk_widget_grab_focus( focusMe );
     459    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), t, TRUE, TRUE, 0 );
     460
    501461    return d;
    502462}
    503 
  • trunk/gtk/makemeta-ui.h

    r7658 r9130  
    1515
    1616#include <gtk/gtk.h>
    17 #include <libtransmission/transmission.h>
     17#include "tr-core.h"
    1818
    19 GtkWidget* make_meta_ui( GtkWindow  * parent,
    20                          tr_session * session );
     19GtkWidget* make_meta_ui( GtkWindow  * parent, TrCore * core );
    2120
    2221#endif
  • trunk/gtk/tr-core.c

    r9071 r9130  
    862862}
    863863
     864void
     865tr_core_add_ctor( TrCore * core, tr_ctor * ctor )
     866{
     867    const gboolean doStart = pref_flag_get( PREF_KEY_START );
     868    const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     869    tr_core_apply_defaults( ctor );
     870    add_ctor( core, ctor, doStart, doPrompt );
     871}
     872
    864873/* invoked remotely via dbus. */
    865874gboolean
  • trunk/gtk/tr-core.h

    r8889 r9130  
    136136                               GError     ** err );
    137137
     138/** @brief Add a torrent.
     139    @param ctor this function assumes ownership of the ctor */
     140void tr_core_add_ctor( TrCore  * core,
     141                       tr_ctor * ctor );
     142
     143
    138144/** Add a torrent. */
    139145void tr_core_add_torrent( TrCore*, TrTorrent*, gboolean doNotify );
Note: See TracChangeset for help on using the changeset viewer.