From 3.1.3 to 3.2

Namespace: MonoTouch

 

Type Changed: MonoTouch.Constants

Removed:

public const string Version = "3.1.3";

Added:

public const string Version = "3.2.0";
        public const string ImageIOLibrary = "/System/Library/Frameworks/ImageIO.framework/ImageIO";
        public const string AssetsLibraryLibrary = "/System/Library/Frameworks/AssetLibrary.framework/AssetLibrary";
        public const string CoreVideoLibrary = "/System/Library/Frameworks/CoreVideo.framework/CoreVideo";

Namespace: MonoTouch.AVFoundation

Type Changed: MonoTouch.AVFoundation.AVAsset

Added:

public virtual bool ProtectedContent {
                get;
        }

Type Changed: MonoTouch.AVFoundation.AVAssetExportSession

Added:

public static MonoTouch.Foundation.NSString Preset1280x720 {
                get;
        }
        public static MonoTouch.Foundation.NSString Preset640x480 {
                get;
        }
        public static MonoTouch.Foundation.NSString Preset960x540 {
                get;
        }
        public static MonoTouch.Foundation.NSString PresetAppleM4A {
                get;
        }
        public static MonoTouch.Foundation.NSString PresetHighestQuality {
                get;
        }
        public static MonoTouch.Foundation.NSString PresetLowQuality {
                get;
        }
        public static MonoTouch.Foundation.NSString PresetMediumQuality {
                get;
        }
        public static MonoTouch.Foundation.NSString PresetPassthrough {
                get;
        }
        public virtual MonoTouch.Foundation.NSError Error {
                get;
        }

Type Changed: MonoTouch.AVFoundation.AVAssetExportSessionStatus

Added:

Waiting,

Type Changed: MonoTouch.AVFoundation.AVMetadataItem

Added:

public virtual MonoTouch.CoreMedia.CMTime Duration {
                get;
        }

Type Changed: MonoTouch.AVFoundation.AVMutableMetadataItem

Added:

public virtual MonoTouch.CoreMedia.CMTime Duration {
                get;
        }

Namespace: MonoTouch.AddressBookUI

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationControllerDelegate

Added:

public override void DidShowViewController (MonoTouch.UIKit.UINavigationController navigationController, MonoTouch.UIKit.UIViewController viewController, bool animated);
        public override void WillShowViewController (MonoTouch.UIKit.UINavigationController navigationController, MonoTouch.UIKit.UIViewController viewController, bool animated);

Namespace: MonoTouch.AssetsLibrary

New Type: MonoTouch.AssetsLibrary.ALAsset

public class ALAsset : MonoTouch.Foundation.NSObject {
        
        public ALAsset ();
        public ALAsset (MonoTouch.Foundation.NSCoder coder);
        public ALAsset (MonoTouch.Foundation.NSObjectFlag t);
        public ALAsset (IntPtr handle);
        
        public virtual ALAssetRepresentation RepresentationForUti (string uti);
        public virtual MonoTouch.Foundation.NSObject ValueForProperty (MonoTouch.Foundation.NSString property);
        
        public ALAssetType AssetType {
                get;
        }
        public override IntPtr ClassHandle {
                get;
        }
        public MonoTouch.Foundation.NSDate Date {
                get;
        }
        public virtual ALAssetRepresentation DefaultRepresentation {
                get;
        }
        public double Duration {
                get;
        }
        public MonoTouch.CoreLocation.CLLocation Location {
                get;
        }
        public ALAssetOrientation Orientation {
                get;
        }
        public string [] Representations {
                get;
        }
        public virtual MonoTouch.CoreGraphics.CGImage Thumbnail {
                get;
        }
        public MonoTouch.Foundation.NSDictionary UtiToUrlDictionary {
                get;
        }
}

New Type: MonoTouch.AssetsLibrary.ALAssetOrientation

[Serializable]
public enum ALAssetOrientation {
        Up,
        Down,
        Left,
        Right,
        UpMirrored,
        DownMirrored,
        LeftMirrored,
        RightMirrored
}

New Type: MonoTouch.AssetsLibrary.ALAssetRepresentation

public class ALAssetRepresentation : MonoTouch.Foundation.NSObject {
        
        public ALAssetRepresentation ();
        public ALAssetRepresentation (MonoTouch.Foundation.NSCoder coder);
        public ALAssetRepresentation (MonoTouch.Foundation.NSObjectFlag t);
        public ALAssetRepresentation (IntPtr handle);
        
        public virtual uint GetBytes (IntPtr buffer, long offset, uint length, out MonoTouch.Foundation.NSError error);
        public virtual MonoTouch.CoreGraphics.CGImage GetFullScreenImage ();
        public virtual MonoTouch.CoreGraphics.CGImage GetImage ();
        public virtual MonoTouch.CoreGraphics.CGImage GetImage (MonoTouch.Foundation.NSDictionary options);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual MonoTouch.Foundation.NSDictionary Metadata {
                get;
        }
        public virtual ALAssetOrientation Orientation {
                get;
        }
        public virtual float Scale {
                get;
        }
        public virtual long Size {
                get;
        }
        public virtual MonoTouch.Foundation.NSUrl Url {
                get;
        }
        public virtual string Uti {
                get;
        }
}

New Type: MonoTouch.AssetsLibrary.ALAssetsEnumerator

[Serializable]
public delegate void ALAssetsEnumerator (ALAsset result, int index, ref bool stop);

New Type: MonoTouch.AssetsLibrary.ALAssetsFilter

public class ALAssetsFilter : MonoTouch.Foundation.NSObject {
        
        public ALAssetsFilter ();
        public ALAssetsFilter (MonoTouch.Foundation.NSCoder coder);
        public ALAssetsFilter (MonoTouch.Foundation.NSObjectFlag t);
        public ALAssetsFilter (IntPtr handle);
        
        public static ALAssetsFilter AllAssets {
                get;
        }
        public static ALAssetsFilter AllPhotos {
                get;
        }
        public static ALAssetsFilter AllVideos {
                get;
        }
        public override IntPtr ClassHandle {
                get;
        }
}

New Type: MonoTouch.AssetsLibrary.ALAssetsGroup

public class ALAssetsGroup : MonoTouch.Foundation.NSObject {
        
        public ALAssetsGroup ();
        public ALAssetsGroup (MonoTouch.Foundation.NSCoder coder);
        public ALAssetsGroup (MonoTouch.Foundation.NSObjectFlag t);
        public ALAssetsGroup (IntPtr handle);
        
        public virtual void Enumerate (ALAssetsEnumerator result);
        public virtual void Enumerate (MonoTouch.Foundation.NSEnumerationOptions options, ALAssetsEnumerator result);
        public virtual void Enumerate (MonoTouch.Foundation.NSIndexSet indexSet, MonoTouch.Foundation.NSEnumerationOptions options, ALAssetsEnumerator result);
        public virtual void SetAssetsFilter (ALAssetsFilter filter);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual int Count {
                get;
        }
        public MonoTouch.Foundation.NSString Name {
                get;
        }
        public string PersistentID {
                get;
        }
        public virtual MonoTouch.CoreGraphics.CGImage PosterImage {
                get;
        }
        public ALAssetsGroupType Type {
                get;
        }
}

New Type: MonoTouch.AssetsLibrary.ALAssetsGroupType

[Serializable]
[Flags]
public enum ALAssetsGroupType : uint {
        Library,
        Album,
        Event,
        Faces,
        SavedPhotos,
        All
}

New Type: MonoTouch.AssetsLibrary.ALAssetType

[Serializable]
public enum ALAssetType {
        Video,
        Photo,
        Unknown
}

Namespace: MonoTouch.AudioToolbox

New Type: MonoTouch.AudioToolbox.AudioBuffer

public struct AudioBuffer {
        
        public override string ToString ();
        
        public int NumberChannels;
        public int DataByteSize;
        public IntPtr Data;
}

New Type: MonoTouch.AudioToolbox.AudioBufferList

public class AudioBufferList {
        
        public AudioBufferList ();
        
        public override string ToString ();
        
        public int BufferCount {
                get;
        }
        public AudioBuffer[] Buffers {
                get;
        }
}

New Type: MonoTouch.AudioToolbox.MutableAudioBufferList

public class MutableAudioBufferList : AudioBufferList, IDisposable {
        
        public MutableAudioBufferList (int nubuffers, int bufferSize);
        
        public void Dispose ();
        public virtual void Dispose (bool disposing);
        protected override void Finalize ();
}

Namespace: MonoTouch.AudioUnit

New Type: MonoTouch.AudioUnit.AudioComponent

public class AudioComponent : MonoTouch.ObjCRuntime.INativeObject {
        
        public static AudioComponent FindComponent (AudioComponentDescription cd);
        public static AudioComponent FindComponent (AudioTypeConverter conveter);
        public static AudioComponent FindComponent (AudioTypeEffect effect);
        public static AudioComponent FindComponent (AudioTypeGenerator generator);
        public static AudioComponent FindComponent (AudioTypeMixer mixer);
        public static AudioComponent FindComponent (AudioTypeMusicDevice musicDevice);
        public static AudioComponent FindComponent (AudioTypeOutput output);
        public static AudioComponent FindComponent (AudioTypePanner panner);
        public static AudioComponent FindNextComponent (AudioComponent cmp, AudioComponentDescription cd);
        public AudioUnit CreateAudioUnit ();
        
        public AudioComponentDescription Description {
                get;
        }
        public IntPtr Handle {
                get;
        }
        public string Name {
                get;
        }
        public Version Version {
                get;
        }
}

New Type: MonoTouch.AudioUnit.AudioComponentDescription

public class AudioComponentDescription {
        
        public AudioComponentDescription ();
        
        public static AudioComponentDescription CreateConverter (AudioTypeConverter converter);
        public static AudioComponentDescription CreateEffect (AudioTypeEffect effect);
        public static AudioComponentDescription CreateGenerator (AudioTypeGenerator generator);
        public static AudioComponentDescription CreateGeneric (AudioComponentType type, int subType);
        public static AudioComponentDescription CreateMixer (AudioTypeMixer mixer);
        public static AudioComponentDescription CreateMusicDevice (AudioTypeMusicDevice musicDevice);
        public static AudioComponentDescription CreateOutput (AudioTypeOutput outputType);
        public static AudioComponentDescription CreatePanner (AudioTypePanner panner);
        public override string ToString ();
        
