/******************************************************************************
 * $Id: InfoOptionsViewController.m 13601 2012-10-29 22:44:12Z livings124 $
 *
 * Copyright (c) 2010-2012 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.
 *****************************************************************************/

#import "InfoOptionsViewController.h"
#import "NSStringAdditions.h"
#import "Torrent.h"

#define OPTION_POPUP_GLOBAL 0
#define OPTION_POPUP_NO_LIMIT 1
#define OPTION_POPUP_LIMIT 2

#define OPTION_POPUP_PRIORITY_HIGH 0
#define OPTION_POPUP_PRIORITY_NORMAL 1
#define OPTION_POPUP_PRIORITY_LOW 2

#define INVALID -99

@interface InfoOptionsViewController (Private)

- (void) setupInfo;
- (void) setGlobalLabels;
- (void) updateOptionsNotification: (NSNotification *) notification;

@end

@implementation InfoOptionsViewController

- (id) init
{
    if ((self = [super initWithNibName: @"InfoOptionsView" bundle: nil]))
    {
        [self setTitle: NSLocalizedString(@"Options", "Inspector view -> title")];
    }
    
    return self;
}

- (void) awakeFromNib
{
    [self setGlobalLabels];
    
    [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(setGlobalLabels) name: @"UpdateGlobalOptions" object: nil];
    [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(updateOptionsNotification:) name: @"UpdateOptionsNotification" object: nil];
    
    #warning remove when 10.7-only with auto layout
    const CGFloat padding = 6.0; //this shows as 8 in IB
    [fPrioritySectionLabel sizeToFit];
    [fPriorityLabel sizeToFit];
    NSRect priorityPopUpFrame = [fPriorityPopUp frame];
    priorityPopUpFrame.origin.x = NSMaxX([fPriorityLabel frame]) + padding;
    [fPriorityPopUp setFrame: priorityPopUpFrame];
    
    [fTransferBandwidthSectionLabel sizeToFit];
    [fDownloadLimitCheck sizeToFit];
    [fUploadLimitCheck sizeToFit];
    NSRect downloadLimitFieldFrame = [fDownloadLimitField frame];
    NSRect uploadLimitFieldFrame = [fUploadLimitField frame];
    const CGFloat speedLimitFieldX = MAX(NSMaxX([fDownloadLimitCheck frame]), NSMaxX([fUploadLimitCheck frame])) + padding;
    downloadLimitFieldFrame.origin.x = speedLimitFieldX;
    uploadLimitFieldFrame.origin.x = speedLimitFieldX;
    [fDownloadLimitField setFrame: downloadLimitFieldFrame];
    [fUploadLimitField setFrame: uploadLimitFieldFrame];
    [fDownloadLimitLabel sizeToFit];
    [fUploadLimitLabel sizeToFit];
    NSRect downloadLimitLabelFrame = [fDownloadLimitLabel frame];
    NSRect uploadLimitLabelFrame = [fUploadLimitLabel frame];
    downloadLimitLabelFrame.origin.x = NSMaxX([fDownloadLimitField frame]) + padding;
    uploadLimitLabelFrame.origin.x = NSMaxX([fUploadLimitField frame]) + padding;
    [fDownloadLimitLabel setFrame: downloadLimitLabelFrame];
    [fUploadLimitLabel setFrame: uploadLimitLabelFrame];
    [fGlobalLimitCheck sizeToFit];
    
    [fSeedingLimitsSectionLabel sizeToFit];
    [fRatioLabel sizeToFit];
    [fInactivityLabel sizeToFit];
    NSRect ratioPopUpFrame = [fRatioPopUp frame];
    NSRect idlePopUpFrame = [fIdlePopUp frame];
    const CGFloat seedingLimitPopUpX = MAX(NSMaxX([fRatioLabel frame]), NSMaxX([fInactivityLabel frame])) + padding;
    ratioPopUpFrame.origin.x = seedingLimitPopUpX;
    idlePopUpFrame.origin.x = seedingLimitPopUpX;
    [fRatioPopUp setFrame: ratioPopUpFrame];
    [fIdlePopUp setFrame: idlePopUpFrame];
    NSRect ratioLimitFieldFrame = [fRatioLimitField frame];
    NSRect idleLimitFieldFrame = [fIdleLimitField frame];
    const CGFloat seedingLimitFieldX = NSMaxX(ratioPopUpFrame) + padding;
    ratioLimitFieldFrame.origin.x = seedingLimitFieldX + 2.0;
    idleLimitFieldFrame.origin.x = seedingLimitFieldX + 2.0;
    [fRatioLimitField setFrame: ratioLimitFieldFrame];
    [fIdleLimitField setFrame: idleLimitFieldFrame];
    [fIdleLimitLabel sizeToFit];
    NSRect idleLimitLabelFrame = [fIdleLimitLabel frame];
    idleLimitLabelFrame.origin.x = NSMaxX(idleLimitFieldFrame) + padding;
    [fIdleLimitLabel setFrame: idleLimitLabelFrame];
    NSRect ratioLimitGlobalLabelFrame = [fRatioLimitGlobalLabel frame];
    NSRect idleLimitGlobalLabelFrame = [fIdleLimitGlobalLabel frame];
    ratioLimitGlobalLabelFrame.origin.x = seedingLimitFieldX;
    idleLimitGlobalLabelFrame.origin.x = seedingLimitFieldX;
    [fRatioLimitGlobalLabel setFrame: ratioLimitGlobalLabelFrame];
    [fIdleLimitGlobalLabel setFrame: idleLimitGlobalLabelFrame];
    [fRemoveSeedingCompleteCheck sizeToFit];
    
    [fAdvancedSectionLabel sizeToFit];
    [fMaxConnectionsLabel sizeToFit];
    NSRect peersConnectFrame = [fPeersConnectField frame];
    peersConnectFrame.origin.x = NSMaxX([fMaxConnectionsLabel frame]) + padding;
    [fPeersConnectField setFrame: peersConnectFrame];
    [fPeersConnectLabel sizeToFit];
    NSRect peersConnectLabelFrame = [fPeersConnectLabel frame];
    peersConnectLabelFrame.origin.x = NSMaxX(peersConnectFrame) + padding;
    [fPeersConnectLabel setFrame: peersConnectLabelFrame];
}

