*

* Ignored if usesAlternatingRowBackgroundColors is NO.

*/

/*!

* @brief Whether the outlineView should draw its background

[self setUsesAlternatingRowBackgroundColors:NO];

drawsBackground = YES;

drawsGradientSelection = NO;

}

//Configuring ----------------------------------------------------------------------

- (void)setDrawsGradientSelection:(BOOL)inDrawsGradientSelection

- (void)setAlternatingRowColor:(NSColor *)color

{

if (color != alternatingRowColor) {

[self setNeedsDisplay:YES];

}

}

//Open the plist file

arrayPath = [ownerBundle pathForResource:name ofType:@"plist"];

}

- (NSComparisonResult)compare:(NSArray *)other

}

[self appendAttributedString:tempString];

}

- (NSUInteger)replaceOccurrencesOfString:(NSString *)target withString:(NSString*)replacement options:(NSStringCompareOptions)opts range:(NSRange)searchRange

break;

}

return numberOfReplacements;

}

#define FONT_HEIGHT_STRING @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789()"

+ (CGFloat)stringHeightForAttributes:(NSDictionary *)attributes

{

return [string heightWithWidth:1e7f];

}

+ (NSAttributedString *)stringWithString:(NSString *)inString

{

NSParameterAssert(inString != nil);

}

+ (NSAttributedString *)attributedStringWithString:(NSString *)inString linkRange:(NSRange)linkRange linkDestination:(id)inLink

NSParameterAssert(inLink != nil);

NSParameterAssert([inLink isKindOfClass:[NSURL class]]);

//Throws NSInvalidArgumentException if the range is out-of-range.

[attributedString addAttribute:NSLinkAttributeName value:inLink range:linkRange];

NSParameterAssert([inLink isKindOfClass:[NSURL class]]);

NSDictionary *attributes = [NSDictionary dictionaryWithObject:inLink forKey:NSLinkAttributeName];

}

- (CGFloat)heightWithWidth:(CGFloat)width

CGFloat height = [layoutManager usedRectForTextContainer:textContainer].size.height;

return height;

}

* when the unarchiver is deallocated. We could rely upon autoreleasing the unarchiver, but it

* is cleaner to make the NSAttributedString autorelease itself.

*/

} else {

/* For reading previously stored NSData objects - we used to store them as RTF data, but that

* here isn't a speed problem. We previously used AIHTMLDecoder to handle Jaguar old-data unarchiving...

* but that's in Adium.framework and the cross over most certainly isn't worth it.

*/

}

}

}

@catch(id exc) { }

- (NSAttributedString *)attributedStringByConvertingAttachmentsToStrings

{

if ([self length] && [self containsAttachments]) {

[newAttributedString convertAttachmentsToStringsUsingPlaceholder:AILocalizedString(@"<<Attachment>>", nil)];

return newAttributedString;

if (URL) {

if (!newAttributedString) {

currentAttributedString = newAttributedString;

}

}

}

}

- (NSAttributedString *)attributedStringByConvertingLinksToStrings

{

NSMutableAttributedString *str = [self mutableCopy];

[str addFormattingForLinks];

}

@end

[[NSNotificationCenter defaultCenter] removeObserver:self

name:NSViewFrameDidChangeNotification

object:nil];

}

//Auto Scrolling ---------------------------------------------------------------

//these three return an autoreleased copy.

- (NSBezierPath *)bezierPathByFlippingHorizontally {

}

- (NSBezierPath *)bezierPathByFlippingVertically {

}

- (NSBezierPath *)bezierPathByScalingToSize:(NSSize)newSize {

}

@end

*/

- (NSCharacterSet *)immutableCopy

{

}

@end

//the rgb.txt file that comes with Mac OS X 10.3.8 contains 752 entries.

//we create 3 autoreleased objects for each one.

//best to not pollute our caller's autorelease pool.

NSMutableDictionary *mutableDict = [NSMutableDictionary dictionary];

}

state.prevChar = ch[i];

} //for (unsigned i = 0; i < length; ++i)

//why not use -copy? because this is subclass-friendly.

//you can call this method on NSMutableDictionary and get a mutable dictionary back.

result = [[self alloc] initWithDictionary:mutableDict];

end:

}

@end

* View which draws, simply filling its bounds with a particular color.

*/

@interface AIColoredBoxView : NSView {

}

/*!

*

* The <tt>NSColor</tt> to draw in the view

*/

@end

@implementation AIColoredBoxView

- (BOOL)isOpaque

{

return NO;

return self;

}

//Sets the minimum string length required before completion kicks in

- (void)setMinStringLength:(int)length

