UndoManager

beginUndoGrouping

beginUndoGrouping(): Promise<void>

func beginUndoGrouping()

disableUndoRegistration

disableUndoRegistration(): Promise<void>

func disableUndoRegistration()

enableUndoRegistration

enableUndoRegistration(): Promise<void>

func enableUndoRegistration()

endUndoGrouping

endUndoGrouping(): Promise<void>

func endUndoGrouping()

init

static init(): Promise<UndoManager>

init()

prepare

prepare(target: unknown): Promise<unknown>

func prepare(withInvocationTarget target: Any) -> Any

redo

redo(): Promise<void>

func redo()

redoActionUserInfoValue

redoActionUserInfoValue(key: UndoManager_UserInfoKey): Promise<(unknown) | null>

func redoActionUserInfoValue(forKey key: UndoManager.UserInfoKey) -> Any?

redoMenuTitle

redoMenuTitle(actionName: string): Promise<string>

func redoMenuTitle(forUndoActionName actionName: String) -> String

removeAllActions

removeAllActions(): Promise<void>

func removeAllActions()

removeAllActions

removeAllActionsWithTarget(target: unknown): Promise<void>

func removeAllActions(withTarget target: Any)

setActionIsDiscardable

setActionIsDiscardable(discardable: boolean): Promise<void>

func setActionIsDiscardable(_ discardable: Bool)

setActionName

setActionName(actionName: string): Promise<void>

func setActionName(_ actionName: String)

setActionUserInfoValue

setActionUserInfoValue(info: (unknown) | null, key: UndoManager_UserInfoKey): Promise<void>

func setActionUserInfoValue(_ info: Any?, forKey key: UndoManager.UserInfoKey)

undo

undo(): Promise<void>

func undo()

undoActionUserInfoValue

undoActionUserInfoValue(key: UndoManager_UserInfoKey): Promise<(unknown) | null>

func undoActionUserInfoValue(forKey key: UndoManager.UserInfoKey) -> Any?

undoMenuTitle

undoMenuTitle(actionName: string): Promise<string>

func undoMenuTitle(forUndoActionName actionName: String) -> String

undoNestedGroup

undoNestedGroup(): Promise<void>

func undoNestedGroup()

canRedo

get canRedo(): Promise<boolean>

var canRedo: Bool { get }

canUndo

get canUndo(): Promise<boolean>

var canUndo: Bool { get }

groupingLevel

get groupingLevel(): Promise<number>

var groupingLevel: Int { get }

groupsByEvent

get groupsByEvent(): Promise<boolean>

var groupsByEvent: Bool { get set }

groupsByEvent

setGroupsByEvent(value: boolean): Promise<void>

var groupsByEvent: Bool { get set }

levelsOfUndo

get levelsOfUndo(): Promise<number>

var levelsOfUndo: Int { get set }

levelsOfUndo

setLevelsOfUndo(value: number): Promise<void>

var levelsOfUndo: Int { get set }

redoActionIsDiscardable

get redoActionIsDiscardable(): Promise<boolean>

var redoActionIsDiscardable: Bool { get }

redoActionName

get redoActionName(): Promise<string>

var redoActionName: String { get }

redoCount

get redoCount(): Promise<number>

var redoCount: Int { get }

redoMenuItemTitle

get redoMenuItemTitle(): Promise<string>

var redoMenuItemTitle: String { get }

isRedoing

get isRedoing(): Promise<boolean>

var isRedoing: Bool { get }

runLoopModes

get runLoopModes(): Promise<Array<RunLoop_Mode>>

var runLoopModes: [RunLoop.Mode] { get set }

runLoopModes

setRunLoopModes(value: Array<RunLoop_Mode>): Promise<void>

var runLoopModes: [RunLoop.Mode] { get set }

undoActionIsDiscardable

get undoActionIsDiscardable(): Promise<boolean>

var undoActionIsDiscardable: Bool { get }

undoActionName

get undoActionName(): Promise<string>

var undoActionName: String { get }

undoCount

get undoCount(): Promise<number>

var undoCount: Int { get }

undoMenuItemTitle

get undoMenuItemTitle(): Promise<string>

var undoMenuItemTitle: String { get }

isUndoRegistrationEnabled

get isUndoRegistrationEnabled(): Promise<boolean>

var isUndoRegistrationEnabled: Bool { get }

isUndoing

get isUndoing(): Promise<boolean>

var isUndoing: Bool { get }

registerUndo

registerUndo(target: SDKHandle, handler: ((arg0: SDKHandle) => void)): Promise<void>

@MainActor @preconcurrency func registerUndo<TargetType>(withTarget target: TargetType, handler: @escaping @MainActor (TargetType) -> Void) where TargetType : AnyObject

Registers the specified closure to implement a single undo operation that the target receives. To avoid retain cycles with the target, operate on the closure parameter rather than on variables in an outer scope that reference the same target. - Parameters: - target: The target of the undo operation. The undo manager maintains an unowned reference to the target to prevent retain cycles. - handler: A closure to execute when an operation is undone. The closure takes a single argument, the target of the undo operation.

setActionName

setActionName72256(actionNameResource?: (LocalizedStringResource) | null): Promise<void>

@MainActor @preconcurrency final func setActionName(_ actionNameResource: LocalizedStringResource?)

Sets the name of the action associated with the Undo or Redo command using a localized string resource. This version of `setActionName(_:)` takes a ``LocalizedStringResource``. When using this version, ``undoActionName``, ``redoActionName``, ``undoMenuItemTitle``, and ``redoMenuItemTitle`` interpret the provided resource using the current locale. The undo manager parses the parameter as Markdown using ``AttributedString/init(localized:)`` in order to support inflection. If `actionNameResource` is `nil`, the undo manager removes the action name currently associated with the menu command. - Parameter actionNameResource: The name of the action, as a ``LocalizedStringResource``. Pass in `nil` to reset the action name currently associated with the menu command.