        public AudioComponentType ComponentType;
        public int ComponentSubType;
        public AudioComponentManufacturerType ComponentManufacturer;
        public int ComponentFlags;
        public int ComponentFlagsMask;
}

New Type: MonoTouch.AudioUnit.AudioComponentManufacturerType

[Serializable]
public enum AudioComponentManufacturerType {
        Apple
}

New Type: MonoTouch.AudioUnit.AudioComponentType

[Serializable]
public enum AudioComponentType {
        Output,
        MusicDevice,
        MusicEffect,
        FormatConverter,
        Effect,
        Mixer,
        Panner,
        OfflineEffect,
        Generator
}

New Type: MonoTouch.AudioUnit.AudioGraphEventArgs

public class AudioGraphEventArgs : AudioUnitEventArgs {
        
        public AudioGraphEventArgs (AudioUnitRenderActionFlags actionFlags, MonoTouch.AudioToolbox.AudioTimeStamp timeStamp, int busNumber, int numberFrames, MonoTouch.AudioToolbox.AudioBufferList data);
}

New Type: MonoTouch.AudioUnit.AudioTypeConverter

[Serializable]
public enum AudioTypeConverter {
        AU,
        AUiPodTime
}

New Type: MonoTouch.AudioUnit.AudioTypeEffect

[Serializable]
public enum AudioTypeEffect {
        AUiPodEQ
}

New Type: MonoTouch.AudioUnit.AudioTypeGenerator

[Serializable]
public enum AudioTypeGenerator {
        
}

New Type: MonoTouch.AudioUnit.AudioTypeMixer

[Serializable]
public enum AudioTypeMixer {
        MultiChannel,
        Embedded3D
}

New Type: MonoTouch.AudioUnit.AudioTypeMusicDevice

[Serializable]
public enum AudioTypeMusicDevice {
        None
}

New Type: MonoTouch.AudioUnit.AudioTypeOutput

[Serializable]
public enum AudioTypeOutput {
        Generic,
        Remote,
        VoiceProcessingIO
}

New Type: MonoTouch.AudioUnit.AudioTypePanner

[Serializable]
public enum AudioTypePanner {
        
}

New Type: MonoTouch.AudioUnit.AudioUnit

public class AudioUnit : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
        
        public AudioUnit (AudioComponent component);
        
        public void Dispose ();
        public void Dispose (bool disposing);
        public MonoTouch.AudioToolbox.AudioStreamBasicDescription GetAudioFormat (AudioUnitScopeType scope, uint audioUnitElement);
        public int Initialize ();
        public void Render (AudioUnitRenderActionFlags flags, MonoTouch.AudioToolbox.AudioTimeStamp timeStamp, int outputBusnumber, int numberFrames, MonoTouch.AudioToolbox.AudioBufferList data);
        public void SetAudioFormat (MonoTouch.AudioToolbox.AudioStreamBasicDescription audioFormat, AudioUnitScopeType scope, uint audioUnitElement);
        public void SetEnableIO (bool enableIO, AudioUnitScopeType scope, uint audioUnitElement);
        public void Start ();
        public void Stop ();
        public AudioUnitStatus TryRender (AudioUnitRenderActionFlags flags, MonoTouch.AudioToolbox.AudioTimeStamp timeStamp, int outputBusnumber, int numberFrames, MonoTouch.AudioToolbox.AudioBufferList data);
        public int Uninitialize ();
        
        public AudioComponent Component {
                get;
        }
        public IntPtr Handle {
                get;
        }
        public bool IsPlaying {
                get;
        }
        
        public event EventHandler<audiouniteventargs> RenderCallback; } </audiouniteventargs>

New Type: MonoTouch.AudioUnit.AudioUnitEventArgs

public class AudioUnitEventArgs : EventArgs {
        
        public AudioUnitEventArgs (AudioUnitRenderActionFlags actionFlags, MonoTouch.AudioToolbox.AudioTimeStamp timestamp, int busNumber, int frames, MonoTouch.AudioToolbox.AudioBufferList data);
        
        public readonly AudioUnitRenderActionFlags ActionFlags;
        public readonly MonoTouch.AudioToolbox.AudioTimeStamp TimeStamp;
        public readonly int BusNumber;
        public readonly int NumberFrames;
        public readonly MonoTouch.AudioToolbox.AudioBufferList Data;
}

New Type: MonoTouch.AudioUnit.AudioUnitException

public class AudioUnitException : Exception {
}

New Type: MonoTouch.AudioUnit.AudioUnitPropertyIDType

[Serializable]
public enum AudioUnitPropertyIDType {
        ClassInfo,
        MakeConnection,
        SampleRate,
        ParameterList,
        ParameterInfo,
        StreamFormat,
        ElementCount,
        Latency,
        SupportedNumChannels,
        MaximumFramesPerSlice,
        AudioChannelLayout,
        TailTime,
        BypassEffect,
        LastRenderError,
        SetRenderCallback,
        FactoryPresets,
        RenderQuality,
        InPlaceProcessing,
        ElementName,
        SupportedChannelLayoutTags,
        PresentPreset,
        ShouldAllocateBuffer,
        CurrentDevice,
        ChannelMap,
        EnableIO,
        StartTime,
        SetInputCallback,
        HasIO,
        StartTimestampsAtZero
}

New Type: MonoTouch.AudioUnit.AudioUnitRenderActionFlags

[Serializable]
[Flags]
public enum AudioUnitRenderActionFlags {
        PreRender,
        PostRender,
        OutputIsSilence,
        OfflinePreflight,
        OfflineRender,
        OfflineComplete,
        PostRenderError
}

New Type: MonoTouch.AudioUnit.AudioUnitScopeType

[Serializable]
public enum AudioUnitScopeType {
        Global,
        Input,
        Output
}

New Type: MonoTouch.AudioUnit.AudioUnitStatus

[Serializable]
public enum AudioUnitStatus {
        NoError,
        ParameterError,
        InvalidProperty,
        InvalidParameter,
        InvalidElement,
        NoConnection,
        FailedInitialization,
        TooManyFramesToProcess,
        InvalidFile,
        FormatNotSupported,
        Uninitialized,
        InvalidScope,
        PropertyNotWritable,
        CannotDoInCurrentContext,
        InvalidPropertyValue,
        PropertyNotInUse,
        Initialized,
        InvalidOfflineRender,
        Unauthorized
}

New Type: MonoTouch.AudioUnit.AudioUnitUtils

public static class AudioUnitUtils {
        
        public static MonoTouch.AudioToolbox.AudioStreamBasicDescription AUCanonicalASBD (double sampleRate, int channel);
        public static void SetOverrideCategoryDefaultToSpeaker (bool isSpeaker);
        
        public const int SampleFractionBits = 24;
}

New Type: MonoTouch.AudioUnit.AUGraph

public class AUGraph : IDisposable {
        
        public AUGraph ();
        
        public int AddNode (AudioComponentDescription cd);
        public void ConnnectNodeInput (int inSourceNode, uint inSourceOutputNumber, int inDestNode, uint inDestInputNumber);
        public void Dispose ();
        public virtual void Dispose (bool disposing);
        protected override void Finalize ();
        public AudioUnit GetNodeInfo (int node);
        public void Initialize ();
        public void Open ();
        public void Start ();
        public void Stop ();
        public int TryOpen ();
        
        public IntPtr Handler {
                get;
        }
        
        public event EventHandler<audiographeventargs> RenderCallback; } </audiographeventargs>

New Type: MonoTouch.AudioUnit.ExtAudioFile

public class ExtAudioFile : IDisposable {
        
        public static ExtAudioFile CreateWithUrl (MonoTouch.CoreFoundation.CFUrl url, MonoTouch.AudioToolbox.AudioFileType fileType, MonoTouch.AudioToolbox.AudioStreamBasicDescription inStreamDesc, MonoTouch.AudioToolbox.AudioFileFlags flag);
        public static ExtAudioFile OpenUrl (MonoTouch.CoreFoundation.CFUrl url);
        public void Dispose ();
        public long FileTell ();
        public int Read (int numberFrames, MonoTouch.AudioToolbox.AudioBufferList data);
        public void Seek (long frameOffset);
        public void WriteAsync (int numberFrames, MonoTouch.AudioToolbox.AudioBufferList data);
        
        public MonoTouch.AudioToolbox.AudioStreamBasicDescription ClientDataFormat {
                set;
        }
        public MonoTouch.AudioToolbox.AudioStreamBasicDescription FileDataFormat {
                get;
        }
        public long FileLengthFrames {
                get;
        }
}

Namespace: MonoTouch.AudioUnitWrapper

New Type: MonoTouch.AudioUnitWrapper._AudioConverter

public class _AudioConverter : IDisposable {
        
        public static _AudioConverter CreateInstance (MonoTouch.AudioToolbox.AudioStreamBasicDescription srcFormat, MonoTouch.AudioToolbox.AudioStreamBasicDescription destFormat);
        public void Dispose ();
        public void FillBuffer (MonoTouch.AudioToolbox.AudioBufferList data, uint numberFrames, MonoTouch.AudioToolbox.AudioStreamPacketDescription[] packetDescs);
        
        public byte [] DecompressionMagicCookie {
                set;
        }
        
        public event EventHandler<_AudioConverterEventArgs> EncoderCallback;
}

New Type: MonoTouch.AudioUnitWrapper._AudioConverterEventArgs

public class _AudioConverterEventArgs : EventArgs {
        
        public _AudioConverterEventArgs (uint _NumberDataPackets, MonoTouch.AudioToolbox.AudioBufferList _Data, MonoTouch.AudioToolbox.AudioStreamPacketDescription[] _DataPacketDescription);
        
        public uint NumberDataPackets;
        public readonly MonoTouch.AudioToolbox.AudioBufferList Data;
        public readonly MonoTouch.AudioToolbox.AudioStreamPacketDescription[] DataPacketDescription;
}

Namespace: MonoTouch.CoreAnimation

New Type: MonoTouch.CoreAnimation.CAEdgeAntialiasingMask