{

//Set the strings that this field will use to auto-complete

- (void)setCompletingStrings:(NSArray *)strings

{

}

//Adds a string to the existing string list

NSArray *sortedArray = [possibleCompletions sortedArrayUsingSelector:@selector(compareLength:)];

if ([sortedArray count] > 0){

return [sortedArray objectAtIndex:0];

//When the AICompletingTextfield is modified to be able to provide multiple choices of completions, the entire array can be used later.

NSLog(@"%s: Could not serialize. Error: \"%@\".", __PRETTY_FUNCTION__, retainedError);

[self validateAsPropertyList];

return NO;

}

return YES;

[mutable translate:translation add:addition remove:removal];

result = [[self class] dictionaryWithDictionary:mutable];

} else {

}

return result;

NSMutableDictionary *mutableSelf = [self mutableCopy];

[mutableSelf intersectSetOfKeys:keys];

NSDictionary *result = [NSDictionary dictionaryWithDictionary:mutableSelf];

return result;

}

- (NSDictionary *)dictionaryWithDifferenceWithSetOfKeys:(NSSet *)keys

NSMutableDictionary *mutableSelf = [self mutableCopy];

[mutableSelf minusSetOfKeys:keys];

NSDictionary *result = [NSDictionary dictionaryWithDictionary:mutableSelf];

return result;

}

mutabilityOption:NSPropertyListMutableContainers

format:NULL

errorDescription:&error];

if (!dictionary && create) dictionary = [NSMutableDictionary dictionary];

}

}

//Add items that aren't in the removal set.

for (NSString *key in addition) {

if (!(removal && [removal containsObject:key])) {

[[NSNotificationCenter defaultCenter] removeObserver:self

name:NSWindowDidMoveNotification

object:self];

}

//Watch the window move. If it gets near an edge, dock it to that edge

if (err != noErr)

return nil;

if (! folderURL)

return nil;

return [folderURL path];

}

NSString *resolvedPath = nil;

CFURLRef url;

kCFURLPOSIXPathStyle, /* isDir */ false);

if (url) {

FSRef fsRef;

&targetIsFolder, &wasAliased) == noErr && wasAliased) {

CFURLRef resolvedUrl = CFURLCreateFromFSRef(NULL, &fsRef);

if (resolvedUrl) {

CFRelease(resolvedUrl);

}

}

CFRelease(url);

}

}

@end

{

if ((self = [super init])) {

trackingRect = inTrackingRect;

}

return self;

}

- (NSRect)trackingRect{

return trackingRect;

}

staticView = [[NSImageView alloc] initWithFrame:frame];

[staticView setImage:inImage];

[staticView setAutoresizingMask:(NSViewWidthSizable | NSViewHeightSizable)];

}

return self;

- (IBAction)close:(id)sender

{

[panel orderOut:nil];

}

- (void)setMaxOpacity:(CGFloat)inMaxOpacity

@implementation AIGenericViewCell

- (void)setEmbeddedView:(NSView *)inView

{

if (embeddedView != inView) {

}

}

- (id)copyWithZone:(NSZone *)zone

{

AIGenericViewCell *newCell = [super copyWithZone:zone];

return newCell;

}

NSRect frame = [embeddedView frame];

NSRect usableFrame = NSMakeRect(0,0,frame.size.width,frame.size.height);

[image lockFocus];

[embeddedView setNeedsDisplay:YES];

[embeddedView drawRect:usableFrame];

NSRect subUsableFrame = NSMakeRect(0, 0, subFrame.size.width, subFrame.size.height);

//Cache to an image

[subImage lockFocus];

[subView drawRect:subUsableFrame];

[subImage unlockFocus];

- (void)dealloc

{

[hostAndObserverListLock lock];

[hostAndObserverListLock unlock];

[[NSNotificationCenter defaultCenter] removeObserver:self];

}

#pragma mark -

NSString *hostCopy = [host copy];

[self scheduleReachabilityMonitoringForHost:hostCopy

observer:newObserver];

}

/*!

if ((!host) || ([host isEqualToString:[hosts objectAtIndex:i]])) {

[hosts removeObjectAtIndex:i];

[observers removeObjectAtIndex:i];

CFRunLoopGetCurrent(),

kCFRunLoopDefaultMode);

[reachabilities removeObjectAtIndex:i];

{

[hostAndObserverListLock lock];

if (i != NSNotFound) {

NSString *host = [hosts objectAtIndex:i];

id <AIHostReachabilityObserver> observer = [observers objectAtIndex:i];

if (![host isEqualToString:[hosts objectAtIndex:idx]])

continue;

SCNetworkConnectionFlags flags;

if (SCNetworkReachabilityGetFlags(otherReachability, &flags)

(flags & kSCNetworkFlagsIsDirect) ? 'd' : '-');

#endif

[self reachabilityChanged:target];

}

*/

static void hostResolvedCallback(CFHostRef theHost, CFHostInfoType typeInfo, const CFStreamError *error, void *info)

