objc2_app_kit/generated/
NSToolbarItem.rs

1//! This file has been automatically generated by `objc2`'s `header-translator`.
2//! DO NOT EDIT
3use core::ffi::*;
4use core::ptr::NonNull;
5use objc2::__framework_prelude::*;
6#[cfg(feature = "objc2-cloud-kit")]
7#[cfg(target_vendor = "apple")]
8use objc2_cloud_kit::*;
9use objc2_foundation::*;
10
11use crate::*;
12
13/// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritemvisibilitypriority?language=objc)
14// NS_TYPED_EXTENSIBLE_ENUM
15pub type NSToolbarItemVisibilityPriority = NSInteger;
16
17/// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritemvisibilityprioritystandard?language=objc)
18pub static NSToolbarItemVisibilityPriorityStandard: NSToolbarItemVisibilityPriority = 0;
19
20/// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritemvisibilityprioritylow?language=objc)
21pub static NSToolbarItemVisibilityPriorityLow: NSToolbarItemVisibilityPriority = -1000;
22
23/// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritemvisibilitypriorityhigh?language=objc)
24pub static NSToolbarItemVisibilityPriorityHigh: NSToolbarItemVisibilityPriority = 1000;
25
26/// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritemvisibilitypriorityuser?language=objc)
27pub static NSToolbarItemVisibilityPriorityUser: NSToolbarItemVisibilityPriority = 2000;
28
29extern_class!(
30    /// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritem?language=objc)
31    #[unsafe(super(NSObject))]
32    #[thread_kind = MainThreadOnly]
33    #[derive(Debug, PartialEq, Eq, Hash)]
34    pub struct NSToolbarItem;
35);
36
37extern_conformance!(
38    unsafe impl NSCopying for NSToolbarItem {}
39);
40
41unsafe impl CopyingHelper for NSToolbarItem {
42    type Result = Self;
43}
44
45extern_conformance!(
46    unsafe impl NSObjectProtocol for NSToolbarItem {}
47);
48
49impl NSToolbarItem {
50    extern_methods!(
51        #[cfg(feature = "NSToolbar")]
52        /// Initialize the toolbar item with an identifier which is a development language string used by the toolbar and its delegate for identification purposes.
53        #[unsafe(method(initWithItemIdentifier:))]
54        #[unsafe(method_family = init)]
55        pub unsafe fn initWithItemIdentifier(
56            this: Allocated<Self>,
57            item_identifier: &NSToolbarItemIdentifier,
58        ) -> Retained<Self>;
59
60        #[cfg(feature = "NSToolbar")]
61        #[unsafe(method(itemIdentifier))]
62        #[unsafe(method_family = none)]
63        pub unsafe fn itemIdentifier(&self) -> Retained<NSToolbarItemIdentifier>;
64
65        #[cfg(feature = "NSToolbar")]
66        /// Use this to determine the toolbar in which an item is currently displayed.
67        #[unsafe(method(toolbar))]
68        #[unsafe(method_family = none)]
69        pub unsafe fn toolbar(&self) -> Option<Retained<NSToolbar>>;
70
71        /// Use this to set the item's label that appears in the toolbar.
72        /// The label may also be used for the default `menuFormRepresentation` of the item.
73        /// Also, developers should make sure the length of the label is appropriate and not too long.
74        #[unsafe(method(label))]
75        #[unsafe(method_family = none)]
76        pub unsafe fn label(&self) -> Retained<NSString>;
77
78        /// Setter for [`label`][Self::label].
79        #[unsafe(method(setLabel:))]
80        #[unsafe(method_family = none)]
81        pub unsafe fn setLabel(&self, label: &NSString);
82
83        /// Use this to set the item's label that appears when the item is in the customization palette.
84        /// All Items must have a palette label, and for most things it is reasonable to set them to the same string as the label used in the toolbar.
85        #[unsafe(method(paletteLabel))]
86        #[unsafe(method_family = none)]
87        pub unsafe fn paletteLabel(&self) -> Retained<NSString>;
88
89        /// Setter for [`paletteLabel`][Self::paletteLabel].
90        #[unsafe(method(setPaletteLabel:))]
91        #[unsafe(method_family = none)]
92        pub unsafe fn setPaletteLabel(&self, palette_label: &NSString);
93
94        /// An array of all alternate labels this item may display.
95        /// The item will use the size of the longest label to prevent resizing when the label is changed.
96        #[unsafe(method(possibleLabels))]
97        #[unsafe(method_family = none)]
98        pub unsafe fn possibleLabels(&self) -> Retained<NSSet<NSString>>;
99
100        /// Setter for [`possibleLabels`][Self::possibleLabels].
101        #[unsafe(method(setPossibleLabels:))]
102        #[unsafe(method_family = none)]
103        pub unsafe fn setPossibleLabels(&self, possible_labels: &NSSet<NSString>);
104
105        /// Use this to set a tooltip to be used when the item is displayed in the toolbar. (forwards to `-view` if it responds)
106        #[unsafe(method(toolTip))]
107        #[unsafe(method_family = none)]
108        pub unsafe fn toolTip(&self) -> Option<Retained<NSString>>;
109
110        /// Setter for [`toolTip`][Self::toolTip].
111        #[unsafe(method(setToolTip:))]
112        #[unsafe(method_family = none)]
113        pub unsafe fn setToolTip(&self, tool_tip: Option<&NSString>);
114
115        #[cfg(feature = "NSMenuItem")]
116        /// The menu form of a toolbar item's purpose is twofold.
117        /// First, when the window is too small to display an item, it will be clipped but remain accessible from a "clipped items" menu containing the menu item returned here.
118        /// Second, in text only mode, the menu returned will be used to create the displayed items.
119        /// Singleton menu items will be clickable, while submenu items will be represented as a pull down.
120        /// For instance, say you want a button that allows you to switch between modes A, B, and C.
121        /// You could represent this as a menu by: a menu item "mode" with three submenu items "A", "B", and "C".
122        /// By default, this method returns a singleton menu item with item label as the title.
123        /// For standard items, the target, action is set.
124        #[unsafe(method(menuFormRepresentation))]
125        #[unsafe(method_family = none)]
126        pub unsafe fn menuFormRepresentation(&self) -> Option<Retained<NSMenuItem>>;
127
128        #[cfg(feature = "NSMenuItem")]
129        /// Setter for [`menuFormRepresentation`][Self::menuFormRepresentation].
130        #[unsafe(method(setMenuFormRepresentation:))]
131        #[unsafe(method_family = none)]
132        pub unsafe fn setMenuFormRepresentation(
133            &self,
134            menu_form_representation: Option<&NSMenuItem>,
135        );
136
137        /// Tag for your own custom purpose. (forwards to `-view` if it responds)
138        #[unsafe(method(tag))]
139        #[unsafe(method_family = none)]
140        pub unsafe fn tag(&self) -> NSInteger;
141
142        /// Setter for [`tag`][Self::tag].
143        #[unsafe(method(setTag:))]
144        #[unsafe(method_family = none)]
145        pub unsafe fn setTag(&self, tag: NSInteger);
146
147        /// Set and get the action of an item. (forwards to `-view` if it responds)
148        #[unsafe(method(target))]
149        #[unsafe(method_family = none)]
150        pub unsafe fn target(&self) -> Option<Retained<AnyObject>>;
151
152        /// This is a [weak property][objc2::topics::weak_property].
153        /// Setter for [`target`][Self::target].
154        #[unsafe(method(setTarget:))]
155        #[unsafe(method_family = none)]
156        pub unsafe fn setTarget(&self, target: Option<&AnyObject>);
157
158        /// Set and get the action of an item.
159        /// For custom views, this method will call `-setAction:` on the view if it responds. (forwards to `-view` if it responds)
160        #[unsafe(method(action))]
161        #[unsafe(method_family = none)]
162        pub unsafe fn action(&self) -> Option<Sel>;
163
164        /// Setter for [`action`][Self::action].
165        #[unsafe(method(setAction:))]
166        #[unsafe(method_family = none)]
167        pub unsafe fn setAction(&self, action: Option<Sel>);
168
169        /// Set and get the enabled flag of an item.
170        /// For custom views, this method will call `-setEnabled:` on the view if it responds. (forwards to `-view` if it responds)
171        #[unsafe(method(isEnabled))]
172        #[unsafe(method_family = none)]
173        pub unsafe fn isEnabled(&self) -> bool;
174
175        /// Setter for [`isEnabled`][Self::isEnabled].
176        #[unsafe(method(setEnabled:))]
177        #[unsafe(method_family = none)]
178        pub unsafe fn setEnabled(&self, enabled: bool);
179
180        #[cfg(feature = "NSImage")]
181        #[unsafe(method(image))]
182        #[unsafe(method_family = none)]
183        pub unsafe fn image(&self) -> Option<Retained<NSImage>>;
184
185        #[cfg(feature = "NSImage")]
186        /// Setter for [`image`][Self::image].
187        #[unsafe(method(setImage:))]
188        #[unsafe(method_family = none)]
189        pub unsafe fn setImage(&self, image: Option<&NSImage>);
190
191        /// Set and get the title of an item.
192        /// For custom views, this method will call `-setTitle:` on the view if it responds. (forwards to `-view` if it responds)
193        #[unsafe(method(title))]
194        #[unsafe(method_family = none)]
195        pub unsafe fn title(&self) -> Retained<NSString>;
196
197        /// Setter for [`title`][Self::title].
198        #[unsafe(method(setTitle:))]
199        #[unsafe(method_family = none)]
200        pub unsafe fn setTitle(&self, title: &NSString);
201
202        /// When set on an item without a custom view, the button produced will have a bordered style.
203        /// Defaults to NO.
204        #[unsafe(method(isBordered))]
205        #[unsafe(method_family = none)]
206        pub unsafe fn isBordered(&self) -> bool;
207
208        /// Setter for [`isBordered`][Self::isBordered].
209        #[unsafe(method(setBordered:))]
210        #[unsafe(method_family = none)]
211        pub unsafe fn setBordered(&self, bordered: bool);
212
213        /// Whether or not the item behaves as a navigation item (i.e. back/forward) in the toolbar.
214        /// Navigation items may be specially positioned by the system outside the normal list of items of the toolbar in the order specified by `-toolbarDefaultItemIdentifiers:`.
215        /// Defaults to NO.
216        #[unsafe(method(isNavigational))]
217        #[unsafe(method_family = none)]
218        pub unsafe fn isNavigational(&self) -> bool;
219
220        /// Setter for [`isNavigational`][Self::isNavigational].
221        #[unsafe(method(setNavigational:))]
222        #[unsafe(method_family = none)]
223        pub unsafe fn setNavigational(&self, navigational: bool);
224
225        #[cfg(all(feature = "NSResponder", feature = "NSView"))]
226        /// Items with automatically generated views will return nil from this getter.
227        /// Custom views may be provided but not all `NSToolbarItem` subclasses support custom views.
228        /// Note that, by default, many of the set/get methods will be implemented by calls forwarded to the view you set, if it responds to it.
229        #[unsafe(method(view))]
230        #[unsafe(method_family = none)]
231        pub unsafe fn view(&self) -> Option<Retained<NSView>>;
232
233        #[cfg(all(feature = "NSResponder", feature = "NSView"))]
234        /// Setter for [`view`][Self::view].
235        #[unsafe(method(setView:))]
236        #[unsafe(method_family = none)]
237        pub unsafe fn setView(&self, view: Option<&NSView>);
238
239        /// An item is visible if it is present in the NSToolbar and not in the overflow menu.
240        /// This property is key value observable.
241        #[unsafe(method(isVisible))]
242        #[unsafe(method_family = none)]
243        pub unsafe fn isVisible(&self) -> bool;
244
245        /// When an item is hidden it will not be visible in the toolbar. The item will still be visible in the customization panel. Because hidden items may be visible during user customization, use the `visible` property to determine if an item is currently displayed. Note that even hidden toolbar items are sync'd to other toolbars with a shared identifier, but its `hidden` state can be unique to each instance. Use this property to show a toolbar item in one toolbar instance but not another.
246        #[unsafe(method(isHidden))]
247        #[unsafe(method_family = none)]
248        pub unsafe fn isHidden(&self) -> bool;
249
250        /// Setter for [`isHidden`][Self::isHidden].
251        #[unsafe(method(setHidden:))]
252        #[unsafe(method_family = none)]
253        pub unsafe fn setHidden(&self, hidden: bool);
254
255        /// Unless you have already set your own custom view, you should not call these methods.
256        /// The min size should be small enough to look nice in all display modes.
257        /// If you do not set a min/max size, the view's size properties will be calculated using constraints. Apps linked before 10.14 will use the view's current size.
258        /// In general, apps should rely on the automatic measurements and constraints to define min/max sizes rather than setting these properties since this will account for localizations.
259        #[deprecated = "This property is no longer recommended. Instead, let the system automatically measure the size of the view using constraints."]
260        #[unsafe(method(minSize))]
261        #[unsafe(method_family = none)]
262        pub unsafe fn minSize(&self) -> NSSize;
263
264        /// Setter for [`minSize`][Self::minSize].
265        #[deprecated = "This property is no longer recommended. Instead, let the system automatically measure the size of the view using constraints."]
266        #[unsafe(method(setMinSize:))]
267        #[unsafe(method_family = none)]
268        pub unsafe fn setMinSize(&self, min_size: NSSize);
269
270        #[deprecated = "This property is no longer recommended. Instead, let the system automatically measure the size of the view using constraints."]
271        #[unsafe(method(maxSize))]
272        #[unsafe(method_family = none)]
273        pub unsafe fn maxSize(&self) -> NSSize;
274
275        /// Setter for [`maxSize`][Self::maxSize].
276        #[deprecated = "This property is no longer recommended. Instead, let the system automatically measure the size of the view using constraints."]
277        #[unsafe(method(setMaxSize:))]
278        #[unsafe(method_family = none)]
279        pub unsafe fn setMaxSize(&self, max_size: NSSize);
280
281        /// When a toolbar does not have enough space to fit all its items, it must push some into the overflow menu.
282        /// Items with the highest `visibilityPriority` level are chosen last for the overflow menu.
283        /// The default `visibilityPriority` value is `NSToolbarItemVisibilityPriorityStandard`.
284        /// To suggest that an item always remain visible, give it a value greater than `NSToolbarItemVisibilityPriorityStandard`, but less than `NSToolbarItemVisibilityPriorityUser`.
285        /// In 10.7, users can no longer modify the toolbar item visibility priority.
286        #[unsafe(method(visibilityPriority))]
287        #[unsafe(method_family = none)]
288        pub unsafe fn visibilityPriority(&self) -> NSToolbarItemVisibilityPriority;
289
290        /// Setter for [`visibilityPriority`][Self::visibilityPriority].
291        #[unsafe(method(setVisibilityPriority:))]
292        #[unsafe(method_family = none)]
293        pub unsafe fn setVisibilityPriority(
294            &self,
295            visibility_priority: NSToolbarItemVisibilityPriority,
296        );
297
298        /// Typically you should not invoke this method.
299        /// This method is called by its toolbar during validation.
300        /// Standard items validate themselves by sending the `-validateToolbarItem:` validate message to the current validator.
301        /// Since items with custom views don't always have meaningful target/actions, they do nothing.
302        /// So for your custom items it may be useful to override this method and invent your own validation.
303        #[unsafe(method(validate))]
304        #[unsafe(method_family = none)]
305        pub unsafe fn validate(&self);
306
307        /// This property only affects automatic validation performed by NSToolbar.
308        /// Explicit validation requests, such as the `-[NSToolbar validateVisibleItems]` method, will invoke the `-validate` method even if `autovalidates` is `NO`.
309        /// Defaults to YES.
310        #[unsafe(method(autovalidates))]
311        #[unsafe(method_family = none)]
312        pub unsafe fn autovalidates(&self) -> bool;
313
314        /// Setter for [`autovalidates`][Self::autovalidates].
315        #[unsafe(method(setAutovalidates:))]
316        #[unsafe(method_family = none)]
317        pub unsafe fn setAutovalidates(&self, autovalidates: bool);
318
319        /// Duplicate items outside of spaces are not allowed.
320        #[deprecated = "Duplicates are no longer supported."]
321        #[unsafe(method(allowsDuplicatesInToolbar))]
322        #[unsafe(method_family = none)]
323        pub unsafe fn allowsDuplicatesInToolbar(&self) -> bool;
324    );
325}
326
327/// Methods declared on superclass `NSObject`.
328impl NSToolbarItem {
329    extern_methods!(
330        #[unsafe(method(init))]
331        #[unsafe(method_family = init)]
332        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
333
334        #[unsafe(method(new))]
335        #[unsafe(method_family = new)]
336        pub unsafe fn new(mtm: MainThreadMarker) -> Retained<Self>;
337    );
338}
339
340impl NSToolbarItem {
341    extern_methods!();
342}
343
344#[cfg(feature = "NSMenu")]
345extern_conformance!(
346    unsafe impl NSMenuItemValidation for NSToolbarItem {}
347);
348
349#[cfg(feature = "NSUserInterfaceValidation")]
350extern_conformance!(
351    unsafe impl NSValidatedUserInterfaceItem for NSToolbarItem {}
352);
353
354extern_protocol!(
355    /// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbaritemvalidation?language=objc)
356    pub unsafe trait NSToolbarItemValidation: NSObjectProtocol + MainThreadOnly {
357        /// `NSToolbarItemValidation` extends the standard validation idea by introducing this new method which is sent to validators for each visible standard `NSToolbarItem` with a valid target/action pair.
358        /// Note: This message is sent from NSToolbarItem's validate method, however validate will not send this message for items that have custom views.
359        #[unsafe(method(validateToolbarItem:))]
360        #[unsafe(method_family = none)]
361        unsafe fn validateToolbarItem(&self, item: &NSToolbarItem) -> bool;
362    }
363);
364
365extern_protocol!(
366    /// [Apple's documentation](https://developer.apple.com/documentation/appkit/nscloudsharingvalidation?language=objc)
367    pub unsafe trait NSCloudSharingValidation: NSObjectProtocol + MainThreadOnly {
368        #[cfg(all(feature = "NSUserInterfaceValidation", feature = "objc2-cloud-kit"))]
369        #[cfg(target_vendor = "apple")]
370        /// `NSToolbarItems` created with `NSToolbarCloudSharingItemIdentifier` use this method for further validation after sending `-validateToolbarItem:` or `-validateUserInterfaceItem:`.
371        /// The validator for the item's action should return the current CKShare corresponding to the selected item, if any.
372        /// The state of the item will be changed reflect the state of the CKShare.
373        #[unsafe(method(cloudShareForUserInterfaceItem:))]
374        #[unsafe(method_family = none)]
375        unsafe fn cloudShareForUserInterfaceItem(
376            &self,
377            item: &ProtocolObject<dyn NSValidatedUserInterfaceItem>,
378        ) -> Option<Retained<CKShare>>;
379    }
380);
381
382extern "C" {
383    /// A space item of a standard fixed size.
384    ///
385    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarspaceitemidentifier?language=objc)
386    #[cfg(feature = "NSToolbar")]
387    pub static NSToolbarSpaceItemIdentifier: &'static NSToolbarItemIdentifier;
388}
389
390extern "C" {
391    /// A space item of flexible width.
392    ///
393    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarflexiblespaceitemidentifier?language=objc)
394    #[cfg(feature = "NSToolbar")]
395    pub static NSToolbarFlexibleSpaceItemIdentifier: &'static NSToolbarItemIdentifier;
396}
397
398extern "C" {
399    /// A standard item that is configured to show the color panel when invoked.
400    ///
401    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarshowcolorsitemidentifier?language=objc)
402    #[cfg(feature = "NSToolbar")]
403    pub static NSToolbarShowColorsItemIdentifier: &'static NSToolbarItemIdentifier;
404}
405
406extern "C" {
407    /// A standard item that is configured to show the font panel when invoked.
408    ///
409    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarshowfontsitemidentifier?language=objc)
410    #[cfg(feature = "NSToolbar")]
411    pub static NSToolbarShowFontsItemIdentifier: &'static NSToolbarItemIdentifier;
412}
413
414extern "C" {
415    /// A standard item that is configured to send -printDocument: to the firstResponder when invoked
416    ///
417    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarprintitemidentifier?language=objc)
418    #[cfg(feature = "NSToolbar")]
419    pub static NSToolbarPrintItemIdentifier: &'static NSToolbarItemIdentifier;
420}
421
422extern "C" {
423    /// A standard item that is configured to send -toggleSidebar: to the firstResponder when invoked.
424    ///
425    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbartogglesidebaritemidentifier?language=objc)
426    #[cfg(feature = "NSToolbar")]
427    pub static NSToolbarToggleSidebarItemIdentifier: &'static NSToolbarItemIdentifier;
428}
429
430extern "C" {
431    /// A standard item that is configured to send -toggleInspector: to the firstResponder when invoked.
432    ///
433    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbartoggleinspectoritemidentifier?language=objc)
434    #[cfg(feature = "NSToolbar")]
435    pub static NSToolbarToggleInspectorItemIdentifier: &'static NSToolbarItemIdentifier;
436}
437
438extern "C" {
439    /// A standard item for cloud sharing via NSSharingServiceNameCloudSharing. It validates itself and modifies its appearance by using the NSCloudSharingValidation protocol. It sends -performCloudSharing: to the firstResponder.
440    ///
441    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarcloudsharingitemidentifier?language=objc)
442    #[cfg(feature = "NSToolbar")]
443    pub static NSToolbarCloudSharingItemIdentifier: &'static NSToolbarItemIdentifier;
444}
445
446extern "C" {
447    /// A standard item that is configured to send -showWritingTools: to the firstResponder when invoked.
448    ///
449    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarwritingtoolsitemidentifier?language=objc)
450    #[cfg(feature = "NSToolbar")]
451    pub static NSToolbarWritingToolsItemIdentifier: &'static NSToolbarItemIdentifier;
452}
453
454extern "C" {
455    /// Creates a new NSTrackingSeparatorToolbarItem and automatically configures it to track the divider of the sidebar if one is discovered.
456    /// Only applies to windows with `NSWindowStyleMaskFullSizeContentView` applied.
457    ///
458    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarsidebartrackingseparatoritemidentifier?language=objc)
459    #[cfg(feature = "NSToolbar")]
460    pub static NSToolbarSidebarTrackingSeparatorItemIdentifier: &'static NSToolbarItemIdentifier;
461}
462
463extern "C" {
464    /// Creates a new NSTrackingSeparatorToolbarItem and automatically configures it to track the divider of the inspector if one is discovered.
465    /// Only applies to windows with `NSWindowStyleMaskFullSizeContentView` applied.
466    ///
467    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarinspectortrackingseparatoritemidentifier?language=objc)
468    #[cfg(feature = "NSToolbar")]
469    pub static NSToolbarInspectorTrackingSeparatorItemIdentifier: &'static NSToolbarItemIdentifier;
470}
471
472extern "C" {
473    /// Deprecated Item Identifiers
474    ///
475    /// See also [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarseparatoritemidentifier?language=objc)
476    #[cfg(feature = "NSToolbar")]
477    pub static NSToolbarSeparatorItemIdentifier: &'static NSToolbarItemIdentifier;
478}
479
480extern "C" {
481    /// [Apple's documentation](https://developer.apple.com/documentation/appkit/nstoolbarcustomizetoolbaritemidentifier?language=objc)
482    #[cfg(feature = "NSToolbar")]
483    pub static NSToolbarCustomizeToolbarItemIdentifier: &'static NSToolbarItemIdentifier;
484}