[Serializable]
[Flags]
public enum CAEdgeAntialiasingMask {
        LeftEdge,
        RightEdge,
        BottomEdge,
        TopEdge,
        All,
        LeftRightEdges,
        TopBottomEdges
}

Type Changed: MonoTouch.CoreAnimation.CALayer

Removed:

public virtual uint EdgeAntialiasingMask {

Added:

public virtual CAEdgeAntialiasingMask EdgeAntialiasingMask {

Type Changed: MonoTouch.CoreAnimation.CAMediaTimingFunction

Added:

public static MonoTouch.Foundation.NSString EaseIn {
                get;
        }
        public static MonoTouch.Foundation.NSString EaseInEaseOut {
                get;
        }
        public static MonoTouch.Foundation.NSString EaseOut {
                get;
        }
        public static MonoTouch.Foundation.NSString Linear {
                get;
        }

Type Changed: MonoTouch.CoreAnimation.CAShapeLayer

Added:

public virtual float StrokeEnd {
                get;
                set;
        }
        public virtual float StrokeStart {
                get;
                set;
        }

Type Changed: MonoTouch.CoreAnimation.CAValueFunction

Removed:

public virtual CAValueFunction FromName (string name);

Added:

public static CAValueFunction FromName (string name);

Namespace: MonoTouch.CoreData

Type Changed: MonoTouch.CoreData.NSEntityDescription

Removed:

public static NSEntityDescription InsertNewObjectForEntityForName (string entityName, NSManagedObjectContext context);

Added:

public static MonoTouch.Foundation.NSObject InsertNewObjectForEntityForName (string entityName, NSManagedObjectContext context);

Namespace: MonoTouch.CoreFoundation

New Type: MonoTouch.CoreFoundation.CFType

public class CFType {
        
        public CFType ();
        
        public static int GetTypeID (IntPtr typeRef);
}

Namespace: MonoTouch.CoreGraphics

Type Changed: MonoTouch.CoreGraphics.CGFont

Added:

public static CGFont CreateFromProvider (CGDataProvider provider);

New Type: MonoTouch.CoreGraphics.CGPDFArray

public class CGPDFArray : MonoTouch.ObjCRuntime.INativeObject {
        
        public bool GetArray (int idx, out CGPDFArray array);
        public bool GetBoolean (int idx, out bool result);
        public bool GetDictionary (int idx, out CGPDFArray result);
        public bool GetFloat (int idx, out float result);
        public bool GetInt (int idx, out int result);
        public bool GetName (int idx, out string result);
        public bool GetStream (int idx, out CGPDFStream result);
        
        public int Count {
                get;
        }
        public IntPtr Handle {
                get;
        }
}

New Type: MonoTouch.CoreGraphics.CGPDFDictionary

public class CGPDFDictionary : MonoTouch.ObjCRuntime.INativeObject {
        
        public bool GetArray (string key, out CGPDFArray array);
        public bool GetBoolean (string key, out bool result);
        public bool GetDictionary (string key, out CGPDFDictionary result);
        public bool GetFloat (string key, out float result);
        public bool GetInt (string key, out int result);
        public bool GetName (string key, out string result);
        public bool GetStream (string key, out CGPDFStream result);
        
        public int Count {
                get;
        }
        public IntPtr Handle {
                get;
        }
}

Type Changed: MonoTouch.CoreGraphics.CGPDFDocument

Removed:

public CGPDFPage GetPage (int page);

Type Changed: MonoTouch.CoreGraphics.CGPDFPage

Added:

public CGPDFDictionary Dictionary {
                get;
        }

New Type: MonoTouch.CoreGraphics.CGPDFStream

public class CGPDFStream : MonoTouch.ObjCRuntime.INativeObject {
        
        public MonoTouch.Foundation.NSData Data {
                get;
        }
        public CGPDFDictionary Dictionary {
                get;
        }
        public IntPtr Handle {
                get;
        }
}

Namespace: MonoTouch.CoreLocation

New Type: MonoTouch.CoreLocation.CLAuthorizationStatus

[Serializable]
public enum CLAuthorizationStatus {
        NotDetermined,
        Restricted,
        Denied,
        Authorized
}

New Type: MonoTouch.CoreLocation.CLAuthroziationChangedEventArgs

public class CLAuthroziationChangedEventArgs : EventArgs {
        
        public CLAuthroziationChangedEventArgs (CLAuthorizationStatus status);
        
        public CLAuthorizationStatus Status {
                get;
                set;
        }
}

Type Changed: MonoTouch.CoreLocation.CLLocation

Added:

public CLLocation (CLLocationCoordinate2D coordinate, double altitude, double hAccuracy, double vAccuracy, double course, double speed, MonoTouch.Foundation.NSDate timestamp);
        public static readonly double AccurracyBestForNavigation;

Type Changed: MonoTouch.CoreLocation.CLLocationManager

Added:

public static CLAuthorizationStatus Status {
                get;
        }
        public event EventHandler<CLAuthroziationChangedEventArgs> AuthorizationChanged;

Type Changed: MonoTouch.CoreLocation.CLLocationManagerDelegate

Added:

public virtual void AuthorizationChanged (CLLocationManager manager, CLAuthorizationStatus status);

Namespace: MonoTouch.CoreText

Type Changed: MonoTouch.CoreText.CTFont

Added:

public CTFont (MonoTouch.CoreGraphics.CGFont font, float size, MonoTouch.CoreGraphics.CGAffineTransform transform, CTFontDescriptor descriptor);
        public CTFont (MonoTouch.CoreGraphics.CGFont font, float size, CTFontDescriptor descriptor);
        public CTFont (MonoTouch.CoreGraphics.CGFont font, float size, MonoTouch.CoreGraphics.CGAffineTransform transform);
        public void DrawGlyphs (MonoTouch.CoreGraphics.CGContext context, ushort [] glyphs, System.Drawing.PointF [] positions);
        public int GetLigatureCaretPositions (ushort glyph, float [] positions);

Type Changed: MonoTouch.CoreText.CTFontTable

Removed:

VerticalMetrics

Added:

VerticalMetrics,
        SBitmapData,
        SExtendedBitmapData

Type Changed: MonoTouch.CoreText.CTFrameAttributeKey

Added:

public static readonly MonoTouch.Foundation.NSString PathFillRule;
        public static readonly MonoTouch.Foundation.NSString PathWidth;

Type Changed: MonoTouch.CoreText.CTFramePathFillRule

Added:

[Serializable]
 public enum CTFramePathFillRule {
        EvenOdd,
        WindingNumber
 }

Namespace: MonoTouch.EventKit

Type Changed: MonoTouch.EventKit.EKErrorCode



Added:

InvalidSpan

Type Changed: MonoTouch.EventKit.EKEventViewAction

Added:

[Serializable]
 public enum EKEventViewAction {
        Done,
        Responded,
        Deleted
 }

Namespace: MonoTouch.EventKitUI

Type Changed: MonoTouch.EventKitUI.EKEventViewController

Added:

public EKEventViewDelegate Delegate {
                get;
                set;
        }
        public virtual MonoTouch.Foundation.NSObject WeakDelegate {
                get;
                set;
        }
        
        public event EventHandler<EKEventViewEventArgs> Completed;

New Type: MonoTouch.EventKitUI.EKEventViewDelegate

public abstract class EKEventViewDelegate : MonoTouch.Foundation.NSObject {
        
        public EKEventViewDelegate ();
        public EKEventViewDelegate (MonoTouch.Foundation.NSCoder coder);
        public EKEventViewDelegate (MonoTouch.Foundation.NSObjectFlag t);
        public EKEventViewDelegate (IntPtr handle);
        
        public abstract void Completed (EKEventViewController controller, MonoTouch.EventKit.EKEventViewAction action);
}

New Type: MonoTouch.EventKitUI.EKEventViewEventArgs

public class EKEventViewEventArgs : EventArgs {
        
        public EKEventViewEventArgs (MonoTouch.EventKit.EKEventViewAction action);
        
        public MonoTouch.EventKit.EKEventViewAction Action {
                get;
                set;
        }
}

Namespace: MonoTouch.Foundation

Type Changed: MonoTouch.Foundation.NSBundle

Added:

public static bool LoadNib (string nibName, NSObject owner);
        public virtual NSDictionary InfoDictionary {
                get;
        }

Type Changed: MonoTouch.Foundation.NSDate

Added:

public static NSDate DistantFuture {
                get;
        }
        public static NSDate DistantPast {
                get;
        }

Type Changed: MonoTouch.Foundation.NSDictionary

Added:

public IntPtr LowlevelObjectForKey (IntPtr key);

New Type: MonoTouch.Foundation.NSEnumerationOptions

[Serializable]
[Flags]
public enum NSEnumerationOptions {
        SortConcurrent,
        Reverse
}

New Type: MonoTouch.Foundation.NSKeyValueChange

[Serializable]
public enum NSKeyValueChange {
        Setting,
        Insertion,
        Removal,
        Replacement
}

New Type: MonoTouch.Foundation.NSKeyValueObservingOptions

[Serializable]
[Flags]
public enum NSKeyValueObservingOptions {
        New,
        Old,
        OldNew,
        Initial,
        Prior
}

New Type: MonoTouch.Foundation.NSKeyValueSetMutationKind

[Serializable]
public enum NSKeyValueSetMutationKind {
        UnionSet,
        MinusSet,
        IntersectSet,
        SetSet
}

Type Changed: MonoTouch.Foundation.NSMutableAttributedString

Removed:

public virtual void AddAttribute (string name, NSObject value, NSRange range);

Added:

public virtual void AddAttribute (NSString attributeName, NSObject value, NSRange range);

Type Changed: MonoTouch.Foundation.NSMutableDictionary

Added:

public static NSMutableDictionary LowlevelFromObjectAndKey (IntPtr obj, IntPtr key);
        public void LowlevelSetObject (IntPtr obj, IntPtr key);
        public void LowlevelSetObject (NSObject obj, IntPtr key);

Type Changed: MonoTouch.Foundation.NSObject

Added:

public static bool AutomaticallyNotifiesObserversForKey (string key);
        public static NSSet GetKeyPathsForValuesAffecting (NSString key);
        public virtual void AccessibilityDecrement ();
        public virtual void AccessibilityIncrement ();
        public virtual bool AccessibilityScroll (MonoTouch.UIKit.UIAccessibilityScrollDirection direction);
        public virtual void AddObserver (NSObject observer, NSString keyPath, NSKeyValueObservingOptions options, IntPtr context);
        public virtual void DidChange (NSKeyValueChange changeKind, NSIndexSet indexes, NSString forKey);
        public virtual void DidChange (NSString forKey, NSKeyValueSetMutationKind mutationKind, NSSet objects);
        public virtual void DidChangeValue (string forKey);
        public virtual NSDictionary GetDictionaryOfValuesFromKeys (NSString[] keys);
        public virtual void ObserveValue (NSString keyPath, NSObject ofObject, NSDictionary change, IntPtr context);
        public virtual void RemoveObserver (NSObject observer, NSString keyPath);
        public virtual void SetNilValueForKey (NSString key);
        public virtual void SetValueForKey (NSObject value, NSString key);
        public virtual void SetValueForKeyPath (NSObject value, NSString keyPath);
        public virtual void SetValueForUndefinedKey (NSObject value, NSString undefinedKey);
        public virtual void SetValuesForKeysWithDictionary (NSDictionary keyedValues);
        public virtual NSObject ValueForKey (NSString key);
        public virtual NSObject ValueForKeyPath (NSString keyPath);
        public virtual NSObject ValueForUndefinedKey (NSString key);
        public virtual void WillChange (NSKeyValueChange changeKind, NSIndexSet indexes, NSString forKey);
        public virtual void WillChange (NSString forKey, NSKeyValueSetMutationKind mutationKind, NSSet objects);
        public virtual void WillChangeValue (string forKey);
        public static NSString ChangeIndexesKey {
                get;
        }
        public static NSString ChangeKindKey {
                get;
        }
        public static NSString ChangeNewKey {
                get;
        }
        public static NSString ChangeNotificationIsPriorKey {
                get;
        }
        public static NSString ChangeOldKey {
                get;
        }

Type Changed: MonoTouch.Foundation.NSRunLoop

Added:

public static NSString NSDefaultRunLoopMode {
                get;
        }
        public static NSString NSRunLoopCommonModes {
                get;
        }

Type Changed: MonoTouch.Foundation.NSStream

Removed:

public virtual NSObject Delegate {

Added:

public virtual void Open ();
        public static NSString NetworkServiceTypeVoIP {
                get;
        }
        public NSStreamDelegate Delegate {
        public virtual NSObject WeakDelegate {
                get;
                set;
        }
        
        public event EventHandler<NSStreamEventArgs> OnEvent;

Type Changed: MonoTouch.Foundation.NSStreamDelegate

Removed:

Could not find MonoTouch.Foundation.NSStreamDelegate

Added:

public class NSStreamDelegate : NSObject {
        
        public NSStreamDelegate ();
        public NSStreamDelegate (NSCoder coder);
        public NSStreamDelegate (NSObjectFlag t);
        public NSStreamDelegate (IntPtr handle);
        
        public virtual void HandleEvent (NSStream theStream, NSStreamEvent streamEvent);
 }

Type Changed: MonoTouch.Foundation.NSStreamEvent

Removed:

Could not find MonoTouch.Foundation.NSStreamEvent

Added:

[Serializable]
 public enum NSStreamEvent : uint {
        None,
        OpenCompleted,
        HasBytesAvailable,
        HasSpaceAvailable,
        ErrorOccurred,
        EndEncountered
 }

Type Changed: MonoTouch.Foundation.NSStreamEventArgs

Removed:

Could not find MonoTouch.Foundation.NSStreamEventArgs

Added:

public class NSStreamEventArgs : EventArgs {
        
        public NSStreamEventArgs (NSStreamEvent streamEvent);
        
        public NSStreamEvent StreamEvent {
                get;
                set;
        }
 }

Type Changed: MonoTouch.Foundation.NSString

Added:

public System.Drawing.SizeF DrawString (System.Drawing.PointF point, float width, MonoTouch.UIKit.UIFont font, float minFontSize, float actualFontSize, MonoTouch.UIKit.UILineBreakMode breakMode, MonoTouch.UIKit.UIBaselineAdjustment adjustment);
        public System.Drawing.SizeF DrawString (System.Drawing.PointF point, float width, MonoTouch.UIKit.UIFont font, float fontSize, MonoTouch.UIKit.UILineBreakMode breakMode, MonoTouch.UIKit.UIBaselineAdjustment adjustment);
        public System.Drawing.SizeF DrawString (System.Drawing.PointF point, float width, MonoTouch.UIKit.UIFont font, MonoTouch.UIKit.UILineBreakMode breakMode);
        public System.Drawing.SizeF DrawString (System.Drawing.PointF point, MonoTouch.UIKit.UIFont font);
        public System.Drawing.SizeF DrawString (System.Drawing.RectangleF rect, MonoTouch.UIKit.UIFont font);
        public System.Drawing.SizeF DrawString (System.Drawing.RectangleF rect, MonoTouch.UIKit.UIFont font, MonoTouch.UIKit.UILineBreakMode mode);
        public System.Drawing.SizeF DrawString (System.Drawing.RectangleF rect, MonoTouch.UIKit.UIFont font, MonoTouch.UIKit.UILineBreakMode mode, MonoTouch.UIKit.UITextAlignment alignment);
        public static explicit operator NSString (string str);

Namespace: MonoTouch.GameKit

Type Changed: MonoTouch.GameKit.GKAchievement

Added:

public virtual bool Hidden {
                get;
        }

Type Changed: MonoTouch.GameKit.GKAchievementDescription

Removed:

set;
                set;
                set;
                set;
                set;
                set;
                set;

Type Changed: MonoTouch.GameKit.GKError

Added:

InvalidParameter

New Type: MonoTouch.GameKit.GKFriendRequestComposeViewController

public class GKFriendRequestComposeViewController : MonoTouch.UIKit.UINavigationController {
        
        public GKFriendRequestComposeViewController ();
        public GKFriendRequestComposeViewController (MonoTouch.Foundation.NSCoder coder);
        public GKFriendRequestComposeViewController (MonoTouch.Foundation.NSObjectFlag t);
        public GKFriendRequestComposeViewController (IntPtr handle);
        
        public virtual void AddRecipientsFromAliases (string [] aliases);
        public virtual void AddRecipientsFromEmails (string [] emailAddresses);
        public virtual void AddRecipientsFromPlayerIDs (string [] emailAddresses);
        
        public static int MaxNumberOfRecipients {
                get;
        }
        public override IntPtr ClassHandle {
                get;
        }
        public GKFriendRequestComposeViewControllerDelegate ComposeViewDelegate {
                get;
                set;
        }
        public virtual string Message {
                set;
        }
        public virtual MonoTouch.Foundation.NSObject WeakComposeViewDelegate {
                get;
                set;
        }
        
        public event EventHandler DidFinish;
}

New Type: MonoTouch.GameKit.GKFriendRequestComposeViewControllerDelegate

public abstract class GKFriendRequestComposeViewControllerDelegate : MonoTouch.Foundation.NSObject {
        
        public GKFriendRequestComposeViewControllerDelegate ();
        public GKFriendRequestComposeViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
        public GKFriendRequestComposeViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
        public GKFriendRequestComposeViewControllerDelegate (IntPtr handle);
        
        public abstract void DidFinish (GKFriendRequestComposeViewController viewController);
}

Namespace: MonoTouch.ImageIO

New Type: MonoTouch.ImageIO.CGImageDestination

public class CGImageDestination : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
        
        public static CGImageDestination FromData (MonoTouch.Foundation.NSData data, string typeIdentifier, int imageCount);
        public static CGImageDestination FromData (MonoTouch.Foundation.NSData data, string typeIdentifier, int imageCount, CGImageDestinationOptions options);
        public static CGImageDestination FromUrl (MonoTouch.Foundation.NSUrl url, string typeIdentifier, int imageCount);
        public static CGImageDestination FromUrl (MonoTouch.Foundation.NSUrl url, string typeIdentifier, int imageCount, CGImageDestinationOptions options);
        public static int GetTypeID ();
        public void AddImage (MonoTouch.CoreGraphics.CGImage image, MonoTouch.Foundation.NSDictionary properties);
        public void AddImage (CGImageSource source, int index, MonoTouch.Foundation.NSDictionary properties);
        public void Close ();
        public void Dispose ();
        protected virtual void Dispose (bool disposing);
        protected override void Finalize ();
        public void SetProperties (MonoTouch.Foundation.NSDictionary properties);
        
        public static string [] TypeIdentifiers {
                get;
        }
        public IntPtr Handle {
                get;
        }
}

New Type: MonoTouch.ImageIO.CGImageDestinationOptions

public class CGImageDestinationOptions {
        
        public CGImageDestinationOptions ();
        
        public MonoTouch.CoreGraphics.CGColor DestinationBackgroundColor {
                get;
                set;
        }
        public Nullable<float> LossyCompressionQuality {          get;            set;    } } </float>

New Type: MonoTouch.ImageIO.CGImageOptions

public class CGImageOptions {
        
        public CGImageOptions ();
        
        public string BestGuessTypeIdentifier {
                get;
                set;
        }
        public bool ShouldAllowFloat {
                get;
                set;
        }
        public bool ShouldCache {
                get;
                set;
        }
}

New Type: MonoTouch.ImageIO.CGImageSource

public class CGImageSource : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
        
        public static CGImageSource CreateIncremental (CGImageOptions options);
        public static CGImageSource FromData (MonoTouch.Foundation.NSData data);
        public static CGImageSource FromData (MonoTouch.Foundation.NSData data, CGImageOptions options);
        public static CGImageSource FromDataProvider (MonoTouch.CoreGraphics.CGDataProvider provider);
        public static CGImageSource FromDataProvider (MonoTouch.CoreGraphics.CGDataProvider provider, CGImageOptions options);
        public static CGImageSource FromUrl (MonoTouch.Foundation.NSUrl url);
        public static CGImageSource FromUrl (MonoTouch.Foundation.NSUrl url, CGImageOptions options);
        public static int GetTypeID ();
        public MonoTouch.Foundation.NSDictionary CopyProperties (MonoTouch.Foundation.NSDictionary dict);
        public MonoTouch.Foundation.NSDictionary CopyProperties (MonoTouch.Foundation.NSDictionary dict, int imageIndex);
        public MonoTouch.CoreGraphics.CGImage CreateImage (int index, CGImageOptions options);
        public MonoTouch.CoreGraphics.CGImage CreateThumbnail (int index, CGImageThumbnailOptions options);
        public void Dispose ();
        protected virtual void Dispose (bool disposing);
        protected override void Finalize ();
        public CGImageSourceStatus GetStatus ();
        public CGImageSourceStatus GetStatus (int index);
        public void UpdateData (MonoTouch.Foundation.NSData data, bool final);
        public void UpdateDataProvider (MonoTouch.CoreGraphics.CGDataProvider provider);
        
        public static string [] TypeIdentifiers {
                get;
        }
        public IntPtr Handle {
                get;
        }
        public int ImageCount {
                get;
        }
        public string TypeIdentifier {
                get;
        }
}

New Type: MonoTouch.ImageIO.CGImageSourceStatus

[Serializable]
public enum CGImageSourceStatus {
        Complete,
        Incomplete,
        ReadingHeader,
        UnknownType,
        InvalidData,
        UnexpectedEOF
}

New Type: MonoTouch.ImageIO.CGImageThumbnailOptions

public class CGImageThumbnailOptions : CGImageOptions {
        
        public CGImageThumbnailOptions ();
        
        public bool CreateThumbnailFromImageAlways {
                get;
                set;
        }
        public bool CreateThumbnailFromImageIfAbsent {
                get;
                set;
        }
        public bool CreateThumbnailWithTransform {
                get;
                set;
        }
        public Nullable<int> MaxPixelSize {               get;            set;    } } </int>

Namespace: MonoTouch.MapKit

Type Changed: MonoTouch.MapKit.MKAnnotationView

Added:

public virtual void SetDragState (MKAnnotationViewDragState newDragState, bool animated);

Type Changed: MonoTouch.MapKit.MKCircle

Removed:

public virtual bool Intersects (MKMapRect rect);
        public virtual MKMapRect BoundingMapRect {
                get;
        }
        public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }
        public virtual string Subtitle {
                get;
        }
        public virtual string Title {
                get;
        }

Type Changed: MonoTouch.MapKit.MKMapPoint

Added:

public static MKMapPoint FromCoordinate (MonoTouch.CoreLocation.CLLocationCoordinate2D coordinate);

Type Changed: MonoTouch.MapKit.MKMapView

Added:

public virtual MonoTouch.Foundation.NSSet GetAnnotations (MKMapRect mapRect);

New Type: MonoTouch.MapKit.MKOverlay

public class MKOverlay : MKAnnotation {
        
        public MKOverlay ();
        public MKOverlay (MonoTouch.Foundation.NSCoder coder);
        public MKOverlay (MonoTouch.Foundation.NSObjectFlag t);
        public MKOverlay (IntPtr handle);
        
        public virtual bool Intersects (MKMapRect rect);
        
        public virtual MKMapRect BoundingMapRect {
                get;
        }
        public override MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }
        public override string Subtitle {
                get;
        }
        public override string Title {
                get;
        }
}

