mirror of
https://gitee.com/csharpui/CPF.git
synced 2025-04-05 17:37:51 +08:00
765 lines
22 KiB
C#
765 lines
22 KiB
C#
using CPF.Mac.Foundation;
|
|
using CPF.Mac.ObjCRuntime;
|
|
using System;
|
|
using System.ComponentModel;
|
|
|
|
namespace CPF.Mac.AppKit
|
|
{
|
|
[Register("NSToolbar", true)]
|
|
public class NSToolbar : NSObject
|
|
{
|
|
[Register]
|
|
private sealed class _NSToolbarDelegate : NSToolbarDelegate
|
|
{
|
|
internal NSToolbarWillInsert willInsertItem;
|
|
|
|
internal NSToolbarIdentifiers defaultItemIdentifiers;
|
|
|
|
internal NSToolbarIdentifiers allowedItemIdentifiers;
|
|
|
|
internal NSToolbarIdentifiers selectableItemIdentifiers;
|
|
|
|
internal EventHandler willAddItem;
|
|
|
|
internal EventHandler didRemoveItem;
|
|
|
|
[Preserve(Conditional = true)]
|
|
public override NSToolbarItem WillInsertItem(NSToolbar toolbar, string itemIdentifier, bool willBeInserted)
|
|
{
|
|
return willInsertItem?.Invoke(toolbar, itemIdentifier, willBeInserted);
|
|
}
|
|
|
|
[Preserve(Conditional = true)]
|
|
public override string[] DefaultItemIdentifiers(NSToolbar toolbar)
|
|
{
|
|
return defaultItemIdentifiers?.Invoke(toolbar);
|
|
}
|
|
|
|
[Preserve(Conditional = true)]
|
|
public override string[] AllowedItemIdentifiers(NSToolbar toolbar)
|
|
{
|
|
return allowedItemIdentifiers?.Invoke(toolbar);
|
|
}
|
|
|
|
[Preserve(Conditional = true)]
|
|
public override string[] SelectableItemIdentifiers(NSToolbar toolbar)
|
|
{
|
|
return selectableItemIdentifiers?.Invoke(toolbar);
|
|
}
|
|
|
|
[Preserve(Conditional = true)]
|
|
public override void WillAddItem(NSNotification notification)
|
|
{
|
|
willAddItem?.Invoke(notification, EventArgs.Empty);
|
|
}
|
|
|
|
[Preserve(Conditional = true)]
|
|
public override void DidRemoveItem(NSNotification notification)
|
|
{
|
|
didRemoveItem?.Invoke(notification, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
private static readonly IntPtr selCustomizationPaletteIsRunningHandle = Selector.GetHandle("customizationPaletteIsRunning");
|
|
|
|
private static readonly IntPtr selIdentifierHandle = Selector.GetHandle("identifier");
|
|
|
|
private static readonly IntPtr selItemsHandle = Selector.GetHandle("items");
|
|
|
|
private static readonly IntPtr selVisibleItemsHandle = Selector.GetHandle("visibleItems");
|
|
|
|
private static readonly IntPtr selConfigurationDictionaryHandle = Selector.GetHandle("configurationDictionary");
|
|
|
|
private static readonly IntPtr selDelegateHandle = Selector.GetHandle("delegate");
|
|
|
|
private static readonly IntPtr selSetDelegate_Handle = Selector.GetHandle("setDelegate:");
|
|
|
|
private static readonly IntPtr selIsVisibleHandle = Selector.GetHandle("isVisible");
|
|
|
|
private static readonly IntPtr selSetVisible_Handle = Selector.GetHandle("setVisible:");
|
|
|
|
private static readonly IntPtr selDisplayModeHandle = Selector.GetHandle("displayMode");
|
|
|
|
private static readonly IntPtr selSetDisplayMode_Handle = Selector.GetHandle("setDisplayMode:");
|
|
|
|
private static readonly IntPtr selSelectedItemIdentifierHandle = Selector.GetHandle("selectedItemIdentifier");
|
|
|
|
private static readonly IntPtr selSetSelectedItemIdentifier_Handle = Selector.GetHandle("setSelectedItemIdentifier:");
|
|
|
|
private static readonly IntPtr selSizeModeHandle = Selector.GetHandle("sizeMode");
|
|
|
|
private static readonly IntPtr selSetSizeMode_Handle = Selector.GetHandle("setSizeMode:");
|
|
|
|
private static readonly IntPtr selShowsBaselineSeparatorHandle = Selector.GetHandle("showsBaselineSeparator");
|
|
|
|
private static readonly IntPtr selSetShowsBaselineSeparator_Handle = Selector.GetHandle("setShowsBaselineSeparator:");
|
|
|
|
private static readonly IntPtr selAllowsUserCustomizationHandle = Selector.GetHandle("allowsUserCustomization");
|
|
|
|
private static readonly IntPtr selSetAllowsUserCustomization_Handle = Selector.GetHandle("setAllowsUserCustomization:");
|
|
|
|
private static readonly IntPtr selAutosavesConfigurationHandle = Selector.GetHandle("autosavesConfiguration");
|
|
|
|
private static readonly IntPtr selSetAutosavesConfiguration_Handle = Selector.GetHandle("setAutosavesConfiguration:");
|
|
|
|
private static readonly IntPtr selInitWithIdentifier_Handle = Selector.GetHandle("initWithIdentifier:");
|
|
|
|
private static readonly IntPtr selInsertItemWithItemIdentifierAtIndex_Handle = Selector.GetHandle("insertItemWithItemIdentifier:atIndex:");
|
|
|
|
private static readonly IntPtr selRemoveItemAtIndex_Handle = Selector.GetHandle("removeItemAtIndex:");
|
|
|
|
private static readonly IntPtr selRunCustomizationPalette_Handle = Selector.GetHandle("runCustomizationPalette:");
|
|
|
|
private static readonly IntPtr selSetConfigurationFromDictionary_Handle = Selector.GetHandle("setConfigurationFromDictionary:");
|
|
|
|
private static readonly IntPtr selValidateVisibleItemsHandle = Selector.GetHandle("validateVisibleItems");
|
|
|
|
private static readonly IntPtr class_ptr = Class.GetHandle("NSToolbar");
|
|
|
|
private object __mt_Items_var;
|
|
|
|
private object __mt_VisibleItems_var;
|
|
|
|
private object __mt_ConfigurationDictionary_var;
|
|
|
|
private object __mt_WeakDelegate_var;
|
|
|
|
private static NSString _NSToolbarSeparatorItemIdentifier;
|
|
|
|
private static NSString _NSToolbarSpaceItemIdentifier;
|
|
|
|
private static NSString _NSToolbarFlexibleSpaceItemIdentifier;
|
|
|
|
private static NSString _NSToolbarShowColorsItemIdentifier;
|
|
|
|
private static NSString _NSToolbarShowFontsItemIdentifier;
|
|
|
|
private static NSString _NSToolbarCustomizeToolbarItemIdentifier;
|
|
|
|
private static NSString _NSToolbarPrintItemIdentifier;
|
|
|
|
public override IntPtr ClassHandle => class_ptr;
|
|
|
|
public virtual bool IsCustomizationPaletteRunning
|
|
{
|
|
[Export("customizationPaletteIsRunning")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selCustomizationPaletteIsRunningHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selCustomizationPaletteIsRunningHandle);
|
|
}
|
|
}
|
|
|
|
public virtual string Identifier
|
|
{
|
|
[Export("identifier")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selIdentifierHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selIdentifierHandle));
|
|
}
|
|
}
|
|
|
|
public virtual NSToolbarItem[] Items
|
|
{
|
|
[Export("items")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSToolbarItem[])(__mt_Items_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<NSToolbarItem>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selItemsHandle)) : NSArray.ArrayFromHandle<NSToolbarItem>(Messaging.IntPtr_objc_msgSend(base.Handle, selItemsHandle))));
|
|
}
|
|
}
|
|
|
|
public virtual NSToolbarItem[] VisibleItems
|
|
{
|
|
[Export("visibleItems")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSToolbarItem[])(__mt_VisibleItems_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<NSToolbarItem>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selVisibleItemsHandle)) : NSArray.ArrayFromHandle<NSToolbarItem>(Messaging.IntPtr_objc_msgSend(base.Handle, selVisibleItemsHandle))));
|
|
}
|
|
}
|
|
|
|
public virtual NSDictionary ConfigurationDictionary
|
|
{
|
|
[Export("configurationDictionary")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSDictionary)(__mt_ConfigurationDictionary_var = ((!IsDirectBinding) ? ((NSDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selConfigurationDictionaryHandle))) : ((NSDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selConfigurationDictionaryHandle)))));
|
|
}
|
|
}
|
|
|
|
public virtual NSObject WeakDelegate
|
|
{
|
|
[Export("delegate")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSObject)(__mt_WeakDelegate_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selDelegateHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selDelegateHandle))));
|
|
}
|
|
[Export("setDelegate:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetDelegate_Handle, value?.Handle ?? IntPtr.Zero);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetDelegate_Handle, value?.Handle ?? IntPtr.Zero);
|
|
}
|
|
__mt_WeakDelegate_var = value;
|
|
}
|
|
}
|
|
|
|
public NSToolbarDelegate Delegate
|
|
{
|
|
get
|
|
{
|
|
return WeakDelegate as NSToolbarDelegate;
|
|
}
|
|
set
|
|
{
|
|
WeakDelegate = value;
|
|
}
|
|
}
|
|
|
|
public virtual bool Visible
|
|
{
|
|
[Export("isVisible")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selIsVisibleHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsVisibleHandle);
|
|
}
|
|
[Export("setVisible:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_bool(base.Handle, selSetVisible_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetVisible_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual NSToolbarDisplayMode DisplayMode
|
|
{
|
|
[Export("displayMode")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSToolbarDisplayMode)Messaging.UInt64_objc_msgSend(base.Handle, selDisplayModeHandle);
|
|
}
|
|
return (NSToolbarDisplayMode)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selDisplayModeHandle);
|
|
}
|
|
[Export("setDisplayMode:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_UInt64(base.Handle, selSetDisplayMode_Handle, (ulong)value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_UInt64(base.SuperHandle, selSetDisplayMode_Handle, (ulong)value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual string SelectedItemIdentifier
|
|
{
|
|
[Export("selectedItemIdentifier")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selSelectedItemIdentifierHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selSelectedItemIdentifierHandle));
|
|
}
|
|
[Export("setSelectedItemIdentifier:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
IntPtr intPtr = NSString.CreateNative(value);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetSelectedItemIdentifier_Handle, intPtr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetSelectedItemIdentifier_Handle, intPtr);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
}
|
|
}
|
|
|
|
public virtual NSToolbarSizeMode SizeMode
|
|
{
|
|
[Export("sizeMode")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSToolbarSizeMode)Messaging.UInt64_objc_msgSend(base.Handle, selSizeModeHandle);
|
|
}
|
|
return (NSToolbarSizeMode)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selSizeModeHandle);
|
|
}
|
|
[Export("setSizeMode:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_UInt64(base.Handle, selSetSizeMode_Handle, (ulong)value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_UInt64(base.SuperHandle, selSetSizeMode_Handle, (ulong)value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool ShowsBaselineSeparator
|
|
{
|
|
[Export("showsBaselineSeparator")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selShowsBaselineSeparatorHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selShowsBaselineSeparatorHandle);
|
|
}
|
|
[Export("setShowsBaselineSeparator:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_bool(base.Handle, selSetShowsBaselineSeparator_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetShowsBaselineSeparator_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool AllowsUserCustomization
|
|
{
|
|
[Export("allowsUserCustomization")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selAllowsUserCustomizationHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selAllowsUserCustomizationHandle);
|
|
}
|
|
[Export("setAllowsUserCustomization:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_bool(base.Handle, selSetAllowsUserCustomization_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetAllowsUserCustomization_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool AutosavesConfiguration
|
|
{
|
|
[Export("autosavesConfiguration")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selAutosavesConfigurationHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selAutosavesConfigurationHandle);
|
|
}
|
|
[Export("setAutosavesConfiguration:")]
|
|
set
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_bool(base.Handle, selSetAutosavesConfiguration_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetAutosavesConfiguration_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarSeparatorItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarSeparatorItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarSeparatorItemIdentifier == null)
|
|
{
|
|
_NSToolbarSeparatorItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarSeparatorItemIdentifier");
|
|
}
|
|
return _NSToolbarSeparatorItemIdentifier;
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarSpaceItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarSpaceItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarSpaceItemIdentifier == null)
|
|
{
|
|
_NSToolbarSpaceItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarSpaceItemIdentifier");
|
|
}
|
|
return _NSToolbarSpaceItemIdentifier;
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarFlexibleSpaceItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarFlexibleSpaceItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarFlexibleSpaceItemIdentifier == null)
|
|
{
|
|
_NSToolbarFlexibleSpaceItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarFlexibleSpaceItemIdentifier");
|
|
}
|
|
return _NSToolbarFlexibleSpaceItemIdentifier;
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarShowColorsItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarShowColorsItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarShowColorsItemIdentifier == null)
|
|
{
|
|
_NSToolbarShowColorsItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarShowColorsItemIdentifier");
|
|
}
|
|
return _NSToolbarShowColorsItemIdentifier;
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarShowFontsItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarShowFontsItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarShowFontsItemIdentifier == null)
|
|
{
|
|
_NSToolbarShowFontsItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarShowFontsItemIdentifier");
|
|
}
|
|
return _NSToolbarShowFontsItemIdentifier;
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarCustomizeToolbarItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarCustomizeToolbarItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarCustomizeToolbarItemIdentifier == null)
|
|
{
|
|
_NSToolbarCustomizeToolbarItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarCustomizeToolbarItemIdentifier");
|
|
}
|
|
return _NSToolbarCustomizeToolbarItemIdentifier;
|
|
}
|
|
}
|
|
|
|
[Field("NSToolbarPrintItemIdentifier", "AppKit")]
|
|
public static NSString NSToolbarPrintItemIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (_NSToolbarPrintItemIdentifier == null)
|
|
{
|
|
_NSToolbarPrintItemIdentifier = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSToolbarPrintItemIdentifier");
|
|
}
|
|
return _NSToolbarPrintItemIdentifier;
|
|
}
|
|
}
|
|
|
|
public NSToolbarWillInsert WillInsertItem
|
|
{
|
|
get
|
|
{
|
|
return EnsureNSToolbarDelegate().willInsertItem;
|
|
}
|
|
set
|
|
{
|
|
EnsureNSToolbarDelegate().willInsertItem = value;
|
|
}
|
|
}
|
|
|
|
public NSToolbarIdentifiers DefaultItemIdentifiers
|
|
{
|
|
get
|
|
{
|
|
return EnsureNSToolbarDelegate().defaultItemIdentifiers;
|
|
}
|
|
set
|
|
{
|
|
EnsureNSToolbarDelegate().defaultItemIdentifiers = value;
|
|
}
|
|
}
|
|
|
|
public NSToolbarIdentifiers AllowedItemIdentifiers
|
|
{
|
|
get
|
|
{
|
|
return EnsureNSToolbarDelegate().allowedItemIdentifiers;
|
|
}
|
|
set
|
|
{
|
|
EnsureNSToolbarDelegate().allowedItemIdentifiers = value;
|
|
}
|
|
}
|
|
|
|
public NSToolbarIdentifiers SelectableItemIdentifiers
|
|
{
|
|
get
|
|
{
|
|
return EnsureNSToolbarDelegate().selectableItemIdentifiers;
|
|
}
|
|
set
|
|
{
|
|
EnsureNSToolbarDelegate().selectableItemIdentifiers = value;
|
|
}
|
|
}
|
|
|
|
public event EventHandler WillAddItem
|
|
{
|
|
add
|
|
{
|
|
_NSToolbarDelegate nSToolbarDelegate = EnsureNSToolbarDelegate();
|
|
nSToolbarDelegate.willAddItem = (EventHandler)System.Delegate.Combine(nSToolbarDelegate.willAddItem, value);
|
|
}
|
|
remove
|
|
{
|
|
_NSToolbarDelegate nSToolbarDelegate = EnsureNSToolbarDelegate();
|
|
nSToolbarDelegate.willAddItem = (EventHandler)System.Delegate.Remove(nSToolbarDelegate.willAddItem, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler DidRemoveItem
|
|
{
|
|
add
|
|
{
|
|
_NSToolbarDelegate nSToolbarDelegate = EnsureNSToolbarDelegate();
|
|
nSToolbarDelegate.didRemoveItem = (EventHandler)System.Delegate.Combine(nSToolbarDelegate.didRemoveItem, value);
|
|
}
|
|
remove
|
|
{
|
|
_NSToolbarDelegate nSToolbarDelegate = EnsureNSToolbarDelegate();
|
|
nSToolbarDelegate.didRemoveItem = (EventHandler)System.Delegate.Remove(nSToolbarDelegate.didRemoveItem, value);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("init")]
|
|
public NSToolbar()
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend(base.Handle, Selector.Init);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, Selector.Init);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("initWithCoder:")]
|
|
public NSToolbar(NSCoder coder)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSToolbar(NSObjectFlag t)
|
|
: base(t)
|
|
{
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSToolbar(IntPtr handle)
|
|
: base(handle)
|
|
{
|
|
}
|
|
|
|
[Export("initWithIdentifier:")]
|
|
public NSToolbar(string identifier)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (identifier == null)
|
|
{
|
|
throw new ArgumentNullException("identifier");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(identifier);
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selInitWithIdentifier_Handle, intPtr);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selInitWithIdentifier_Handle, intPtr);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
}
|
|
|
|
[Export("insertItemWithItemIdentifier:atIndex:")]
|
|
public virtual void InsertItem(string itemIdentifier, long index)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (itemIdentifier == null)
|
|
{
|
|
throw new ArgumentNullException("itemIdentifier");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(itemIdentifier);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr_Int64(base.Handle, selInsertItemWithItemIdentifierAtIndex_Handle, intPtr, index);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr_Int64(base.SuperHandle, selInsertItemWithItemIdentifierAtIndex_Handle, intPtr, index);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
}
|
|
|
|
[Export("removeItemAtIndex:")]
|
|
public virtual void RemoveItem(long index)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_Int64(base.Handle, selRemoveItemAtIndex_Handle, index);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_Int64(base.SuperHandle, selRemoveItemAtIndex_Handle, index);
|
|
}
|
|
}
|
|
|
|
[Export("runCustomizationPalette:")]
|
|
public virtual void RunCustomizationPalette(NSObject sender)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (sender == null)
|
|
{
|
|
throw new ArgumentNullException("sender");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selRunCustomizationPalette_Handle, sender.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selRunCustomizationPalette_Handle, sender.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("setConfigurationFromDictionary:")]
|
|
public virtual void SetConfigurationFromDictionary(NSDictionary configDict)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (configDict == null)
|
|
{
|
|
throw new ArgumentNullException("configDict");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetConfigurationFromDictionary_Handle, configDict.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetConfigurationFromDictionary_Handle, configDict.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("validateVisibleItems")]
|
|
public virtual void ValidateVisibleItems()
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selValidateVisibleItemsHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selValidateVisibleItemsHandle);
|
|
}
|
|
}
|
|
|
|
private _NSToolbarDelegate EnsureNSToolbarDelegate()
|
|
{
|
|
NSToolbarDelegate nSToolbarDelegate = Delegate;
|
|
if (nSToolbarDelegate == null || !(nSToolbarDelegate is _NSToolbarDelegate))
|
|
{
|
|
nSToolbarDelegate = (Delegate = new _NSToolbarDelegate());
|
|
}
|
|
return (_NSToolbarDelegate)nSToolbarDelegate;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
if (base.Handle == IntPtr.Zero)
|
|
{
|
|
__mt_Items_var = null;
|
|
__mt_VisibleItems_var = null;
|
|
__mt_ConfigurationDictionary_var = null;
|
|
__mt_WeakDelegate_var = null;
|
|
}
|
|
}
|
|
}
|
|
}
|