- (void) dealloc
{
    [[NSNotificationCenter defaultCenter] removeObserver: self];
    
    [fTorrents release];
    
    [super dealloc];
}

- (void) setInfoForTorrents: (NSArray *) torrents
{
    //don't check if it's the same in case the metadata changed
    [fTorrents release];
    fTorrents = [torrents retain];
    
    fSet = NO;
}

- (void) updateInfo
{
    if (!fSet)
        [self setupInfo];
    
    fSet = YES;
}

- (void) updateOptions
{
    if ([fTorrents count] == 0)
        return;
    
    //get bandwidth info
    NSEnumerator * enumerator = [fTorrents objectEnumerator];
    Torrent * torrent = [enumerator nextObject]; //first torrent
    
    NSInteger uploadUseSpeedLimit = [torrent usesSpeedLimit: YES] ? NSOnState : NSOffState,
                uploadSpeedLimit = [torrent speedLimit: YES],
                downloadUseSpeedLimit = [torrent usesSpeedLimit: NO] ? NSOnState : NSOffState,
                downloadSpeedLimit = [torrent speedLimit: NO],
                globalUseSpeedLimit = [torrent usesGlobalSpeedLimit] ? NSOnState : NSOffState;
    
    while ((torrent = [enumerator nextObject])
            && (uploadUseSpeedLimit != NSMixedState || uploadSpeedLimit != INVALID
                || downloadUseSpeedLimit != NSMixedState || downloadSpeedLimit != INVALID
                || globalUseSpeedLimit != NSMixedState))
    {
        if (uploadUseSpeedLimit != NSMixedState && uploadUseSpeedLimit != ([torrent usesSpeedLimit: YES] ? NSOnState : NSOffState))
            uploadUseSpeedLimit = NSMixedState;
        
        if (uploadSpeedLimit != INVALID && uploadSpeedLimit != [torrent speedLimit: YES])
            uploadSpeedLimit = INVALID;
        
        if (downloadUseSpeedLimit != NSMixedState && downloadUseSpeedLimit != ([torrent usesSpeedLimit: NO] ? NSOnState : NSOffState))
            downloadUseSpeedLimit = NSMixedState;
        
        if (downloadSpeedLimit != INVALID && downloadSpeedLimit != [torrent speedLimit: NO])
            downloadSpeedLimit = INVALID;
        
        if (globalUseSpeedLimit != NSMixedState && globalUseSpeedLimit != ([torrent usesGlobalSpeedLimit] ? NSOnState : NSOffState))
            globalUseSpeedLimit = NSMixedState;
    }
    
    //set upload view
    [fUploadLimitCheck setState: uploadUseSpeedLimit];
    [fUploadLimitCheck setEnabled: YES];
    
    [fUploadLimitLabel setEnabled: uploadUseSpeedLimit == NSOnState];
    [fUploadLimitField setEnabled: uploadUseSpeedLimit == NSOnState];
    if (uploadSpeedLimit != INVALID)
        [fUploadLimitField setIntValue: uploadSpeedLimit];
    else
        [fUploadLimitField setStringValue: @""];
    
    //set download view
    [fDownloadLimitCheck setState: downloadUseSpeedLimit];
    [fDownloadLimitCheck setEnabled: YES];
    
    [fDownloadLimitLabel setEnabled: downloadUseSpeedLimit == NSOnState];
    [fDownloadLimitField setEnabled: downloadUseSpeedLimit == NSOnState];
    if (downloadSpeedLimit != INVALID)
        [fDownloadLimitField setIntValue: downloadSpeedLimit];
    else
        [fDownloadLimitField setStringValue: @""];
    
    //set global check
    [fGlobalLimitCheck setState: globalUseSpeedLimit];
    [fGlobalLimitCheck setEnabled: YES];
    
    //get ratio and idle info
    enumerator = [fTorrents objectEnumerator];
    torrent = [enumerator nextObject]; //first torrent
    
    NSInteger checkRatio = [torrent ratioSetting], checkIdle = [torrent idleSetting],
            removeWhenFinishSeeding = [torrent removeWhenFinishSeeding] ? NSOnState : NSOffState;
    CGFloat ratioLimit = [torrent ratioLimit];
    NSUInteger idleLimit = [torrent idleLimitMinutes];
    
    while ((torrent = [enumerator nextObject])
            && (checkRatio != INVALID || ratioLimit != INVALID || checkIdle != INVALID || idleLimit != INVALID))
    {
        if (checkRatio != INVALID && checkRatio != [torrent ratioSetting])
            checkRatio = INVALID;
        
        if (ratioLimit != INVALID && ratioLimit != [torrent ratioLimit])
            ratioLimit = INVALID;
        
        if (checkIdle != INVALID && checkIdle != [torrent idleSetting])
            checkIdle = INVALID;
        
        if (idleLimit != INVALID && idleLimit != [torrent idleLimitMinutes])
            idleLimit = INVALID;
        
        if (removeWhenFinishSeeding != NSMixedState && removeWhenFinishSeeding != ([torrent removeWhenFinishSeeding] ? NSOnState : NSOffState))
            removeWhenFinishSeeding = NSMixedState;
    }
    
    //set ratio view
    NSInteger index;
    if (checkRatio == TR_RATIOLIMIT_SINGLE)
        index = OPTION_POPUP_LIMIT;
    else if (checkRatio == TR_RATIOLIMIT_UNLIMITED)
        index = OPTION_POPUP_NO_LIMIT;
    else if (checkRatio == TR_RATIOLIMIT_GLOBAL)
        index = OPTION_POPUP_GLOBAL;
    else
        index = -1;
    [fRatioPopUp selectItemAtIndex: index];
    [fRatioPopUp setEnabled: YES];
    
    [fRatioLimitField setHidden: checkRatio != TR_RATIOLIMIT_SINGLE];
    if (ratioLimit != INVALID)
        [fRatioLimitField setFloatValue: ratioLimit];
    else
        [fRatioLimitField setStringValue: @""];
    
    [fRatioLimitGlobalLabel setHidden: checkRatio != TR_RATIOLIMIT_GLOBAL];
    
    //set idle view
    if (checkIdle == TR_IDLELIMIT_SINGLE)
        index = OPTION_POPUP_LIMIT;
    else if (checkIdle == TR_IDLELIMIT_UNLIMITED)
        index = OPTION_POPUP_NO_LIMIT;
    else if (checkIdle == TR_IDLELIMIT_GLOBAL)
        index = OPTION_POPUP_GLOBAL;
    else
        index = -1;
    [fIdlePopUp selectItemAtIndex: index];
    [fIdlePopUp setEnabled: YES];
    
    [fIdleLimitField setHidden: checkIdle != TR_IDLELIMIT_SINGLE];
    if (idleLimit != INVALID)
        [fIdleLimitField setIntegerValue: idleLimit];
    else
        [fIdleLimitField setStringValue: @""];
    [fIdleLimitLabel setHidden: checkIdle != TR_IDLELIMIT_SINGLE];
    
    [fIdleLimitGlobalLabel setHidden: checkIdle != TR_IDLELIMIT_GLOBAL];
    
    //set remove transfer when seeding finishes
    [fRemoveSeedingCompleteCheck setState: removeWhenFinishSeeding];
    [fRemoveSeedingCompleteCheck setEnabled: YES];
    
    //get priority info
    enumerator = [fTorrents objectEnumerator];
    torrent = [enumerator nextObject]; //first torrent
    
    NSInteger priority = [torrent priority];
    
    while ((torrent = [enumerator nextObject]) && priority != INVALID)
    {
        if (priority != INVALID && priority != [torrent priority])
            priority = INVALID;
    }
    
    //set priority view
    if (priority == TR_PRI_HIGH)
        index = OPTION_POPUP_PRIORITY_HIGH;
    else if (priority == TR_PRI_NORMAL)
        index = OPTION_POPUP_PRIORITY_NORMAL;
    else if (priority == TR_PRI_LOW)
        index = OPTION_POPUP_PRIORITY_LOW;
    else
        index = -1;
    [fPriorityPopUp selectItemAtIndex: index];
    [fPriorityPopUp setEnabled: YES];
    
    //get peer info
    enumerator = [fTorrents objectEnumerator];
    torrent = [enumerator nextObject]; //first torrent
    
    NSInteger maxPeers = [torrent maxPeerConnect];
    
    while ((torrent = [enumerator nextObject]))
    {
        if (maxPeers != [torrent maxPeerConnect])
        {
            maxPeers = INVALID;
            break;
        }
    }
    
    //set peer view
    [fPeersConnectField setEnabled: YES];
    [fPeersConnectLabel setEnabled: YES];
    if (maxPeers != INVALID)
        [fPeersConnectField setIntValue: maxPeers];
    else
        [fPeersConnectField setStringValue: @""];
}