{

AIHostReachabilityMonitor *self = [infoDict objectForKey:@"self"];

id observer = [infoDict objectForKey:@"observer"];

NSString *host = [infoDict objectForKey:@"host"];

// Only add 1 observer for IPv6 and one for IPv4.

BOOL addedIPv4 = NO, addedIPv6 = NO;

struct sockaddr *remoteAddr = (struct sockaddr *)saData.bytes;

if ((remoteAddr->sa_family == AF_INET && addedIPv4) || (remoteAddr->sa_family == AF_INET6 && addedIPv6)) {

SCNetworkReachabilityRef reachabilityRef;

SCNetworkReachabilityContext reachabilityContext = {

.version = 0,

.retain = CFRetain,

.release = CFRelease,

.copyDescription = CFCopyDescription,

kCFRunLoopDefaultMode);

//Note that we succesfully configured for reachability notifications

forHost:host

observer:observer];

#endif

hostReachabilityChangedCallback(reachabilityRef,

flags,

} else {

/* Perform an immediate reachability check, since we've just scheduled checks for future changes

*/

CFHostClientContext hostContext = {

.version = 0,

self, @"self",

host, @"host",

observer, @"observer",

reachabilityRef, @"reachabilityRef",

.retain = CFRetain,

.release = CFRelease,

.copyDescription = CFCopyDescription,

(UInt8 *)&flags);

//Call the reachability changed callback directly

flags,

//No further need for this CFHost to be in our run loop

CFHostUnscheduleFromRunLoop(theHost,

[hosts addObject:host];

[observers addObject:observer];

//Remove from our unconfigured array

[self removeUnconfiguredHost:host

//Resolve the remote host domain name to an IP asynchronously

CFHostClientContext hostContext = {

.version = 0,

self, @"self",

nodename, @"host",

observer, @"observer",

.retain = CFRetain,

.release = CFRelease,

.copyDescription = CFCopyDescription,

};

CFHostRef host = CFHostCreateWithName(kCFAllocatorDefault,

CFHostSetClient(host,

hostResolvedCallback,

&hostContext);

*/

static void localIPsChangedCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)

{

/* Wait one second after receiving the callback, as it seems to be sent in some cases the middle of the change

* rather than after it is complete.

//Create the CFRunLoopSourceRef we will want to add to our run loop to have

//localIPsChangedCallback() called when the IP list changes

status = CreateIPAddressListChangeCallbackSCF(localIPsChangedCallback,

&storeRef,

&ipChangesRunLoopSourceRef);

NSEnumerator *enumerator;

SCNetworkReachabilityRef reachabilityRef;

enumerator = [reachabilities objectEnumerator];

SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef,

CFRunLoopGetCurrent(),

kCFRunLoopDefaultMode);

[self addObserver:observer

forHost:host];

}

}

#pragma mark -

image = [[NSImage alloc] initWithContentsOfFile:imagePath];

}

}

// Returns an image from the owners bundle with the specified name

NSSize size = [self size];

// Work with a temporary image so we don't modify self

// Lock before drawing to the temporary image

[tempImage lockFocus];

NSSize size = [self size];

NSRect rect = NSMakeRect(0.0f, 0.0f, size.width, size.height);

[self unlockFocus];

NSUInteger height = ((CGFloat)imageRep.pixelsWide - 100.0f)*ratio;

// Create a new rep with the lowered size

pixelsWide:width

pixelsHigh:height

bitsPerSample:imageRep.bitsPerSample

isPlanar:imageRep.isPlanar

colorSpaceName:NSCalibratedRGBColorSpace

bytesPerRow:imageRep.bytesPerRow

// Draw the old rep into the new rep

[NSGraphicsContext saveGraphicsState];

- (id)copyWithZone:(NSZone *)zone

{

AIImageButton *newButton = [super copyWithZone:zone];

[newButton setCornerRadius:[self cornerRadius]];

return newButton;

- (void)dealloc

{

[imageFloater close:nil];

}

#pragma mark Drawing

if (imageFloater) {

[imageFloater close:nil];

}

// Rounded corners

[roundedImage unlockFocus];

[self setImage:roundedImage];

}

/* If the image would go off the right side of the screen from its origin, shift the origin left

point.x = maxXOrigin;

}

[imageFloater setMaxOpacity:1.0f];

[imageFloater moveFloaterToPoint:point];

[imageFloater setVisible:YES animate:NO];

{

if (!imageFloaterShouldBeOpen) {

[imageFloater close:nil];

}

}

*/

@interface AIImageCollectionView : NSCollectionView {

@protected

NSInteger highlightStyle;

CGFloat highlightSize;

NSUInteger highlightedIndex;

}

@property (assign) NSInteger highlightStyle;

@property (assign) CGFloat highlightSize;

highlightedIndex = NSNotFound;

// Mouse Tracking

options:(NSTrackingMouseEnteredAndExited |

NSTrackingActiveInKeyWindow |

NSTrackingInVisibleRect)

owner:self

// Temporary solution, 1st tracking area will only report MouseMoved Events

options:(NSTrackingMouseMoved |

NSTrackingActiveInKeyWindow |

NSTrackingInVisibleRect)

owner:self

// Track for item's selection changes

[self addObserver:self forKeyPath:@"selectionIndexes"

{

[self removeObserver:self forKeyPath:@"selectionIndexes"];

[self removeObserver:self forKeyPath:@"content"];

}

- (void)drawRect:(NSRect)dirtyRect

// Proceed only if size or delta are changing

if ((NSEqualSizes(originalSize, size)) && (delta == 1.0) && !flipImage) {

} else {

NSImage *newImage;

// Write GIF Extension Blocks

[self writeGIFExtensionBlocksInData:GIFRepresentationData forRepresenation:(NSBitmapImageRep *)bestRep];

newImage = [[NSImage alloc] initWithData:GIFRepresentationData];

} else {

[newImage lockFocus];

[newImage unlockFocus];

}

}

}

// Proceed only if size or delta are changing

if ((NSEqualSizes(originalSize, size)) && (delta == 1.0) && !flipImage) {

} else {

// Scale proportionally (rather than stretching to fit) if requested and needed

// Write GIF Extension Blocks

[self writeGIFExtensionBlocksInData:GIFRepresentationData forRepresenation:(NSBitmapImageRep *)bestRep];

newImage = [[NSImage alloc] initWithData:GIFRepresentationData];

} else {

[newImage unlockFocus];

}

}

}

//Dealloc

- (void)dealloc

{

}

//Copy

- (void)setFont:(NSFont *)inFont

{

if (font != inFont) {

}

}

- (NSFont *)font

- (void)setSubString:(NSString *)inSubString

{

if (subString != inSubString) {

}

}

[NSGraphicsContext restoreGraphicsState];

}

//Draw the substring

if (subString) {

NSAffineTransform *subStringTranslation = [NSAffineTransform transform];

//Draw the substring

[attributedSubString drawInRect:cellFrame];

}

}

