@jupyterlab/notebook

constructor

constructor(model: ISharedNotebook);

• Construct the cell list.

property changed

readonly changed: ISignal<this, IObservableList.IChangedArgs<ICellModel>>;

• A signal emitted when the cell list has changed.

property isDisposed

readonly isDisposed: boolean;

• Test whether the cell list has been disposed.

property length

readonly length: number;

• Get the length of the cell list.

  Returns

  The number of cells in the cell list.

property model

protected model: ISharedNotebook;

method [Symbol.iterator]

[Symbol.iterator]: () => IterableIterator<ICellModel>;

• Create an iterator over the cells in the cell list.

  Returns

  A new iterator starting at the front of the cell list.

method dispose

dispose: () => void;

• Dispose of the resources held by the cell list.

method get

get: (index: number) => ICellModel;

• Get the cell at the specified index.

  Parameter index

  The positive integer index of interest.

  Returns

  The cell at the specified index.

constructor

constructor(widget: Notebook, translator?: ITranslator);

• Construct a new cell type switcher.

property handleChange

handleChange: (event: React.ChangeEvent<HTMLSelectElement>) => void;

• Handle change events for the HTMLSelect component.

property handleKeyDown

handleKeyDown: (event: React.KeyboardEvent) => void;

• Handle keydown events for the HTMLSelect component.

method render

render: () => JSX.Element;

constructor

constructor(translator?: ITranslator);

• Construct a new CommandEdit status item.

property translator

protected translator: ITranslator;

method render

render: () => JSX.Element | null;

• Render the CommandEdit status item.

constructor

constructor(translator?: ITranslator, showProgress?: boolean);

• Construct the kernel status widget.

method render

render: () => JSX.Element | null;

• Render the execution status item.

constructor

constructor(content: KernelMessage.IExecuteReplyMsg);

• Construct the kernel error.

property errorName

readonly errorName: string;

• Exception name

property errorValue

readonly errorValue: string;

• Exception value

property traceback

readonly traceback: string[];

• Traceback

constructor

constructor(options: Notebook.IOptions);

• Construct a notebook widget.

property activeCell

readonly activeCell: any;

• Get the active cell widget.

  #### Notes This is a cell or null if there is no active cell.

property activeCellChanged

readonly activeCellChanged: ISignal<this, any>;

• A signal emitted when the active cell changes.

  #### Notes This can be due to the active index changing or the cell at the active index changing.

property activeCellIndex

activeCellIndex: number;

• The active cell index of the notebook.

  #### Notes The index will be clamped to the bounds of the notebook cells.

property lastClipboardInteraction

lastClipboardInteraction: 'copy' | 'cut' | 'paste';

property mode

mode: NotebookMode;

• The interactivity mode of the notebook.

property selectedCells

readonly selectedCells: Cell[];

• List of selected and active cells

property selectionChanged

readonly selectionChanged: ISignal<this, void>;

• A signal emitted when the selection state of the notebook changes.

property stateChanged

readonly stateChanged: ISignal<this, IChangedArgs<any>>;

• A signal emitted when the state of the notebook changes.

method addFooter

protected addFooter: () => void;

• Adds a footer to the notebook.

method deselect

deselect: (widget: Cell) => void;

• Deselect a cell widget.

  #### Notes It is a no-op if the value does not change. It will emit the selectionChanged signal.

method deselectAll

deselectAll: () => void;

• Deselect all of the cells.

method dispose

dispose: () => void;

• Dispose of the resources held by the widget.

method extendContiguousSelectionTo

extendContiguousSelectionTo: (index: number) => void;

• Move the head of an existing contiguous selection to extend the selection.

  Parameter index

  The new head of the existing selection.

  #### Notes If there is no existing selection, the active cell is considered an existing one-cell selection.

  If the new selection is a single cell, that cell becomes the active cell and all cells are deselected.

  There is no change if there are no cells (i.e., activeCellIndex is -1).

method getContiguousSelection

getContiguousSelection: () =>
    | { head: number; anchor: number }
    | { head: null; anchor: null };

• Get the head and anchor of a contiguous cell selection.

  The head of a contiguous selection is always the active cell.

  If there are no cells selected, {head: null, anchor: null} is returned.

  Throws an error if the currently selected cells do not form a contiguous selection.

method handleEvent

handleEvent: (event: Event) => void;

