Changeset 144


Ignore:
Timestamp:
Mar 11, 2006, 3:46:59 AM (16 years ago)
Author:
titer
Message:

Fixing the progress cell. The progress also is resizable now.

Location:
branches/new_api/macosx
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/new_api/macosx/English.lproj/MainMenu.nib/info.nib

    r106 r144  
    1616                <string>54 521 112 118 0 0 1152 842 </string>
    1717                <key>783</key>
    18                 <string>483 459 420 250 0 0 1440 878 </string>
     18                <string>411 429 420 250 0 0 1280 832 </string>
    1919                <key>796</key>
    2020                <string>484 520 420 129 0 0 1440 878 </string>
     
    2727        <integer>3</integer>
    2828        <key>IBSystem Version</key>
    29         <string>8F1111g</string>
     29        <string>8H14</string>
    3030</dict>
    3131</plist>
  • branches/new_api/macosx/ProgressCell.h

    r143 r144  
    2929@interface ProgressCell : NSCell
    3030{
    31     Torrent * fTorrent;
    32     NSColor * fTextColor;
     31    Torrent          * fTorrent;
     32    NSColor          * fTextColor;
     33
     34    NSBitmapImageRep * fBackground;
     35    NSBitmapImageRep * fBitmap;
     36    int                fWidth;
     37    int8_t           * fPieces;
    3338}
    3439- (void) setTorrent:   (Torrent *) torrent;
  • branches/new_api/macosx/ProgressCell.m

    r143 r144  
    8181      0x00ED00FF, 0x00F200FF, 0x00F400FF, 0x00B500FF };
    8282
     83/* 0, 255, 0 */
     84static uint32_t kBack[] =
     85    { 0xB2B2B2FF, 0xDADADAFF, 0xEAEAEAFF, 0xECECECFF, 0xEAEAEAFF,
     86      0xE2E2E2FF, 0xE1E1E1FF, 0xE7E7E7FF, 0xEDEDEDFF, 0xF3F3F3FF,
     87      0xF6F6F6FF, 0xF8F8F8FF, 0xFAFAFAFF, 0xD7D7D7FF };
     88
    8389- (void) setTorrent: (Torrent *) torrent
    8490{
     
    9197}
    9298
    93 #if 0
    9499/***********************************************************************
    95100 * init
     
    104109    /* Load the background image for the progress bar and get it as a
    105110       32-bit bitmap */
    106     fBackgroundBmp = [[[NSImage imageNamed: @"Progress.png"]
    107                         representations] objectAtIndex: 0];
    108 
    109     /* Allocate another bitmap of the same size. We will draw the
    110        progress bar in it */
    111     fProgressBmp = [[NSBitmapImageRep alloc]
    112         initWithBitmapDataPlanes: NULL pixelsWide:
    113         [fBackgroundBmp size].width pixelsHigh:
    114         [fBackgroundBmp size].height bitsPerSample: 8
    115         samplesPerPixel: 4 hasAlpha: YES isPlanar: NO
    116         colorSpaceName: NSCalibratedRGBColorSpace
    117         bytesPerRow: 0 bitsPerPixel: 0];
     111    fBackground = [[[NSImage imageNamed: @"Progress.png"]
     112                     representations] objectAtIndex: 0];
    118113
    119114    return self;
     
    121116
    122117/***********************************************************************
    123  * setStat
    124  ***********************************************************************
    125  * Readies ourselves to draw updated info.
    126  **********************************************************************/
    127 - (void) setStat: (tr_stat_t *) stat whiteText: (BOOL) w
    128 {
    129     int i;
    130     uint8_t * in, * out;
    131 
    132     fStat      = stat;
    133     fWhiteText = w;
    134 
    135     /* Update the strings to be displayed */
    136     if( fStat->progress == 1.0 )
    137         fDlString = [@"Ratio: " stringByAppendingString:
    138                         [NSString stringForRatio: fStat->downloaded
    139                             upload: fStat->uploaded]];
     118 * buildSimpleBar
     119 **********************************************************************/
     120- (void) buildSimpleBar
     121{
     122    int        h, w, end, pixelsPerRow;
     123    uint32_t * p;
     124    uint32_t * colors;
     125
     126    pixelsPerRow = [fBitmap bytesPerRow] / 4;
     127
     128    /* The background image is 124*18 pixels, but the actual
     129       progress bar is 120*14 : the first two columns, the last
     130       two columns and the last four lines contain the shadow. */
     131
     132    p   = (uint32_t *) [fBitmap bitmapData] + 2;
     133    end = lrintf( floor( 0.5 /*fStat->progress*/ * fWidth ) );
     134
     135    /*
     136    if( fStat->status & TR_STATUS_SEED )
     137        colors = kGreen;
     138    else if( fStat->status & ( TR_STATUS_CHECK | TR_STATUS_DOWNLOAD ) )
     139    */
     140        colors = kBlue2;
     141    /*
    140142    else
    141         fDlString = [@"DL: " stringByAppendingString:
    142                         [NSString stringForSpeed: fStat->rateDownload]];
    143     fUlString = [@"UL: " stringByAppendingString:
    144                     [NSString stringForSpeed: fStat->rateUpload]];
     143        colors = kGray;
     144    */
     145
     146    for( h = 0; h < 14; h++ )
     147    {
     148        for( w = 0; w < end; w++ )
     149        {
     150            p[w] = htonl( colors[h] );
     151        }
     152        for( w = end; w < fWidth; w++ )
     153        {
     154            p[w] = htonl( kBack[h] );
     155        }
     156        p += pixelsPerRow;
     157    }
     158}
     159
     160/***********************************************************************
     161 * buildAdvancedBar
     162 **********************************************************************/
     163- (void) buildAdvancedBar
     164{
     165    int        h, w, end, pixelsPerRow;
     166    uint32_t * p;
     167    uint32_t * colors;
     168
     169    fPieces = malloc( fWidth );
     170    [fTorrent getAvailability: fPieces size: fWidth];
     171
     172#if 0
     173    if( fStat->status & TR_STATUS_SEED )
     174    {
     175        /* All green, same as the simple bar */
     176        [self buildSimpleBar];
     177        return;
     178    }
     179#endif
     180
     181    pixelsPerRow = [fBitmap bytesPerRow] / 4;
     182
     183    /* First two lines: dark blue to show progression */
     184    p    = (uint32_t *) [fBitmap bitmapData];
     185    p   += 2;
     186    end  = lrintf( floor( /*fStat->progress*/ 0.5 * fWidth ) );
     187    for( h = 0; h < 2; h++ )
     188    {
     189        for( w = 0; w < end; w++ )
     190        {
     191            p[w] = htonl( kBlue4[h] );
     192        }
     193        for( w = end; w < fWidth; w++ )
     194        {
     195            p[w] = htonl( kBack[h] );
     196        }
     197        p += pixelsPerRow;
     198    }
     199
     200    /* Lines 2 to 14: blue or grey depending on whether
     201       we have the piece or not */
     202    for( w = 0; w < fWidth; w++ )
     203    {
     204        /* Point to pixel ( 2 + w, 2 ). We will then draw
     205           "vertically" */
     206        p  = (uint32_t *) ( [fBitmap bitmapData] +
     207                2 * [fBitmap bytesPerRow] );
     208        p += 2 + w;
     209
     210        if( fPieces[w] < 0 )
     211        {
     212            colors = kGray;
     213        }
     214        else if( fPieces[w] < 1 )
     215        {
     216            colors = kRed;
     217        }
     218        else if( fPieces[w] < 2 )
     219        {
     220            colors = kBlue1;
     221        }
     222        else if( fPieces[w] < 3 )
     223        {
     224            colors = kBlue2;
     225        }
     226        else
     227        {
     228            colors = kBlue3;
     229        }
     230
     231        for( h = 2; h < 14; h++ )
     232        {
     233            p[0]  = htonl( colors[h] );
     234            p    += pixelsPerRow;
     235        }
     236    }
     237
     238    free( fPieces );
     239}
     240
     241- (void) buildBar
     242{
     243    int i, j;
     244    uint32_t * in, * out;
    145245
    146246    /* Reset our bitmap to the background image... */
    147     in  = [fBackgroundBmp bitmapData];
    148     out = [fProgressBmp bitmapData];
    149     for( i = 0; i < [fProgressBmp size].height; i++ )
    150     {
    151         memcpy( out, in, [fProgressBmp size].width * 4 );
    152         in  += [fBackgroundBmp bytesPerRow];
    153         out += [fProgressBmp bytesPerRow];
     247    in  = (uint32_t *) [fBackground bitmapData];
     248    out = (uint32_t *) [fBitmap bitmapData];
     249    for( i = 0; i < [fBitmap size].height - 4; i++ )
     250    {
     251        for( j = 0; j < 2; j++ )
     252        {
     253            out[j] = in[j];
     254        }
     255        for( j = fWidth + 2; j < fWidth + 4; j++ )
     256        {
     257            out[j] = in[(int)[fBackground size].width + j - fWidth - 4];
     258        }
     259        in  += [fBackground bytesPerRow] / 4;
     260        out += [fBitmap bytesPerRow] / 4;
     261    }
     262    for( i = [fBitmap size].height - 4; i < [fBitmap size].height; i++ )
     263    {
     264        for( j = 0; j < 2; j++ )
     265        {
     266            out[j] = in[j];
     267        }
     268        for( j = 2; j < fWidth + 2; j++ )
     269        {
     270            out[j] = in[2];
     271        }
     272        for( j = fWidth + 2; j < fWidth + 4; j++ )
     273        {
     274            out[j] = in[(int)[fBackground size].width + j - fWidth - 4];
     275        }
     276        in  += [fBackground bytesPerRow] / 4;
     277        out += [fBitmap bytesPerRow] / 4;
    154278    }
    155279
     
    165289    }
    166290}
    167 
    168 /***********************************************************************
    169  * buildSimpleBar
    170  **********************************************************************/
    171 - (void) buildSimpleBar
    172 {
    173     int        h, w, end, pixelsPerRow;
    174     uint32_t * p;
    175     uint32_t * colors;
    176 
    177     pixelsPerRow = [fProgressBmp bytesPerRow] / 4;
    178 
    179     /* The background image is 124*18 pixels, but the actual
    180        progress bar is 120*14 : the first two columns, the last
    181        two columns and the last four lines contain the shadow. */
    182 
    183     p   = (uint32_t *) [fProgressBmp bitmapData] + 2;
    184     end = lrintf( floor( fStat->progress * 120 ) );
    185 
    186     if( fStat->status & TR_STATUS_SEED )
    187         colors = kGreen;
    188     else if( fStat->status & ( TR_STATUS_CHECK | TR_STATUS_DOWNLOAD ) )
    189         colors = kBlue2;
    190     else
    191         colors = kGray;
    192 
    193     for( h = 0; h < 14; h++ )
    194     {
    195         for( w = 0; w < end; w++ )
    196         {
    197             p[w] = htonl( colors[h] );
    198         }
    199         p += pixelsPerRow;
    200     }
    201 }
    202 
    203 /***********************************************************************
    204  * buildAdvancedBar
    205  **********************************************************************/
    206 - (void) buildAdvancedBar
    207 {
    208     int        h, w, end, pixelsPerRow;
    209     uint32_t * p;
    210     uint32_t * colors;
    211 
    212     if( fStat->status & TR_STATUS_SEED )
    213     {
    214         /* All green, same as the simple bar */
    215         [self buildSimpleBar];
    216         return;
    217     }
    218 
    219     pixelsPerRow = [fProgressBmp bytesPerRow] / 4;
    220 
    221     /* First two lines: dark blue to show progression */
    222     p    = (uint32_t *) [fProgressBmp bitmapData];
    223     p   += 2;
    224     end  = lrintf( floor( fStat->progress * 120 ) );
    225     for( h = 0; h < 2; h++ )
    226     {
    227         for( w = 0; w < end; w++ )
    228         {
    229             p[w] = htonl( kBlue4[h] );
    230         }
    231         p += pixelsPerRow;
    232     }
    233 
    234     /* Lines 2 to 14: blue or grey depending on whether
    235        we have the piece or not */
    236     for( w = 0; w < 120; w++ )
    237     {
    238         /* Point to pixel ( 2 + w, 2 ). We will then draw
    239            "vertically" */
    240         p  = (uint32_t *) ( [fProgressBmp bitmapData] +
    241                 2 * [fProgressBmp bytesPerRow] );
    242         p += 2 + w;
    243 
    244         if( fStat->pieces[w] < 0 )
    245         {
    246             colors = kGray;
    247         }
    248         else if( fStat->pieces[w] < 1 )
    249         {
    250             colors = kRed;
    251         }
    252         else if( fStat->pieces[w] < 2 )
    253         {
    254             colors = kBlue1;
    255         }
    256         else if( fStat->pieces[w] < 3 )
    257         {
    258             colors = kBlue2;
    259         }
    260         else
    261         {
    262             colors = kBlue3;
    263         }
    264 
    265         for( h = 2; h < 14; h++ )
    266         {
    267             p[0]  = htonl( colors[h] );
    268             p    += pixelsPerRow;
    269         }
    270     }
    271 }
    272 #endif
    273291
    274292/***********************************************************************
     
    280298- (void) drawWithFrame: (NSRect) cellFrame inView: (NSView *) view
    281299{
    282 #if 0
    283300    NSImage * img;
    284301    NSMutableDictionary * attributes;
     
    291308
    292309    pen = cellFrame.origin;
     310
     311    fWidth  = NSWidth( cellFrame ) - 14;
     312
     313    fBitmap = [[NSBitmapImageRep alloc]
     314        initWithBitmapDataPlanes: nil pixelsWide: fWidth + 4
     315        pixelsHigh: 18 bitsPerSample: 8 samplesPerPixel: 4
     316        hasAlpha: YES isPlanar: NO colorSpaceName:
     317        NSCalibratedRGBColorSpace bytesPerRow: 0 bitsPerPixel: 0];
     318    [self buildBar];
    293319
    294320    /* Init an NSImage with our bitmap in order to draw it. We need to
     
    296322       display is set to thousands of colors when Transmission was
    297323       started */
    298     img = [[NSImage alloc] initWithSize: [fProgressBmp size]];
    299     [img addRepresentation: fProgressBmp];
     324    img = [[NSImage alloc] initWithSize: [fBitmap size]];
     325    [img addRepresentation: fBitmap];
    300326    [img setFlipped: YES];
    301327
     
    303329    pen.x += 5; pen.y += 5;
    304330    [img drawAtPoint: pen fromRect: NSMakeRect( 0, 0,
    305             [fProgressBmp size].width, [fProgressBmp size].height )
     331            [img size].width, [img size].height )
    306332        operation: NSCompositeSourceOver fraction: 1.0];
    307333
    308334    [img release];
     335    [fBitmap release];
    309336
    310337    /* Draw the strings with font 10 */
    311338    attributes = [NSDictionary dictionaryWithObjectsAndKeys:
    312         [NSFont messageFontOfSize: 10.0],
    313         NSFontAttributeName,
    314         fWhiteText ? [NSColor whiteColor] : [NSColor blackColor],
    315         NSForegroundColorAttributeName,
    316         NULL];
     339        [NSFont messageFontOfSize: 10.0], NSFontAttributeName,
     340        fTextColor, NSForegroundColorAttributeName, nil];
    317341    pen.x += 5; pen.y += 20;
    318     [fDlString drawAtPoint: pen withAttributes: attributes];
     342    [[fTorrent downloadString] drawAtPoint: pen withAttributes: attributes];
    319343    pen.x += 0; pen.y += 15;
    320     [fUlString drawAtPoint: pen withAttributes: attributes];
     344    [[fTorrent uploadString] drawAtPoint: pen withAttributes: attributes];
    321345
    322346    [view unlockFocus];
    323 #endif
    324347}
    325348
  • branches/new_api/macosx/Torrent.h

    r142 r144  
    3030    tr_info_t    * fInfo;
    3131    tr_stat_t    * fStat;
    32     int8_t         fPieces[120];
    3332    BOOL           fResumeOnWake;
    3433
     
    3635    NSMutableString * fStatusString;
    3736    NSMutableString * fInfoString;
     37    NSMutableString * fDownloadString;
     38    NSMutableString * fUploadString;
    3839}
    3940
     
    4142- (void)       setFolder: (NSString *) path;
    4243- (NSString *) getFolder;
     44- (void)       getAvailability: (int8_t *) tab size: (int) size;
    4345
    4446- (void)       update;
     
    5860- (NSString *) statusString;
    5961- (NSString *) infoString;
     62- (NSString *) downloadString;
     63- (NSString *) uploadString;
    6064
    6165@end
  • branches/new_api/macosx/Torrent.m

    r142 r144  
    2222
    2323#import "Torrent.h"
     24#import "StringAdditions.h"
    2425
    2526@implementation Torrent
     
    4546    [fIcon retain];
    4647
    47     fStatusString = [[NSMutableString alloc] initWithCapacity: 50];
    48     fInfoString   = [[NSMutableString alloc] initWithCapacity: 50];
     48    fStatusString   = [[NSMutableString alloc] initWithCapacity: 50];
     49    fInfoString     = [[NSMutableString alloc] initWithCapacity: 50];
     50    fDownloadString = [[NSMutableString alloc] initWithCapacity: 10];
     51    fUploadString   = [[NSMutableString alloc] initWithCapacity: 10];
    4952
    5053    [self update];
     
    6063        [fStatusString release];
    6164        [fInfoString release];
     65        [fDownloadString release];
     66        [fUploadString release];
    6267    }
    6368    [super dealloc];
     
    7277{
    7378    return [NSString stringWithUTF8String: tr_torrentGetFolder( fHandle )];
     79}
     80
     81- (void) getAvailability: (int8_t *) tab size: (int) size
     82{
     83    tr_torrentAvailability( fHandle, tab, size );
    7484}
    7585
     
    135145#endif
    136146
    137     tr_torrentAvailability( fHandle, fPieces, 120 );
     147    [fUploadString   setString: @""];
     148    if( fStat->progress == 1.0 )
     149    {
     150        [fDownloadString setString: @"Ratio: "];
     151        [fDownloadString appendString: [NSString stringForRatio:
     152            fStat->downloaded upload: fStat->uploaded]];
     153    }
     154    else
     155    {
     156        [fDownloadString setString: @"DL: "];
     157        [fDownloadString appendString: [NSString stringForSpeed:
     158            fStat->rateDownload]];
     159    }
     160    [fUploadString setString: @"UL: "];
     161    [fUploadString appendString: [NSString stringForSpeed:
     162        fStat->rateUpload]];
    138163}
    139164
     
    220245}
    221246
     247- (NSString *) downloadString
     248{
     249    return fDownloadString;
     250}
     251
     252- (NSString *) uploadString
     253{
     254    return fUploadString;
     255}
     256
    222257@end
Note: See TracChangeset for help on using the changeset viewer.