@class IKPictureTakerRecentPicture; // Private 10.5+ class

@interface AIImageViewWithImagePicker : NSImageView {

NSString *title;

id pictureTaker;

BOOL usePictureTaker;

BOOL presentPictureTakerAsSheet;

NSSize maxSize;

}

@property (assign) BOOL usePictureTaker;

@property (assign) BOOL presentPictureTakerAsSheet;

@property (assign) BOOL shouldUpdateRecentRepository;

*/

- (void)dealloc

{

if (pictureTaker) {

[pictureTaker close];

}

delegate = nil;

}

#pragma mark Getters and Setters

[pictureTaker setInputImage:inImage];

}

}

/*!

- (void)setTitle:(NSString *)inTitle

{

if (title != inTitle) {

if (pictureTaker) {

[pictureTaker setTitle:title];

pasteboard:pboard

source:sourceObject

slideBack:slideBack];

}

/*

*/

- (void)concludeDragOperation:(id <NSDraggingInfo>)sender

{

if (!droppedImage) {

return;

NSData *imageData = (type ? [pb dataForType:type] : nil);

if (imageData) {

if (image) {

NSSize imageSize = [image size];

{

if (usePictureTaker) {

if (!pictureTaker) {

[pictureTaker setDelegate:self];

}

NSSize imageSize;

imageData = [NSData dataWithContentsOfURL:[[openPanel URLs] objectAtIndex:0]];

imageSize = (image ? [image size] : NSZeroSize);

if ((maxSize.width > 0 && imageSize.width > maxSize.width) ||

- (void)setRecentPictureAsImageInput:(IKPictureTakerRecentPicture *)recentPicture

{

if (activeRecentPicture != recentPicture) {

}

//Update any open picture taker immediately.

}

+ (BOOL)unlockDefaultKeychainWithPassword:(NSString *)password error:(out NSError **)outError

{

NSData *data = [password dataUsingEncoding:NSUTF8StringEncoding];

NSAssert( UINT_MAX >= [data length], @"Attempting to send more data than Keychain can handle. Abort." );

OSStatus err = SecKeychainUnlock(/*keychain*/ NULL, (UInt32)[data length], [data bytes], /*usePassword*/ true);

if (outError) {

NSError *error = nil;

if (err != noErr) {

*outError = error;

}

return err == noErr;

}

+ (BOOL)allowsUserInteraction_error:(out NSError **)outError

if (aKeychainRef) {

if (!lastKnownDefaultKeychain ||

([lastKnownDefaultKeychain keychainRef] && (aKeychainRef != [lastKnownDefaultKeychain keychainRef]))) {

lastKnownDefaultKeychain = [[self alloc] init];

}

CFRelease(aKeychainRef);

} else {

NSLog(@"No default keychain!");

*outError = error;

}

if (err == noErr) {

}

}

+ (AIKeychain *)keychainWithContentsOfFile:(NSString *)path error:(out NSError **)outError

{

}

- (id)initWithContentsOfFile:(NSString *)path error:(out NSError **)outError

{

*outError = error;

}

if (err != noErr) {

self = nil;

}

}

//SecKeychainCreate

+ (AIKeychain *)keychainWithPath:(NSString *)path password:(NSString *)password promptUser:(BOOL)prompt initialAccess:(SecAccessRef)initialAccess error:(out NSError **)outError

{

}

- (id)initWithPath:(NSString *)path password:(NSString *)password promptUser:(BOOL)prompt initialAccess:(SecAccessRef)initialAccess error:(out NSError **)outError

{

* ensure that the NSData that we create is an NSData.

*we create our own pool to ensure that both objects are released ASAP.

*/

void *passwordBytes = NULL;

u_int32_t passwordLength = 0;

OSStatus err = SecKeychainCreate([path fileSystemRepresentation], passwordLength, passwordBytes, prompt, initialAccess, &keychainRef);

if (outError) {

NSError *error = nil;

if (err != noErr) {

*outError = error;

}

if (err != noErr) {

self = nil;

}

}

return self;

+ (AIKeychain *)keychainWithKeychainRef:(SecKeychainRef)newKeychainRef

{

}

- (id)initWithKeychainRef:(SecKeychainRef)newKeychainRef

}

- (BOOL)unlockKeychainWithPassword:(NSString *)password error:(out NSError **)outError

{

NSData *data = [password dataUsingEncoding:NSUTF8StringEncoding];

NSAssert( UINT_MAX >= [data length], @"Attempting to send more data than Keychain can handle. Abort." );

OSStatus err = SecKeychainUnlock(keychainRef, (UInt32)[data length], [data bytes], /*usePassword*/ true);

if (outError) {

NSError *error = nil;

if (err != noErr) {

*outError = error;

}

return err == noErr;

}

#pragma mark -

NSParameterAssert(server != nil);

//domain is optional

NSData *passwordData = [password dataUsingEncoding:NSUTF8StringEncoding];

(UInt32)[passwordData length], [passwordData bytes],

outKeychainItem);

if (outError) {

NSError *error = nil;

if (err != noErr) {

}

*outError = error;

}

}

- (void)addInternetPassword:(NSString *)password forServer:(NSString *)server account:(NSString *)account protocol:(SecProtocolType)protocol error:(out NSError **)outError

*/

SecKeychainItemRef item = NULL;

[self findInternetPasswordForServer:server

securityDomain:domain

authenticationType:authType

keychainItem:&item

error:&error];

if (error) {

//Retain this because of the autorelease pool.

} else {

NSData *passwordData = [password dataUsingEncoding:NSUTF8StringEncoding];

NSAssert( UINT_MAX >= [passwordData length], @"Attempting to send more data than Keychain can handle. Abort." );

keychainRef, AIKEYCHAIN_ERROR_USERINFO_KEYCHAIN,

nil];

//Retain this because of the autorelease pool.

}

*outError = error;

} //if (outError)

} //if (!error) (findInternetPasswordForServer:...)

} //if (err == errSecDuplicateItem)

} //if (error) (addInternetPassword:...)

} //if (password)

}