Type Changed: MonoTouch.MapKit.MKPlacemark

Removed:

public class MKPlacemark : MonoTouch.Foundation.NSObject {

Added:

public class MKPlacemark : MKAnnotation {
        public override MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }
        public override string Subtitle {
                get;
        }
        public override string Title {
                get;
        }

Type Changed: MonoTouch.MapKit.MKPointAnnotation

Removed:

public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }

Type Changed: MonoTouch.MapKit.MKPolygon

Removed:

public virtual bool Intersects (MKMapRect rect);
        public virtual MKMapRect BoundingMapRect {
                get;
        }
        public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }
        public virtual string Subtitle {
                get;
        }
        public virtual string Title {
                get;
        }

Type Changed: MonoTouch.MapKit.MKPolyline

Removed:

public virtual bool Intersects (MKMapRect rect);
        public virtual MKMapRect BoundingMapRect {
                get;
        }
        public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }
        public virtual string Subtitle {
                get;
        }
        public virtual string Title {
                get;
        }

Type Changed: MonoTouch.MapKit.MKShape

Removed:

public class MKShape : MonoTouch.Foundation.NSObject {
        public virtual string Subtitle {
        public virtual string Title {
                set;

Added:

public class MKShape : MKAnnotation {
        public override MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
        public override string Subtitle {
                get;
        }
        public override string Title {

Type Changed: MonoTouch.MapKit.MKUserLocation

Removed:

public class MKUserLocation : MonoTouch.Foundation.NSObject {
        public virtual string Subtitle {
                set;
        public virtual string Title {
                set;

Added:

public class MKUserLocation : MKAnnotation {
        public override MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
                get;
                set;
        }
        public override string Subtitle {
        public override string Title {

Namespace: MonoTouch.MediaPlayer

Type Changed: MonoTouch.MediaPlayer.MPMediaItem

Added:

public static string GetPersistentIDProperty (MPMediaGrouping groupingType);
        public static string GetTitleProperty (MPMediaGrouping groupingType);

Type Changed: MonoTouch.MediaPlayer.MPMediaItemProperty

Removed:

public const string PersistendID = "persistendID";

Added:

public const string PersistentID = "persistentID";

Type Changed: MonoTouch.MediaPlayer.MPMediaPlaylistProperty

Removed:

public const string PersistendID = "playlistPersistentID";

Added:

public const string PersistentID = "playlistPersistentID";

Type Changed: MonoTouch.MediaPlayer.MPMediaQuery

Added:

public virtual MPMediaQuerySection[] CollectionSections {
                get;
        }
        public virtual MPMediaQuerySection[] ItemSections {
                get;
        }

Type Changed: MonoTouch.MediaPlayer.MPMediaQuerySection

Removed:

Could not find MonoTouch.MediaPlayer.MPMediaQuerySection

Added:

public class MPMediaQuerySection : MonoTouch.Foundation.NSObject {
        
        public MPMediaQuerySection ();
        public MPMediaQuerySection (MonoTouch.Foundation.NSCoder coder);
        public MPMediaQuerySection (MonoTouch.Foundation.NSObjectFlag t);
        public MPMediaQuerySection (IntPtr handle);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual MonoTouch.Foundation.NSRange Range {
                get;
        }
        public virtual string Title {
                get;
        }
 }

Type Changed: MonoTouch.MediaPlayer.MPVolumeView

Added:

public virtual bool ShowsRouteButton {
                get;
                set;
        }
        public virtual bool ShowsVolumeSlider {
                get;
                set;
        }

Namespace: MonoTouch.MessageUI

Type Changed: MonoTouch.MessageUI.MFMailComposeViewControllerDelegate

Added:

public override void DidShowViewController (MonoTouch.UIKit.UINavigationController navigationController, MonoTouch.UIKit.UIViewController viewController, bool animated);
        public override void WillShowViewController (MonoTouch.UIKit.UINavigationController navigationController, MonoTouch.UIKit.UIViewController viewController, bool animated);

Namespace: MonoTouch.ObjCRuntime

Type Changed: MonoTouch.ObjCRuntime.Messaging

Added:

public static bool bool_objc_msgSend_int (IntPtr receiver, IntPtr selector, int arg1);
        public static bool bool_objc_msgSendSuper_int (IntPtr receiver, IntPtr selector, int arg1);
        public static IntPtr IntPtr_objc_msgSend_CLLocationCoordinate2D_Double_Double_Double_Double_Double_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1, double arg2, double arg3, double arg4, double arg5, double arg6, IntPtr arg7);
        public static IntPtr IntPtr_objc_msgSend_SizeF_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.SizeF arg1, IntPtr arg2);
        public static IntPtr IntPtr_objc_msgSendSuper_CLLocationCoordinate2D_Double_Double_Double_Double_Double_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1, double arg2, double arg3, double arg4, double arg5, double arg6, IntPtr arg7);
        public static IntPtr IntPtr_objc_msgSendSuper_SizeF_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.SizeF arg1, IntPtr arg2);
        public static uint UInt32_objc_msgSend_IntPtr_Int64_UInt32_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, long arg2, uint arg3, IntPtr arg4);
        public static uint UInt32_objc_msgSendSuper_IntPtr_Int64_UInt32_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, long arg2, uint arg3, IntPtr arg4);
        public static void void_objc_msgSend_int_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, int arg1, IntPtr arg2, IntPtr arg3);
        public static void void_objc_msgSend_int_RectangleF (IntPtr receiver, IntPtr selector, int arg1, System.Drawing.RectangleF arg2);
        public static void void_objc_msgSend_IntPtr_Boolean_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, bool arg2, IntPtr arg3);
        public static void void_objc_msgSend_IntPtr_IntPtr_int_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3, IntPtr arg4);
        public static void void_objc_msgSend_RectangleF_int (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1, int arg2);
        public static void void_objc_msgSend_RectangleF_IntPtr_Boolean_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1, IntPtr arg2, bool arg3, IntPtr arg4);
        public static void void_objc_msgSendSuper_int_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, int arg1, IntPtr arg2, IntPtr arg3);
        public static void void_objc_msgSendSuper_int_RectangleF (IntPtr receiver, IntPtr selector, int arg1, System.Drawing.RectangleF arg2);
        public static void void_objc_msgSendSuper_IntPtr_Boolean_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, bool arg2, IntPtr arg3);
        public static void void_objc_msgSendSuper_IntPtr_IntPtr_int_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3, IntPtr arg4);
        public static void void_objc_msgSendSuper_RectangleF_int (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1, int arg2);
        public static void void_objc_msgSendSuper_RectangleF_IntPtr_Boolean_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1, IntPtr arg2, bool arg3, IntPtr arg4);

