Inherits from | |
Conforms to | |
Framework | /System/Library/Frameworks/AppKit.framework |
Availability | Available in Mac OS X v10.0 and later. |
Companion guide | |
Declared in | NSDrawer.h NSGraphics.h NSWindow.h |
Related sample code |
The NSWindow
class defines objects (known as windows) that manage and coordinate the windows an application displays on the screen. A single NSWindow
object corresponds to at most one onscreen window. The two principal functions of a window are to provide an area in which views can be placed and to accept and distribute, to the appropriate views, events the user instigates through actions with the mouse and keyboard.
Note: Although the NSWindow
class inherits the NSCoding
protocol from NSResponder
, the class does not support coding. Legacy support for archivers exists but its use is deprecated and may not work. Any attempt to archive or unarchive an NSWindow
object using a keyed coding object raises an NSInvalidArgumentException
exception.
– initWithContentRect:styleMask:backing:defer:
– initWithContentRect:styleMask:backing:defer:screen:
– styleMask
– worksWhenModal
– alphaValue
– setAlphaValue:
– backgroundColor
– setBackgroundColor:
– contentView
– setContentView:
– canHide
– setCanHide:
– hidesOnDeactivate
– setHidesOnDeactivate:
– collectionBehavior
– setCollectionBehavior:
– isOpaque
– setOpaque:
– hasShadow
– setHasShadow:
– invalidateShadow
– autorecalculatesContentBorderThicknessForEdge:
– setAutorecalculatesContentBorderThickness:forEdge:
– contentBorderThicknessForEdge:
– setContentBorderThickness:forEdge:
– delegate
– setDelegate:
– canBeVisibleOnAllSpaces
Deprecated in Mac OS X v10.5
– setCanBeVisibleOnAllSpaces:
Deprecated in Mac OS X v10.5
+ defaultDepthLimit
– windowNumber
– gState
– canStoreColor
– deviceDescription
– canBecomeVisibleWithoutLogin
– setCanBecomeVisibleWithoutLogin:
– sharingType
– setSharingType:
– backingType
– setBackingType:
– backingLocation
– preferredBackingLocation
– setPreferredBackingLocation:
– isOneShot
– setOneShot:
– depthLimit
– setDepthLimit:
– hasDynamicDepthLimit
– setDynamicDepthLimit:
+ contentRectForFrameRect:styleMask:
+ frameRectForContentRect:styleMask:
+ minFrameWidthWithTitle:styleMask:
– contentRectForFrameRect:
– frameRectForContentRect:
– attachedSheet
– isSheet
– window:willPositionSheet:usingRect:
delegate method
– windowWillBeginSheet:
delegate method
– windowDidEndSheet:
delegate method
– frame
– setFrameOrigin:
– setFrameTopLeftPoint:
– constrainFrameRect:toScreen:
– cascadeTopLeftFromPoint:
– setFrame:display:
– setFrame:display:animate:
– animationResizeTime:
– windowWillUseStandardFrame:defaultFrame:
delegate method
– aspectRatio
– setAspectRatio:
– minSize
– setMinSize:
– maxSize
– setMaxSize:
– isZoomed
– performZoom:
– zoom:
– windowShouldZoom:toFrame:
delegate method
– resizeFlags
– showsResizeIndicator
– setShowsResizeIndicator:
– resizeIncrements
– setResizeIncrements:
– preservesContentDuringLiveResize
– setPreservesContentDuringLiveResize:
– windowWillResize:toSize:
delegate method
– windowDidResize:
delegate method
– contentAspectRatio
– setContentAspectRatio:
– contentMinSize
– setContentMinSize:
– setContentSize:
– contentMaxSize
– setContentMaxSize:
– contentResizeIncrements
– setContentResizeIncrements:
– isVisible
– orderOut:
– orderBack:
– orderFront:
– orderFrontRegardless
– orderWindow:relativeTo:
– level
– setLevel:
+ removeFrameUsingName:
– setFrameUsingName:
– setFrameUsingName:force:
– saveFrameUsingName:
– frameAutosaveName
– setFrameAutosaveName:
– stringWithSavedFrame
– setFrameFromString:
– isKeyWindow
– canBecomeKeyWindow
– makeKeyWindow
– makeKeyAndOrderFront:
– becomeKeyWindow
– windowDidBecomeKey:
delegate method
– resignKeyWindow
– windowDidResignKey:
delegate method
– isMainWindow
– canBecomeMainWindow
– makeMainWindow
– becomeMainWindow
– windowDidBecomeMain:
delegate method
– resignMainWindow
– windowDidResignMain:
delegate method
– isFlushWindowDisabled
– enableFlushWindow
– disableFlushWindow
– flushWindow
– flushWindowIfNeeded
– defaultButtonCell
– setDefaultButtonCell:
– enableKeyEquivalentForDefaultButtonCell
– disableKeyEquivalentForDefaultButtonCell
– areCursorRectsEnabled
– enableCursorRects
– disableCursorRects
– discardCursorRects
– invalidateCursorRectsForView:
– resetCursorRects
+ standardWindowButton:forStyleMask:
– standardWindowButton:
– showsToolbarButton
– setShowsToolbarButton:
+ menuChanged:
– currentEvent
– nextEventMatchingMask:
– nextEventMatchingMask:untilDate:inMode:dequeue:
– discardEventsMatchingMask:beforeEvent:
– postEvent:atStart:
– sendEvent:
– tryToPerform:with:
– selectKeyViewPrecedingView:
– selectKeyViewFollowingView:
– selectPreviousKeyView:
– selectNextKeyView:
– keyViewSelectionDirection
– autorecalculatesKeyViewLoop
– recalculateKeyViewLoop
– setAutorecalculatesKeyViewLoop:
– acceptsMouseMovedEvents
– ignoresMouseEvents
– setIgnoresMouseEvents:
– mouseLocationOutsideOfEventStream
– setAcceptsMouseMovedEvents:
– display
– displayIfNeeded
– viewsNeedDisplay
– setViewsNeedDisplay:
– isAutodisplay
– setAutodisplay:
– useOptimizedDrawing:
– graphicsContext
– disableScreenUpdatesUntilFlush
– update
– windowDidUpdate:
delegate method
– windowDidExpose:
delegate method
– dragImage:at:offset:event:pasteboard:source:slideBack:
– registerForDraggedTypes:
– unregisterDraggedTypes
– window:shouldDragDocumentWithEvent:from:withPasteboard:
delegate method
– windowWillReturnUndoManager:
delegate method
– title
– setTitle:
– setTitleWithRepresentedFilename:
– representedFilename
– setRepresentedFilename:
– representedURL
– setRepresentedURL:
– window:shouldPopUpDocumentPathMenu:
delegate method
– isMovableByWindowBackground
– setMovableByWindowBackground:
– center
– windowWillMove:
delegate method
– windowDidMove:
delegate method
– windowDidChangeScreen:
delegate method
– windowDidChangeScreenProfile:
delegate method
– performClose:
– close
– windowShouldClose:
delegate method
– windowWillClose:
delegate method
– isReleasedWhenClosed
– setReleasedWhenClosed:
– isMiniaturized
– performMiniaturize:
– miniaturize:
– windowWillMiniaturize:
delegate method
– windowDidMiniaturize:
delegate method
– deminiaturize:
– windowDidDeminiaturize:
delegate method
– miniwindowImage
– setMiniwindowImage:
– miniwindowTitle
– setMiniwindowTitle:
Returns the content rectangle used by a window with a given frame rectangle and window style.
+ (NSRect)contentRectForFrameRect:(NSRect)windowFrame styleMask:(NSUInteger)windowStyle
The frame rectangle for the window expressed in screen coordinates.
The window style for the window. See “Constants” for a list of style mask values.
The content rectangle, expressed in screen coordinates, used by the window with windowFrame and windowStyle.
When a NSWindow
instance is available, you should use contentRectForFrameRect:
instead of this method.
NSWindow.h
Returns the default depth limit for instances of NSWindow
.
+ (NSWindowDepth)defaultDepthLimit
The default depth limit for instances of NSWindow
, determined by the depth of the deepest screen level available to the window server.
The value returned can be examined with the Application Kit functions NSPlanarFromDepth
, NSColorSpaceFromDepth
, NSBitsPerSampleFromDepth
, and NSBitsPerPixelFromDepth
.
NSWindow.h
Returns the frame rectangle used by a window with a given content rectangle and window style.
+ (NSRect)frameRectForContentRect:(NSRect)windowContentRect styleMask:(NSUInteger)windowStyle
The content rectangle for a window expressed in screen coordinates.
The window style for the window. See “Constants” for a list of style mask values.
The frame rectangle, expressed in screen coordinates, used by the window with windowContentRect and windowStyle.
When a NSWindow
instance is available, you should use frameRectForContentRect:
instead of this method.
NSWindow.h
This method does nothing; it is here for backward compatibility.
+ (void)menuChanged:(NSMenu *)menu
The menu object that changed.
– menu
(NSResponder
)NSWindow.h
Returns the minimum width a window’s frame rectangle must have for it to display a title, with a given window style.
+ (CGFloat)minFrameWidthWithTitle:(NSString *)windowTitle styleMask:(NSUInteger)windowStyle
The title for the window.
The window style for the window. See “Constants” for a list of style mask values.
The minimum width of the window’s frame, using windowStyle
, in order to display windowTitle
.
NSWindow.h
Removes the frame data stored under a given name from the application’s user defaults.
+ (void)removeFrameUsingName:(NSString *)frameName
The name of the frame to remove.
NSWindow.h
Returns a new instance of a given standard window button, sized appropriately for a given window style.
+ (NSButton *)standardWindowButton:(NSWindowButton)windowButtonKind forStyleMask:(NSUInteger)windowStyle
The kind of standard window button to return.
The window style for which windowButtonKind is to be sized. See “Window Style Masks” for the list of allowable values.
The new window button of the kind identified by windowButtonKind; nil
when no such button kind exists.
The caller is responsible for adding the button to the view hierarchy and for setting the target to be the window.
NSWindow.h
Indicates whether the window accepts mouse-moved events.
- (BOOL)acceptsMouseMovedEvents
YES
when the window accepts (and distributes) mouse-moved events; NO
otherwise.
The NSWindow
default is NO
.
NSWindow.h
Adds a given window as a child window of the window.
- (void)addChildWindow:(NSWindow *)childWindow ordered:(NSWindowOrderingMode)orderingMode
The child window to order.
NSWindowAbove
: childWindow is ordered immediately in front of the window.
NSWindowBelow
: childWindow is ordered immediately behind the window.
After the childWindow is added as a child of the window, it is maintained in relative position indicated by orderingMode for subsequent ordering operations involving either window. While this attachment is active, moving childWindow will not cause the window to move (as in sliding a drawer in or out), but moving the window will cause childWindow to move.
Note that you should not create cycles between parent and child windows. For example, you should not add window B as child of window A, then add window A as a child of window B.
NSWindow.h
Indicates whether the window can display tooltips even when the application is in the background.
- (BOOL)allowsToolTipsWhenApplicationIsInactive
YES
if the window can display tooltips even when the application is in the background; NO
otherwise.
The default is NO
.
NSWindow.h
Returns the window’s alpha value.
- (CGFloat)alphaValue
The window’s alpha value.
NSWindow.h
Specifies the duration of a smooth frame-size change.
- (NSTimeInterval)animationResizeTime:(NSRect)newWindowFrame
The frame rectangle specified in setFrame:display:animate:
.
The duration of the frame size change.
Subclasses can override this method to control the total time for the frame change.
The NSWindow
implementation uses the value from the NSWindowResizeTime
user default as the time in seconds to resize by 150 pixels. If this value is unspecified, NSWindowResizeTime
is 0.20 seconds (this default value may be differ in different releases of Mac OS X).
NSWindow.h
Indicates whether the window’s cursor rectangles are enabled.
- (BOOL)areCursorRectsEnabled
YES
when cursor rectangles are enabled, NO
otherwise.
NSWindow.h
Returns the window’s aspect ratio, which constrains the size of its frame rectangle to integral multiples of this ratio when the user resizes it.
- (NSSize)aspectRatio
The window’s aspect ratio.
The size of the window’s frame rectangle is constrained to integral multiples of this ratio when the user resizes it. You can set an NSWindow
object’s size to any ratio programmatically.
NSWindow.h
Returns the sheet attached to the window.
- (NSWindow *)attachedSheet
The sheet attached to the window; nil when the window doesn’t have a sheet attached.
NSWindow.h
Indicates whether the window calculates the thickness of a given border automatically.
- (BOOL)autorecalculatesContentBorderThicknessForEdge:(NSRectEdge)edge
Border whose thickness autorecalculation status to set:
NSMaxYEdge
: Top border.
NSMinYEdge
: Bottom border.
YES
when the window autorecalculates the given border’s thickness; NO
otherwise.
NSWindow.h
Indicates whether the window automatically recalculates the key view loop when views are added.
- (BOOL)autorecalculatesKeyViewLoop
YES
if the window automatically recalculates the key view loop when views are added; NO
otherwise.
NSWindow.h
Returns the color of the window’s background.
- (NSColor *)backgroundColor
The window’s background color.
NSWindow.h
Indicates the window’s backing store location.
- (NSWindowBackingLocation)backingLocation
The location of the window’s backing store. See “Constants” for possible values.
NSWindow.h
Returns the window’s backing store type.
- (NSBackingStoreType)backingType
The backing store type.
The possible return values are described in “Constants.”
NSWindow.h
Invoked automatically to inform the window that it has become the key window; never invoke this method directly.
- (void)becomeKeyWindow
This method reestablishes the window’s first responder, sends the becomeKeyWindow
message to that object if it responds, and posts an NSWindowDidBecomeKeyNotification
to the default notification center.
NSWindow.h
Invoked automatically to inform the window that it has become the main window; never invoke this method directly.
- (void)becomeMainWindow
This method posts an NSWindowDidBecomeMainNotification
to the default notification center.
NSWindow.h
Stores the window’s raster image from a given rectangle expressed in the window’s base coordinate system.
- (void)cacheImageInRect:(NSRect)rectangle
The rectangle representing the image to cache.
This method allows the window to perform temporary drawing, such as a band around the selection as the user drags the mouse, and to quickly restore the previous image by invoking restoreCachedImage
and flushWindowIfNeeded
. The next time the window displays, it discards its cached image rectangles. You can also explicitly use discardCachedImage
to free the memory occupied by cached image rectangles. aRect is made integral before caching the image to avoid antialiasing artifacts.
Only the last cached rectangle is remembered and can be restored.
NSWindow.h
Indicates whether the window can become the key window.
- (BOOL)canBecomeKeyWindow
YES
if the window can become the key window, NO
otherwise.
Attempts to make the window the key window are abandoned if this method returns NO
. The NSWindow
implementation returns YES
if the window has a title bar or a resize bar, NO
otherwise.
NSWindow.h
Indicates whether the window can become the application’s main window.
- (BOOL)canBecomeMainWindow
YES
when the window can become the main window; NO
otherwise.
Attempts to make the window the main window are abandoned if this method returns NO
. The NSWindow
implementation returns YES
if the window is visible, is not an NSPanel
object, and has a title bar or a resize mechanism. Otherwise it returns NO
.
NSWindow.h
Indicates whether the window can be displayed at the log-in window. Default: NO
.
- (BOOL)canBecomeVisibleWithoutLogin
YES
when the window can be displayed at the log-in window; NO
otherwise.
NSWindow.h
Indicates whether the window can be hidden when its application becomes hidden (during execution of the NSApplication
hide:
method).
- (BOOL)canHide
YES
if the window can be hidden when its application becomes hidden; NO
otherwise.
The default is YES
.
NSWindow.h
Indicates whether the window has a depth limit that allows it to store color values.
- (BOOL)canStoreColor
YES
when the window’s depth limit allows it to store color values; NO
otherwise.
– depthLimit
– shouldDrawColor
(NSView
)NSWindow.h
Positions the window's top left to a given point.
- (NSPoint)cascadeTopLeftFromPoint:(NSPoint)topLeft
The new top-left point, in screen coordinates, for the window. When NSZeroPoint
, the window is not moved, except as needed to constrain to the visible screen
The point shifted from top left of the window in screen coordinates.
The returned point can be passed to a subsequent invocation of cascadeTopLeftFromPoint:
to position the next window so the title bars of both windows are fully visible.
NSWindow.h
Sets the window’s location to the center of the screen.
- (void)center
The window is placed exactly in the center horizontally and somewhat above center vertically. Such a placement carries a certain visual immediacy and importance. This method doesn’t put the window onscreen, however; use makeKeyAndOrderFront:
to do that.
You typically use this method to place a window—most likely an alert dialog—where the user can’t miss it. This method is invoked automatically when a panel is placed on the screen by the runModalForWindow:
method of the NSApplication
class.
NSWindow.h
Returns an array of the window’s attached child windows.
- (NSArray *)childWindows
An array containing the window’s child windows.
NSWindow.h
Removes the window from the screen.
- (void)close
If the window is set to be released when closed, a release
message is sent to the object after the current event is completed. For an NSWindow
object, the default is to be released on closing, while for an NSPanel
object, the default is not to be released. You can use the setReleasedWhenClosed:
method to change the default behavior.
A window doesn’t have to be visible to receive the close message. For example, when the application terminates, it sends the close message to all windows in its window list, even those that are not currently visible.
The close method posts an NSWindowWillCloseNotification
notification to the default notification center.
The close method differs in two important ways from the performClose:
method:
It does not attempt to send a windowShouldClose:
message to the window or its delegate.
It does not simulate the user clicking the close button by momentarily highlighting the button.
Use performClose:
if you need these features.
NSWindow.h
Identifies the window’s behavior in window collections.
- (NSWindowCollectionBehavior)collectionBehavior;
The collection behavior identifier.
NSWindow.h
Modifies and returns a frame rectangle so that its top edge lies on a specific screen.
- (NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen *)screen
The proposed frame rectangle to adjust.
The screen on which the top edge of the window’s frame is to lie.
The adjusted frame rectangle.
If the window is resizable and the window’s height is greater than the screen height, the rectangle’s height is adjusted to fit within the screen as well. The rectangle’s width and horizontal location are unaffected. You shouldn’t need to invoke this method yourself; it’s invoked automatically (and the modified frame is used to locate and set the size of the window) whenever a titled NSWindow
object is placed onscreen and whenever its size is changed.
Subclasses can override this method to prevent their instances from being constrained or to constrain them differently.
NSWindow.h
Returns the window’s content aspect ratio.
- (NSSize)contentAspectRatio
The window’s content aspect ratio.
The default content aspect ratio is (0, 0)
.
NSWindow.h
Indicates the thickness of a given border of the window.
- (CGFloat)contentBorderThicknessForEdge:(NSRectEdge)edge
Border whose thickness to get:
NSMaxYEdge
: Top border.
NSMinYEdge
: Bottom border.
Thickness of the given border, in points.
NSWindow.h
Returns the maximum size of the window’s content view.
- (NSSize)contentMaxSize
The maximum size of the window’s content view.
NSWindow.h
Returns the minimum size of the window’s content view.
- (NSSize)contentMinSize
The minimum size of the window’s content view.
NSWindow.h
Returns the window’s content rectangle with a given frame rectangle.
- (NSRect)contentRectForFrameRect:(NSRect)windowFrame
The frame rectangle for the window expressed in screen coordinates.
The window’s content rectangle, expressed in screen coordinates, with windowFrame.
The window uses its current style mask in computing the content rectangle. See “Constants” for a list of style mask values. The main advantage of this instance-method counterpart to contentRectForFrameRect:styleMask:
is that it allows you to take toolbars into account when converting between content and frame rectangles. (The toolbar is not included in the content rectangle.)
NSWindow.h
Returns the window’s content-view resizing increments.
- (NSSize)contentResizeIncrements
The window’s content-view resizing increments.
NSWindow.h
Returns the window’s content view, the highest accessible NSView
object in the window’s view hierarchy.
- (id)contentView
The content view.
NSWindow.h
Converts a given point from the window’s base coordinate system to the screen coordinate system.
- (NSPoint)convertBaseToScreen:(NSPoint)point
The point expressed in the window’s base coordinate system.
point expressed in screen coordinates.
NSWindow.h
Converts a given point from the screen coordinate system to the window’s base coordinate system.
- (NSPoint)convertScreenToBase:(NSPoint)aPoint
The point expressed in screen coordinates.
point expressed in the window’s base coordinate system.
NSWindow.h
Returns the event currently being processed by the application, by invoking NSApplication
’s currentEvent
method.
- (NSEvent *)currentEvent
The event being processed by the application.
NSWindow.h
Returns EPS data that draws the region of the window within a given rectangle.
- (NSData *)dataWithEPSInsideRect:(NSRect)rect
A rectangle (expressed in the window’s coordinate system) that identifies the region to be expressed as EPS data.
The region in the window (identified by rect) as EPS data.
This data can be placed on a pasteboard, written to a file, or used to create an NSImage
object.
– dataWithEPSInsideRect:
(NSView
)– writeEPSInsideRect:toPasteboard:
(NSView
)NSWindow.h
Returns PDF data that draws the region of the window within a given rectangle.
- (NSData *)dataWithPDFInsideRect:(NSRect)rect
A rectangle (expressed in the window’s coordinate system) that identifies the region to be expressed as PDF data.
The region in the window (identified by rect) as PDF data.
This data can be placed on a pasteboard, written to a file, or used to create an NSImage
object.
– dataWithPDFInsideRect:
(NSView
)– writePDFInsideRect:toPasteboard:
(NSView
)NSWindow.h
Returns the deepest screen the window is on (it may be split over several screens).
- (NSScreen *)deepestScreen
The deepest screen the window is on; nil
when the window is offscreen.
– screen
+ deepestScreen
(NSScreen
)NSWindow.h
Returns the button cell that performs as if clicked when the window receives a Return (or Enter) key event.
- (NSButtonCell *)defaultButtonCell
The button cell.
This cell draws itself as the focal element for keyboard interface control, unless another button cell is focused on, in which case the default button cell temporarily draws itself as normal and disables its key equivalent.
The window receives a Return key event if no responder in its responder chain claims it, or if the user presses the Control key along with the Return key.
– setDefaultButtonCell:
– disableKeyEquivalentForDefaultButtonCell
– enableKeyEquivalentForDefaultButtonCell
NSWindow.h
Returns the window’s delegate.
- (id)delegate
The window’s delegate, or nil
if it doesn’t have a delegate.
NSWindow.h
Deminimizes the window.
- (void)deminiaturize:(id)sender
The message’s sender.
Invoke this method to programmatically deminimize a minimized window in the Dock.
NSWindow.h
Returns the depth limit of the window.
- (NSWindowDepth)depthLimit
Depth limit of the window.
The value returned can be examined with the Application Kit functions NSPlanarFromDepth
, NSColorSpaceFromDepth
, NSBitsPerSampleFromDepth
, and NSBitsPerPixelFromDepth
.
NSWindow.h
Returns a dictionary containing information about the window’s resolution.
- (NSDictionary *)deviceDescription
A dictionary containing resolution information about the window, such as color, depth, and so on.
This information is useful for tuning images and colors to the window’s display capabilities. The contents of the dictionary are described in “Display Device—Descriptions”
.
– deviceDescription
(NSScreen
)– bestRepresentationForDevice:
(NSImage
)– colorUsingColorSpaceName:
(NSColor
)NSWindow.h
Disables all cursor rectangle management within the window.
- (void)disableCursorRects
Use this method when you need to do some special cursor manipulation and you don’t want the Application Kit interfering.
NSWindow.h
Disables the flushWindow
method for the window.
- (void)disableFlushWindow
If the window is buffered, disabling flushWindow
prevents drawing from being automatically flushed by the NSView
display...
methods from the window’s backing store to the screen. This method permits several views to be drawn before the results are shown to the user.
Flushing should be disabled only temporarily, while the window’s display is being updated. Each disableFlushWindow
message must be paired with a subsequent enableFlushWindow
message. Invocations of these methods can be nested; flushing isn’t reenabled until the last (unnested) enableFlushWindow
message is sent.
NSWindow.h
Disables the default button cell’s key equivalent, so it doesn’t perform a click when the user presses Return (or Enter).
- (void)disableKeyEquivalentForDefaultButtonCell
NSWindow.h
Disables the window’s screen updates until the window is flushed.
- (void)disableScreenUpdatesUntilFlush
This method can be invoked to synchronize hardware surface flushes with the window’s flushes. The window immediately disables screen updates using the NSDisableScreenUpdates
function and reenables screen updates when the window flushes. Sending this message multiple times during a window update cycle has no effect.
NSWindow.h
Discards all of the window’s cached image rectangles.
- (void)discardCachedImage
An NSWindow
object automatically discards its cached image rectangles when it displays.
NSWindow.h
Invalidates all cursor rectangles in the window.
- (void)discardCursorRects
This method is invoked by resetCursorRects
to clear out existing cursor rectangles before resetting them. You shouldn’t invoke it in the code you write, but you might want to override it to change its behavior.
NSWindow.h
Forwards the message to the NSApplication
object, NSApp
.
- (void)discardEventsMatchingMask:(NSUInteger)eventMask beforeEvent:(NSEvent *)lastEvent
The mask of the events to discard.
The event up to which queued events are discarded from the queue.
– discardEventsMatchingMask:beforeEvent:
(NSApplication
)NSWindow.h
Passes a display message down the window’s view hierarchy, thus redrawing all views within the window, including the frame view that draws the border, title bar, and other peripheral elements.
- (void)display
You rarely need to invoke this method. NSWindow
objects normally record which of their views need display and display them automatically on each pass through the event loop.
– display
(NSView
)– displayIfNeeded
– isAutodisplay
NSWindow.h
Passes a displayIfNeeded
message down the window’s view hierarchy, thus redrawing all views that need to be displayed, including the frame view that draws the border, title bar, and other peripheral elements.
- (void)displayIfNeeded
This method is useful when you want to modify some number of views and then display only the ones that were modified.
You rarely need to invoke this method. NSWindow
objects normally record which of their views need display and display them automatically on each pass through the event loop.
– display
– displayIfNeeded
(NSView
)– setNeedsDisplay:
(NSView
)– isAutodisplay
NSWindow.h
Indicates whether the window context should be updated when the screen profile changes or when the window moves to a different screen.
- (BOOL)displaysWhenScreenProfileChanges
YES
when the window context should be updated when the screen profile changes or when the window moves to a different screen; NO
otherwise.
The default value is NO
.
NSWindow.h
Provides the application’s Dock tile.
- (NSDockTile *)dockTile
The application’s Dock tile.
NSWindow.h
Begins a dragging session.
- (void)dragImage:(NSImage *)image at:(NSPoint)imageLocation offset:(NSSize)pointerOffset event:(NSEvent *)event pasteboard:(NSPasteboard *)pasteboard source:(id)sourceObject slideBack:(BOOL)slideBack
The object to be dragged.
Location of the image’s bottom-left corner in the window’s coordinate system. It determines the placement of the dragged image under the pointer.
The pointer’s location relative to the mouse-down location. Not used in Mac OS X v10.4 and later.
The left-mouse down event that triggered the dragging operation.
The pasteboard that holds the data to be transfered to the destination.
The object serving as the controller of the dragging operation. It must conform to the NSDraggingSource
informal protocol.
Specifies whether the drag image should slide back to imageLocation if it's rejected by the drag destination. Pass YES
to specify slideback behavior, NO
to specify otherwise.
This method should be invoked only from within a view’s implementation of the mouseDown:
or mouseDragged:
methods (which overrides the version defined in NSResponder
class). Essentially the same as the NSView
method of the same name, except that imageLocation is given in the NSWindow
object’s base coordinate system.
NSWindow.h
Returns the collection of drawers associated with the window.
- (NSArray *)drawers
The collection of drawers associated with the window.
NSDrawer.h
Reenables cursor rectangle management within the window after a disableCursorRects
message.
- (void)enableCursorRects
NSWindow.h
Reenables the flushWindow
method for the window after it was disabled through a previous disableFlushWindow
message.
- (void)enableFlushWindow
NSWindow.h
Reenables the default button cell’s key equivalent, so it performs a click when the user presses Return (or Enter).
- (void)enableKeyEquivalentForDefaultButtonCell
NSWindow.h
Forces the field editor to give up its first responder status and prepares it for its next assignment.
- (void)endEditingFor:(id)object
The object that is using the window’s field editor.
If the field editor is the first responder, it’s made to resign that status even if its resignFirstResponder
method returns NO
. This registration forces the field editor to send a textDidEndEditing:
message to its delegate. The field editor is then removed from the view hierarchy, its delegate is set to nil
, and it’s emptied of any text it may contain.
This method is typically invoked by the object using the field editor when it’s finished. Other objects normally change the first responder by simply using makeFirstResponder:
, which allows a field editor or other object to retain its first responder status if, for example, the user has entered an invalid value. The endEditingFor:
method should be used only as a last resort if the field editor refuses to resign first responder status. Even in this case, you should always allow the field editor a chance to validate its text and take whatever other action it needs first. You can do this by first trying to make the NSWindow
object the first responder:
if ([myWindow makeFirstResponder:myWindow]) { |
/* All fields are now valid; it’s safe to use fieldEditor:forObject: |
to claim the field editor. */ |
} |
else { |
/* Force first responder to resign. */ |
[myWindow endEditingFor:nil]; |
} |
NSWindow.h
Returns the window’s field editor, creating it if requested.
- (NSText *)fieldEditor:(BOOL)createWhenNeeded forObject:(id)anObject
If YES
, creates a field editor if one doesn’t exist; if NO
, does not create a field editor.
A freshly created NSWindow
object doesn’t have a field editor. After a field editor has been created for a window, the createWhenNeeded argument is ignored. By passing NO
for createWhenNeeded and testing the return value, however, you can predicate an action on the existence of the field editor.
A text-displaying object for which the delegate (in windowWillReturnFieldEditor:toObject:
) assigns a custom field editor. Pass nil
to get the default field editor, which can be the NSWindow
field editor or a custom field editor returned by the delegate.
Returns the field editor for the designated object (anObject) or, if anObject is nil
, the default field editor. Returns nil
if createFlag is NO
and if the field editor doesn’t exist.
The field editor is a single NSTextView
object that is shared among all the controls in a window for light text-editing needs. It is automatically instantiated when needed, and it can be used however your application sees fit. Typically, the field editor is used by simple text-bearing objects—for example, an NSTextField
object uses its window’s field editor to display and manipulate text. The field editor can be shared by any number of objects, and so its state may be constantly changing. Therefore, it shouldn’t be used to display text that demands sophisticated layout (for this you should create a dedicated NSTextView
object).
The field editor may be in use by some view object, so be sure to properly dissociate it from that object before actually using it yourself (the appropriate way to do this is illustrated in the description of endEditingFor:
). Once you retrieve the field editor, you can insert it in the view hierarchy, set a delegate to interpret text events, and have it perform whatever editing is needed. Then, when it sends a textDidEndEditing:
message to the delegate, you can get its text to display or store and remove the field editor using endEditingFor:
.
The window’s delegate can substitute a custom field editor in place of the window’s field editor by implementing windowWillReturnFieldEditor:toObject:
. The custom field editor can become the default editor (common to all text-displaying objects) or specific to a particular text-displaying object (anObject). The window sends this message to its delegate with itself and anObject as the arguments; if the delegate returns a non-nil
value, the window returns that object instead of its field editor in fieldEditor:forObject:
. However, note the following:
If the window’s delegate is identical to anObject, windowWillReturnFieldEditor:toObject:
isn’t sent to the delegate.
The object returned by the delegate method, though it may become first responder, does not become the window's default field editor. Other objects continue to use the window's default field editor.
NSWindow.h
Returns the window’s first responder.
- (NSResponder *)firstResponder
The first responder.
The first responder is usually the first object in a responder chain to receive an event or action message. In most cases, the first responder is a view object in that the user selects or activates with the mouse or keyboard.
You can use the firstResponder
method in custom subclasses of responder classes (NSWindow
, NSApplication
, NSView
, and subclasses) to determine if an instance of the subclass is currently the first responder. You can also use it to help locate a text field that currently has first-responder status. For more on this subject, see “Event Handling Basics.“
– makeFirstResponder:
– acceptsFirstResponder
(NSResponder
)NSWindow.h
Flushes the window’s offscreen buffer to the screen if the window is buffered and flushing is enabled.
- (void)flushWindow
Does nothing for other display devices, such as a printer. This method is automatically invoked by the NSWindow
display
and displayIfNeeded
methods and the corresponding NSView
display
and displayIfNeeded
methods.
NSWindow.h
Flushes the window’s offscreen buffer to the screen if flushing is enabled and if the last flushWindow
message had no effect because flushing was disabled.
- (void)flushWindowIfNeeded
To avoid unnecessary flushing, use this method rather than flushWindow
to flush an NSWindow
object after flushing has been reenabled.
NSWindow.h
Returns the window’s frame rectangle.
- (NSRect)frame
The frame rectangle of the window in screen coordinates.
NSWindow.h
Returns the name used to automatically save the window’s frame rectangle data in the defaults system, as set through setFrameAutosaveName:
.
- (NSString *)frameAutosaveName
The name used to save the window’s frame rectangle automatically in the defaults system.
NSWindow.h
Returns the window’s frame rectangle with a given content rectangle.
- (NSRect)frameRectForContentRect:(NSRect)windowContent
The content rectangle for the window expressed in screen coordinates.
The window’s frame rectangle, expressed in screen coordinates, with windowContent.
The window uses its current style mask in computing the frame rectangle. See “Constants” for a list of style mask values. The major advantage of this instance-method counterpart to frameRectForContentRect:styleMask:
is that it allows you to take toolbars into account when converting between content and frame rectangles. (The toolbar is included in the frame rectangle but not the content rectangle.)
NSWindow.h
Provides the graphics context associated with the window for the current thread.
- (NSGraphicsContext *)graphicsContext
The graphics context associated with the window for the current thread.
NSWindow.h
Returns the window’s graphics state object.
- (NSInteger)gState
The graphics state object associated with the window.
This graphics state is used by default for all NSView
objects in the window’s view hierarchy, but individual views can be made to use their own with the NSView
method allocateGState
.
NSWindow.h
Indicates whether the window’s depth limit can change to match the depth of the screen it’s on.
- (BOOL)hasDynamicDepthLimit
YES
when the window has a dynamic depth limit; NO
otherwise.
NSWindow.h
Indicates whether the window has a shadow.
- (BOOL)hasShadow
YES
when the window has a shadow; NO
otherwise.
NSWindow.h
Indicates whether the window is removed from the screen when its application becomes inactive.
- (BOOL)hidesOnDeactivate
YES
if the window is removed from the screen when its application is deactivated; NO
if it remains onscreen.
The default for NSWindow
is NO
; the default for NSPanel
is YES
.
NSWindow.h
Indicates whether the window is transparent to mouse events.
- (BOOL)ignoresMouseEvents
YES
when the window is transparent to mouse events; NO
otherwise.
NSWindow.h
Returns view that’s made first responder the first time the window is placed onscreen.
- (NSView *)initialFirstResponder
The view that’s made first responder the first time the window is placed onscreen.
NSWindow.h
Initializes the window with the specified values.
- (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)windowStyle backing:(NSBackingStoreType)bufferingType defer:(BOOL)deferCreation
Location and size of the window’s content area in screen coordinates. Note that the window server limits window position coordinates to ±16,000 and sizes to 10,000.
The window’s style. Either it can be NSBorderlessWindowMask
, or it can contain any of the options described in “Constants,” combined using the C bitwise OR operator. Borderless windows display none of the usual peripheral elements and are generally useful only for display or caching purposes; you should normally not need to create them. Also, note that a window’s style mask should include NSTitledWindowMask
if it includes any of the others.
Specifies how the drawing done in the window is buffered by the window device, and possible values are described in “Constants.”
Specifies whether the window server creates a window device for the window immediately. When YES
, the window server defers creating the window device until the window is moved onscreen. All display messages sent to the window or its views are postponed until the window is created, just before it’s moved onscreen.
The initialized window.
This method is the designated initializer for the NSWindow
class.
Deferring the creation of the window improves launch time and minimizes the virtual memory load on the window server.
The new window creates a view to be its default content view. You can replace it with your own object by using the setContentView:
method.
NSWindow.h
Initializes an allocated window with the specified values.
- (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)windowStyle backing:(NSBackingStoreType)bufferingType defer:(BOOL)deferCreation screen:(NSScreen *)screen
Location and size of the window’s content area in screen coordinates. Note that the window server limits window position coordinates to ±16,000 and sizes to 10,000.
The window’s style. It can be either NSBorderlessWindowMask
, or it can contain any of the options described in “Constants,” combined using the C bitwise OR operator. Borderless windows display none of the usual peripheral elements and are generally useful only for display or caching purposes; you should normally not need to create them. Also, note that a window’s style mask should include NSTitledWindowMask
if it includes any of the others.
Specifies how the drawing done in the window is buffered by the window device; possible values are described in “Constants.”
Specifies whether the window server creates a window device for the window immediately. When YES
, the window server defers creating the window device until the window is moved onscreen. All display messages sent to the window or its views are postponed until the window is created, just before it’s moved onscreen.
Specifies where the window’s content rectangle is drawn if the window is to be drawn in a screen other than the main screen. The content rectangle is drawn relative to the bottom-left corner of screen
. When nil
, the content rectangle is drawn on the main screen.
The initialized window.
The main screen is the one that contains the current key window or, if there is no key window, the one that contains the main menu. If there’s neither a key window nor a main menu (if there’s no active application), the main screen is the one where the origin of the screen coordinate system is located.
NSWindow.h
Returns a Cocoa window created from a Carbon window.
- (NSWindow *)initWithWindowRef:(void *)carbonWindowRef
The Carbon WindowRef
object to use to create the Cocoa window.
A Cocoa window created from carbonWindowRef.
For more information on Carbon-Cocoa integration, see Using a Carbon User Interface in a Cocoa Application in Carbon-Cocoa Integration Guide.
For historical reasons, contrary to normal memory management policy initWithWindowRef:
does not retain windowRef. It is therefore recommended that you make sure you retain windowRef before calling this method. If windowRef is still valid when the Cocoa window is deallocated, the Cocoa window will release it.
NSWindow.h
Marks as invalid the cursor rectangles of a given NSView
object in the window’s view hierarchy, so they’ll be set up again when the window becomes key (or immediately if the window is key).
- (void)invalidateCursorRectsForView:(NSView *)view
The view in the window’s view hierarchy.
– resetCursorRects
– resetCursorRects
(NSView
)NSWindow.h
Invalidates the window shadow so that it is recomputed based on the current window shape.
- (void)invalidateShadow
NSWindow.h
Indicates whether the window automatically displays views that need to be displayed.
- (BOOL)isAutodisplay
YES
when the window automatically displays views that need to be displayed; NO
otherwise.
Automatic display typically occurs on each pass through the event loop.
NSWindow.h
Indicates whether the window’s document has been edited.
- (BOOL)isDocumentEdited
YES
when the window’s document has been edited; NO
otherwise.
Initially, by default, NSWindow
objects are in the “not edited” state.
NSWindow.h
Indicates whether the window is excluded from the application’s Windows menu.
- (BOOL)isExcludedFromWindowsMenu
YES
when the window is excluded from the Windows menu; NO
otherwise.
The default initial setting is NO
.
NSWindow.h
Indicates whether the window’s flushing ability is disabled.
- (BOOL)isFlushWindowDisabled
YES
when the window’s flushing ability has been disabled; NO
otherwise.
NSWindow.h
Indicates whether the window is the key window for the application.
- (BOOL)isKeyWindow
YES
if the window is the key window for the application; NO
otherwise.
NSWindow.h
Indicates whether the window is the application’s main window.
- (BOOL)isMainWindow
YES
when the window is the main window for the application, NO
otherwise.
NSWindow.h
Indicates whether the window is minimized.
- (BOOL)isMiniaturized
YES
if the window is minimized, otherwise NO
.
A minimized window is removed from the screen and replaced by a image, icon, or button that represents it, called the counterpart.
NSWindow.h
Indicates whether the window is movable by clicking and dragging anywhere in its background.
- (BOOL)isMovableByWindowBackground
YES
when the window is movable by clicking and dragging anywhere in its background; NO
otherwise.
A window with a style mask of NSTexturedBackgroundWindowMask
is movable by background by default. Sheets and drawers cannot be movable by window background.
NSWindow.h
Indicates whether the window device the window manages is freed when it’s removed from the screen list.
- (BOOL)isOneShot
YES
when the window’s window device is freed when it’s removed from the screen list; NO
otherwise.
The default is NO
.
NSWindow.h
Indicates whether the window is opaque.
- (BOOL)isOpaque
YES
when the window is opaque; NO
otherwise.
The default is YES
.
NSWindow.h
Indicates whether the window is released when it receives the close
message.
- (BOOL)isReleasedWhenClosed
YES
if the window is automatically released after being closed; NO
if it’s simply removed from the screen.
The default for NSWindow
is YES
; the default for NSPanel
is NO
. Release when closed, however, is ignored for windows owned by window controllers.
NSWindow.h
Indicates whether the window has ever run as a modal sheet.
- (BOOL)isSheet
YES
if the window has ever run as a modal sheet, otherwise NO
.
Sheets are created using the NSPanel
subclass.
NSWindow.h
Indicates whether the window is visible onscreen (even when It’s obscured by other windows).
- (BOOL)isVisible
YES
when the window is onscreen (even if it’s obscured by other windows); NO
otherwise.
– visibleRect
(NSView
)NSWindow.h
Returns a Boolean value that indicates whether the window is in a zoomed state.
- (BOOL)isZoomed
YES
if the window is in a zoomed state, otherwise NO
.
The zoomed state of the window is determined using the following steps:
If the delegate or the window class implements windowWillUseStandardFrame:defaultFrame:, it is invoked to obtain the zoomed frame of the window. The result of isZoomed
is then determined by whether or not the current window frame is equal to the zoomed frame.
If the neither the delegate nor the window class implements windowWillUseStandardFrame:defaultFrame:, a default frame that nearly fits the screen is chosen. If the delegate or window class implements windowWillResize:toSize:, it is invoked to validate the proposed zoomed frame. Once the zoomed frame is validated, the result of isZoomed
is determined by whether or not the current window frame is equal to the zoomed frame.
NSWindow.h
Handles a given keyboard event that may need to be interpreted as changing the key view or triggering a keyboard equivalent.
- (void)keyDown:(NSEvent *)event
The keyboard event to process.
– selectNextKeyView:
– nextKeyView
(NSView
)– performMnemonic:
(NSView
)NSWindow.h
Returns the direction the window is currently using to change the key view.
- (NSSelectionDirection)keyViewSelectionDirection
The direction the window is using to change the key view.
This direction can be one of the values described in “Constants.”
NSWindow.h
Returns the window level of the window.
- (NSInteger)level
The window level.
See “Constants” for a list of possible values.
NSWindow.h
Attempts to make a given responder the first responder for the window.
- (BOOL)makeFirstResponder:(NSResponder *)responder
The responder to set as the window’s first responder. nil
makes the window its first responder.
YES
when the operation is successful; NO
otherwise.
If responder isn’t already the first responder, this method first sends a resignFirstResponder
message to the object that is the first responder. If that object refuses to resign, it remains the first responder, and this method immediately returns NO
. If the current first responder resigns, this method sends a becomeFirstResponder
message to responder. If responder does not accept first responder status, the NSWindow
object becomes first responder; in this case, the method returns YES
even if responder refuses first responder status.
If responder is nil
, this method still sends resignFirstResponder
to the current first responder. If the current first responder refuses to resign, it remains the first responder and this method immediately returns NO
. If the current first responder returns YES
from resignFirstResponder
, the window is made its own first responder and this method returns YES
.
The Application Kit framework uses this method to alter the first responder in response to mouse-down events; you can also use it to explicitly set the first responder from within your program. The responder object is typically an NSView
object in the window’s view hierarchy. If this method is called explicitly, first send acceptsFirstResponder
to responder, and do not call makeFirstResponder:
if acceptsFirstResponder
returns NO
.
Use setInitialFirstResponder:
to the set the first responder to be used when the window is brought onscreen for the first time.
– becomeFirstResponder
(NSResponder
)– resignFirstResponder
(NSResponder
)NSWindow.h
Moves the window to the front of the screen list, within its level, and makes it the key window; that is, it shows the window.
- (void)makeKeyAndOrderFront:(id)sender
The message’s sender.
NSWindow.h
Makes the window the key window.
- (void)makeKeyWindow
NSWindow.h
Makes the window the main window.
- (void)makeMainWindow
NSWindow.h
Returns the maximum size to which the window’s frame (including its title bar) can be sized.
- (NSSize)maxSize
The maximum size to which the window’s frame (including its title bar) can be sized either by the user or by the setFrame...
methods other than setFrame:display:
.
NSWindow.h
Removes the window from the screen list and displays the minimized window in the Dock.
- (void)miniaturize:(id)sender
The message’s sender.
NSWindow.h
Returns the custom miniaturized window image of the window.
- (NSImage *)miniwindowImage
The custom miniaturized window image.
The miniaturized window image is the image displayed in the Dock when the window is minimized. If you did not assign a custom image to the window, this method returns nil
.
NSWindow.h
Returns the title displayed in the window’s minimized window.
- (NSString *)miniwindowTitle
The title displayed in the window’s minimized window.
NSWindow.h
Returns the minimum size to which the window’s frame (including its title bar) can be sized.
- (NSSize)minSize
The minimum size to which the window’s frame (including its title bar) can be sized either by the user or by the setFrame...
methods other than setFrame:display:
.
NSWindow.h
Returns the current location of the pointer reckoned in the window’s base coordinate system.
- (NSPoint)mouseLocationOutsideOfEventStream
The current location of the pointer reckoned in the window’s base coordinate system, regardless of the current event being handled or of any events pending.
For the same information in screen coordinates, use NSEvent
's mouseLocation
.
– currentEvent
(NSApplication
)NSWindow.h
Returns the next event matching a given mask.
- (NSEvent *)nextEventMatchingMask:(NSUInteger)eventMask
The mask that the event to return must match. Events with nonmatching masks are removed from the queue. See discardEventsMatchingMask:beforeEvent:
in NSApplication
for the list of mask values.
The next event whose mask matches eventMask; nil
when no matching event was found.
This method sends the message nextEventMatchingMask:eventMask untilDate:[NSDate distantFuture] inMode:NSEventTrackingRunLoopMode dequeue:YES
to the application (NSApp
).
– nextEventMatchingMask:untilDate:inMode:dequeue:
(NSApplication
)NSWindow.h
Forwards the message to the global NSApplication
object, NSApp
.
- (NSEvent *)nextEventMatchingMask:(NSUInteger)eventMask untilDate:(NSDate *)expirationDate inMode:(NSString *)runLoopMode dequeue:(BOOL)dequeue
The mask that the event to return must match.
The date until which to wait for events.
The run loop mode to use while waiting for events
YES
to remove the returned event from the event queue; NO
to leave the returned event in the queue.
The next event whose mask matches eventMask; nil
when no matching event was found.
– nextEventMatchingMask:untilDate:inMode:dequeue:
(NSApplication
)NSWindow.h
Moves the window to the back of its level in the screen list, without changing either the key window or the main window.
- (void)orderBack:(id)sender
Message originator.
NSWindow.h
Moves the window to the front of its level in the screen list, without changing either the key window or the main window.
- (void)orderFront:(id)sender
The message’s sender.
NSWindow.h
Moves the window to the front of its level, even if its application isn’t active, without changing either the key window or the main window.
- (void)orderFrontRegardless
The message’s sender.
Normally an NSWindow
object can’t be moved in front of the key window unless it and the key window are in the same application. You should rarely need to invoke this method; it’s designed to be used when applications are cooperating in such a way that an active application (with the key window) is using another application to display data.
NSWindow.h
Removes the window from the screen list, which hides the window.
- (void)orderOut:(id)sender
The message’s sender.
If the window is the key or main window, the NSWindow
object immediately behind it is made key or main in its place. Calling the orderOut:
method causes the window to be removed from the screen, but does not cause it to be released. See the close
method for information on when a window is released.
NSWindow.h
Repositions the window’s window device in the window server’s screen list.
- (void)orderWindow:(NSWindowOrderingMode)orderingMode relativeTo:(NSInteger)otherWindowNumber
NSWindowOut
: The window is removed from the screen list and otherWindowNumber is ignored.
NSWindowAbove
: The window is ordered immediately in front of the window whose window number is otherWindowNumber
NSWindowBelow
: The window is placed immediately behind the window represented by otherWindowNumber.
The number of the window the window is to be placed in front of or behind. Pass 0
to place the window in front of (when orderingMode is NSWindowAbove
) or behind (when orderingMode is NSWindowBelow
) all other windows in its level.
NSWindow.h
Returns the parent window to which the window is attached as a child.
- (NSWindow *)parentWindow
The window to which the window is attached as a child.
NSWindow.h
This action method simulates the user clicking the close button by momentarily highlighting the button and then closing the window.
- (void)performClose:(id)sender
The message’s sender.
If the window’s delegate or the window itself implements windowShouldClose:
, that message is sent with the window as the argument. (Only one such message is sent; if both the delegate and the NSWindow
object implement the method, only the delegate receives the message.) If the windowShouldClose:
method returns NO
, the window isn’t closed. If it returns YES
, or if it isn’t implemented, performClose:
invokes the close
method to close the window.
If the window doesn’t have a close button or can’t be closed (for example, if the delegate replies NO
to a windowShouldClose:
message), the system emits the alert sound.
NSWindow.h
Simulates the user clicking the minimize button by momentarily highlighting the button, then minimizing the window.
- (void)performMiniaturize:(id)sender
The message’s sender.
If the window doesn’t have a minimize button or can’t be minimized for some reason, the system emits the alert sound.
NSWindow.h
This action method simulates the user clicking the zoom box by momentarily highlighting the button and then zooming the window.
- (void)performZoom:(id)sender
The object sending the message.
If the window doesn’t have a zoom box or can’t be zoomed for some reason, the computer beeps.
NSWindow.h
Forwards the message to the global NSApplication
object, NSApp
.
- (void)postEvent:(NSEvent *)event atStart:(BOOL)atStart
The event to add to the window’s event queue.
YES
to place the event in the front of the queue; NO
to place it in the back.
NSWindow.h
Indicates the preferred location for the window’s backing store.
- (NSWindowBackingLocation)preferredBackingLocation
The preferred location for the window’s backing store. See “Constants” for possible values.
NSWindow.h
Returns a Boolean value that indicates whether the window tries to optimize live resize operations by preserving the content of views that have not changed.
- (BOOL)preservesContentDuringLiveResize
YES
if the window tries to optimize live resize operations by preserving the content of views that have not moved; NO
otherwise.
When live-resize optimization is active, the window redraws only those views that moved (or do not support this optimization) during a live resize operation.
See preservesContentDuringLiveResize
in NSView
for additional information on how to support this optimization.
NSWindow.h
This action method runs the Print panel, and if the user chooses an option other than canceling, prints the window (its frame view and all subviews).
- (void)print:(id)sender
The message’s sender.
NSWindow.h
Marks the key view loop as dirty and in need of recalculation.
- (void)recalculateKeyViewLoop
The key view loop is actually recalculated the next time someone requests the next or previous key view of the window. The recalculated loop is based on the geometric order of the views in the window.
If you do not want to maintain the key view loop of your window manually, you can use this method to do it for you. When it is first loaded, NSWindow
calls this method automatically if your window does not have a key view loop already established. If you add or remove views later, you can call this method manually to update the window’s key view loop. You can also call setAutorecalculatesKeyViewLoop:
to have the window recalculate the loop automatically.
NSWindow.h
Registers a give set of pasteboard types as the pasteboard types the window will accept as the destination of an image-dragging session.
- (void)registerForDraggedTypes:(NSArray *)pasteboardTypes
An array of the pasteboard types the window will accept as the destination of an image-dragging session.
Registering an NSWindow
object for dragged types automatically makes it a candidate destination object for a dragging session. NSWindow
has a default implementation for many of the methods in the NSDraggingDestination
informal protocol. The default implementation forwards each message to the delegate if the delegate responds to the selector of the message. The messages forwarded this way are draggingEntered:
, draggingUpdated:
, draggingExited:
, prepareForDragOperation:
, performDragOperation:
, and concludeDragOperation:
.
NSWindow.h
Detaches a given child window from the window.
- (void)removeChildWindow:(NSWindow *)childWindow
The child window to detach.
NSWindow.h
Returns the pathname of the file the window represents.
- (NSString *)representedFilename
The path to the file of the window’s represented file.
NSWindow.h
Provides the URL of the file the window represents.
- (NSURL *)representedURL
The URL for the file the window represents.
When the URL specifies a path, the window shows an icon in its title bar, as described in Table 1.
Filepath | Document icon |
---|---|
Empty | None. |
Specifies a nonexistent file | Generic. |
Specifies an existent file | Specific for the file’s type. |
You can customize the file icon in the tile bar with the following code:
[[<window> standardWindowButton:NSWindowDocumentIconButton] setImage:<image>] |
When the URL identifies an existing file, the window’s title offers a pop-up menu showing the path components of the URL. (The user displays this menu by Command-clicking the title.) The behavior and contents of this menu can be controlled with window:shouldPopUpDocumentPathMenu:
.
NSWindow.h
Clears the window’s cursor rectangles and the cursor rectangles of the NSView
objects in its view hierarchy.
- (void)resetCursorRects
Invokes discardCursorRects
to clear the window’s cursor rectangles, then sends resetCursorRects
to every NSView
object in the window’s view hierarchy.
This method is typically invoked by the NSApplication object when it detects that the key window’s cursor rectangles are invalid. In program code, it’s more efficient to invoke invalidateCursorRectsForView:
.
NSWindow.h
Invoked automatically when the window resigns key window status; never invoke this method directly.
- (void)resignKeyWindow
This method sends resignKeyWindow
to the window’s first responder, sends windowDidResignKey:
to the window’s delegate, and posts an NSWindowDidResignKeyNotification
to the default notification center.
NSWindow.h
Invoked automatically when the window resigns main window status; never invoke this method directly.
- (void)resignMainWindow
This method sends windowDidResignMain:
to the window’s delegate and posts an NSWindowDidResignMainNotification
to the default notification center.
NSWindow.h
Returns the flags field of the event record for the mouse-down event that initiated the resizing session.
- (NSInteger)resizeFlags
A mask indicating which of the modifier keys was held down when the mouse-down event occurred. The flags are listed in NSEvent
object’s modifierFlags
method description.
This method is valid only while the window is being resized
You can use this method to constrain the direction or amount of resizing. Because of its limited validity, this method should only be invoked from within an implementation of the delegate method windowWillResize:toSize:
.
NSWindow.h
Returns the window’s resizing increments.
- (NSSize)resizeIncrements
The window’s resizing increments.
NSWindow.h
Splices the window’s cached image rectangles, if any, back into its raster image (and buffer if it has one), undoing the effect of any drawing performed within those areas since they were established using cacheImageInRect:
.
- (void)restoreCachedImage
You must invoke flushWindow
after this method to guarantee proper redisplay. An NSWindow
object automatically discards its cached image rectangles when it displays.
NSWindow.h
The action method for the “Customize Toolbar…” menu item.
- (void)runToolbarCustomizationPalette:(id)sender
The message’s sender.
See the NSToolbar
class description for additional information.
NSWindow.h
Saves the window’s frame rectangle in the user defaults system under a given name.
- (void)saveFrameUsingName:(NSString *)frameName
The name under which the frame is to be saved.
With the companion method setFrameUsingName:
, you can save and reset an NSWindow
object’s frame over various launches of an application. The default is owned by the application and stored under the name "NSWindow Frame
frameName"
. See NSUserDefaults
for more information.
NSWindow.h
Returns the screen the window is on.
- (NSScreen *)screen
The screen where most of the window is on; nil
when the window is offscreen.
When the window is partly on one screen and partly on another, the screen where most of it lies is returned.
NSWindow.h
Makes key the view that follows the given view.
- (void)selectKeyViewFollowingView:(NSView *)referenceView
The view whose following view in the key view loop is sought.
Sends the nextValidKeyView
message to referenceView and, if that message returns an NSView
object, invokes makeFirstResponder:
with the returned object.
NSWindow.h
Makes key the view that precedes the given view.
- (void)selectKeyViewPrecedingView:(NSView *)referenceView
The view whose preceding view in the key view loop is sought.
Sends the previousValidKeyView
message to referenceView and, if that message returns an NSView
object, invokes makeFirstResponder:
with the returned object.
NSWindow.h
This action method searches for a candidate next key view and, if it finds one, invokes makeFirstResponder:
to establish it as the first responder.
- (void)selectNextKeyView:(id)sender
The message’s sender.
The candidate is one of the following (searched for in this order):
The current first responder’s next valid key view, as returned by the nextValidKeyView
method of NSView
The object designated as the window’s initial first responder (using setInitialFirstResponder:
) if it returns YES
to an acceptsFirstResponder
message
Otherwise, the initial first responder’s next valid key view, which may end up being nil
NSWindow.h
This action method searches for a candidate previous key view and, if it finds one, invokes makeFirstResponder:
to establish it as the first responder.
- (void)selectPreviousKeyView:(id)sender
The message’s sender.
The candidate is one of the following (searched for in this order):
The current first responder’s previous valid key view, as returned by the previousValidKeyView
method of NSView
The object designated as the window’s initial first responder (using setInitialFirstResponder:
) if it returns YES
to an acceptsFirstResponder
message
Otherwise, the initial first responder’s previous valid key view, which may end up being nil
NSWindow.h
This action method dispatches mouse and keyboard events sent to the window by the NSApplication
object.
- (void)sendEvent:(NSEvent *)event
The mouse or keyboard event to process.
Never invoke this method directly. A right mouse-down event in a window of an inactive application is not delivered to the corresponding NSWindow
object. It is instead delivered to the NSApplication
object through a sendEvent:
message with a window number of 0.
NSWindow.h
Specifies whether the window is to accept mouse-moved events.
- (void)setAcceptsMouseMovedEvents:(BOOL)acceptMouseMovedEvents
YES
to have the window accept mouse-moved events (and to distribute them to its responders); NO
to not accept such events.
NSWindow.h
Specifies whether the window can display tooltips even when the application is in the background.
- (void)setAllowsToolTipsWhenApplicationIsInactive:(BOOL)allowTooltipsWhenAppInactive
YES
to have the window display tooltips even when its application is inactive; NO
to suppress tooltip display when inactive.
The message does not take effect until the window changes to an active state.
Note: Enabling tooltips in an inactive application will cause the application to do work any time the pointer passes over the window, thus degrading system performance.
NSWindow.h
Applies a given alpha value to the entire window.
- (void)setAlphaValue:(CGFloat)windowAlpha
The alpha value to apply.
NSWindow.h
Sets the window’s aspect ratio, which constrains the size of its frame rectangle to integral multiples of this ratio when the user resizes it.
- (void)setAspectRatio:(NSSize)aspectRatio
The aspect ratio to be maintained during resizing actions.
An NSWindow
object’s aspect ratio and its resize increments are mutually exclusive attributes. In fact, setting one attribute cancels the setting of the other. For example, to cancel an established aspect ratio setting for an NSWindow
object, you send it a setResizeIncrements:
message with the width and height set to 1.0
:
[myWindow setResizeIncrements:NSMakeSize(1.0,1.0)]; |
The setContentAspectRatio:
method takes precedence over this method.
NSWindow.h
Specifies whether the window is to automatically display the views that are marked as needing it.
- (void)setAutodisplay:(BOOL)autodisplay
YES
to have the window automatically display views that need to be displayed; NO
to specify otherwise.
If autodisplay is NO
, the window or its views must be explicitly displayed.
NSWindow.h
Specifies whether the window calculates the thickness of a given border automatically.
- (void)setAutorecalculatesContentBorderThickness:(BOOL)autorecalculateContentBorderThickness forEdge:(NSRectEdge)edge
YES
to have the window calculate the thickness of edge automatically; NO
otherwise.
Border whose thickness autorecalculation status to set:
NSMaxYEdge
: Top border.
NSMinYEdge
: Bottom border.
Turning off a border’s autorecalculation status sets its border thickness to 0.0
.
NSWindow.h
Specifies whether to recalculate the key view loop automatically when views are added or removed.
- (void)setAutorecalculatesKeyViewLoop:(BOOL)autorecalculateKeyViewLoop
YES
to recalculate the key view loop automatically; NO
otherwise.
If autorecalculateKeyViewLoop is NO
, the client code must update the key view loop manually or call recalculateKeyViewLoop
to have the window recalculate it.
NSWindow.h
Sets the window’s background color to the given color.
- (void)setBackgroundColor:(NSColor *)color
Color to set as the window’s background color.
NSWindow.h
Sets the window’s backing store type to a given type.
- (void)setBackingType:(NSBackingStoreType)backingType
The backing store type to set.
The valid backing store types are described in “Constants.”
This method can be used only to switch a buffered window to retained or vice versa; you can’t change the backing type to or from nonretained after initializing an NSWindow
object (an error is generated if you attempt to do so).
– backingType
– initWithContentRect:styleMask:backing:defer:
– initWithContentRect:styleMask:backing:defer:screen:
NSWindow.h
Specifies whether the window can be displayed at the login window.
- (void)setCanBecomeVisibleWithoutLogin:(BOOL)canBecomeVisibleWithoutLogin
YES
to allow the window to be displayed at the login window; NO
to prevent this behavior.
NSWindow.h
Specifies whether the window can be hidden when its application becomes hidden (during execution of the NSApplication
hide:
method).
- (void)setCanHide:(BOOL)canHide
YES
specifies that the window can be hidden when its application becomes hidden; NO
specifies otherwise.
NSWindow.h
Specifies the window’s behavior in window collections.
- (void)setCollectionBehavior:(NSWindowCollectionBehavior)collectionBehavior;
The collection behavior identifier to set.
NSWindow.h
Sets the aspect ratio (height in relation to width) of the window’s content view, constraining the dimensions of its content rectangle to integral multiples of that ratio when the user resizes it.
- (void)setContentAspectRatio:(NSSize)contentAspectRatio
The aspect ratio of the window’s content view.
You can set a window’s content view to any size programmatically, regardless of its aspect ratio. This method takes precedence over setAspectRatio:
.
NSWindow.h
Specifies the thickness of a given border of the window.
- (void)setContentBorderThickness:(CGFloat)borderThickness forEdge:(NSRectEdge)edge
Thickness for edge, in points.
Border whose thickness to set:
NSMaxYEdge
: Top border.
NSMinYEdge
: Bottom border.
NSWindow.h
Sets the maximum size of the window’s content view in the window’s base coordinate system.
- (void)setContentMaxSize:(NSSize)contentMaxSize
The maximum size of the window’s content view in the window’s base coordinate system.
The maximum size constraint is enforced for resizing by the user as well as for the setContentSize:
method and the setFrame...
methods other than setFrame:display:
. This method takes precedence over setMaxSize:
.
NSWindow.h
Sets the minimum size of the window’s content view in the window’s base coordinate system.
- (void)setContentMinSize:(NSSize)contentMinSize
The minimum size of the window’s content view in the window’s base coordinate system.
The minimum size constraint is enforced for resizing by the user as well as for the setContentSize:
method and the setFrame...
methods other than setFrame:display:
. This method takes precedence over setMinSize:
.
NSWindow.h
Restricts the user’s ability to resize the window so the width and height of its content view change by multiples of width and height increments.
- (void)setContentResizeIncrements:(NSSize)contentResizeIncrements
The content-view resizing increments to set.
As the user resizer the window, the size of its content view changes by integral multiples of contentResizeIncrements.width
and contentResizeIncrements.height
. However, you can set a window’s size to any width and height programmatically. This method takes precedence over setResizeIncrements:
.
NSWindow.h
Sets the size of the window’s content view to a given size, which is expressed in the window’s base coordinate system.
- (void)setContentSize:(NSSize)size
The new size of the window’s content view in the window’s base coordinate system.
This size in turn alters the size of the NSWindow
object itself. Note that the window server limits window sizes to 10,000; if necessary, be sure to limit aSize relative to the frame rectangle.
NSWindow.h
Makes a given view the window’s content view.
- (void)setContentView:(NSView *)view
View that is to become the window’s content view.
The window retains the new content view and owns it thereafter. The view object is resized to fit precisely within the content area of the window. You can modify the content view’s coordinate system through its bounds rectangle, but can’t alter its frame rectangle (that is, its size or location) directly.
This method causes the old content view to be released; if you plan to reuse it, be sure to retain it before sending this message and to release it as appropriate when adding it to another NSWindow
object or NSView
.
NSWindow.h
Makes the key equivalent of button cell the Return (or Enter) key, so when the user presses Return that button performs as if clicked.
- (void)setDefaultButtonCell:(NSButtonCell *)defaultButtonCell
The button cell to perform as if clicked when the window receives a Return (or Enter) key event.
– defaultButtonCell
– disableKeyEquivalentForDefaultButtonCell
– enableKeyEquivalentForDefaultButtonCell
NSWindow.h
Sets the window’s delegate to a given object or removes an existing delegate.
- (void)setDelegate:(id)delegate
The delegate for the window. Pass nil
to remove an existing delegate.
An NSWindow
object’s delegate is inserted in the responder chain after the window itself and is informed of various actions by the window through delegation messages.
– delegate
– tryToPerform:with:
– sendAction:to:from:
(NSApplication
)NSWindow.h
Sets the depth limit of the window to a given limit.
- (void)setDepthLimit:(NSWindowDepth)depthLimit
The depth limit to set.
The NSBestDepth
function provides the best depth limit based on a set of parameters.
Passing a value of 0
for depthLimit sets the depth limit to the window’s default depth limit. A depth limit of 0 can be useful for reverting an NSWindow
object to its initial depth.
NSWindow.h
Specifies whether the window context should be updated when the screen profile changes.
- (void)setDisplaysWhenScreenProfileChanges:(BOOL)displaysWhenScreenProfileChanges
YES
specifies that the window context should be changed in these situations:
A majority of the window is moved to a different screen whose profile is different than the previous screen.
The ColorSync profile of the current screen changes.
NO
specifies that the screen profile information for the window context doesn’t change.
After the window context is updated, the window is told to display itself. If you need to update offscreen caches for the window, you should register to receive the NSWindowDidChangeScreenProfileNotification
notification.
NSWindow.h
Specifies whether the window’s document has been edited.
- (void)setDocumentEdited:(BOOL)documentEdited
YES
to specify that the window’s document has been edited; NO
to specify otherwise.
You should send setDocumentEdited:YES
to an NSWindow
object every time the window’s document changes in such a way that it needs to be saved. Conversely, when the document is saved, you should send setDocumentEdited:NO
. Then, before closing the window you can use isDocumentEdited
to determine whether to allow the user a chance to save the document.
NSWindow.h
Sets whether the window changes its depth to match the depth of the screen it’s on, or the depth of the deepest screen when it spans multiple screens.
- (void)setDynamicDepthLimit:(BOOL)dynamicDepthLimit
YES
specifies a dynamic depth limit; NO
specifies otherwise.
When dynamicDepthLimit is NO
, the window uses either its preset depth limit or the default depth limit. A different, and nondynamic, depth limit can be set with the setDepthLimit:
method.
NSWindow.h
Specifies whether the window’s title is omitted from the application’s Windows menu.
- (void)setExcludedFromWindowsMenu:(BOOL)excludedFromWindowsMenu
YES
to specify that the window is to be omitted from the application’s Windows menu; NO
to specify otherwise.
NSWindow.h
Sets the origin and size of the window’s frame rectangle according to a given frame rectangle, thereby setting its position and size onscreen.
- (void)setFrame:(NSRect)windowFrame display:(BOOL)displayViews
The frame rectangle for the window.
Specifies whether the window redraws the views that need to be displayed. When YES
the window sends a displayIfNeeded
message down its view hierarchy, thus redrawing all views.
Note that the window server limits window position coordinates to ±16,000 and sizes to 10,000.
NSWindow.h
Sets the origin and size of the window’s frame rectangle, with optional animation, according to a given frame rectangle, thereby setting its position and size onscreen.
- (void)setFrame:(NSRect)windowFrame display:(BOOL)displayViews animate:(BOOL)performAnimation
The frame rectangle for the window.
Specifies whether the window redraws the views that need to be displayed. When YES
the window sends a displayIfNeeded
message down its view hierarchy, thus redrawing all views.
Specifies whether the window performs a smooth resize. YES to perform the animation, whose duration is specified by animationResizeTime:
.
NSWindow.h
Sets the name used to automatically save the window’s frame rectangle in the defaults system to a given name.
- (BOOL)setFrameAutosaveName:(NSString *)frameName
The name under which the frame is to be saved.
YES
when the frame name is set successfully; NO
when frameName is being used as an autosave name by another NSWindow
object in the application (in which case the window’s old name remains in effect).
If frameName isn’t the empty string (@""
), the window’s frame is saved as a user default (as described in saveFrameUsingName:
) each time the frame changes.
When the window has an autosave name, its frame data is written whenever the frame rectangle changes.
If there is a frame rectangle previously stored for frameName in the user defaults, the window’s frame is set to this frame rectangle. That is, when you call this method with a previously used frameName, the window picks up the previously saved setting. For example, if you call setFrameAutosaveName:
for a window that is already onscreen, this method could cause the window to move to a different screen location. For this reason, it is generally better to call this method before the window is visible on screen.
Keep in mind that a window controller may change the window’s position when it displays it if window cascading is turned on. To preclude the window controller from changing a window’s position from the one saved in the defaults system, you must send setShouldCascadeWindows:NO
to the window controller.
NSWindow.h
Sets the window’s frame rectangle from a given string representation.
- (void)setFrameFromString:(NSString *)frameString
A string representation of a frame rectangle, previously creating using stringWithSavedFrame
.
The frame is constrained according to the window’s minimum and maximum size settings. This method causes a windowWillResize:toSize:
message to be sent to the delegate.
NSWindow.h
Positions the bottom-left corner of the window’s frame rectangle at a given point in screen coordinates.
- (void)setFrameOrigin:(NSPoint)point
The new position of the window’s bottom-left corner in screen coordinates.
Note that the window server limits window position coordinates to ±16,000.
NSWindow.h
Positions the top-left corner of the window’s frame rectangle at a given point in screen coordinates.
- (void)setFrameTopLeftPoint:(NSPoint)point
The new position of the window’s top-left corner in screen coordinates.
Note that the window server limits window position coordinates to ±16,000; if necessary, adjust aPoint relative to the window’s lower-left corner to account for this limit.
NSWindow.h
Sets the window’s frame rectangle by reading the rectangle data stored under a given name from the defaults system.
- (BOOL)setFrameUsingName:(NSString *)frameName
The name of the frame to read.
YES
when frameName is read and the frame is set successfully; NO
otherwise.
The frame is constrained according to the window’s minimum and maximum size settings. This method causes a windowWillResize:toSize:
message to be sent to the delegate.
NSWindow.h
Sets the window’s frame rectangle by reading the rectangle data stored under a given name from the defaults system. Can operate on nonresizable windows.
- (BOOL)setFrameUsingName:(NSString *)frameName force:(BOOL)force
The name of the frame to read.
YES
to use setFrameUsingName:
on a nonresizable window; NO
to fail on a nonresizable window.
YES
when frameName is read and the frame is set successfully; NO
otherwise.
NSWindow.h
Specifies whether the window has a shadow.
- (void)setHasShadow:(BOOL)hasShadow
YES
specifies that the window has a shadow; NO
specifies otherwise.
If the shadow setting changes, the window shadow is invalidated, forcing the window shadow to be recomputed.
NSWindow.h
Specifies whether the window is removed from the screen when the application is inactive.
- (void)setHidesOnDeactivate:(BOOL)hideOnDeactivate
NSWindow.h
Specifies whether the window is transparent to mouse clicks and other mouse events, allowing overlay windows.
- (void)setIgnoresMouseEvents:(BOOL)ignoreMouseEvents
NSWindow.h
Sets a given view as the one that’s made first responder (also called the key view) the first time the window is placed onscreen.
- (void)setInitialFirstResponder:(NSView *)view
The view to make first responder the first time the window is placed onscreen.
NSWindow.h
Sets the window’s window level to a given level.
- (void)setLevel:(NSInteger)windowLevel
The window level to set.
Some useful predefined values, ordered from lowest to highest, are described in “Constants.”
Each level in the list groups windows within it in front of those in all preceding groups. Floating windows, for example, appear in front of all normal-level windows. When a window enters a new level, it’s ordered in front of all its peers in that level.
The constant NSTornOffMenuWindowLevel
is preferable to its synonym, NSSubmenuWindowLevel
.
NSWindow.h
Sets the maximum size to which the window’s frame (including its title bar) can be sized.
- (void)setMaxSize:(NSSize)maxFrameSize
The maximum size of the window’s frame.
The maximum size constraint is enforced for resizing by the user as well as for the setFrame...
methods other than setFrame:display:
. Note that the window server limits window sizes to 10,000.
The default maximum size of a window is {FLT_MAX, FLT_MAX}
(FLT_MAX
is defined in /usr/include/float.h
). Once the maximum size of a window has been set, there is no way to reset it other than specifying this default maximum size.
The setContentMaxSize: method takes precedence over this method.
NSWindow.h
Sets the window’s custom minimized window image to a given image.
- (void)setMiniwindowImage:(NSImage *)miniwindowImage
Image to set as the window’s minimized window image.
When the user minimizes the window, the Dock displays miniwindowImage in the corresponding Dock tile, scaling it as needed to fit in the tile. If you do not specify a custom image using this method, the Dock creates one for you automatically.
You can also call this method as needed to change the minimized window image. Typically, you would specify a custom image immediately prior to a window being minimized—when the system posts an NSWindowWillMiniaturizeNotification
. You can call this method while the window is minimized to update the current image in the Dock. However, this method is not recommended for creating complex animations in the Dock.
Support for custom images is disabled by default. To enable support, set the AppleDockIconEnabled
key to YES
when first registering your application’s user defaults. You must set this key prior to calling the init
method of NSApplication
, which reads the current value of the key.
NSWindow.h
Sets the title of the window’s miniaturized counterpart to a given string and redisplays it.
- (void)setMiniwindowTitle:(NSString *)miniwindowTitle
The string to set as the title of the minimized window.
A minimized window’s title normally reflects that of its full-size counterpart, abbreviated to fit if necessary. Although this method allows you to set the minimized window’s title explicitly, changing the full-size NSWindow
object’s title (through setTitle:
or setTitleWithRepresentedFilename:
) automatically changes the minimized window’s title as well.
NSWindow.h
Sets the minimum size to which the window’s frame (including its title bar) can be sized to aSize.
- (void)setMinSize:(NSSize)minFrameSize
The minimum size of the window’s frame.
The minimum size constraint is enforced for resizing by the user as well as for the setFrame...
methods other than setFrame:display:
.
The setContentMinSize:
method takes precedence over this method.
NSWindow.h
Sets whether the window is movable by clicking and dragging anywhere in its background.
- (void)setMovableByWindowBackground:(BOOL)movableByWindowBackground
YES
to specify that the window is movable by background, NO
to specify that the window is not movable by background.
NSWindow.h
Sets whether the window device that the window manages should be freed when it’s removed from the screen list.
- (void)setOneShot:(BOOL)oneShot
YES
to free the window’s window device when it’s removed from the screen list (hidden) and to create another one when it’s returned to the screen; NO
to reuse the window device.
Freeing the window device when it’s removed from the screen list can result in memory savings and performance improvement for NSWindow
objects that don’t take long to display. It’s particularly appropriate for NSWindow
objects the user might use once or twice but not display continually.
NSWindow.h
Specifies whether the window is opaque.
- (void)setOpaque:(BOOL)opaque
NSWindow.h
Adds the window as a child of a given window. For use by subclasses when setting the parent window in the window.
- (void)setParentWindow:(NSWindow *)parentWindow
The window to be a child of the given window.
You should call super if overriding.
NSWindow.h
Specifies the preferred location for the window’s backing store.
- (void)setPreferredBackingLocation:(NSWindowBackingLocation)preferredBackingLocation
The preferred location for the window’s backing store. See “Constants” for possible values.
Use only when optimizing for performance.
NSWindow.h
Specifies whether the window tries to optimize live resize operations by preserving the content of views that have not changed.
- (void)setPreservesContentDuringLiveResize:(BOOL)preservesContentDuringLiveResize
YES
turns on live-resize optimization; NO
turns it off for the window and all of its contained views.
By default, live-resize optimization is turned on.
You might consider disabling this optimization for the window if none of the window’s contained views can take advantage of it. Disabling the optimization for the window prevents it from checking each view to see if the optimization is supported.
NSWindow.h
Specifies whether the window is released when it receives the close
message.
- (void)setReleasedWhenClosed:(BOOL)releasedWhenClosed
YES
to specify that the window is to be hidden and released when it receives a close message; NO
to specify that the window is only hidden, not released.
Another strategy for releasing an NSWindow
object is to have its delegate autorelease it on receiving a windowShouldClose:
message.
NSWindow.h
Sets the pathname of the file the window represents.
- (void)setRepresentedFilename:(NSString *)filePath
The path to the file to set as the window’s represented file.
NSWindow.h
Specifies the URL of the file the window represents.
- (void)setRepresentedURL:(NSURL *)representedURL
The URL of the file the window is to represent.
NSWindow.h
Restricts the user’s ability to resize the window so the width and height change by multiples of width and height increments.
- (void)setResizeIncrements:(NSSize)resizeIncrements
The resizing increments to set.
As the user resizer the window, its size changes by multiples of increments.width
and increments.height
, which should be whole numbers, 1.0 or greater. Whatever the current resizing increments, you can set an NSWindow
object’s size to any height and width programmatically.
Resize increments and aspect ratio are mutually exclusive attributes. For more information, see setAspectRatio:
.
The setContentResizeIncrements: method takes precedence over this method.
NSWindow.h
Specifies the level of access other processes have to the window’s content.
- (void)setSharingType:(NSWindowSharingType)sharingType
The sharing level of the window’s content. See “Constants” for possible values.
NSWindow.h
Specifies whether the window’s resize indicator is visible
- (void)setShowsResizeIndicator:(BOOL)showResizeIndicator
Specifies the resize indicator state. YES
to show it, NO
to hide it.
This method does not affect whether the window is resizable.
NSWindow.h
Specifies whether the window shows the toolbar control button.
- (void)setShowsToolbarButton:(BOOL)showsToolbarButton
If the window does not have a toolbar, this method has no effect.
NSWindow.h
Sets the string that appears in the window’s title bar (if it has one) to a given string and displays the title.
- (void)setTitle:(NSString *)title
The string to set as the window’s title.
Also sets the title of the window’s miniaturized window.
NSWindow.h
Sets a given path as the window’s title, formatting it as a file-system path, and records this path as the window’s associated filename using setRepresentedFilename:
.
- (void)setTitleWithRepresentedFilename:(NSString *)filePath
The file path to set as the window’s title.
The filename—not the pathname—is displayed in the window’s title bar.
This method also sets the title bar of the window’s minimized window.
NSWindow.h
Sets the window’s toolbar.
- (void)setToolbar:(NSToolbar *)toolbar
The toolbar for the window.
See the NSToolbar
class description for additional information.
NSWindow.h
Specifies whether the window’s views need to be displayed..
- (void)setViewsNeedDisplay:(BOOL)viewsNeedDisplay
YES
to specify that the window’s views need to be displayed; NO
to specify otherwise.
You should rarely need to invoke this method; the NSView
method setNeedsDisplay:
and similar methods invoke it automatically.
NSWindow.h
Sets the window’s window controller.
- (void)setWindowController:(NSWindowController *)windowController
Window controller to set.
NSWindow.h
Indicates the level of access other processes have to the window’s content.
- (NSWindowSharingType)sharingType
The sharing level of the window’s content. See “Constants” for possible values.
NSWindow.h
Returns a Boolean value that indicates whether the window’s resize indicator is visible.
- (BOOL)showsResizeIndicator
YES
when the window’s resize indicator is visible, otherwise NO
.
NSWindow.h
Indicates whether the toolbar control button is currently displayed.
- (BOOL)showsToolbarButton
YES
if the standard toolbar button is currently displayed; NO
otherwise.
When clicked, the toolbar control button shows or hides a window’s toolbar. The toolbar control button appears in a window’s title bar.
NSWindow.h
Returns the window button of a given window button kind in the window’s view hierarchy.
- (NSButton *)standardWindowButton:(NSWindowButton)windowButtonKind
The kind of standard window button to return.
Window button in the window’s view hierarchy of the kind identified by windowButtonKind; nil
when such button is not in the window’s view hierarchy.
NSWindow.h
Returns a string representation of the window’s frame rectangle.
- (NSString *)stringWithSavedFrame
A string representation of the window’s frame rectangle in a format that can be used with a later setFrameFromString:
message.
NSWindow.h
Returns the window’s style mask, indicating what kinds of control items it displays.
- (NSUInteger)styleMask
The window’s style mask.
See the information about the style mask in “Constants.” A window’s style is set when the object is initialized. Once set, it can’t be changed.
NSWindow.h
Returns either the string that appears in the title bar of the window, or the path to the represented file.
- (NSString *)title
The window’s title or the path to the represented file.
If the title has been set using setTitleWithRepresentedFilename:
, this method returns the file’s path.
NSWindow.h
The action method for the “Hide Toolbar” menu item (which alternates with “Show Toolbar”).
- (void)toggleToolbarShown:(id)sender
The message’s sender.
See the NSToolbar
class description for additional information.
NSWindow.h
Returns the window’s toolbar.
- (NSToolbar *)toolbar
The window’s toolbar.
See the NSToolbar
class description for additional information.
NSWindow.h
Dispatches action messages with a given argument.
- (BOOL)tryToPerform:(SEL)selector with:(id)object
The selector to attempt to execute.
The message’s argument.
YES when the window or its delegate perform selector with object; NO otherwise.
The window tries to perform the method selector using its inherited NSResponder
method tryToPerform:with:
. If the window doesn’t perform selector, the delegate is given the opportunity to perform it using its inherited NSObject
method performSelector:withObject:
.
NSWindow.h
Unregisters the window as a possible destination for dragging operations.
- (void)unregisterDraggedTypes
NSWindow.h
Updates the window.
- (void)update
The NSWindow
implementation of this method does nothing more than post an NSWindowDidUpdateNotification
notification to the default notification center. A subclass can override this method to perform specialized operations, but it should send an update message to super
just before returning. For example, the NSMenu
class implements this method to disable and enable menu commands.
An NSWindow
object is automatically sent an update
message on every pass through the event loop and before it’s displayed onscreen. You can manually cause an update
message to be sent to all visible NSWindow
objects through the NSApplication
updateWindows
method.
– setWindowsNeedUpdate:
(NSApplication
)NSWindow.h
Specifies whether the window is to optimize focusing and drawing when displaying its views.
- (void)useOptimizedDrawing:(BOOL)optimizedDrawing
YES
to have the window optimize focusing and drawing for its views; NO
to specify otherwise, in which case, the window does not preserve the Z-ordering of overlapping views when an object explicitly sends lockFocus
to a view and draws directly to it, instead of using the AppKit standard display mechanism.
The optimizations may prevent sibling subviews from being displayed in the correct order—which matters only if the subviews overlap. You should always set optimizedDrawing to YES
when there are no overlapping subviews within the window. The default is NO
.
NSWindow.h
Returns the scale factor applied to the window.
- (CGFloat)userSpaceScaleFactor
The scale factor applied to the window.
Clients can multiply view coordinates by the returned scale factor to get a set of new coordinates that are scaled to the resolution of the target screen. For example, if the scale factor is 1.25 and the view frame size is 80 x 80, the actual size of the view frame is 100 x 100 pixels on the target screen.
NSWindow.h
Searches for an object that responds to a Services request.
- (id)validRequestorForSendType:(NSString *)sendType returnType:(NSString *)returnType
The input type of the Services request.
The return type of the Services request.
The object that responds to the services request; nil
when none is found.
Messages to perform this method are initiated by the Services menu. It’s part of the mechanism that passes validRequestorForSendType:returnType:
messages up the responder chain.
This method works by forwarding the message to the window’s delegate if it responds (and provided it isn’t an NSResponder
object with its own next responder). If the delegate doesn’t respond to the message or returns nil
when sent it, this method forwards the message to the NSApplication
object. If the NSApplication
object returns nil
, this method also returns nil
. Otherwise this method returns the object returned by the delegate or the NSApplication
object.
– validRequestorForSendType:returnType:
(NSResponder
)– validRequestorForSendType:returnType:
(NSApplication
)NSWindow.h
Indicates whether any of the window’s views need to be displayed.
- (BOOL)viewsNeedDisplay
YES
when any of the window’s views need to be displayed; NO
otherwise.
NSWindow.h
Returns the window’s window controller.
- (id)windowController
The window’s window controller.
NSWindow.h
Provides the window number of the window’s window device.
- (NSInteger)windowNumber
The window number of the window’s window device.
Each window device in an application is given a unique window number—note that this isn’t the same as the global window number assigned by the window server. This number can be used to identify the window device with the orderWindow:relativeTo:
method and in the Application Kit function NSWindowList
. .
If the window doesn’t have a window device, the value returned will be equal to or less than 0.
NSWindow.h
Returns the Carbon WindowRef
associated with the window, creating one if necessary.
- (void *)windowRef
This method can be used to create a WindowRef
for a window containing a Carbon control. Subsequent calls to this method return the existing WindowRef
. You use a WindowRef
to create a Carbon window reference for a Cocoa window; this assists the integration of Carbon and Cocoa code and objects.
For more information see MacWindows.h
. For more information on Carbon-Cocoa integration, see Carbon-Cocoa Integration Guide.
NSWindow.h
Indicates whether the window is able to receive keyboard and mouse events even when some other window is being run modally.
- (BOOL)worksWhenModal
YES
if the window is able to receive keyboard and mouse events even when some other window is being run modally; NO
otherwise.
The NSWindow
implementation of this method returns NO
. Only subclasses of NSPanel
should override this default.
– setWorksWhenModal:
(NSPanel
)NSWindow.h
This action method toggles the size and location of the window between its standard state (provided by the application as the “best” size to display the window’s data) and its user state (a new size and location the user may have set by moving or resizing the window).
- (void)zoom:(id)sender
The object sending the message.
For more information on the standard and user states, see windowWillUseStandardFrame:defaultFrame:
.
The zoom:
method is typically invoked after a user clicks the window’s zoom box but may also be invoked programmatically from the performZoom:
method. It performs the following steps:
Invokes the windowWillUseStandardFrame:defaultFrame:
method, if the delegate or the window class implements it, to obtain a “best fit” frame for the window. If neither the delegate nor the window class implements the method, uses a default frame that nearly fills the current screen, which is defined to be the screen containing the largest part of the window’s current frame.
Adjusts the resulting frame, if necessary, to fit on the current screen.
Compares the resulting frame to the current frame to determine whether the window’s standard frame is currently displayed. If the current frame is within a few pixels of the standard frame in size and location, it is considered a match.
Determines a new frame. If the window is currently in the standard state, the new frame represents the user state, saved during a previous zoom. If the window is currently in the user state, the new frame represents the standard state, computed in step 1 above. If there is no saved user state because there has been no previous zoom, the size and location of the window do not change.
Determines whether the window currently allows zooming. By default, zooming is allowed. If the window’s delegate implements the windowShouldZoom:toFrame:
method, zoom:
invokes that method. If the delegate doesn’t implement the method but the window does, zoom:
invokes the window’s version. windowShouldZoom:toFrame:
returns NO
if zooming is not currently allowed.
If the window currently allows zooming, sets the new frame.
NSWindow.h
Determines whether the sender allows the user to drag the sender’s represented file’s icon from the sender’s title bar.
- (BOOL)window:(NSWindow *)sender shouldDragDocumentWithEvent:(NSEvent *)mouseEvent from:(NSPoint)startPoint withPasteboard:(NSPasteboard *)pasteboard
The window whose represented file’s icon the user wants to drag.
The left-mouse down event that triggered the dragging operation.
The location at which the user started the dragging operation.
The pasteboard containing the contents of the represented file, which the delegate can modify.
YES
to allow the drag to proceed, NO
to prevent it.
To implement its own dragging process, the delegate can perform the dragging operation and return NO
.
NSWindow.h
Determines whether the sender displays the title pop-up menu in response to a Command-click on the sender’s title.
- (BOOL)window:(NSWindow *)sender shouldPopUpDocumentPathMenu:(NSMenu *)titleMenu
The window whose title the user Command-clicked.
The menu the sender displays, if allowed. By default its items are the path components of the file represented by sender.
YES
to allow the display of the title pop-up menu, NO
to prevent it.
NSWindow.h
Sent to the delegate just before the animation of a sheet, giving it the opportunity to return a custom location for the attachment of a sheet to a window.
- (NSRect)window:(NSWindow *)window willPositionSheet:(NSWindow *)sheet usingRect:(NSRect)defaultSheetRect
The window containing the sheet to be animated.
The sheet to be animated.
The default sheet location, just under the title bar of the window, aligned with the left and right edges of the window.
A custom location for the attachment of sheet to window.
This method is also invoked whenever the user resizes window while sheet is attached.
This method is useful in many situations. If your window has a toolbar, for example, you can specify a location for the sheet that is just below it. If you want the sheet associated with a certain control or view, you could position the sheet so that it appears to originate from the object (through animation) or is positioned next to it.
Neither the defaultSheetRect parameter nor the returned NSRect
value define the boundary of the sheet. They indicate where the top-left edge of the sheet is attached to the window. The origin is expressed in window coordinates; the default origin.y
value is the height of the content view and the default origin.x
value is zero. The size.width
value indicates the width and behavior of the initial animation; if size.width
is narrower than the sheet, the sheet genies out from the specified location, and if size.width
is wider than the sheet, the sheet slides out. You cannot affect the size of the sheet through the size.width
and size.height
fields. It is recommended that you specify zero for the size.height
value as this field may have additional meaning in a future release.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has become key.
- (void)windowDidBecomeKey:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has become main.
- (void)windowDidBecomeMain:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has changed screens.
- (void)windowDidChangeScreen:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has changed screen display profiles.
- (void)windowDidChangeScreenProfile:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has been deminimized.
- (void)windowDidDeminiaturize:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object closes a sheet.
- (void)windowDidEndSheet:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has been exposed.
- (void)windowDidExpose:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has been minimized.
- (void)windowDidMiniaturize:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has been moved.
- (void)windowDidMove:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has resigned its status as key window.
- (void)windowDidResignKey:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object has resigned its status as main window.
- (void)windowDidResignMain:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after a window has been resized.
- (void)windowDidResize:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately after an NSWindow
object receives an update
message.
- (void)windowDidUpdate:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Invoked when the user attempts to close a window or a window receives a performClose:
message.
- (BOOL)windowShouldClose:(id)window
The window being closed.
YES
to allow window to be closed, otherwise NO
.
This method may not always be called during window closing. Specifically, this method is not called when a user quits an application. You can find additional information on application termination in Graceful Application Termination.
NSWindow.h
Sent just before sender is zoomed to allow or disallow the operation.
- (BOOL)windowShouldZoom:(NSWindow *)window toFrame:(NSRect)proposedFrame
The window being zoomed.
The rectangle to which window is being zoomed.
YES
to allow the window frame to become proposedFrame; NO
otherwise.
NSWindow.h
Sent by the default notification center immediately before an NSWindow
object opens a sheet.
- (void)windowWillBeginSheet:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately before an NSWindow
object closes.
- (void)windowWillClose:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately before an NSWindow
object is minimized.
- (void)windowWillMiniaturize:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Sent by the default notification center immediately before an NSWindow
object is moved.
- (void)windowWillMove:(NSNotification *)notification
You can retrieve the NSWindow
object in question by sending object
to notification.
NSWindow.h
Invoked when a window is being resized (whether by the user or through one of the setFrame...
methods other than setFrame:display:
).
- (NSSize)windowWillResize:(NSWindow *)window toSize:(NSSize)proposedFrameSize
The window being resized.
The size to which window is being resized.
The proposedFrameSize contains the size (in screen coordinates) the sender will be resized to. To resize to a different size, simply return the desired size from this method; to avoid resizing, return the current size. The NSWindow
object’s minimum and maximum size constraints have already been applied when this method is invoked.
While the user is resizing a window, the delegate is sent a series of windowWillResize:toSize:
messages as the window’s outline is dragged. The window’s outline is displayed at the constrained size as set by this method.
NSWindow.h
Invoked when the field editor for a text-displaying object is requested.
- (id)windowWillReturnFieldEditor:(NSWindow *)window toObject:(id)anObject
The window that is requesting the field editor from the delegate.
A text-displaying object to be associated with the field editor. If nil
, the requested field editor is the default.
The field editor for anObject
; returns nil
when the delegate has no field editor to assign.
This method may be called multiple times while a control is first responder. Therefore, you must return the same field editor object for the control while the control is being edited.
NSWindow.h
Invoked when the undo manager for a window is requested. Returns the appropriate undo manager for the window.
- (NSUndoManager *)windowWillReturnUndoManager:(NSWindow *)window
The window whose undo manager is being requested.
The appropriate undo manager for window.
If this method is not implemented by the delegate, the NSWindow
object creates an NSUndoManager
object for window.
NSWindow.h
Invoked by the zoom:
method while determining a frame an NSWindow
object may be zoomed to.
- (NSRect)windowWillUseStandardFrame:(NSWindow *)window defaultFrame:(NSRect)defaultFrame
The window whose frame size is being determined.
The size of the current screen, which is the screen containing the largest part of the window’s current frame, possibly reduced on the top, bottom, left, or right, depending on the current interface style. The frame is reduced on the top to leave room for the menu bar.
The standard frame for window.
The standard frame for a window should supply the size and location that are “best” for the type of information shown in the window, taking into account the available display or displays. For example, the best width for a window that displays a word-processing document is the width of a page or the width of the display, whichever is smaller. The best height can be determined similarly. On return from this method, the zoom:
method modifies the returned standard frame, if necessary, to fit on the current screen.
To customize the standard state, implement windowWillUseStandardFrame:defaultFrame:
in the class of the window’s delegate or, if necessary, in a window subclass. Your version should return a suitable standard frame, based on the currently displayed data or other factors.
NSWindow.h
These constants specify the presence of a title and various buttons in a window’s border. It can be NSBorderlessWindowMask
, or it can contain any of the following options, combined using the C bitwise OR operator:
enum { NSBorderlessWindowMask = 0, NSTitledWindowMask = 1 << 0, NSClosableWindowMask = 1 << 1, NSMiniaturizableWindowMask = 1 << 2, NSResizableWindowMask = 1 << 3, NSTexturedBackgroundWindowMask = 1 << 8 };
NSBorderlessWindowMask
The window displays none of the usual peripheral elements. Useful only for display or caching purposes.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSTitledWindowMask
The window displays a title bar.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSClosableWindowMask
The window displays a close button.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSMiniaturizableWindowMask
The window displays a minimize button.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSResizableWindowMask
The window displays a resize control.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSTexturedBackgroundWindowMask
The window displays with a metal-textured background. Additionally, the window may be moved by clicking and dragging anywhere in the window background. A bordered window with this mask gets rounded bottom corners.
Available in Mac OS X v10.2 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants specify the window’s level. The stacking of levels takes precedence over the stacking of windows within each level. That is, even the bottom window in a level will obscure the top window of the next level down. Levels are listed in order from lowest to highest. These constants are mapped (using #define
statements) to corresponding elements in the Window Level Keys
in Core Graphics.
#define NSNormalWindowLevel kCGNormalWindowLevel #define NSFloatingWindowLevel kCGFloatingWindowLevel #define NSSubmenuWindowLevel kCGTornOffMenuWindowLevel #define NSTornOffMenuWindowLevel kCGTornOffMenuWindowLevel #define NSMainMenuWindowLevel kCGMainMenuWindowLevel #define NSStatusWindowLevel kCGStatusWindowLevel #define NSModalPanelWindowLevel kCGModalPanelWindowLevel #define NSPopUpMenuWindowLevel kCGPopUpMenuWindowLevel #define NSScreenSaverWindowLevel kCGScreenSaverWindowLevel
NSNormalWindowLevel
The default level for NSWindow
objects.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSFloatingWindowLevel
Useful for floating palettes.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSSubmenuWindowLevel
Reserved for submenus. Synonymous with NSTornOffMenuWindowLevel
, which is preferred.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSTornOffMenuWindowLevel
The level for a torn-off menu. Synonymous with NSSubmenuWindowLevel
.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSModalPanelWindowLevel
The level for a modal panel.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSMainMenuWindowLevel
Reserved for the application’s main menu.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSStatusWindowLevel
The level for a status window.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSPopUpMenuWindowLevel
The level for a pop-up menu.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSScreenSaverWindowLevel
The level for a screen saver.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants are the keys for device description dictionaries used by deviceDescription
.
NSString *NSDeviceResolution; NSString *NSDeviceColorSpaceName; NSString *NSDeviceBitsPerSample; NSString *NSDeviceIsScreen; NSString *NSDeviceIsPrinter; NSString *NSDeviceSize;
NSDeviceResolution
The corresponding value is an NSValue
object containing a value of type NSSize
that describes the window’s raster resolution in dots per inch (dpi).
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSDeviceColorSpaceName
The corresponding value is an NSString
object giving the name of the window’s color space.
See “Color Space Names” in Application Kit Constants Reference for a list of possible values.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSDeviceBitsPerSample
The corresponding value is an NSNumber
object containing an integer that gives the bit depth of the window’s raster image (2-bit, 8-bit, and so forth).
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSDeviceIsScreen
If there is a corresponding value, this indicates that the display device is a screen.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSDeviceIsPrinter
If there is a corresponding value, this indicates that the display device is a printer.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSDeviceSize
The corresponding value is an NSValue
object containing a value of type NSSize
that gives the size of the window’s frame rectangle.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSGraphics.h
This constant provides a way to manage scaling factors:
enum { NSUnscaledWindowMask = 1 << 11 };
NSUnscaledWindowMask
Specifies that the window is created without any scaling factors applied.
The client is responsible for all scaling operations in the window. Such a window returns 1.0
from its userSpaceScaleFactor
method.
Currently restricted to borderless windows (NSBorderlessWindowMask
).
Available in Mac OS X v10.4 and later.
Declared in NSWindow.h
.
NSWindow.h
This constant controls the look of a window and its toolbar.
enum { NSUnifiedTitleAndToolbarWindowMask = 1 << 12 };
NSUnifiedTitleAndToolbarWindowMask
Specifies a window whose toolbar and title bar are rendered on a single continuous background.
Available in Mac OS X v10.4 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants specify the direction a window is currently using to change the key view. They’re used by keyViewSelectionDirection
.
typedef enum _NSSelectionDirection { NSDirectSelection = 0, NSSelectingNext, NSSelectingPrevious } NSSelectionDirection;
NSDirectSelection
The window isn’t traversing the key view loop.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSSelectingNext
The window is proceeding to the next valid key view.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSSelectingPrevious
The window is proceeding to the previous valid key view.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants provide a way to access standard title bar buttons:
typedef enum { NSWindowCloseButton, NSWindowMiniaturizeButton, NSWindowZoomButton, NSWindowToolbarButton, NSWindowDocumentIconButton } NSWindowButton;
NSWindowCloseButton
The close button.
Available in Mac OS X v10.2 and later.
Declared in NSWindow.h
.
NSWindowMiniaturizeButton
The minimize button.
Available in Mac OS X v10.2 and later.
Declared in NSWindow.h
.
NSWindowZoomButton
The zoom button.
Available in Mac OS X v10.2 and later.
Declared in NSWindow.h
.
NSWindowToolbarButton
The toolbar button.
Available in Mac OS X v10.2 and later.
Declared in NSWindow.h
.
NSWindowDocumentIconButton
The document icon button.
Available in Mac OS X v10.2 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants are passed to NSRunLoop
's performSelector:target:argument:order:modes:
.
enum { NSDisplayWindowRunLoopOrdering, NSResetCursorRectsRunLoopOrdering };
NSDisplayWindowRunLoopOrdering
The priority at which windows are displayed.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSResetCursorRectsRunLoopOrdering
The priority at which cursor rects are reset.
Available in Mac OS X v10.0 and later.
Declared in NSWindow.h
.
NSWindow.h
This type represents the depth, or amount of memory, devoted to a single pixel in a window or screen. A depth of 0 indicates default depth. Window depths should not be made persistent as they will not be the same across systems.
typedef int NSWindowDepth;
Use the functions NSColorSpaceFromDepth
, NSBitsPerPixelFromDepth
, and NSPlanarFromDepth
to extract info from an NSWindowDepth
value. Use NSBestDepth
to compute window depths. NSBestDepth
tries to accommodate all the parameters (match or better); if there are multiple matches, it gives the closest, with matching color space first, then bps, then planar, then bpp. bpp is “bits per pixel”; 0 indicates default (same as the number of bits per plane, either bps or bps * NSNumberOfColorComponents
); other values maybe used as hints to provide backing stores of different configuration: for instance, 8-bit color.
NSGraphics.h
These constants specify how the drawing done in a window is buffered by the window device.
typedef enum _NSBackingStoreType { NSBackingStoreRetained = 0, NSBackingStoreNonretained = 1, NSBackingStoreBuffered = 2 } NSBackingStoreType;
NSBackingStoreRetained
The window uses a buffer, but draws directly to the screen where possible and to the buffer for obscured portions.
You should not use this mode. It combines the limitations of NSBackingStoreNonretained
with the memory use of NSBackingStoreBuffered
. The original NeXTSTEP implementation was an interesting compromise that worked well with fast memory mapped framebuffers on the CPU bus—something that hasn't been in general use since around 1994. These tend to have performance problems.
In Mac OS X 10.5 and later, requests for retained windows will result in the window system creating a buffered window, as that better matches actual use.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSBackingStoreNonretained
The window draws directly to the screen without using any buffer.
You should not use this mode. It exists primarily for use in the original Classic Blue Box. It does not support Quartz drawing, alpha blending, or opacity. Moreover, it does not support hardware acceleration, and interferes with system-wide display acceleration. If you use this mode, your application must manage visibility region clipping itself, and manage repainting on visibility changes.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSBackingStoreBuffered
The window renders all drawing into a display buffer and then flushes it to the screen.
You should use this mode. It supports hardware acceleration, Quartz drawing, and takes advantage of the GPU when possible. It also supports alpha channel drawing, opacity controls, using the compositor.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSGraphics.h
These constants let you specify how a window is ordered relative to another window. For more information, see orderWindow:relativeTo:
.
typedef enum _NSWindowOrderingMode { NSWindowAbove = 1, NSWindowBelow = -1, NSWindowOut = 0 } NSWindowOrderingMode;
NSWindowAbove
Moves the window above the indicated window.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSWindowBelow
Moves the window below the indicated window.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSWindowOut
Moves the window off the screen.
Available in Mac OS X v10.0 and later.
Declared in NSGraphics.h
.
NSGraphics.h
A private data structure used internally by NSWindow
.
typedef struct NSWindowAuxiliary NSWindowAuxiliaryOpaque;
NSWindow.h
These constants and data type represent the access levels other processes can have to a window’s content.
typedef enum { NSWindowSharingNone = 0, NSWindowSharingReadOnly = 1, NSWindowSharingReadWrite = 2 }; typedef NSUInteger NSWindowSharingType;
NSWindowSharingNone
The window’s contents cannot be read by another process.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindowSharingReadOnly
The window’s contents can be read but not modified by another process.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindowSharingReadWrite
The window’s contents can be read and modified by another process.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants and data type represent a window’s possible backing locations.
enum { NSWindowBackingLocationDefault = 0, NSWindowBackingLocationVideoMemory = 1, NSWindowBackingLocationMainMemory = 2 }; typedef NSUInteger NSWindowBackingLocation;
NSWindowBackingLocationDefault
Determined by the operating system.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindowBackingLocationVideoMemory
Video memory.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindowBackingLocationMainMemory
Physical memory.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindow.h
These constants and data type identify window behavior in relation to window browsers and organizers, such as Spaces.
enum { NSWindowCollectionBehaviorDefault = 0, NSWindowCollectionBehaviorCanJoinAllSpaces = 1 << 0, NSWindowCollectionBehaviorMoveToActiveSpace = 1 << 1 }; typedef NSUInteger NSWindowCollectionBehavior;
NSWindowCollectionBehaviorDefault
The window can be associated to one space at a time.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindowCollectionBehaviorCanJoinAllSpaces
The window appears in all spaces. The menu bar behaves this way.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindowCollectionBehaviorMoveToActiveSpace
Making the window active does not cause a space switch; the window switches to the active space.
Available in Mac OS X v10.5 and later.
Declared in NSWindow.h
.
NSWindow.h
Posted whenever an NSWindow
object becomes the key window.
The notification object is the NSWindow
object that has become key. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object becomes the main window.
The notification object is the NSWindow
object that has become main. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever a portion of an NSWindow
object’s frame moves onto or off of a screen.
The notification object is the NSWindow
object that has changed screens. This notification does not contain a userInfo dictionary.
This notification is not sent in Mac OS X versions earlier than 10.4.
NSWindow.h
Posted whenever the display profile for the screen containing the window changes.
This notification is sent only if the window returns YES
from displaysWhenScreenProfileChanges
. This notification may be sent when a majority of the window is moved to a different screen (whose profile is also different from the previous screen) or when the ColorSync profile for the current screen changes.
The notification object is the NSWindow
object whose profile changed. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object is deminimized.
The notification object is the NSWindow
object that has been deminimized. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object closes an attached sheet.
The notification object is the NSWindow
object that contained the sheet. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever a portion of a nonretained NSWindow
object is exposed, whether by being ordered in front of other windows or by other windows being removed from in front of it.
The notification object is the NSWindow
object that has been exposed. The userInfo dictionary contains the following information:
Key |
Value |
---|---|
|
The rectangle that has been exposed (an |
NSWindow.h
Posted whenever an NSWindow
object is minimized.
The notification object is the NSWindow
object that has been minimized. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object is moved.
The notification object is the NSWindow
object that has moved. This notification does not contain a userInfo dictionary.
Note: This notification is sent when the window that moved didn’t also change size. See NSWindowDidResizeNotification
for more information.
NSWindow.h
Posted whenever an NSWindow
object resigns its status as key window.
The notification object is the NSWindow
object that has resigned its key window status. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object resigns its status as main window.
The notification object is the NSWindow
object that has resigned its main window status. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object’s size changes.
The notification object is the NSWindow
object whose size has changed. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object receives an update
message.
The notification object is the NSWindow
object that received the update
message. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object is about to open a sheet.
The notification object is the NSWindow
object that is about to open the sheet. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object is about to close.
The notification object is the NSWindow
object that is about to close. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object is about to be minimized.
The notification object is the NSWindow
object that is about to be minimized. This notification does not contain a userInfo dictionary.
NSWindow.h
Posted whenever an NSWindow
object is about to move.
The notification object is the NSWindow
object that is about to move. This notification does not contain a userInfo dictionary.
NSWindow.h
© 2009 Apple Inc. All Rights Reserved. (Last updated: 2009-03-04)