keychainItem:(out SecKeychainItemRef *)outKeychainItem

error:(out NSError **)outError

{

SecKeychainItemRef keychainItem = NULL;

NSError *error = nil;

}

}

if (outKeychainItem) *outKeychainItem = keychainItem;

else if (keychainItem) CFRelease(keychainItem);

}

- (void)deleteInternetPasswordForServer:(NSString *)server account:(NSString *)account protocol:(SecProtocolType)protocol error:(out NSError **)outError

NSParameterAssert(service != nil);

NSParameterAssert(account != nil);

NSData *passwordData = [password dataUsingEncoding:NSUTF8StringEncoding];

(UInt32)[passwordData length], [passwordData bytes],

outKeychainItem);

if (outError) {

NSError *error = nil;

if (err != noErr) {

}

*outError = error;

}

}

- (NSString *)findGenericPasswordForService:(NSString *)service

account:(NSString *)account

error:(out NSError **)outError

{

SecKeychainItemRef keychainItem = NULL;

NSError *error = nil;

if (keychainItem) CFRelease(keychainItem);

}

#pragma mark -

//Common init

- (void)_initLinkTextView

{

[[NSNotificationCenter defaultCenter] addObserver:self

selector:@selector(frameDidChange:)

name:NSViewFrameDidChangeNotification

- (void)dealloc

{

[[NSNotificationCenter defaultCenter] removeObserver:self];

}

//Pass clicks to the link tracking controller

NSMenuItem *menuItem;

NSEnumerator *enumerator;

enumerator = [linkMenuItems reverseObjectEnumerator];

while ((menuItem = [enumerator nextObject])) {

//Create a link tracking controller for any view

+ (id)linkTrackingControllerForView:(NSView *)inControlView withTextStorage:(NSTextStorage *)inTextStorage layoutManager:(NSLayoutManager *)inLayoutManager textContainer:(NSTextContainer *)inTextContainer

{

}

//Create a tracking controller for a text view

+ (id)linkTrackingControllerForTextView:(NSTextView *)inTextView

{

}

//Track links in the passed rect. Returns YES if links exist within our text. Pass a 0 width/height visible rect to stop any link tracking.

//Called when the mouse leaves the link

- (void)mouseExited:(NSEvent *)theEvent

{

}

//Handle a mouse down. Returns NO if the mouse down event should continue to be processed

NSUInteger charIndex;

NSRectArray linkRects = nil;

//Find clicked char index

mouseLoc = [controlView convertPoint:[theEvent locationInWindow] fromView:nil];

- (void)dealloc

{

[self _endCursorTracking];

}

//Begins cursor tracking, registering tracking rects for all our available links

visibleLinkRect = NSIntersectionRect(linkRect, visibleRect);

//Create a flexible link instance

url:linkURL

if (!linkArray) linkArray = [[NSMutableArray alloc] init];

[linkArray addObject:trackedLink];

//Install a tracking rect for the link (The userData of each tracking rect is the AIFlexibleLink it covers)

[trackedLink setTrackingTag:trackingTag];

}

}

}