Namespace: MonoTouch.OpenGLES

Namespace: MonoTouch.QuickLook

Namespace: MonoTouch.Security

New Type: MonoTouch.Security.SecAccessible

[Serializable]
public enum SecAccessible {
        WhenUnlocked,
        AfterFirstUnlock,
        Always,
        WhenUnlockedThisDeviceOnly,
        AfterFirstUnlockThisDeviceOnly,
        AlwaysThisDeviceOnly
}

New Type: MonoTouch.Security.SecAuthenticationType

[Serializable]
public enum SecAuthenticationType {
        Ntlm,
        Msn,
        Dpa,
        Rpa,
        HttpBasic,
        HttpDigest,
        HtmlForm,
        Default
}

New Type: MonoTouch.Security.SecCertificate

public class SecCertificate : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
        
        public SecCertificate (MonoTouch.Foundation.NSData data);
        
        public static int GetTypeID ();
        public void Dispose ();
        public virtual void Dispose (bool disposing);
        protected override void Finalize ();
        
        public MonoTouch.Foundation.NSData DerData {
                get;
        }
        public IntPtr Handle {
                get;
        }
        public string SubjectSummary {
                get;
        }
}

New Type: MonoTouch.Security.SecIdentity

public class SecIdentity : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
        
        public static int GetTypeID ();
        public void Dispose ();
        public virtual void Dispose (bool disposing);
        protected override void Finalize ();
        
        public SecCertificate Certificate {
                get;
        }
        public IntPtr Handle {
                get;
        }
}

