The UIView class defines a rectangular area on the screen and the interfaces for managing the content in that area. At runtime, a view object handles the rendering of any content in its area and also handles any interactions with that content. The UIView class itself provides basic behavior for filling its rectangular area with a background color. More sophisticated content can be presented by subclassing UIView and implementing the necessary drawing and event-handling code yourself. The UIKit framework also includes a set of standard subclasses that range from simple buttons to complex tables and can be used as-is. For example, a UILabelobject draws a text string and a UIImageView object draws an image.
Because view objects are the main way your application interacts with the user, they have a number of responsibilities. Here are just a few:
- Drawing and animation
- Views draw content in their rectangular area using technologies such as UIKit, Core Graphics, and OpenGL ES.
- Some view properties can be animated to new values.
- Layout and subview management
- A view may contain zero or more subviews.
- Each view defines its own default resizing behavior in relation to its parent view.
- A view can define the size and position of its subviews as needed.
- Event handling
- A view is a responder and can handle touch events and other events defined by the
UIResponderclass. - Views can use the
addGestureRecognizer:method to install gesture recognizers to handle common gestures.
- A view is a responder and can handle touch events and other events defined by the
Views can embed other views and create sophisticated visual hierarchies. This creates a parent-child relationship between the view being embedded (known as the subview) and the parent view doing the embedding (known as the superview). Normally, a subview’s visible area is not clipped to the bounds of its superview, but in iOS you can use the clipsToBounds property to alter that behavior. A parent view may contain any number of subviews but each subview has only one superview, which is responsible for positioning its subviews appropriately.
The geometry of a view is defined by its frame, bounds, and center properties. The frame defines the origin and dimensions of the view in the coordinate system of its superview and is commonly used during layout to adjust the size or position of the view. The center property can be used to adjust the position of the view without changing its size. The bounds defines the internal dimensions of the view as it sees them and is used almost exclusively in custom drawing code. The size portion of the frame and bounds rectangles are coupled together so that changing the size of either rectangle updates the size of both.
For detailed information about how to use the UIView class, see View Programming Guide for iOS.
NOTE
In iOS 2.x, the maximum size of a UIView object is 1024 x 1024 points. In iOS 3.0 and later, views are no longer restricted to this maximum size but are still limited by the amount of memory they consume. It is in your best interests to keep view sizes as small as possible. Regardless of which version of iOS is running, you should consider tiling any content that is significantly larger than the dimensions the screen.
Creating a View
To create a view programmatically, you can use code like the following:
CGRect viewRect = CGRectMake(10, 10, 100, 100);UIView* myView = [[UIView alloc] initWithFrame:viewRect];
This code creates the view and positions it at the point (10, 10) in its superview’s coordinate system (once it is added to that superview). To add a subview to another view, you use the addSubview: method. In iOS, sibling views may overlap each other without any issues, allowing complex view placement. The addSubview: method places the specified view on top of other siblings. You can specify the relative z-order of a subview by adding it using the insertSubview:aboveSubview: and insertSubview:belowSubview: methods. You can also exchange the position of already added subviews using the exchangeSubviewAtIndex:withSubviewAtIndex:method.
When creating a view, it is important to assign an appropriate value to the autoresizingMask property to ensure the view resizes correctly. View resizing primarily occurs when the orientation of your application’s interface changes but it may happen at other times as well. For example, calling the setNeedsLayout method forces your view to update its layout.
The View Drawing Cycle
View drawing occurs on an as-needed basis. When a view is first shown, or when all or part of it becomes visible due to layout changes, the system asks the view to draw its contents. For views that contain custom content using UIKit or Core Graphics, the system calls the view’s drawRect: method. Your implementation of this method is responsible for drawing the view’s content into the current graphics context, which is set up by the system automatically prior to calling this method. This creates a static visual representation of your view’s content that can then be displayed on the screen.
When the actual content of your view changes, it is your responsibility to notify the system that your view needs to be redrawn. You do this by calling your view’s setNeedsDisplay or setNeedsDisplayInRect: method of the view. These methods let the system know that it should update the view during the next drawing cycle. Because it waits until the next drawing cycle to update the view, you can call these methods on multiple views to update them at the same time.
NOTE
If you are using OpenGL ES to do your drawing, you should use the GLKView class instead of subclassing UIView. For more information about how to draw using OpenGL ES, see OpenGL ES Programming Guide for iOS.
For detailed information about the view drawing cycle and the role your views have in this cycle, see View Programming Guide for iOS.
Animations
Changes to several view properties can be animated—that is, changing the property creates an animation that conveys the change to the user over a short period of time. The UIView class does most of the work of performing the actual animations but you must still indicate which property changes you want to be animated. There are two different ways to initiate animations:
- In iOS 4 and later, use the block-based animation methods. (Recommended)
- Use the begin/commit animation methods.
The block-based animation methods (such as animateWithDuration:animations:) greatly simplify the creation of animations. With one method call, you specify the animations to be performed and the options for the animation. However, block-based animations are available only in iOS 4 and later. If your application runs on earlier versions of iOS, you must use the beginAnimations:context: and commitAnimations class methods to mark the beginning and ending of your animations.
The following properties of the UIView class are animatable:
@property frame@property bounds@property center@property transform@property alpha@property backgroundColor@property contentStretch
For more information about how to configure animations, see View Programming Guide for iOS.
抛砖引玉：
1）继承自UIresponder，因此有touch和手势的方法，直接重写就可以实现在当前View进行对具体的操作的处理。
- A view is a responder and can handle touch events and other events defined by the
UIResponderclass. - Views can use the
addGestureRecognizer:method to install gesture recognizers to handle common gestures.
2）具有动画能力。The block-based animation methods (such as animateWithDuration:animations:)；使用块可以快速实现关键帧动画、基础动画。
3）具有绘制自己的方法drawRect：系统会优先调用此方法在当前绘图文本上绘制， This creates a static visual representation of your view’s content that can then be displayed on the screen，是静态可视的。因此当你在系统绘制后改变视图的内容，需要自己手动调用When the actual content of your view changes, it is your responsibility to notify the system that your view needs to be redrawn. You do this by calling your view’s setNeedsDisplay or setNeedsDisplayInRect: method of the view，来强制让系统在下一个绘图周期更新视图内容，这样视图才会按照你想的那样更新。
4）对于绘制会使用 UIKit or Core Graphics，知道这两者的区别和联系，以及具体的怎么使用，这样就可以自定义视图的绘制内容。
5）理解UIView的几个属性，center，frame，bounds，重要的是理解他们相对于那个视图。