//Flush the link array

}

//Configure the mouse for being over a link or not

[[inHoveredLink title] caseInsensitiveCompare:[inHoveredLink url]] != NSOrderedSame &&

[[@"http://" stringByAppendingString:[inHoveredLink title]] caseInsensitiveCompare:[inHoveredLink url]] != NSOrderedSame) {

[AITooltipUtilities showTooltipWithString:hoveredString onWindow:nil atPoint:inPoint orientation:TooltipAbove]; //Show tooltip

}

if (showTooltip) {

[AITooltipUtilities showTooltipWithString:nil onWindow:nil atPoint:NSMakePoint(0,0) orientation:TooltipAbove]; //Hide the tooltip

}

mouseOverLink = NO;

if (linkURL) {

NSMenuItem *menuItem;

target:self

action:@selector(copyLink:)

[menuItem setRepresentedObject:linkURL];

[menuItemsArray addObject:menuItem];

}

//Copy the absolute URL to the clipboard

- (void)copyLink:(id)sender

{

[[NSPasteboard generalPasteboard] declareTypes:[NSArray arrayWithObject:NSRTFPboardType] owner:nil];

[[NSPasteboard generalPasteboard] setData:[copyString RTFFromRange:NSMakeRange(0,[copyString length]) documentAttributes:nil] forType:NSRTFPboardType];

}

[self addItem:theMenuItem];

}

- (NSMenuItem *)addItemWithTitle:(NSString *)aString target:(id)target action:(SEL)aSelector keyEquivalent:(NSString *)charCode tag:(NSInteger)tag

[self addItem:theMenuItem];

}

- (NSMenuItem *)addItemWithTitle:(NSString *)aString target:(id)target action:(SEL)aSelector keyEquivalent:(NSString *)charCode representedObject:(id)object

[self addItem:theMenuItem];

}

NSMenu *menu = [self menu];

NSInteger idx = [menu indexOfItem:self];

[menu removeItemAtIndex:idx];

[self setKeyEquivalent:@""];

[menu insertItem:self atIndex:idx];

}

- (NSComparisonResult)titleCompare:(NSMenuItem *)inMenuItem

{

if (itemA == itemB) return;

NSInteger indexA = menuA ? [menuA indexOfItem:itemA] : -1;

NSInteger indexB = menuB ? [menuB indexOfItem:itemB] : -1;

if ((menuA == menuB) && (indexA < indexB)) {

NSMenuItem *primaryItem = [containingMenu itemAtIndex:(menuItemIndex-1)];

//Remove the primary item and readd it

[containingMenu removeItemAtIndex:(menuItemIndex-1)];

[containingMenu insertItem:primaryItem atIndex:(menuItemIndex-1)];

//Remove the alternate item and readd it

[containingMenu removeItemAtIndex:menuItemIndex];

[containingMenu insertItem:alternateItem atIndex:menuItemIndex];

}

@end

groupRowHeight = 0;

}

//Cell used for content rows

- (void)setContentCell:(NSCell *)cell{

if (contentCell != cell) {

}

contentRowHeight = [contentCell cellSize].height;

[self noteHeightOfRowsWithIndexesChanged:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(0, [self numberOfRows])]];

//Cell used for group rows