• Handle the DOM events for the widget.

  Parameter event

  The DOM event sent to the widget.

  #### Notes This method implements the DOM EventListener interface and is called in response to events on the notebook panel's node. It should not be called directly by user code.

method isSelected

isSelected: (widget: Cell) => boolean;

• Whether a cell is selected.

method isSelectedOrActive

isSelectedOrActive: (widget: Cell) => boolean;

• Whether a cell is selected or is the active cell.

method moveCell

moveCell: (from: number, to: number, n?: number) => void;

• Move cells preserving widget view state.

  #### Notes This is required because at the model level a move is a deletion followed by an insertion. Hence the view state is not preserved.

  Parameter from

  The index of the cell to move

  Parameter to

  The new index of the cell

  Parameter n

  Number of cells to move

method onActivateRequest

protected onActivateRequest: (msg: Message) => void;

• Handle 'activate-request' messages.

method onAfterAttach

protected onAfterAttach: (msg: Message) => void;

• Handle after-attach messages for the widget.

method onAfterShow

protected onAfterShow: (msg: Message) => void;

• A message handler invoked on an 'after-show' message.

method onBeforeDetach

protected onBeforeDetach: (msg: Message) => void;

• Handle before-detach messages for the widget.

method onBeforeHide

protected onBeforeHide: (msg: Message) => void;

• A message handler invoked on an 'before-hide' message.

method onCellInserted

protected onCellInserted: (index: number, cell: Cell) => void;

• Handle a cell being inserted.

method onCellRemoved

protected onCellRemoved: (index: number, cell: Cell) => void;

• Handle a cell being removed.

method onModelChanged

protected onModelChanged: (
    oldValue: INotebookModel,
    newValue: INotebookModel
) => void;

• Handle a new model.

method onResize

protected onResize: (msg: Widget.ResizeMessage) => void;

• A message handler invoked on a 'resize' message.

method onUpdateRequest

protected onUpdateRequest: (msg: Message) => void;

• Handle update-request messages sent to the widget.

method scrollToCell

scrollToCell: (cell: Cell, align?: WindowedList.ScrollToAlign) => Promise<void>;

• Scroll so that the given cell is in view. Selects and activates cell.

  Parameter cell

  A cell in the notebook widget.

  Parameter align

  Type of alignment.

method select

select: (widget: Cell) => void;

• Select a cell widget.

  #### Notes It is a no-op if the value does not change. It will emit the selectionChanged signal.

method setFragment

setFragment: (fragment: string) => Promise<void>;

• Set URI fragment identifier.

property executed

static readonly executed: ISignal<
    any,
    {
        notebook: Notebook;
        cell: Cell;
        success: boolean;
        error?: KernelError | null;
    }
>;

• A signal that emits whenever a cell completes execution.

property executionScheduled

static readonly executionScheduled: ISignal<
    any,
    { notebook: Notebook; cell: Cell }
>;

• A signal that emits whenever a cell execution is scheduled.

property selectionExecuted

static readonly selectionExecuted: ISignal<
    any,
    { notebook: Notebook; lastCell: Cell }
>;

• A signal that emits when one notebook's cells are all executed.

constructor

constructor(editorWidget: NotebookPanel, options: IAdapterOptions);

property activeEditor

readonly activeEditor: any;

• Get the activated CM editor.

property documentPath

readonly documentPath: string;

• Get current path of the document.

property editor

readonly editor: Notebook;

• The wrapped Notebook widget.

property editors

readonly editors: Document.ICodeBlockOptions[];

• Get the list of CM editor with its type in the document,

property editorWidget

editorWidget: NotebookPanel;

property languageFileExtension

readonly languageFileExtension: string;

• Get the file extension of the document.

property mimeType

readonly mimeType: string;

• Get the mime type of the document.

property options

protected options: IAdapterOptions;

property ready

readonly ready: Promise<void>;

• Promise that resolves once the adapter is initialized

property wrapperElement

readonly wrapperElement: HTMLElement;

• Get the inner HTMLElement of the document widget.

method createVirtualDocument

createVirtualDocument: () => VirtualDocument;

• Generate the virtual document associated with the document.

method dispose

dispose: () => void;

• Dispose the widget.

method getEditorIndex

getEditorIndex: (ceEditor: Document.IEditor) => number;

• Get the index of input editor

  Parameter ceEditor

  instance of the code editor

method getEditorIndexAt

getEditorIndexAt: (position: IVirtualPosition) => number;

