Introduce an isCSSAnimated flag on RenderElement for performance
[WebKit-https.git] / Source / WebCore / platform / ios / wak / WKView.mm
1 /*
2  * Copyright (C) 2005, 2006, 2007, 2008, 2009 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #import "WKViewPrivate.h"
28
29 #if PLATFORM(IOS)
30
31 #import "WAKViewPrivate.h"
32 #import "WAKWindow.h"
33 #import "WKUtilities.h"
34 #import <wtf/Assertions.h>
35
36 void _WKViewSetSuperview (WKViewRef view, WKViewRef superview)
37 {
38     // Not retained.
39     view->superview = superview;
40 }
41
42 void _WKViewWillRemoveSubview(WKViewRef view, WKViewRef subview)
43 {
44     if (view->context && view->context->willRemoveSubviewCallback)
45         view->context->willRemoveSubviewCallback(view, subview);
46 }
47
48 void _WKViewSetWindow (WKViewRef view, WAKWindow *window)
49 {
50     if (view->window == window)
51         return;
52
53     [window retain];
54     [view->window release];
55
56     view->window = window;
57
58     // Set the window on all subviews.
59     WKViewRef firstChild = WKViewFirstChild(view);
60     if (firstChild) {
61         _WKViewSetWindow (firstChild, window);
62         WKViewRef nextSibling = WKViewNextSibling(firstChild);
63         while (nextSibling) {
64             _WKViewSetWindow (nextSibling, window);
65             nextSibling = WKViewNextSibling(nextSibling);
66         }
67     }
68
69     if (view->context && view->context->notificationCallback)
70         view->context->notificationCallback (view, WKViewNotificationViewDidMoveToWindow, view->context->notificationUserInfo);
71 }
72
73 static void _WKViewClearSuperview(const void *value, void *context)
74 {
75     UNUSED_PARAM(context);
76     _WKViewSetSuperview((WKViewRef)value, 0);
77 }
78
79 static void _WKViewDealloc (WKObjectRef v)
80 {
81     WKViewRef view = (WKViewRef)v;
82     
83     if (view->subviews) {
84         CFArrayApplyFunction(view->subviews, CFRangeMake(0, CFArrayGetCount(view->subviews)), _WKViewClearSuperview, NULL);
85         CFRelease (view->subviews);
86         view->subviews = 0;
87     }
88
89     [view->window release];
90     view->window = nil;
91 }
92
93 void WKViewInitialize (WKViewRef view, CGRect frame, WKViewContext *context)
94 {
95     view->origin = frame.origin;
96     view->bounds.origin = CGPointZero;
97     view->bounds.size = frame.size;
98     
99     view->context = context;
100     view->autoresizingMask = NSViewNotSizable;
101     view->scale = 1.0f;
102 }
103
104 WKClassInfo WKViewClassInfo = { &WKObjectClass, "WKView", _WKViewDealloc };
105
106 WKViewRef WKViewCreateWithFrame (CGRect frame, WKViewContext *context)
107 {
108     WKViewRef view = (WKViewRef)WKCreateObjectWithSize (sizeof(struct _WKView), &WKViewClassInfo);
109     if (!view)
110         return 0;
111     
112     WKViewInitialize (view, frame, context);
113     
114     return view;
115 }
116
117 void _WKViewSetViewContext (WKViewRef view, WKViewContext *context)
118 {
119     if (!view) {
120         WKError ("invalid parameter");
121         return;
122     }
123     view->context = context;
124 }
125
126 CGRect WKViewGetBounds (WKViewRef view)
127 {
128     if (!view) {
129         WKError ("invalid parameter");
130         return CGRectZero;
131     }
132     
133     return view->bounds;
134 }
135
136 CGRect WKViewGetFrame (WKViewRef view)
137 {
138     if (!view) {
139         WKError ("invalid parameter");
140         return CGRectZero;
141     }
142     
143     return WKViewConvertRectToSuperview(view, view->bounds);
144 }
145
146 static void _WKViewRecursivelyInvalidateGState(WKViewRef view)
147 {
148     if (!view) {
149         WKError ("invalid parameter");
150         return;
151     }
152
153     if (view->context && view->context->invalidateGStateCallback)
154         view->context->invalidateGStateCallback(view);
155     
156     WKViewRef subview = WKViewFirstChild(view);
157     while (subview) {
158         _WKViewRecursivelyInvalidateGState(subview);
159         subview = WKViewNextSibling(subview);
160     }
161 }
162
163 void WKViewSetFrameOrigin (WKViewRef view, CGPoint newOrigin)
164 {
165     if (!view) {
166         WKError ("invalid parameter");
167         return;
168     }
169     
170     ASSERT(!isinf(newOrigin.x));
171     ASSERT(!isnan(newOrigin.x));
172     ASSERT(!isinf(newOrigin.y));
173     ASSERT(!isnan(newOrigin.y));
174     
175     if (!CGPointEqualToPoint(view->origin, newOrigin)) {
176         view->origin = newOrigin;
177         _WKViewRecursivelyInvalidateGState(view);
178     }
179 }
180
181 #define XSIZING_BITS(mask)      ((mask) & 7)
182 #define YSIZING_BITS(mask)      (((mask) >> 3) & 7)
183
184 static void _WKViewAutoresizeCoord(bool bByHeight, unsigned int sizingMethod, const CGRect *origSuperFrame, const CGRect *newSuperFrame, CGRect *newFrame)
185 {
186     CGFloat origSuperFrameWidthOrHeight;
187     CGFloat newSuperFrameWidthOrHeight;
188     CGFloat *origFrameXorY;
189     CGFloat *origFrameWidthOrHeight;
190     CGFloat prop;
191     CGFloat tmp;
192     CGFloat xOrY;
193     CGFloat widthOrHeight;
194     CGFloat origMarginsTotal;
195     CGFloat origWidthMinusMinMargin;
196     
197     if (bByHeight) {
198         sizingMethod = YSIZING_BITS(sizingMethod);
199         origSuperFrameWidthOrHeight = origSuperFrame->size.height;
200         newSuperFrameWidthOrHeight = newSuperFrame->size.height;
201         origFrameXorY = &newFrame->origin.y;
202         origFrameWidthOrHeight = &newFrame->size.height;
203     } else {
204         sizingMethod = XSIZING_BITS(sizingMethod);
205         origSuperFrameWidthOrHeight = origSuperFrame->size.width;
206         newSuperFrameWidthOrHeight = newSuperFrame->size.width;
207         origFrameXorY = &newFrame->origin.x;
208         origFrameWidthOrHeight = &newFrame->size.width;
209     }
210     
211     xOrY = *origFrameXorY;
212     widthOrHeight = *origFrameWidthOrHeight;
213     
214     switch (sizingMethod) {
215         case NSViewNotSizable:
216         case NSViewMaxXMargin:
217             break;
218         case NSViewWidthSizable:
219             widthOrHeight = newSuperFrameWidthOrHeight - (origSuperFrameWidthOrHeight - widthOrHeight);
220             if (widthOrHeight < 0.0f)
221                 widthOrHeight = 0.0f;
222                 break;
223         case NSViewWidthSizable | NSViewMaxXMargin:
224             origWidthMinusMinMargin = origSuperFrameWidthOrHeight - xOrY;
225             if (widthOrHeight) {
226                 if (origWidthMinusMinMargin != 0.0f) {
227                     prop = widthOrHeight / origWidthMinusMinMargin;
228                 } else {
229                     prop = 0.0f;
230                 }
231             } else {
232                 prop = 1.0f;
233             }
234                 widthOrHeight = ((newSuperFrameWidthOrHeight - xOrY)) * prop;
235             if (widthOrHeight < 0.0f)
236                 widthOrHeight = 0.0f;
237                 break;
238         case NSViewMinXMargin:
239             xOrY = newSuperFrameWidthOrHeight - (origSuperFrameWidthOrHeight - xOrY);
240             if (xOrY < 0.0f)
241                 xOrY = 0.0f;
242             break;
243         case NSViewMinXMargin | NSViewMaxXMargin:
244             origMarginsTotal = origSuperFrameWidthOrHeight - widthOrHeight;
245             if (xOrY && origMarginsTotal != 0.0f) {
246                 prop = xOrY / origMarginsTotal;
247             }
248                 // Do the 50/50 split even if XorY = 0 and the WidthOrHeight is only
249                 // one pixel shorter...
250                 // FIXME: If origMarginsTotal is in the range (0, 1) then we won't do the 50/50 split. Is this right?
251                 else if (origMarginsTotal == 0.0f 
252                     || (abs(static_cast<int>(origMarginsTotal)) == 1)) {
253                     prop = 0.5f;  // Then split it 50:50.
254                 }
255                 else {
256                     prop = 1.0f;
257                 }
258                 xOrY = ((newSuperFrameWidthOrHeight - widthOrHeight)) * prop;
259             if (xOrY < 0.0f)
260                 xOrY = 0.0f;
261                 break;
262         case NSViewMinXMargin | NSViewWidthSizable:
263             tmp = xOrY + widthOrHeight;
264             if (tmp)
265                 prop = xOrY / tmp;
266             else
267                 prop = 0.5f;
268             xOrY = ((newSuperFrameWidthOrHeight - (origSuperFrameWidthOrHeight - tmp))) * prop;
269             widthOrHeight  = newSuperFrameWidthOrHeight - (xOrY + (origSuperFrameWidthOrHeight - tmp));
270             if (xOrY < 0.0f)
271                 xOrY = 0.0f;
272                 if (widthOrHeight < 0.0f)
273                     widthOrHeight = 0.0f;
274                     break;
275         case NSViewMinXMargin | NSViewWidthSizable | NSViewMaxXMargin:
276             if (origSuperFrameWidthOrHeight)
277                 prop = xOrY / origSuperFrameWidthOrHeight;
278             else
279                 prop = 1.0f / 3.0f;
280             xOrY = (newSuperFrameWidthOrHeight * prop);
281             if (origSuperFrameWidthOrHeight)
282                 prop = widthOrHeight / origSuperFrameWidthOrHeight;
283             else
284                 prop = 1.0f / 3.0f;
285             widthOrHeight = (newSuperFrameWidthOrHeight * prop);
286             break;
287     }
288     
289     *origFrameXorY = floorf(xOrY);
290     *origFrameWidthOrHeight = floorf(widthOrHeight);
291 }
292
293 void _WKViewAutoresize(WKViewRef view, const CGRect *oldSuperFrame, const CGRect *newSuperFrame)
294 {
295     if (view->autoresizingMask != NSViewNotSizable) {
296         CGRect newFrame = WKViewGetFrame(view);
297         _WKViewAutoresizeCoord(false, view->autoresizingMask, oldSuperFrame, newSuperFrame, &newFrame);
298         _WKViewAutoresizeCoord(true, view->autoresizingMask, oldSuperFrame, newSuperFrame, &newFrame);
299         WKViewSetFrameOrigin(view, newFrame.origin);
300         WKViewSetFrameSize(view, newFrame.size);
301     }
302 }
303
304 static void _WKViewAutoresizeChildren(WKViewRef view, const CGRect *oldSuperFrame, const CGRect *newSuperFrame)
305 {
306     WKViewRef child;
307     for (child = WKViewFirstChild(view); child != NULL; child = WKViewNextSibling(child)) {
308         _WKViewAutoresize(child, oldSuperFrame, newSuperFrame);
309     }        
310 }
311
312 void WKViewSetFrameSize (WKViewRef view, CGSize newSize)
313 {
314     if (!view) {
315         WKError ("invalid parameter");
316         return;
317     }
318     
319     ASSERT(!isinf(newSize.width));
320     ASSERT(!isnan(newSize.width));
321     ASSERT(!isinf(newSize.height));
322     ASSERT(!isnan(newSize.height));
323     
324     CGRect frame;
325     frame.origin = CGPointZero;
326     frame.size = newSize;
327     CGSize boundsSize = WKViewConvertRectFromSuperview(view, frame).size;
328     WKViewSetBoundsSize(view, boundsSize);
329 }
330
331 void WKViewSetBoundsSize (WKViewRef view, CGSize newSize)
332 {
333     if (CGSizeEqualToSize(view->bounds.size, newSize))
334         return;
335     
336     CGRect oldFrame = WKViewGetFrame(view);
337     view->bounds.size = newSize;
338     CGRect newFrame = WKViewGetFrame(view);
339     
340     if (view->context && view->context->notificationCallback)
341         view->context->notificationCallback (view, WKViewNotificationViewFrameSizeChanged, view->context->notificationUserInfo);
342     
343     _WKViewAutoresizeChildren(view, &oldFrame, &newFrame);    
344     _WKViewRecursivelyInvalidateGState(view);
345 }
346
347 void WKViewSetBoundsOrigin(WKViewRef view, CGPoint newOrigin)
348 {
349     if (CGPointEqualToPoint(view->bounds.origin, newOrigin))
350         return;
351
352     view->bounds.origin = newOrigin;
353
354     _WKViewRecursivelyInvalidateGState(view);    
355 }
356
357 void WKViewSetScale(WKViewRef view, float scale)
358 {
359     ASSERT(!isinf(scale));
360     ASSERT(!isnan(scale));
361     
362     if (view->scale == scale)
363         return;
364     
365     view->scale = scale;
366     
367     if (view->context && view->context->notificationCallback)
368         view->context->notificationCallback (view, WKViewNotificationViewFrameSizeChanged, view->context->notificationUserInfo);
369 }
370
371 float WKViewGetScale(WKViewRef view)
372 {
373     return view->scale;
374 }
375
376 WAKWindow *WKViewGetWindow (WKViewRef view)
377 {
378     if (!view) {
379         WKError ("invalid parameter");
380         return 0;
381     }
382     
383     return view->window;
384 }
385
386 CFArrayRef WKViewGetSubviews (WKViewRef view)
387 {
388     if (!view) {
389         WKError ("invalid parameter");
390         return 0;
391     }
392     
393     return view->subviews;
394 }
395
396 void WKViewAddSubview (WKViewRef view, WKViewRef subview)
397 {
398     if (!view || !subview) {
399         WKError ("invalid parameter");
400         return;
401     }
402     
403     if (!view->subviews) {
404         view->subviews = CFArrayCreateMutable(NULL, 0, &WKCollectionArrayCallBacks);
405     }
406     CFArrayAppendValue (view->subviews, subview);
407     _WKViewSetSuperview (subview, view);
408     
409     // Set the window on subview and all it's children.
410     _WKViewSetWindow (subview, view->window);
411 }
412
413 void WKViewRemoveFromSuperview (WKViewRef view)
414 {
415     if (!view) {
416         WKError ("invalid parameter");
417         return;
418     }
419
420     _WKViewSetWindow (view, 0);
421
422     if (!view->superview) {
423         return;
424     }
425     
426     CFMutableArrayRef svs = view->superview->subviews;
427     if (!svs) {
428         WKError ("superview has no subviews");
429         return;
430     }
431
432     CFIndex index = WKArrayIndexOfValue (svs, view);
433     if (index < 0) {
434         WKError ("view not in superview subviews");
435         return;
436     }
437
438     _WKViewWillRemoveSubview(view->superview, view);
439     
440     CFArrayRemoveValueAtIndex (svs, index);
441
442     _WKViewSetSuperview (view, 0);
443 }
444
445 WKViewRef WKViewFirstChild (WKViewRef view)
446 {
447     if (!view) {
448         WKError ("invalid parameter");
449         return 0;
450     }
451
452     CFArrayRef sv = view->subviews;
453     
454     if (!sv)
455         return 0;
456         
457     CFIndex count = CFArrayGetCount (sv);
458     if (!count)
459         return 0;
460         
461     return (const WKViewRef)CFArrayGetValueAtIndex (sv, 0);
462 }
463
464 WKViewRef WKViewNextSibling (WKViewRef view)
465 {
466     if (!view) {
467         WKError ("invalid parameter");
468         return 0;
469     }
470
471     if (!view->superview)
472         return 0;
473         
474     CFArrayRef svs = view->superview->subviews;
475     if (!svs)
476         return 0;
477         
478     CFIndex thisIndex = WKArrayIndexOfValue (svs, view);
479     if (thisIndex < 0) {
480         WKError ("internal error, view is not present in superview subviews");
481         return 0;
482     }
483     
484     CFIndex count = CFArrayGetCount (svs);
485     if (thisIndex+1 >= count)
486         return 0;
487         
488     return (const WKViewRef)CFArrayGetValueAtIndex (svs, thisIndex+1);
489 }
490
491 // To remove, see: <rdar://problem/10360425> Remove WKViewTraverseNext from Skankphone
492 WKViewRef WKViewTraverseNext(WKViewRef view)
493 {
494     if (!view) {
495         WKError ("invalid parameter");
496         return 0;
497     }
498
499     WKViewRef firstChild = WKViewFirstChild(view);
500     if (firstChild)
501         return firstChild;
502
503     WKViewRef nextSibling = WKViewNextSibling(view);
504     if (nextSibling)
505         return nextSibling;
506
507     while (view && !WKViewNextSibling(view)) {
508         WAKView *wakView = WAKViewForWKViewRef(view);
509         WAKView *superView = [wakView superview];
510         view = [superView _viewRef];
511     }
512         
513     if (view)
514         return WKViewNextSibling(view);
515     
516     return 0;
517 }
518
519 CGAffineTransform _WKViewGetTransform(WKViewRef view)
520 {
521     CGAffineTransform transform;
522     transform = CGAffineTransformMakeTranslation(view->origin.x, view->origin.y);
523     transform = CGAffineTransformScale(transform, view->scale, view->scale);
524     transform = CGAffineTransformTranslate(transform, -view->bounds.origin.x, -view->bounds.origin.y);
525     return transform;
526 }
527
528 CGRect WKViewGetVisibleRect(WKViewRef viewRef)
529 {
530     if (!viewRef) {
531         WKError ("invalid parameter");
532         return CGRectZero;
533     }
534
535     WKViewRef view = viewRef;
536     CGRect rect = WKViewGetBounds(view);
537     WKViewRef superview = view->superview;
538     
539     while (superview != NULL) {
540         rect = WKViewConvertRectToSuperview(view, rect);
541         rect = CGRectIntersection(WKViewGetBounds(superview), rect);
542         view = superview;
543         superview = superview->superview;
544     }
545     
546     if (view != viewRef) {
547         rect = WKViewConvertRectToBase(view, rect);
548         rect = WKViewConvertRectFromBase(viewRef, rect);
549     }
550     
551     return rect;
552 }
553
554 CGRect WKViewConvertRectToSuperview(WKViewRef view, CGRect r)
555 {
556     if (!view) {
557         WKError ("invalid parameter");
558         return CGRectZero;
559     }
560     
561     return CGRectApplyAffineTransform(r, _WKViewGetTransform(view));
562 }
563
564 CGRect WKViewConvertRectToBase(WKViewRef view, CGRect r)
565 {
566     if (!view) {
567         WKError ("invalid parameter");
568         return CGRectZero;
569     }
570
571     CGRect aRect = r;
572     
573     while (view) {
574         aRect = WKViewConvertRectToSuperview (view, aRect);    
575         view = view->superview;
576     }
577     
578     return aRect;
579 }
580
581 CGPoint WKViewConvertPointToSuperview(WKViewRef view, CGPoint p)
582 {
583     if (!view) {
584         WKError ("invalid parameter");
585         return CGPointZero;
586     }
587
588     return CGPointApplyAffineTransform(p, _WKViewGetTransform(view));
589 }
590
591 CGPoint WKViewConvertPointFromSuperview(WKViewRef view, CGPoint p)
592 {
593     if (!view) {
594         WKError ("invalid parameter");
595         return CGPointZero;
596     }
597     
598     CGAffineTransform transform = CGAffineTransformInvert(_WKViewGetTransform(view));
599     return CGPointApplyAffineTransform(p, transform);
600 }
601
602 CGPoint WKViewConvertPointToBase(WKViewRef view, CGPoint p)
603 {
604     if (!view) {
605         WKError ("invalid parameter");
606         return CGPointZero;
607     }
608
609     CGPoint aPoint = p;
610     
611     while (view) {
612         aPoint = WKViewConvertPointToSuperview (view, aPoint);    
613         view = view->superview;
614     }
615     
616     return aPoint;
617 }
618
619 #define VIEW_ARRAY_SIZE 128
620
621 static void _WKViewGetAncestorViewsIncludingView (WKViewRef view, WKViewRef *views, unsigned maxViews, unsigned *viewCount)
622 {
623     unsigned count = 0;
624     
625     views[count++] = view;
626     WKViewRef superview = view->superview;
627     while (superview) {
628         views[count++] = superview;
629         if (count >= maxViews) {
630             WKError ("Exceeded maxViews, use malloc/realloc");
631             *viewCount = 0;
632             return;
633         }
634         superview = superview->superview;
635     }
636     *viewCount = count;
637 }
638
639 CGPoint WKViewConvertPointFromBase(WKViewRef view, CGPoint p)
640 {
641     if (!view) {
642         WKError ("invalid parameter");
643         return CGPointZero;
644     }
645
646     WKViewRef views[VIEW_ARRAY_SIZE];
647     unsigned viewCount = 0;
648
649     _WKViewGetAncestorViewsIncludingView (view, views, VIEW_ARRAY_SIZE, &viewCount);
650     if (viewCount == 0)
651         return CGPointZero;
652
653     CGPoint aPoint = p;
654     int i;
655     for (i = viewCount-1; i >= 0; i--) {
656         aPoint = WKViewConvertPointFromSuperview (views[i], aPoint);
657     }
658         
659     return aPoint;
660 }
661
662 CGRect WKViewConvertRectFromSuperview(WKViewRef view, CGRect r)
663 {
664     if (!view) {
665         WKError ("invalid parameter");
666         return CGRectZero;
667     }
668     
669     CGAffineTransform transform = CGAffineTransformInvert(_WKViewGetTransform(view));
670     return CGRectApplyAffineTransform(r, transform);
671 }
672
673 CGRect WKViewConvertRectFromBase(WKViewRef view, CGRect r)
674 {
675     if (!view) {
676         WKError ("invalid parameter");
677         return CGRectZero;
678     }
679
680     WKViewRef views[VIEW_ARRAY_SIZE];
681     unsigned viewCount = 0;
682
683     _WKViewGetAncestorViewsIncludingView (view, views, VIEW_ARRAY_SIZE, &viewCount);
684     if (viewCount == 0)
685         return CGRectZero;
686     
687     CGRect aRect = r;
688     int i;
689     for (i = viewCount-1; i >= 0; i--) {
690         aRect = WKViewConvertRectFromSuperview (views[i], aRect);
691     }
692         
693     return aRect;
694 }
695
696 bool WKViewAcceptsFirstResponder (WKViewRef view)
697 {
698     bool result = TRUE;
699     if (view && view->context && view->context->responderCallback)
700         result = view->context->responderCallback(view, WKViewResponderAcceptsFirstResponder, view->context->responderUserInfo);
701     return result;
702 }
703
704 bool WKViewBecomeFirstResponder (WKViewRef view)
705 {
706     bool result = TRUE;
707     if (view && view->context && view->context->responderCallback)
708         result = view->context->responderCallback(view, WKViewResponderBecomeFirstResponder, view->context->responderUserInfo);
709     return result;
710 }
711
712 bool WKViewResignFirstResponder (WKViewRef view)
713 {
714     bool result = TRUE;
715     if (view && view->context && view->context->responderCallback)
716         result = view->context->responderCallback(view, WKViewResponderResignFirstResponder, view->context->responderUserInfo);
717     return result;
718 }
719
720 unsigned int WKViewGetAutoresizingMask(WKViewRef view)
721 {
722     if (!view) {
723         WKError ("invalid parameter");
724         return 0;
725     }    
726     return view->autoresizingMask;
727 }
728
729 void WKViewSetAutoresizingMask (WKViewRef view, unsigned int mask)
730 {
731     if (!view) {
732         WKError ("invalid parameter");
733         return;
734     }    
735     view->autoresizingMask = mask;
736 }
737
738 #endif // PLATFORM(IOS)