- (void)setGroupCell:(NSCell *)cell{

if (groupCell != cell) {

}

groupRowHeight = [groupCell cellSize].height;

*

* @result The object with the highest priority, performing no other comparison

*/

/*!

* @brief Greatest NSNumber value

*

* Assumes the \c AIMutableOwnerArray contains \c NSNumber instances

* @result Returns the greatest (highest value) contained \c NSNumber value.

*/

/*!

* @brief Greatest integer value

*

* Assuming the \c AIMutableOwnerArray contains \c NSDate instances, returns the earliest one.

* @return Returns the earliest contained date.

*/

/*!

* @brief Retrieve object by owner

*

* Retrieve an \c NSEnumerator for all objects in the \c AIMutableOwnerArray. Order is not guaranteed.

* @return Returns \c NSEnumerator for all objects.

*/

/*!

* @brief Retrieve array of values

*

* to be notified with the \c AIMutableOwnerArray is modified.

* @param inDelegate The delegate

*/

@end

delegate = nil;

[self _destroyArrays];

}

}

[desc appendString:@">"];

}

//Destroy our storage arrays

- (void)_destroyArrays

{

}

//Delegation -----------------------------------------------------------------------------------------

return delegate;

}

{

return [contentArray countByEnumeratingWithState:state objects:stackbuf count:len];

}

+ (NSMutableString *)stringWithContentsOfASCIIFile:(NSString *)path

{

}

- (NSMutableString*)mutableString

[accessibilityActionNames addObject:NSAccessibilityPressAction];

[accessibilityActionNames addObject:NSAccessibilityShowMenuAction];

}

@end

NSMutableParagraphStyle *paragraphStyle = [[NSParagraphStyle defaultParagraphStyle] mutableCopy];

[paragraphStyle setAlignment:alignment];

}

+ (NSMutableParagraphStyle *)styleWithAlignment:(NSTextAlignment)alignment lineBreakMode:(NSLineBreakMode)mode

[paragraphStyle setAlignment:alignment];

[paragraphStyle setLineBreakMode:mode];

}

@end

delegate:(id <AIProgressDataUploaderDelegate>)delegate

context:(id)context

{

}

- (id)initWithData:(NSData *)inUploadData

context:(id)inContext