• Get the index of editor from the cursor position in the virtual document.

  Parameter position

  the position of cursor in the virtual document.

method getEditorWrapper

getEditorWrapper: (ceEditor: Document.IEditor) => HTMLElement;

• Get the wrapper of input editor.

  Parameter ceEditor

  instance of the code editor

method handleCellChange

handleCellChange: (
    cells: CellList,
    change: IObservableList.IChangedArgs<ICellModel>
) => Promise<void>;

• Update the virtual document on cell changing event.

  Parameter cells

  Observable list of changed cells

  Parameter change

  Changed data

method initOnceReady

protected initOnceReady: () => Promise<void>;

• Initialization function called once the editor and the LSP connection manager is ready. This function will create the virtual document and connect various signals.

method isReady

isReady: () => boolean;

• Method to check if the notebook context is ready.

method language_info

protected language_info: () => nbformat.ILanguageInfoMetadata;

• Get the metadata of notebook.

method onKernelChanged

onKernelChanged: (
    _session: SessionContext,
    change: Session.ISessionConnection.IKernelChangedArgs
) => Promise<void>;

• Callback on kernel changed event, it will disconnect the document with the language server and then reconnect.

  Parameter _session

  Session context of changed kernel

  Parameter change

  Changed data

constructor

constructor(options?: NotebookModel.IOptions);

• Construct a new notebook model.

property cells

readonly cells: CellList;

• Get the observable list of notebook cells.

property collaborative

readonly collaborative: boolean;

• Whether the model is collaborative or not.

property contentChanged

readonly contentChanged: ISignal<this, void>;

• A signal emitted when the document content changes.

property defaultKernelLanguage

readonly defaultKernelLanguage: string;

• The default kernel language of the document.

property defaultKernelName

readonly defaultKernelName: string;

• The default kernel name of the document.

property deletedCells

readonly deletedCells: string[];

• A list of deleted cells for the notebook..

property dirty

dirty: boolean;

• The dirty state of the document.

property isDisposed

readonly isDisposed: boolean;

• Whether the model is disposed.

property metadata

readonly metadata: nbformat.INotebookMetadata;

• The metadata associated with the notebook.

  ### Notes This is a copy of the metadata. Changing a part of it won't affect the model. As this returns a copy of all metadata, it is advised to use getMetadata to speed up the process of getting a single key.

property metadataChanged

readonly metadataChanged: ISignal<INotebookModel, IMapChange<any>>;

• Signal emitted when notebook metadata changes.

property nbformat

readonly nbformat: number;

• The major version number of the nbformat.

property nbformatMinor

readonly nbformatMinor: number;

• The minor version number of the nbformat.

property readOnly

readOnly: boolean;

• The read only state of the document.

property sharedModel

readonly sharedModel: ISharedNotebook;

• The shared notebook model.

property standaloneModel

protected standaloneModel: boolean;

• Whether the model should disposed the shared model on disposal or not.

property stateChanged

readonly stateChanged: ISignal<this, IChangedArgs<any>>;

• A signal emitted when the document state changes.

method deleteMetadata

deleteMetadata: (key: string) => void;

• Delete a metadata

  Parameter key

  Metadata key

method dispose

dispose: () => void;

• Dispose of the resources held by the model.

method fromJSON

fromJSON: (value: nbformat.INotebookContent) => void;

• Deserialize the model from JSON.

  #### Notes Should emit a [contentChanged] signal.

method fromString

fromString: (value: string) => void;

• Deserialize the model from a string.

  #### Notes Should emit a [contentChanged] signal.

method getMetadata

getMetadata: (key: string) => any;

• Get a metadata

  ### Notes This returns a copy of the key value.

  Parameter key

  Metadata key

method setMetadata

setMetadata: (key: string, value: any) => void;

• Set a metadata

  Parameter key

  Metadata key

  Parameter value

  Metadata value

method toJSON

toJSON: () => nbformat.INotebookContent;

• Serialize the model to JSON.

method toString

toString: () => string;

• Serialize the model to a string.

method triggerContentChange

protected triggerContentChange: () => void;

• Trigger a content changed signal.

method triggerStateChange

protected triggerStateChange: (args: IChangedArgs<any>) => void;

• Trigger a state change signal.

constructor

constructor(options?: NotebookModelFactory.IOptions);

• Construct a new notebook model factory.

property collaborative

readonly collaborative: boolean;