- (void) setUseSpeedLimit: (id) sender
{
    const BOOL upload = sender == fUploadLimitCheck;
    
    if ([(NSButton *)sender state] == NSMixedState)
        [sender setState: NSOnState];
    const BOOL limit = [(NSButton *)sender state] == NSOnState;
    
    for (Torrent * torrent in fTorrents)
        [torrent setUseSpeedLimit: limit upload: upload];
    
    NSTextField * field = upload ? fUploadLimitField : fDownloadLimitField;
    [field setEnabled: limit];
    if (limit)
    {
        [field selectText: self];
        [[[self view] window] makeKeyAndOrderFront: self];
    }
    
    NSTextField * label = upload ? fUploadLimitLabel : fDownloadLimitLabel;
    [label setEnabled: limit];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setUseGlobalSpeedLimit: (id) sender
{
    if ([(NSButton *)sender state] == NSMixedState)
        [sender setState: NSOnState];
    const BOOL limit = [(NSButton *)sender state] == NSOnState;
    
    for (Torrent * torrent in fTorrents)
        [torrent setUseGlobalSpeedLimit: limit];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setSpeedLimit: (id) sender
{
    const BOOL upload = sender == fUploadLimitField;
    const NSInteger limit = [sender intValue];
    
    for (Torrent * torrent in fTorrents)
        [torrent setSpeedLimit: limit upload: upload];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setRatioSetting: (id) sender
{
    NSInteger setting;
    BOOL single = NO;
    switch ([sender indexOfSelectedItem])
    {
        case OPTION_POPUP_LIMIT:
            setting = TR_RATIOLIMIT_SINGLE;
            single = YES;
            break;
        case OPTION_POPUP_NO_LIMIT:
            setting = TR_RATIOLIMIT_UNLIMITED;
            break;
        case OPTION_POPUP_GLOBAL:
            setting = TR_RATIOLIMIT_GLOBAL;
            break;
        default:
            NSAssert1(NO, @"Unknown option selected in ratio popup: %ld", [sender indexOfSelectedItem]);
            return;
    }
    
    for (Torrent * torrent in fTorrents)
        [torrent setRatioSetting: setting];
    
    [fRatioLimitField setHidden: !single];
    if (single)
    {
        [fRatioLimitField selectText: self];
        [[[self view] window] makeKeyAndOrderFront: self];
    }
    
    [fRatioLimitGlobalLabel setHidden: setting != TR_RATIOLIMIT_GLOBAL];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setRatioLimit: (id) sender
{
    const CGFloat limit = [sender floatValue];
    
    for (Torrent * torrent in fTorrents)
        [torrent setRatioLimit: limit];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setIdleSetting: (id) sender
{
    NSInteger setting;
    BOOL single = NO;
    switch ([sender indexOfSelectedItem])
    {
        case OPTION_POPUP_LIMIT:
            setting = TR_IDLELIMIT_SINGLE;
            single = YES;
            break;
        case OPTION_POPUP_NO_LIMIT:
            setting = TR_IDLELIMIT_UNLIMITED;
            break;
        case OPTION_POPUP_GLOBAL:
            setting = TR_IDLELIMIT_GLOBAL;
            break;
        default:
            NSAssert1(NO, @"Unknown option selected in idle popup: %ld", [sender indexOfSelectedItem]);
            return;
    }
    
    for (Torrent * torrent in fTorrents)
        [torrent setIdleSetting: setting];
    
    [fIdleLimitField setHidden: !single];
    [fIdleLimitLabel setHidden: !single];
    if (single)
    {
        [fIdleLimitField selectText: self];
        [[[self view] window] makeKeyAndOrderFront: self];
    }
    
    [fIdleLimitGlobalLabel setHidden: setting != TR_IDLELIMIT_GLOBAL];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setIdleLimit: (id) sender
{
    const NSUInteger limit = [sender integerValue];
    
    for (Torrent * torrent in fTorrents)
        [torrent setIdleLimitMinutes: limit];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (IBAction) setRemoveWhenSeedingCompletes: (id) sender
{
    if ([(NSButton *)sender state] == NSMixedState)
        [sender setState: NSOnState];
    const BOOL enable = [(NSButton *)sender state] == NSOnState;
    
    for (Torrent * torrent in fTorrents)
        [torrent setRemoveWhenFinishSeeding: enable];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setPriority: (id) sender
{
    tr_priority_t priority;
    switch ([sender indexOfSelectedItem])
    {
        case OPTION_POPUP_PRIORITY_HIGH:
            priority = TR_PRI_HIGH;
            break;
        case OPTION_POPUP_PRIORITY_NORMAL:
            priority = TR_PRI_NORMAL;
            break;
        case OPTION_POPUP_PRIORITY_LOW:
            priority = TR_PRI_LOW;
            break;
        default:
            NSAssert1(NO, @"Unknown option selected in priority popup: %ld", [sender indexOfSelectedItem]);
            return;
    }
    
    for (Torrent * torrent in fTorrents)
        [torrent setPriority: priority];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateUI" object: nil];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (void) setPeersConnectLimit: (id) sender
{
    NSInteger limit = [sender intValue];
    
    for (Torrent * torrent in fTorrents)
        [torrent setMaxPeerConnect: limit];
    
    [[NSNotificationCenter defaultCenter] postNotificationName: @"UpdateOptionsNotification" object: self];
}

- (BOOL) control: (NSControl *) control textShouldBeginEditing: (NSText *) fieldEditor
{
    [fInitialString release];
    fInitialString = [[control stringValue] retain];
    
    return YES;
}

- (BOOL) control: (NSControl *) control didFailToFormatString: (NSString *) string errorDescription: (NSString *) error
{
    NSBeep();
    if (fInitialString)
    {
        [control setStringValue: fInitialString];
        [fInitialString release];
        fInitialString = nil;
    }
    return NO;
}

@end

@implementation InfoOptionsViewController (Private)

- (void) setupInfo
{
    if ([fTorrents count] == 0)
    {
        [fUploadLimitCheck setEnabled: NO];
        [fUploadLimitCheck setState: NSOffState];
        [fUploadLimitField setEnabled: NO];
        [fUploadLimitLabel setEnabled: NO];
        [fUploadLimitField setStringValue: @""];
        
        [fDownloadLimitCheck setEnabled: NO];
        [fDownloadLimitCheck setState: NSOffState];
        [fDownloadLimitField setEnabled: NO];
        [fDownloadLimitLabel setEnabled: NO];
        [fDownloadLimitField setStringValue: @""];
        
        [fGlobalLimitCheck setEnabled: NO];
        [fGlobalLimitCheck setState: NSOffState];
        
        [fPriorityPopUp setEnabled: NO];
        [fPriorityPopUp selectItemAtIndex: -1];
        
        [fRatioPopUp setEnabled: NO];
        [fRatioPopUp selectItemAtIndex: -1];
        [fRatioLimitField setHidden: YES];
        [fRatioLimitField setStringValue: @""];
        [fRatioLimitGlobalLabel setHidden: YES];
        
        [fIdlePopUp setEnabled: NO];
        [fIdlePopUp selectItemAtIndex: -1];
        [fIdleLimitField setHidden: YES];
        [fIdleLimitField setStringValue: @""];
        [fIdleLimitLabel setHidden: YES];
        [fIdleLimitGlobalLabel setHidden: YES];
        
        [fRemoveSeedingCompleteCheck setEnabled: NO];
        [fRemoveSeedingCompleteCheck setState: NSOffState];
        
        [fPeersConnectField setEnabled: NO];
        [fPeersConnectField setStringValue: @""];
        [fPeersConnectLabel setEnabled: NO];
    }
    else
        [self updateOptions];
}

- (void) setGlobalLabels
{
    NSString * global = [[NSUserDefaults standardUserDefaults] boolForKey: @"RatioCheck"]
        ? [NSString stringForRatio: [[NSUserDefaults standardUserDefaults] floatForKey: @"RatioLimit"]]
        : NSLocalizedString(@"disabled", "Info options -> global setting");
    [fRatioLimitGlobalLabel setStringValue: global];
    
    //idle field
    NSString * globalIdle;
    if ([[NSUserDefaults standardUserDefaults] boolForKey: @"IdleLimitCheck"])
    {
        const NSInteger globalMin = [[NSUserDefaults standardUserDefaults] integerForKey: @"IdleLimitMinutes"];
        globalIdle = globalMin == 1 ? NSLocalizedString(@"1 minute", "Info options -> global setting")
            : [NSString localizedStringWithFormat: NSLocalizedString(@"%d minutes", "Info options -> global setting"), globalMin];
    }
    else
        globalIdle = NSLocalizedString(@"disabled", "Info options -> global setting");
    [fIdleLimitGlobalLabel setStringValue: globalIdle];
}

- (void) updateOptionsNotification: (NSNotification *) notification
{
    if ([notification object] != self)
        [self updateOptions];
}

@end