{

if ((self = [super init])) {

delegate = inDelegate;

context = inContext;

}

return self;

- (void)dealloc

{

}

/*!

{

CFHTTPMessageRef httpRequest = CFHTTPMessageCreateRequest(kCFAllocatorDefault,

CFSTR("POST"),

kCFHTTPVersion1_1);

for (NSString *headerKey in headers) {

CFHTTPMessageSetHeaderFieldValue(httpRequest,

}

stream = CFReadStreamCreateForHTTPRequest(kCFAllocatorDefault, httpRequest);

CFStreamClientContext streamClientContext = {

0,

NULL,

NULL,

NULL

{

totalSize = [uploadData length];

target:self

selector:@selector(updateProgress)

userInfo:nil

timeoutTimer = [[NSTimer alloc] initWithFireDate:[NSDate dateWithTimeIntervalSinceNow:TIMEOUT_INTERVAL]

interval:TIMEOUT_INTERVAL

return;

}

NSInteger bytesWritten = [bytesWrittenPropertyNum integerValue];

if (bytesWritten > bytesSent) {

CFStreamEventType type,

void *info)

{

switch (type) {

case kCFStreamEventHasBytesAvailable:

result = [input string];

if([input isKindOfClass:[NSMutableAttributedString class]]) {

//The input string is mutable, so make a copy of the string.

}

}

+ (id)coercePlainText:(NSString *)input toClass:(Class)class

{

if([class isSubclassOfClass:[NSAttributedString class]]) {

}

return nil;

}

[self removeTrackingRect:trackingTag];

trackingTag = -1;

}

}

#pragma mark Configuration

sendingEnabled = YES;

}

//If true we will invoke selector on target when a send key is pressed

@synthesize sendingEnabled;

+ (AISmoothTooltipTracker *)smoothTooltipTrackerForView:(NSView *)inView withDelegate:(id <AISmoothTooltipTrackerDelegate>)inDelegate

{

}

- (AISmoothTooltipTracker *)initForView:(NSView *)inView withDelegate:(id)inDelegate

{

if ((self = [super init])) {

delegate = inDelegate;

tooltipTrackingTag = -1;

tooltipLocation = NSZeroPoint;

[self removeCursorRect];

[self _stopTrackingMouse];

}

- (void)setDelegate:(id <AISmoothTooltipTrackerDelegate>)inDelegate

{

if (!tooltipMouseLocationTimer) {

tooltipCount = 0;

target:self

selector:@selector(mouseMovementTimer:)

userInfo:nil

}

}

tooltipMouseLocationTimer = nil;

[theTimer invalidate];

}

}

+ (id)stringWithData:(NSData *)data encoding:(NSStringEncoding)encoding

{

}

+ (id)stringWithBytes:(const void *)inBytes length:(unsigned)inLength encoding:(NSStringEncoding)inEncoding

{

}

+ (id)ellipsis

NSRange range = NSMakeRange(0, 0);

outName = [self mutableCopy];

len = [outName length];

while (pos < len) {

}

}

}

#define BUNDLE_STRING @"$$BundlePath$$"

if ([self hasPrefix:BUNDLE_STRING]) {

return [[[[NSBundle mainBundle] bundlePath] stringByExpandingTildeInPath] stringByAppendingString:[self substringFromIndex:[BUNDLE_STRING length]]];

} else {

}

}

if ([self hasPrefix:bundlePath]) {

return [BUNDLE_STRING stringByAppendingString:[self substringFromIndex:[bundlePath length]]];

} else {

}

}

returnString = [[self substringToIndex:length-1] stringByAppendingString:[NSString ellipsis]];

} else {

//We don't need to truncate, so don't append an ellipsis

}

return (returnString);

[string replaceOccurrencesOfString:@"/" withString:@"-" options:NSLiteralSearch range:NSMakeRange(0, length)];

}

//- (NSString *)stringByEncodingURLEscapes

sourceIndex++;

}

}

//stringByDecodingURLEscapes

destIndex++;

}

}

- (NSString *)string

nil];

}

}

- (NSString *)stringByUnescapingFromXMLWithEntities:(NSDictionary *)entities

{

}

#ifndef BSD_LICENSE_ONLY

NSString *uuidStr;

uuid = CFUUIDCreate(NULL);

CFRelease(uuid);

}

+ (NSString *)stringWithCGFloat:(CGFloat)f maxDigits:(NSUInteger)numDigits

if (!lineBreakCharacterSet) {

static const unichar lineBreakCharacters[numberOfLineBreakCharacters] = { LINE_FEED, FORM_FEED, CARRIAGE_RETURN, NEXT_LINE, LINE_SEPARATOR, PARAGRAPH_SEPARATOR };

}

return lineBreakCharacterSet;

substringRange.length = lineBreakRange.location - searchRange.location;

[lines addObject:[self substringWithRange:substringRange]];

searchRange.location = (lineBreakRange.location + lineBreakRange.length);

searchRange.length = selfLength - searchRange.location;

// RFC 2396:

// reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","

NULL,

(CFStringRef)@";/?:@&=+$",

kCFStringEncodingUTF8);

}

@end

+ (id)stringFormatterAllowingCharacters:(NSCharacterSet *)inCharacters length:(NSInteger)inLength caseSensitive:(BOOL)inCaseSensitive errorMessage:(NSString *)inErrorMessage

{

}

- (id)initAllowingCharacters:(NSCharacterSet *)inCharacters length:(NSInteger)inLength caseSensitive:(BOOL)inCaseSensitive errorMessage:(NSString *)inErrorMessage

{

if ((self = [super init])) {

length = inLength;

caseSensitive = inCaseSensitive;

errorCount = 0;

return valid;

}

@end

}

}

//Enabled?

if (enable) {

//Host

if (hostString) {

//Port

if (portNum) {

NSDictionary *authDict;

NSString *pacFile = [proxyDict objectForKey:(NSString *)kSCPropNetProxiesProxyAutoConfigURLString];

if (pacFile) {

NSString *scriptStr = [NSString stringWithContentsOfURL:[NSURL URLWithString:pacFile] encoding:NSUTF8StringEncoding error:NULL];

if (url && scriptStr) {

CFRelease(CFNetworkCopyProxiesForURL(url, NULL));

CFErrorRef error = NULL;

if (error) {

CFStringRef description = CFErrorCopyDescription(error);

- (BOOL)consideredImageForHFSType:(OSType)HFSTypeCode

pathExtension:(NSString *)pathExtension

{

NSArray *removeFileTypes = [NSArray arrayWithObjects:@"pdf", @"PDF", @"psd", @"PSD", @"'PDF '", nil];

[imageFileTypes removeObjectsInArray:removeFileTypes];

//Creates a new instance of AITextAttributes

+ (id)textAttributesWithFontFamily:(NSString *)inFamilyName traits:(NSFontTraitMask)inTraits size:(NSInteger)inSize

{

}

+ (id)textAttributesWithDictionary:(NSDictionary *)inAttributes

{

}

//init

- (id)initWithFontFamily:(NSString *)inFamilyName traits:(NSFontTraitMask)inTraits size:(NSInteger)inSize

{

if ((self = [self init])) {

fontTraitsMask = inTraits;

fontSize = inSize;

}

- (id)initWithDictionary:(NSDictionary *)inAttributes

{

if ((self = [self init])) {