• Whether the model is collaborative or not.

property contentType

readonly contentType: Contents.ContentType;

• The content type of the file.

property disableDocumentWideUndoRedo

disableDocumentWideUndoRedo: boolean;

• Define the disableDocumentWideUndoRedo property.

  Modifiers

  • @experimental
  • @alpha

property fileFormat

readonly fileFormat: Contents.FileFormat;

• The format of the file.

property isDisposed

readonly isDisposed: boolean;

• Get whether the model factory has been disposed.

property name

readonly name: string;

• The name of the model.

method createNew

createNew: (
    options?: DocumentRegistry.IModelOptions<ISharedNotebook>
) => INotebookModel;

• Create a new model for a given path.

  Parameter languagePreference

  An optional kernel language preference.

  Returns

  A new document model.

method dispose

dispose: () => void;

• Dispose of the model factory.

method preferredLanguage

preferredLanguage: (path: string) => string;

• Get the preferred kernel language given a path.

constructor

constructor(options: DocumentWidget.IOptions<Notebook, INotebookModel>);

• Construct a new notebook panel.

property model

readonly model: INotebookModel;

• The model for the widget.

property sessionContext

readonly sessionContext: ISessionContext;

• The session context used by the panel.

property translator

translator: ITranslator;

method [Printing.symbol]

[Printing.symbol]: () => () => Promise<void>;

• Prints the notebook by converting to HTML with nbconvert.

method dispose

dispose: () => void;

• Dispose of the resources used by the widget.

method onBeforeHide

protected onBeforeHide: (msg: Message) => void;

• A message handler invoked on a 'before-hide' message.

method onBeforeShow

protected onBeforeShow: (msg: Message) => void;

• A message handler invoked on a 'before-show' message.

method setConfig

setConfig: (config: NotebookPanel.IConfig) => void;

• Update the options for the current notebook panel.

  Parameter config

  new options to set

method setFragment

setFragment: (fragment: string) => void;

• Set URI fragment identifier.

constructor

constructor(widget: NotebookPanel, translator?: ITranslator);

• Constructor

  Parameter widget

  The widget to search in

  Parameter translator

  Application translator

property currentMatchIndex

readonly currentMatchIndex: number;

• The current index of the selected match.

property delayedActiveCellChangeHandlerReady

protected delayedActiveCellChangeHandlerReady: Promise<void>;

property isReadOnly

readonly isReadOnly: boolean;

• Set to true if the widget under search is read-only, false if it is editable. Will be used to determine whether to show the replace option.

property matchesCount

readonly matchesCount: number;

• The number of matches.

property replaceOptionsSupport

readonly replaceOptionsSupport: IReplaceOptionsSupport;

• Support for options adjusting replacement behavior.

property translator

protected translator: ITranslator;

method clearHighlight

clearHighlight: () => Promise<void>;

• Clear currently highlighted match.

method createNew

static createNew: (
    widget: NotebookPanel,
    translator?: ITranslator
) => ISearchProvider;

• Instantiate a search provider for the notebook panel.

  #### Notes The widget provided is always checked using isApplicable before calling this factory.

  Parameter widget

  The widget to search on

  Parameter translator

  [optional] The translator object

  Returns

  The search provider on the notebook panel

method dispose

dispose: () => void;

• Dispose of the resources held by the search provider.

  #### Notes If the object's dispose method is called more than once, all calls made after the first will be a no-op.

  #### Undefined Behavior It is undefined behavior to use any functionality of the object after it has been disposed unless otherwise explicitly noted.

method endQuery

endQuery: () => Promise<void>;

• Stop the search and clear all internal state.

method getFilters

getFilters: () => { [key: string]: IFilter };

• Get the filters for the given provider.

  Returns

  The filters.

method getInitialQuery

getInitialQuery: () => string;

• Get an initial query value if applicable so that it can be entered into the search box as an initial query

  Returns

  Initial value used to populate the search box.

method highlightNext

highlightNext: (
    loop?: boolean,
    options?: IHighlightAdjacentMatchOptions
) => Promise<ISearchMatch | undefined>;

• Highlight the next match.

  Parameter loop

  Whether to loop within the matches list.

  Returns

  The next match if available.

method highlightPrevious

highlightPrevious: (
    loop?: boolean,
    options?: IHighlightAdjacentMatchOptions
) => Promise<ISearchMatch | undefined>;

