3b0d0bbc2e5b74713bf3666741ead9b40509b49b
[WebKit-https.git] / Source / WebKit / mac / Misc / WebKitNSStringExtras.mm
1 /*
2  * Copyright (C) 2005, 2007 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #import "WebKitNSStringExtras.h"
30
31 #import <WebCore/CoreGraphicsSPI.h>
32 #import <WebCore/FontCascade.h>
33 #import <WebCore/GraphicsContext.h>
34 #import <WebCore/TextRun.h>
35 #import <WebCore/WebCoreNSStringExtras.h>
36 #import <WebKitLegacy/WebNSFileManagerExtras.h>
37 #import <WebKitLegacy/WebNSObjectExtras.h>
38 #import <unicode/uchar.h>
39 #import <sys/param.h>
40
41 #if PLATFORM(IOS)
42 #import <WebCore/WAKViewPrivate.h>
43 #import <WebKitLegacy/DOM.h>
44 #import <WebKitLegacy/WebFrame.h>
45 #import <WebKitLegacy/WebFrameView.h>
46 #import <WebKitLegacy/WebViewPrivate.h>
47 #endif
48
49 NSString *WebKitLocalCacheDefaultsKey = @"WebKitLocalCache";
50
51 using namespace WebCore;
52
53 @implementation NSString (WebKitExtras)
54
55 #if !PLATFORM(IOS)
56 static BOOL canUseFastRenderer(const UniChar *buffer, unsigned length)
57 {
58     unsigned i;
59     for (i = 0; i < length; i++) {
60         UCharDirection direction = u_charDirection(buffer[i]);
61         if (direction == U_RIGHT_TO_LEFT || direction > U_OTHER_NEUTRAL)
62             return NO;
63     }
64     return YES;
65 }
66
67 - (void)_web_drawAtPoint:(NSPoint)point font:(NSFont *)font textColor:(NSColor *)textColor
68 {
69     [self _web_drawAtPoint:point font:font textColor:textColor allowingFontSmoothing:YES];
70 }
71
72 - (void)_web_drawAtPoint:(NSPoint)point font:(NSFont *)font textColor:(NSColor *)textColor allowingFontSmoothing:(BOOL)fontSmoothingIsAllowed
73 {
74     unsigned length = [self length];
75     Vector<UniChar, 2048> buffer(length);
76
77     [self getCharacters:buffer.data()];
78
79     if (canUseFastRenderer(buffer.data(), length)) {
80         // The following is a half-assed attempt to match AppKit's rounding rules for drawAtPoint.
81         // It's probably incorrect for high DPI.
82         // If you change this, be sure to test all the text drawn this way in Safari, including
83         // the status bar, bookmarks bar, tab bar, and activity window.
84         point.y = CGCeiling(point.y);
85
86         NSGraphicsContext *nsContext = [NSGraphicsContext currentContext];
87         CGContextRef cgContext = static_cast<CGContextRef>([nsContext graphicsPort]);
88         GraphicsContext graphicsContext(cgContext);    
89
90         // Safari doesn't flip the NSGraphicsContext before calling WebKit, yet WebCore requires a flipped graphics context.
91         BOOL flipped = [nsContext isFlipped];
92         if (!flipped)
93             CGContextScaleCTM(cgContext, 1, -1);
94
95         FontCascade webCoreFont(FontPlatformData(reinterpret_cast<CTFontRef>(font), [font pointSize]), fontSmoothingIsAllowed ? AutoSmoothing : Antialiased);
96         TextRun run(buffer.data(), length);
97         run.disableRoundingHacks();
98
99         CGFloat red;
100         CGFloat green;
101         CGFloat blue;
102         CGFloat alpha;
103         [[textColor colorUsingColorSpaceName:NSDeviceRGBColorSpace] getRed:&red green:&green blue:&blue alpha:&alpha];
104         graphicsContext.setFillColor(makeRGBA(red * 255, green * 255, blue * 255, alpha * 255), ColorSpaceDeviceRGB);
105
106         webCoreFont.drawText(&graphicsContext, run, FloatPoint(point.x, (flipped ? point.y : (-1 * point.y))));
107
108         if (!flipped)
109             CGContextScaleCTM(cgContext, 1, -1);
110     } else {
111         // The given point is on the baseline.
112         if ([[NSView focusView] isFlipped])
113             point.y -= [font ascender];
114         else
115             point.y += [font descender];
116
117         [self drawAtPoint:point withAttributes:[NSDictionary dictionaryWithObjectsAndKeys:font, NSFontAttributeName, textColor, NSForegroundColorAttributeName, nil]];
118     }
119 }
120
121 - (void)_web_drawDoubledAtPoint:(NSPoint)textPoint
122              withTopColor:(NSColor *)topColor
123               bottomColor:(NSColor *)bottomColor
124                      font:(NSFont *)font
125 {
126     // turn off font smoothing so translucent text draws correctly (Radar 3118455)
127     [self _web_drawAtPoint:textPoint font:font textColor:bottomColor allowingFontSmoothing:NO];
128
129     textPoint.y += 1;
130     [self _web_drawAtPoint:textPoint font:font textColor:topColor allowingFontSmoothing:NO];
131 }
132
133 - (float)_web_widthWithFont:(NSFont *)font
134 {
135     unsigned length = [self length];
136     Vector<UniChar, 2048> buffer(length);
137
138     [self getCharacters:buffer.data()];
139
140     if (canUseFastRenderer(buffer.data(), length)) {
141         FontCascade webCoreFont(FontPlatformData(reinterpret_cast<CTFontRef>(font), [font pointSize]));
142         TextRun run(buffer.data(), length);
143         run.disableRoundingHacks();
144         return webCoreFont.width(run);
145     }
146
147     return [self sizeWithAttributes:[NSDictionary dictionaryWithObjectsAndKeys:font, NSFontAttributeName, nil]].width;
148 }
149 #endif // !PLATFORM(IOS)
150
151 - (NSString *)_web_stringByAbbreviatingWithTildeInPath
152 {
153     NSString *resolvedHomeDirectory = [NSHomeDirectory() stringByResolvingSymlinksInPath];
154     NSString *path;
155     
156     if ([self hasPrefix:resolvedHomeDirectory]) {
157         NSString *relativePath = [self substringFromIndex:[resolvedHomeDirectory length]];
158         path = [NSHomeDirectory() stringByAppendingPathComponent:relativePath];
159     } else {
160         path = self;
161     }
162         
163     return [path stringByAbbreviatingWithTildeInPath];
164 }
165
166 - (NSString *)_web_stringByStrippingReturnCharacters
167 {
168     NSMutableString *newString = [[self mutableCopy] autorelease];
169     [newString replaceOccurrencesOfString:@"\r" withString:@"" options:NSLiteralSearch range:NSMakeRange(0, [newString length])];
170     [newString replaceOccurrencesOfString:@"\n" withString:@"" options:NSLiteralSearch range:NSMakeRange(0, [newString length])];
171     return newString;
172 }
173
174 #if !PLATFORM(IOS)
175 + (NSStringEncoding)_web_encodingForResource:(Handle)resource
176 {
177     return CFStringConvertEncodingToNSStringEncoding(stringEncodingForResource(resource));
178 }
179 #endif
180
181 - (BOOL)_webkit_isCaseInsensitiveEqualToString:(NSString *)string
182 {
183     return stringIsCaseInsensitiveEqualToString(self, string);
184 }
185
186 -(BOOL)_webkit_hasCaseInsensitivePrefix:(NSString *)prefix
187 {
188     return hasCaseInsensitivePrefix(self, prefix);
189 }
190
191 -(BOOL)_webkit_hasCaseInsensitiveSuffix:(NSString *)suffix
192 {
193     return hasCaseInsensitiveSuffix(self, suffix);
194 }
195
196 -(BOOL)_webkit_hasCaseInsensitiveSubstring:(NSString *)substring
197 {
198     return hasCaseInsensitiveSubstring(self, substring);
199 }
200
201 -(NSString *)_webkit_filenameByFixingIllegalCharacters
202 {
203     return filenameByFixingIllegalCharacters(self);
204 }
205
206 -(NSString *)_webkit_stringByTrimmingWhitespace
207 {
208     NSMutableString *trimmed = [[self mutableCopy] autorelease];
209     CFStringTrimWhitespace((CFMutableStringRef)trimmed);
210     return trimmed;
211 }
212
213 - (NSString *)_webkit_stringByCollapsingNonPrintingCharacters
214 {
215     NSMutableString *result = [NSMutableString string];
216     static NSCharacterSet *charactersToTurnIntoSpaces = nil;
217     static NSCharacterSet *charactersToNotTurnIntoSpaces = nil;
218     
219     if (charactersToTurnIntoSpaces == nil) {
220         NSMutableCharacterSet *set = [[NSMutableCharacterSet alloc] init];
221         [set addCharactersInRange:NSMakeRange(0x00, 0x21)];
222         [set addCharactersInRange:NSMakeRange(0x7F, 0x01)];
223         charactersToTurnIntoSpaces = [set copy];
224         [set release];
225         charactersToNotTurnIntoSpaces = [[charactersToTurnIntoSpaces invertedSet] retain];
226     }
227     
228     unsigned length = [self length];
229     unsigned position = 0;
230     while (position != length) {
231         NSRange nonSpace = [self rangeOfCharacterFromSet:charactersToNotTurnIntoSpaces
232             options:0 range:NSMakeRange(position, length - position)];
233         if (nonSpace.location == NSNotFound) {
234             break;
235         }
236
237         NSRange space = [self rangeOfCharacterFromSet:charactersToTurnIntoSpaces
238             options:0 range:NSMakeRange(nonSpace.location, length - nonSpace.location)];
239         if (space.location == NSNotFound) {
240             space.location = length;
241         }
242
243         if (space.location > nonSpace.location) {
244             if (position != 0) {
245                 [result appendString:@" "];
246             }
247             [result appendString:[self substringWithRange:
248                 NSMakeRange(nonSpace.location, space.location - nonSpace.location)]];
249         }
250
251         position = space.location;
252     }
253     
254     return result;
255 }
256
257 - (NSString *)_webkit_stringByCollapsingWhitespaceCharacters
258 {
259     NSMutableString *result = [[NSMutableString alloc] initWithCapacity:[self length]];
260     NSCharacterSet *spaces = [NSCharacterSet whitespaceAndNewlineCharacterSet];
261     static NSCharacterSet *notSpaces = nil;
262
263     if (notSpaces == nil)
264         notSpaces = [[spaces invertedSet] retain];
265
266     unsigned length = [self length];
267     unsigned position = 0;
268     while (position != length) {
269         NSRange nonSpace = [self rangeOfCharacterFromSet:notSpaces options:0 range:NSMakeRange(position, length - position)];
270         if (nonSpace.location == NSNotFound)
271             break;
272
273         NSRange space = [self rangeOfCharacterFromSet:spaces options:0 range:NSMakeRange(nonSpace.location, length - nonSpace.location)];
274         if (space.location == NSNotFound)
275             space.location = length;
276
277         if (space.location > nonSpace.location) {
278             if (position != 0)
279                 [result appendString:@" "];
280             [result appendString:[self substringWithRange:NSMakeRange(nonSpace.location, space.location - nonSpace.location)]];
281         }
282
283         position = space.location;
284     }
285
286     return [result autorelease];
287 }
288
289 #if !PLATFORM(IOS)
290 -(NSString *)_webkit_fixedCarbonPOSIXPath
291 {
292     NSFileManager *fileManager = [NSFileManager defaultManager];
293     if ([fileManager fileExistsAtPath:self]) {
294         // Files exists, no need to fix.
295         return self;
296     }
297
298     NSMutableArray *pathComponents = [[[self pathComponents] mutableCopy] autorelease];
299     NSString *volumeName = [pathComponents objectAtIndex:1];
300     if ([volumeName isEqualToString:@"Volumes"]) {
301         // Path starts with "/Volumes", so the volume name is the next path component.
302         volumeName = [pathComponents objectAtIndex:2];
303         // Remove "Volumes" from the path because it may incorrectly be part of the path (3163647).
304         // We'll add it back if we have to.
305         [pathComponents removeObjectAtIndex:1];
306     }
307
308     if (!volumeName) {
309         // Should only happen if self == "/", so this shouldn't happen because that always exists.
310         return self;
311     }
312
313     if ([[fileManager _webkit_startupVolumeName] isEqualToString:volumeName]) {
314         // Startup volume name is included in path, remove it.
315         [pathComponents removeObjectAtIndex:1];
316     } else if ([[fileManager contentsOfDirectoryAtPath:@"/Volumes" error:NULL] containsObject:volumeName]) {
317         // Path starts with other volume name, prepend "/Volumes".
318         [pathComponents insertObject:@"Volumes" atIndex:1];
319     } else
320         // It's valid.
321         return self;
322
323     NSString *path = [NSString pathWithComponents:pathComponents];
324
325     if (![fileManager fileExistsAtPath:path])
326         // File at canonicalized path doesn't exist, return original.
327         return self;
328
329     return path;
330 }
331 #endif // !PLATFORM(IOS)
332
333 #if PLATFORM(IOS)
334 + (NSString *)_web_stringWithData:(NSData *)data textEncodingName:(NSString *)textEncodingName
335 {
336     return [WebFrame stringWithData:data textEncodingName:textEncodingName];
337 }
338 #endif
339
340 + (NSString *)_webkit_localCacheDirectoryWithBundleIdentifier:(NSString*)bundleIdentifier
341 {
342     NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
343     NSString *cacheDir = [defaults objectForKey:WebKitLocalCacheDefaultsKey];
344
345     if (!cacheDir || ![cacheDir isKindOfClass:[NSString class]]) {
346 #if PLATFORM(IOS)
347         cacheDir = [NSHomeDirectory() stringByAppendingPathComponent:@"Library/Caches"];
348 #else
349         char cacheDirectory[MAXPATHLEN];
350         size_t cacheDirectoryLen = confstr(_CS_DARWIN_USER_CACHE_DIR, cacheDirectory, MAXPATHLEN);
351     
352         if (cacheDirectoryLen)
353             cacheDir = [[NSFileManager defaultManager] stringWithFileSystemRepresentation:cacheDirectory length:cacheDirectoryLen - 1];
354 #endif
355     }
356
357     return [cacheDir stringByAppendingPathComponent:bundleIdentifier];
358 }
359
360 @end