New Type: MonoTouch.Security.SecKey

public class SecKey : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
        
        public static SecStatusCode GenerateKeyPair (MonoTouch.Foundation.NSDictionary parameters, out SecKey publicKey, out SecKey privateKey);
        public static int GetTypeID ();
        public SecStatusCode Decrypt (SecPadding padding, byte [] cipherText, byte [] plainText);
        public SecStatusCode Decrypt (SecPadding padding, IntPtr cipherText, int cipherLen, IntPtr plainText, int playLen);
        public void Dispose ();
        public virtual void Dispose (bool disposing);
        public SecStatusCode Encrypt (SecPadding padding, byte [] plainText, byte [] cipherText);
        public SecStatusCode Encrypt (SecPadding padding, IntPtr plainText, int playLen, IntPtr cipherText, int cipherLen);
        protected override void Finalize ();
        public SecStatusCode RawVerify (SecPadding padding, byte [] signedData, byte [] signature);
        public SecStatusCode RawVerify (SecPadding padding, IntPtr signedData, int signedDataLen, IntPtr signature, int signatureLen);
        
        public IntPtr Handle {
                get;
        }
}

New Type: MonoTouch.Security.SecKeyChain

public static class SecKeyChain {
        
        public static SecStatusCode Add (SecRecord record);
        public static object QueryAsConcreteType (SecRecord query, out SecStatusCode result);
        public static MonoTouch.Foundation.NSData QueryAsData (SecRecord query);
        public static MonoTouch.Foundation.NSData[] QueryAsData (SecRecord query, bool wantPersistentReference, int max, out SecStatusCode status);
        public static MonoTouch.Foundation.NSData QueryAsData (SecRecord query, bool wantPersistentReference, out SecStatusCode status);
        public static MonoTouch.Foundation.NSData[] QueryAsData (SecRecord query, int max);
        public static SecRecord[] QueryAsRecord (SecRecord query, int max, out SecStatusCode result);
        public static SecRecord QueryAsRecord (SecRecord query, out SecStatusCode result);
        public static SecStatusCode Remove (SecRecord record);
        public static SecStatusCode Update (SecRecord query, SecRecord newAttributes);
}

New Type: MonoTouch.Security.SecKeyClass

[Serializable]
public enum SecKeyClass {
        Public,
        Private,
        Symmetric
}

New Type: MonoTouch.Security.SecKeyType

[Serializable]
public enum SecKeyType {
        RSA,
        EC
}

New Type: MonoTouch.Security.SecKind

[Serializable]
public enum SecKind {
        InternetPassword,
        GenericPassword,
        Certificate,
        Key,
        Identity
}

New Type: MonoTouch.Security.SecMatchLimit

public static class SecMatchLimit {
        
        public static IntPtr MatchLimitAll {
                get;
        }
        public static IntPtr MatchLimitOne {
                get;
        }
}

New Type: MonoTouch.Security.SecPadding

[Serializable]
public enum SecPadding {
        None,
        PKCS1,
        OAEP,
        PKCS1MD2,
        PKCS1MD5,
        PKCS1SHA1
}

New Type: MonoTouch.Security.SecPolicy

public class SecPolicy : MonoTouch.Foundation.NSObject {
        
        public static int GetTypeID ();
        public override bool Equals (object other);
        public override int GetHashCode ();
        
        public static bool operator == (SecPolicy a, SecPolicy b);
        public static bool operator != (SecPolicy a, SecPolicy b);
}

New Type: MonoTouch.Security.SecProtocol

[Serializable]
public enum SecProtocol {
        Ftp,
        FtpAccount,
        Http,
        Irc,
        Nntp,
        Pop3,
        Smtp,
        Socks,
        Imap,
        Ldap,
        AppleTalk,
        Afp,
        Telnet,
        Ssh,
        Ftps,
        Https,
        HttpProxy,
        HttpsProxy,
        FtpProxy,
        Smb,
        Rtsp,
        RtspProxy,
        Daap,
        Eppc,
        Ipp,
        Nntps,
        Ldaps,
        Telnets,
        Imaps,
        Ircs,
        Pop3s
}

New Type: MonoTouch.Security.SecRecord

public class SecRecord : IDisposable {
        
        public SecRecord (SecKind secKind);
        
        public SecRecord Clone ();
        public void Dispose ();
        public virtual void Dispose (bool disposing);
        protected override void Finalize ();
        
        public string AccessGroup {
                get;
                set;
        }
        public SecAccessible Accessible {
                get;
                set;
        }
        public string Account {
                get;
                set;
        }
        public string ApplicationLabel {
                get;
                set;
        }
        public MonoTouch.Foundation.NSData ApplicationTag {
                get;
                set;
        }
        public SecAuthenticationType AuthenticationType {
                get;
                set;
        }
        public bool CanDecrypt {
                get;
                set;
        }
        public bool CanDerive {
                get;
                set;
        }
        public bool CanEncrypt {
                get;
                set;
        }
        public bool CanSign {
                get;
                set;
        }
        public bool CanUnwrap {
                get;
                set;
        }
        public bool CanVerify {
                get;
                set;
        }
        public bool CanWrap {
                get;
                set;
        }
        public MonoTouch.Foundation.NSNumber CertificateEncoding {
                get;
        }
        public MonoTouch.Foundation.NSNumber CertificateType {
                get;
        }
        public string Comment {
                get;
                set;
        }
        public MonoTouch.Foundation.NSDate CreationDate {
                get;
                set;
        }
        public int Creator {
                get;
                set;
        }
        public int CreatorType {
                get;
                set;
        }
        public string Description {
                get;
                set;
        }
        public int EffectiveKeySize {
                get;
                set;
        }
        public MonoTouch.Foundation.NSData Generic {
                get;
                set;
        }
        public bool Invisible {
                get;
                set;
        }
        public bool IsNegative {
                get;
                set;
        }
        public bool IsPermanent {
                get;
                set;
        }
        public MonoTouch.Foundation.NSData Issuer {
                get;
        }
        public SecKeyClass KeyClass {
                get;
                set;
        }
        public int KeySizeInBits {
                get;
                set;
        }
        public SecKeyType KeyType {
                get;
                set;
        }
        public string Label {
                get;
                set;
        }
        public bool MatchCaseInsensitive {
                get;
                set;
        }
        public string MatchEmailAddressIfPresent {
                get;
                set;
        }
        public MonoTouch.Foundation.NSData[] MatchIssuers {
                set;
        }
        public MonoTouch.Foundation.NSArray MatchItemList {
                get;
                set;
        }
        public SecPolicy MatchPolicy {
                get;
                set;
        }
        public string MatchSubjectContains {
                get;
                set;
        }
        public bool MatchTrustedOnly {
                get;
                set;
        }
        public MonoTouch.Foundation.NSDate MatchValidOnDate {
                get;
                set;
        }
        public MonoTouch.Foundation.NSDate ModificationDate {
                get;
                set;
        }
        public string Path {
                get;
                set;
        }
        public int Port {
                get;
                set;
        }
        public SecProtocol Protocol {
                get;
                set;
        }
        public MonoTouch.Foundation.NSData PublicKeyHash {
                get;
        }
        public string SecurityDomain {
                get;
                set;
        }
        public MonoTouch.Foundation.NSData SerialNumber {
                get;
        }
        public string Server {
                get;
                set;
        }
        public string Service {
                get;
                set;
        }
        public string Subject {
                get;
        }
        public MonoTouch.Foundation.NSData SubjectKeyID {
                get;
        }
        public MonoTouch.Foundation.NSData ValueData {
                get;
                set;
        }
}

New Type: MonoTouch.Security.SecStatusCode

[Serializable]
public enum SecStatusCode {
        Success,
        Unimplemented,
        Param,
        Allocate,
        NotAvailable,
        ReadOnly,
        AuthFailed,
        NoSuchKeyChain,
        InvalidKeyChain,
        DuplicateKeyChain,
        DuplicateItem,
        ItemNotFound,
        InteractionNotAllowed,
        Decode
}

New Type: MonoTouch.Security.SecTrust

public class SecTrust : MonoTouch.Foundation.NSObject {
        
        public SecTrust ();
        
        public static int GetTypeID ();
}

New Type: MonoTouch.Security.SecurityException

public class SecurityException : Exception {
        
        public SecurityException (SecStatusCode code);
}

Namespace: MonoTouch.StoreKit

New Type: MonoTouch.StoreKit.SKError

[Serializable]
public enum SKError {
        Unknown,
        ClientInvalid,
        PaymentCancelled,
        PaymentInvalid,
        PaymentNotAllowed
}

Type Changed: MonoTouch.StoreKit.SKProductsRequest

Added:

public event EventHandler<SKProductsRequestResponseEventArgs> ReceivedResponse;

Type Changed: MonoTouch.StoreKit.SKProductsRequestDelegate

Added:

public override void RequestFailed (SKRequest request, MonoTouch.Foundation.NSError error);
        public override void RequestFinished (SKRequest request);

Type Changed: MonoTouch.StoreKit.SKProductsRequestResponseEventArgs

Removed:

Could not find MonoTouch.StoreKit.SKProductsRequestResponseEventArgs

Added:

public class SKProductsRequestResponseEventArgs : EventArgs {
        
        public SKProductsRequestResponseEventArgs (SKProductsResponse response);
        
        public SKProductsResponse Response {
                get;
                set;
        }
 }