• Highlight the previous match.

  Parameter loop

  Whether to loop within the matches list.

  Returns

  The previous match if available.

method isApplicable

static isApplicable: (domain: Widget) => domain is NotebookPanel;

• Report whether or not this provider has the ability to search on the given object

  Parameter domain

  Widget to test

  Returns

  Search ability

method replaceAllMatches

replaceAllMatches: (
    newText: string,
    options?: IReplaceOptions
) => Promise<boolean>;

• Replace all matches in the notebook with the provided text

  Parameter newText

  The replacement text.

  Returns

  A promise that resolves with a boolean indicating whether a replace occurred.

method replaceCurrentMatch

replaceCurrentMatch: (
    newText: string,
    loop?: boolean,
    options?: IReplaceOptions
) => Promise<boolean>;

• Replace the currently selected match with the provided text

  Parameter newText

  The replacement text.

  Parameter loop

  Whether to loop within the matches list.

  Returns

  A promise that resolves with a boolean indicating whether a replace occurred.

method startQuery

startQuery: (query: RegExp, filters: IFilters | undefined) => Promise<void>;

• Search for a regular expression with optional filters.

  Parameter query

  A regular expression to test for

  Parameter filters

  Filter parameters to pass to provider

method validateFilter

validateFilter: (name: string, value: boolean) => Promise<boolean>;

constructor

constructor(
    tracker: INotebookTracker,
    parser: any,
    sanitizer: IRenderMime.ISanitizer
);

• Constructor

  Parameter tracker

  Widget tracker

  Parameter parser

  Markdown parser

  Parameter sanitizer

  Sanitizer

property parser

protected parser: any;

property sanitizer

protected sanitizer: IRenderMime.ISanitizer;

constructor

constructor(
    widget: NotebookPanel,
    parser: any,
    sanitizer: IRenderMime.ISanitizer,
    configuration?: TableOfContents.IConfig
);

• Constructor

  Parameter widget

  The widget to search in

  Parameter parser

  Markdown parser

  Parameter sanitizer

  Sanitizer

  Parameter configuration

  Default model configuration

property configMetadataMap

protected configMetadataMap: {
    [k: string]: string[];
    [k: number]: string[];
    [k: symbol]: string[];
};

• Mapping between configuration options and notebook metadata.

  If it starts with !, the boolean value of the configuration option is opposite to the one stored in metadata. If it contains /, the metadata data is nested.

property documentType

readonly documentType: string;

• Type of document supported by the model.

  #### Notes A data-document-type attribute with this value will be set on the tree view .jp-TableOfContents-content[data-document-type="..."]

property isAlwaysActive

readonly isAlwaysActive: boolean;

• Whether the model gets updated even if the table of contents panel is hidden or not.

property parser

protected parser: any;

property sanitizer

protected sanitizer: IRenderMime.ISanitizer;

property supportedOptions

readonly supportedOptions: (string | number | symbol)[];

• List of configuration options supported by the model.

method dispose

dispose: () => void;

• Dispose the object

method getCellHeadings

getCellHeadings: (cell: Cell) => INotebookHeading[];

• Get the headings of a given cell.

  Parameter cell

  Cell

  Returns

  The associated headings

method getHeadings

protected getHeadings: () => Promise<INotebookHeading[] | null>;

• Produce the headings for a document.

  Returns

  The list of new headings or null if nothing needs to be updated.

method loadConfigurationFromMetadata

protected loadConfigurationFromMetadata: () => TableOfContents.IConfig;

• Read table of content configuration from notebook metadata.

  Returns

  ToC configuration from metadata

method onActiveCellChanged

protected onActiveCellChanged: (
    notebook: Notebook,
    cell: Cell<ICellModel>
) => void;

method onExecuted

protected onExecuted: (
    _: unknown,
    args: { notebook: Notebook; cell: Cell }
) => void;

method onExecutionScheduled

protected onExecutionScheduled: (
    _: unknown,
    args: { notebook: Notebook; cell: Cell }
) => void;

method onHeadingsChanged

protected onHeadingsChanged: () => void;

method onMetadataChanged

protected onMetadataChanged: () => void;

method setConfiguration

setConfiguration: (c: TableOfContents.IConfig) => void;

• Model configuration setter.

  Parameter c

  New configuration

method toggleCollapse

toggleCollapse: (options: {
    heading?: INotebookHeading;
    collapsed?: boolean;
}) => void;

• Callback on heading collapse.

  Parameter

  options.heading The heading to change state (all headings if not provided)

  Parameter

  options.collapsed The new collapsed status (toggle existing status if not provided)

method updateRunningStatus

protected updateRunningStatus: (headings: INotebookHeading[]) => void;

constructor

constructor(options: NotebookTools.IOptions);

• Construct a new NotebookTools object.

property activeCell

readonly activeCell: any;

• The active cell widget.

property activeNotebookPanel

readonly activeNotebookPanel: NotebookPanel;

• The current notebook.

property selectedCells

readonly selectedCells: Cell[];

• The currently selected cells.

property translator

translator: ITranslator;

method addItem

addItem: (options: NotebookTools.IAddOptions) => void;

• Add a cell tool item.

method addSection

addSection: (options: NotebookTools.IAddSectionOptions) => void;

property activeCell

readonly activeCell: any;

• The currently focused cell.

  #### Notes This is a read-only property. If there is no cell with the focus, then this value is null.

property activeCellChanged

readonly activeCellChanged: ISignal<this, any>;

• A signal emitted when the current active cell changes.

  #### Notes If there is no cell with the focus, then null will be emitted.

property selectionChanged

readonly selectionChanged: ISignal<this, void>;

• A signal emitted when the selection state changes.

method add

add: (panel: NotebookPanel) => Promise<void>;

• Add a new notebook panel to the tracker.

  Parameter panel

  The notebook panel being added.

method dispose

dispose: () => void;

• Dispose of the resources held by the tracker.

method onCurrentChanged

protected onCurrentChanged: (widget: NotebookPanel) => void;

• Handle the current change event.

constructor

constructor(translator?: ITranslator);

• Construct a new status item.

property translator

translator: ITranslator;

method render

render: () => JSX.Element | null;

• Render the NotebookTrust status item.

constructor

constructor(cells: Cell[], options?: WindowedList.IModelOptions);

• Construct a notebook windowed list model.

property cells

protected cells: Cell[];

property DEFAULT_CELL_MARGIN

static DEFAULT_CELL_MARGIN: number;

• Default cell margin (top + bottom)

property DEFAULT_CELL_SIZE

static DEFAULT_CELL_SIZE: number;

• Default cell height

property DEFAULT_EDITOR_LINE_HEIGHT

static DEFAULT_EDITOR_LINE_HEIGHT: number;

• Default editor line height

property estimateWidgetSize

estimateWidgetSize: (index: number) => number;

• Cell size estimator

  Parameter index

  Cell index

  Returns

  Cell height in pixels

property widgetRenderer

widgetRenderer: (index: number) => Widget;

• Render the cell at index.

  Parameter index

  Cell index

  Returns

  Cell widget

constructor

constructor(options: NotebookWidgetFactory.IOptions<NotebookPanel>);

• Construct a new notebook widget factory.

  Parameter options

  The options used to construct the factory.

property contentFactory

readonly contentFactory: NotebookPanel.IContentFactory;

• The content factory used by the widget factory.

property editorConfig

editorConfig: StaticNotebook.IEditorConfig;

• A configuration object for cell editor settings.

property mimeTypeService

readonly mimeTypeService: IEditorMimeTypeService;

• The service used to look up mime types.

property notebookConfig

notebookConfig: StaticNotebook.INotebookConfig;

• A configuration object for notebook settings.

property rendermime

readonly rendermime: IRenderMimeRegistry;

method createNewWidget

protected createNewWidget: (
    context: DocumentRegistry.IContext<INotebookModel>,
    source?: NotebookPanel
) => NotebookPanel;

• Create a new widget.

  #### Notes The factory will start the appropriate kernel.

property footer

footer: any;

• Notebook widget's footer

property header

header: any;

• Notebook's header

method attachWidget

protected attachWidget: (index: number, widget: Widget) => void;

• Attach a widget to the parent's DOM node.

  Parameter index

  The current index of the widget in the layout.

  Parameter widget

  The widget to attach to the parent.

  #### Notes This method is called automatically by the panel layout at the appropriate time. It should not be called directly by user code.

  The default implementation adds the widgets's node to the parent's node at the proper location, and sends the appropriate attach messages to the widget if the parent is attached to the DOM.

  Subclasses may reimplement this method to control how the widget's node is added to the parent's node.

method detachWidget

protected detachWidget: (index: number, widget: Widget) => void;