Type Changed: MonoTouch.StoreKit.SKRequest

Added:

public event EventHandler<SKRequestErrorEventArgs> RequestFailed;
        public event EventHandler RequestFinished;

Type Changed: MonoTouch.StoreKit.SKRequestDelegate

Removed:

public virtual void RequedFailed (SKRequest request, MonoTouch.Foundation.NSError error);

Added:

public virtual void RequestFailed (SKRequest request, MonoTouch.Foundation.NSError error);

Type Changed: MonoTouch.StoreKit.SKRequestErrorEventArgs

Removed:

Could not find MonoTouch.StoreKit.SKRequestErrorEventArgs

Added:

public class SKRequestErrorEventArgs : EventArgs {
        
        public SKRequestErrorEventArgs (MonoTouch.Foundation.NSError error);
        
        public MonoTouch.Foundation.NSError Error {
                get;
                set;
        }
 }

Namespace: MonoTouch.SystemConfiguration

Namespace: MonoTouch.UIKit

New Type: MonoTouch.UIKit.UIAccessibilityScrollDirection

[Serializable]
public enum UIAccessibilityScrollDirection {
        Right,
        Left,
        Up,
        Down
}

Type Changed: MonoTouch.UIKit.UIApplication

Removed:

public virtual bool SetKeepAliveTimout (double timeout, MonoTouch.Foundation.NSAction handler);

Added:

public virtual bool SetKeepAliveTimeout (double timeout, MonoTouch.Foundation.NSAction handler);

Type Changed: MonoTouch.UIKit.UIApplicationDelegate

Added:

public virtual void OpenUrl (UIApplication application, MonoTouch.Foundation.NSUrl url, string sourceApplication, MonoTouch.Foundation.NSObject annotation);

Type Changed: MonoTouch.UIKit.UIDevice

Added:

public virtual void PlayInputClick ();

Type Changed: MonoTouch.UIKit.UIDocumentInteractionController

Removed:

public virtual UIImage Icons {

Added:

public virtual UIImage[] Icons {

Type Changed: MonoTouch.UIKit.UIGestureRecognizer

Added:

public class Token : MonoTouch.Foundation.NSObject {
                
                public void Activated ();
        }

Type Changed: MonoTouch.UIKit.UIImagePickerControllerDelegate

Added:

public override void DidShowViewController (UINavigationController navigationController, UIViewController viewController, bool animated);
        public override void WillShowViewController (UINavigationController navigationController, UIViewController viewController, bool animated);

New Type: MonoTouch.UIKit.UIMarkupTextPrintFormatter

public class UIMarkupTextPrintFormatter : UIPrintFormatter {
        
        public UIMarkupTextPrintFormatter ();
        public UIMarkupTextPrintFormatter (MonoTouch.Foundation.NSCoder coder);
        public UIMarkupTextPrintFormatter (MonoTouch.Foundation.NSObjectFlag t);
        public UIMarkupTextPrintFormatter (IntPtr handle);
        public UIMarkupTextPrintFormatter (string text);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual string MarkupText {
                get;
                set;
        }
}

Type Changed: MonoTouch.UIKit.UIPickerViewDelegate

Changed:

public virtual string GetView (UIPickerView pickerView, int row, int component, UIView view);

New signature:

public virtual UIView GetView (UIPickerView pickerView, int row, int component, UIView view);

New Type: MonoTouch.UIKit.UIPrint

public static class UIPrint {
        
        public static MonoTouch.Foundation.NSString ErrorDomain {
                get;
        }
}

New Type: MonoTouch.UIKit.UIPrintError

[Serializable]
public enum UIPrintError {
        NotAvailable,
        NoContent,
        UnknownImageFormat,
        JobFailed
}

New Type: MonoTouch.UIKit.UIPrintFormatter

public class UIPrintFormatter : MonoTouch.Foundation.NSObject {
        
        public UIPrintFormatter ();
        public UIPrintFormatter (MonoTouch.Foundation.NSCoder coder);
        public UIPrintFormatter (MonoTouch.Foundation.NSObjectFlag t);
        public UIPrintFormatter (IntPtr handle);
        
        public virtual void DrawRect (System.Drawing.RectangleF rect, int pageIndex);
        public virtual System.Drawing.RectangleF RectangleForPage (int pageIndex);
        public virtual void RemoveFromPrintPageRenderer ();
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual UIEdgeInsets ContentInsets {
                get;
                set;
        }
        public virtual float MaximumContentHeight {
                get;
                set;
        }
        public virtual float MaximumContentWidth {
                get;
                set;
        }
        public virtual int PageCount {
                get;
        }
        public virtual UIPrintPageRenderer PrintPageRenderer {
                get;
        }
        public virtual int StartPage {
                get;
                set;
        }
}

New Type: MonoTouch.UIKit.UIPrintInfo

public class UIPrintInfo : MonoTouch.Foundation.NSObject {
        
        public UIPrintInfo ();
        public UIPrintInfo (MonoTouch.Foundation.NSCoder coder);
        public UIPrintInfo (MonoTouch.Foundation.NSObjectFlag t);
        public UIPrintInfo (IntPtr handle);
        
        public static UIPrintInfo FromDictionary (MonoTouch.Foundation.NSDictionary dictionary);
        
        public static UIPrintInfo PrintInfo {
                get;
        }
        public override IntPtr ClassHandle {
                get;
        }
        public virtual UIPrintInfoDuplex Duplex {
                get;
                set;
        }
        public virtual string JobName {
                get;
                set;
        }
        public virtual UIPrintInfoOrientation Orientation {
                get;
                set;
        }
        public virtual UIPrintInfoOutputType OutputType {
                get;
                set;
        }
        public virtual string PrinterID {
                get;
                set;
        }
        public virtual MonoTouch.Foundation.NSDictionary ToDictionary {
                get;
        }
}

New Type: MonoTouch.UIKit.UIPrintInfoDuplex

[Serializable]
public enum UIPrintInfoDuplex {
        None,
        LongEdge,
        ShortEdge
}

New Type: MonoTouch.UIKit.UIPrintInfoOrientation

[Serializable]
public enum UIPrintInfoOrientation {
        Portrait,
        Landscape
}

New Type: MonoTouch.UIKit.UIPrintInfoOutputType

[Serializable]
public enum UIPrintInfoOutputType {
        General,
        Photo,
        Grayscale
}

New Type: MonoTouch.UIKit.UIPrintInteraction

[Serializable]
public delegate UIViewController UIPrintInteraction (UIPrintInteractionController printInteractionController);

New Type: MonoTouch.UIKit.UIPrintInteractionCompletionHandler

[Serializable]
public delegate void UIPrintInteractionCompletionHandler (UIPrintInteractionController printInteractionController, bool completed, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.UIKit.UIPrintInteractionController

public class UIPrintInteractionController : MonoTouch.Foundation.NSObject {
        
        public UIPrintInteractionController ();
        public UIPrintInteractionController (MonoTouch.Foundation.NSCoder coder);
        public UIPrintInteractionController (MonoTouch.Foundation.NSObjectFlag t);
        public UIPrintInteractionController (IntPtr handle);
        
        public static bool CanPrint (MonoTouch.Foundation.NSData data);
        public static bool CanPrint (MonoTouch.Foundation.NSUrl url);
        public virtual void Dismiss (bool animated);
        public virtual void Present (bool animated, UIPrintInteractionCompletionHandler completion);
        public virtual void PresentFromBarButtonItem (UIBarButtonItem item, bool animated, UIPrintInteractionCompletionHandler completion);
        public virtual void PresentFromRectInView (System.Drawing.RectangleF rect, UIView view, bool animated, UIPrintInteractionCompletionHandler completion);
        
        public static MonoTouch.Foundation.NSSet PrintableUTIs {
                get;
        }
        public static bool PrintingAvailable {
                get;
        }
        public static UIPrintInteractionController SharedPrintController {
                get;
        }
        public UIPrintInteractionPaperList ChoosePaper {
                get;
                set;
        }
        public override IntPtr ClassHandle {
                get;
        }
        public UIPrintInteractionControllerDelegate Delegate {
                get;
                set;
        }
        public UIPrintInteraction GetViewController {
                get;
                set;
        }
        public virtual UIPrintFormatter PrintFormatter {
                get;
                set;
        }
        public virtual UIPrintInfo PrintInfo {
                get;
                set;
        }
        public virtual MonoTouch.Foundation.NSObject[] PrintingItems {
                get;
                set;
        }
        public virtual MonoTouch.Foundation.NSObject PrintItem {
                get;
                set;
        }
        public virtual UIPrintPageRenderer PrintPageRenderer {
                get;
                set;
        }
        public virtual UIPrintPaper PrintPaper {
                get;
        }
        public virtual bool ShowsPageRange {
                get;
                set;
        }
        public virtual MonoTouch.Foundation.NSObject WeakDelegate {
                get;
                set;
        }
        
        public event EventHandler DidDismissPrinterOptions;
        public event EventHandler DidFinishJob;
        public event EventHandler DidPresentPrinterOptions;
        public event EventHandler WillDismissPrinterOptions;
        public event EventHandler WillPresentPrinterOptions;
        public event EventHandler WillStartJob;
}

New Type: MonoTouch.UIKit.UIPrintInteractionControllerDelegate

public class UIPrintInteractionControllerDelegate : MonoTouch.Foundation.NSObject {
        
        public UIPrintInteractionControllerDelegate ();
        public UIPrintInteractionControllerDelegate (MonoTouch.Foundation.NSCoder coder);
        public UIPrintInteractionControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
        public UIPrintInteractionControllerDelegate (IntPtr handle);
        
        public virtual UIPrintPaper ChoosePaper (UIPrintInteractionController printInteractionController, UIPrintPaper[] paperList);
        public virtual void DidDismissPrinterOptions (UIPrintInteractionController printInteractionController);
        public virtual void DidFinishJob (UIPrintInteractionController printInteractionController);
        public virtual void DidPresentPrinterOptions (UIPrintInteractionController printInteractionController);
        public virtual UIViewController GetViewController (UIPrintInteractionController printInteractionController);
        public virtual void WillDismissPrinterOptions (UIPrintInteractionController printInteractionController);
        public virtual void WillPresentPrinterOptions (UIPrintInteractionController printInteractionController);
        public virtual void WillStartJob (UIPrintInteractionController printInteractionController);
}

New Type: MonoTouch.UIKit.UIPrintInteractionPaperList

[Serializable]
public delegate UIPrintPaper UIPrintInteractionPaperList (UIPrintInteractionController printInteractionController, UIPrintPaper[] paperList);

New Type: MonoTouch.UIKit.UIPrintPageRenderer

public class UIPrintPageRenderer : MonoTouch.Foundation.NSObject {
        
        public UIPrintPageRenderer ();
        public UIPrintPageRenderer (MonoTouch.Foundation.NSCoder coder);
        public UIPrintPageRenderer (MonoTouch.Foundation.NSObjectFlag t);
        public UIPrintPageRenderer (IntPtr handle);
        
        public virtual void AddPrintFormatter (UIPrintFormatter formatter, int pageIndex);
        public virtual void DrawContentForPage (int index, System.Drawing.RectangleF contentRect);
        public virtual void DrawFooterForPage (int index, System.Drawing.RectangleF footerRect);
        public virtual void DrawHeaderForPage (int index, System.Drawing.RectangleF headerRect);
        public virtual void DrawPage (int index, System.Drawing.RectangleF pageRect);
        public virtual void DrawPrintFormatterForPage (UIPrintFormatter printFormatter, int index);
        public virtual void PrepareForDrawingPages (MonoTouch.Foundation.NSRange range);
        public virtual UIPrintFormatter[] PrintFormattersForPage (int index);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual float FooterHeight {
                get;
                set;
        }
        public virtual float HeaderHeight {
                get;
                set;
        }
        public virtual int NumberOfPages {
                get;
        }
        public virtual System.Drawing.RectangleF PaperRect {
                get;
        }
        public virtual System.Drawing.RectangleF PrintableRect {
                get;
        }
        public virtual UIPrintFormatter[] PrintFormatters {
                get;
                set;
        }
}

New Type: MonoTouch.UIKit.UIPrintPaper

public class UIPrintPaper : MonoTouch.Foundation.NSObject {
        
        public UIPrintPaper ();
        public UIPrintPaper (MonoTouch.Foundation.NSCoder coder);
        public UIPrintPaper (MonoTouch.Foundation.NSObjectFlag t);
        public UIPrintPaper (IntPtr handle);
        
        public static UIPrintPaper ForPageSize (System.Drawing.SizeF pageSize, UIPrintPaper[] paperList);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual System.Drawing.SizeF PaperSize {
                get;
        }
        public virtual System.Drawing.RectangleF PrintableRect {
                get;
        }
}

Type Changed: MonoTouch.UIKit.UISearchBar

Added:

public event EventHandler<UISearchBarButtonIndexEventArgs> SelectedScopeButtonIndexChanged;

Type Changed: MonoTouch.UIKit.UISearchBarButtonIndexEventArgs

Removed:

Could not find MonoTouch.UIKit.UISearchBarButtonIndexEventArgs

Added:

public class UISearchBarButtonIndexEventArgs : EventArgs {
        
        public UISearchBarButtonIndexEventArgs (int selectedScope);
        
        public int SelectedScope {
                get;
                set;
        }
 }

Type Changed: MonoTouch.UIKit.UISearchBarDelegate

Added:

public virtual void SelectedScopeButtonIndexChanged (UISearchBar searchBar, int selectedScope);

New Type: MonoTouch.UIKit.UISimpleTextPrintFormatter

public class UISimpleTextPrintFormatter : UIPrintFormatter {
        
        public UISimpleTextPrintFormatter ();
        public UISimpleTextPrintFormatter (MonoTouch.Foundation.NSCoder coder);
        public UISimpleTextPrintFormatter (MonoTouch.Foundation.NSObjectFlag t);
        public UISimpleTextPrintFormatter (IntPtr handle);
        public UISimpleTextPrintFormatter (string text);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual UIColor Color {
                get;
                set;
        }
        public virtual UIFont Font {
                get;
                set;
        }
        public virtual UILineBreakMode LineBreakMode {
                get;
                set;
        }
        public virtual string Text {
                get;
                set;
        }
        public virtual UITextAlignment TextAlignment {
                get;
                set;
        }
}

Type Changed: MonoTouch.UIKit.UITableViewDataSource

Removed:

public abstract int RowsInSection (UITableView tableview, int section);

Added:

public abstract int RowsInSection (UITableView tableView, int section);

Type Changed: MonoTouch.UIKit.UITableViewDelegate

Added:

public override void DecelerationEnded (UIScrollView scrollView);
        public override void DecelerationStarted (UIScrollView scrollView);
        public override void DidZoom (UIScrollView scrollView);
        public override void DraggingEnded (UIScrollView scrollView, bool willDecelerate);
        public override void DraggingStarted (UIScrollView scrollView);
        public override void ScrollAnimationEnded (UIScrollView scrollView);
        public override void Scrolled (UIScrollView scrollView);
        public override void ScrolledToTop (UIScrollView scrollView);
        public override bool ShouldScrollToTop (UIScrollView scrollView);
        public override UIView ViewForZoomingInScrollView (UIScrollView scrollView);
        public override void ZoomingEnded (UIScrollView scrollView, UIView withView, float atScale);
        public override void ZoomingStarted (UIScrollView scrollView, UIView view);

Type Changed: MonoTouch.UIKit.UITableViewSource

Added:

public override void DecelerationEnded (UIScrollView scrollView);
        public override void DecelerationStarted (UIScrollView scrollView);
        public override void DidZoom (UIScrollView scrollView);
        public override void DraggingEnded (UIScrollView scrollView, bool willDecelerate);
        public override void DraggingStarted (UIScrollView scrollView);
        public override void ScrollAnimationEnded (UIScrollView scrollView);
        public override void Scrolled (UIScrollView scrollView);
        public override void ScrolledToTop (UIScrollView scrollView);
        public override bool ShouldScrollToTop (UIScrollView scrollView);
        public override UIView ViewForZoomingInScrollView (UIScrollView scrollView);
        public override void ZoomingEnded (UIScrollView scrollView, UIView withView, float atScale);
        public override void ZoomingStarted (UIScrollView scrollView, UIView view);

New Type: MonoTouch.UIKit.UITextInputMode

public class UITextInputMode : MonoTouch.Foundation.NSObject {
        
        public UITextInputMode ();
        public UITextInputMode (MonoTouch.Foundation.NSCoder coder);
        public UITextInputMode (MonoTouch.Foundation.NSObjectFlag t);
        public UITextInputMode (IntPtr handle);
        
        public static UITextInputMode CurrentInputMode {
                get;
        }
        public static MonoTouch.Foundation.NSString CurrentInputModeDidChangeNotification {
                get;
        }
        public override IntPtr ClassHandle {
                get;
        }
        public virtual string PrimaryLanguage {
                get;
        }
}

Type Changed: MonoTouch.UIKit.UITextViewDelegate

Added:

public override void DecelerationEnded (UIScrollView scrollView);
        public override void DecelerationStarted (UIScrollView scrollView);
        public override void DidZoom (UIScrollView scrollView);
        public override void DraggingEnded (UIScrollView scrollView, bool willDecelerate);
        public override void DraggingStarted (UIScrollView scrollView);
        public override void ScrollAnimationEnded (UIScrollView scrollView);
        public override void Scrolled (UIScrollView scrollView);
        public override void ScrolledToTop (UIScrollView scrollView);
        public override bool ShouldScrollToTop (UIScrollView scrollView);
        public override UIView ViewForZoomingInScrollView (UIScrollView scrollView);
        public override void ZoomingEnded (UIScrollView scrollView, UIView withView, float atScale);
        public override void ZoomingStarted (UIScrollView scrollView, UIView view);

Type Changed: MonoTouch.UIKit.UIVideoEditorControllerDelegate

Added:

public override void DidShowViewController (UINavigationController navigationController, UIViewController viewController, bool animated);
        public override void WillShowViewController (UINavigationController navigationController, UIViewController viewController, bool animated);

Type Changed: MonoTouch.UIKit.UIView

Added:

public virtual void DrawRect (System.Drawing.RectangleF area, UIViewPrintFormatter formatter);
        public virtual bool EnableInputClicksWhenVisible {
                get;
        }
        public virtual UIViewPrintFormatter ViewPrintFormatter {
                get;
        }
        
        public event MonoTouch.Foundation.NSAction AnimationWillEnd;
        public event MonoTouch.Foundation.NSAction AnimationWillStart;

Type Changed: MonoTouch.UIKit.UIViewController

Removed:

set;

Added:

public virtual UISplitViewController SplitViewController {
                get;
        }
        public virtual UITabBarController TabBarController {
                get;
        }

Type Changed: MonoTouch.UIKit.UIViewPrintFormatter

Added:

public class UIViewPrintFormatter : UIPrintFormatter {
        
        public UIViewPrintFormatter ();
        public UIViewPrintFormatter (MonoTouch.Foundation.NSCoder coder);
        public UIViewPrintFormatter (MonoTouch.Foundation.NSObjectFlag t);
        public UIViewPrintFormatter (IntPtr handle);
        
        public override IntPtr ClassHandle {
                get;
        }
        public virtual UIView View {
                get;
        }
 }

Namespace: MonoTouch.iAd

Type Changed: MonoTouch.iAd.ADBannerView

Added:

public static MonoTouch.Foundation.NSString SizeIdentifierLandscape {
                get;
        }
        public static MonoTouch.Foundation.NSString SizeIdentifierPortrait {
                get;
        }

Namespace: System.Drawing

Type Changed: System.Drawing.RectangleFExt

Added:

// Extension methods for RectangleF 
 public static class RectangleFExt {
        
        public static void DivideRect (this RectangleF rect, out RectangleF slice, out RectangleF rem, float amount, Edge edge);
        public static RectangleF Inset (this RectangleF rect, float dx, float dy);
        public static RectangleF IntegralRect (this RectangleF rect);
        
        [Serializable]
        public enum Edge {
                MinX,
                MinY,
                MaxX,
                MaxY
        }
 }

Xamarin Workbook

If it's not already installed, install the Xamarin Workbooks app first. The workbook file should download automatically, but if it doesn't, just click to start the workbook download manually.