export default HiGlassComponent; declare class HiGlassComponent extends React.Component { constructor(props: any); topDivRef: React.RefObject; pubSub: any; domEvent: any; pubSubs: any[]; minHorizontalHeight: number; minVerticalWidth: number; resizeSensor: ResizeSensor | null; uid: string; /** @type {Record */ tiledPlots: Record; genomePositionSearchBoxes: {}; /** @type {Record} */ xScales: Record; /** @type {Record} */ yScales: Record; projectionXDomains: {}; projectionYDomains: {}; topDiv: any; zoomToDataExtentOnInit: Set; viewTrackUidsToCombinedUid: {}; combinedUidToViewTrack: {}; scalesChangedListeners: {}; draggingChangedListeners: {}; valueScalesChangedListeners: {}; zoomLocks: {}; locationLocks: {}; locationLocksAxisWise: { x: {}; y: {}; }; valueScaleLocks: {}; prevAuthToken: any; setCenters: {}; plusImg: {}; configImg: {}; viewMarginTop: number; viewMarginBottom: number; viewMarginLeft: number; viewMarginRight: number; viewPaddingTop: number; viewPaddingBottom: number; viewPaddingLeft: number; viewPaddingRight: number; genomePositionSearchBox: any; viewHeaders: {}; boundRefreshView: () => void; unsetOnLocationChange: any[]; viewconfLoaded: boolean; pixiRoot: PIXI.Container; pixiStage: PIXI.Container; pixiMask: PIXI.Graphics; element: any; scrollTop: number; mounted: boolean; pluginTracks: {}; pluginDataFetchers: any; state: { width: number; height: number; rowHeight: number; svgElement: null; canvasElement: null; customDialog: null; views: {}; viewConfig: any; addTrackPositionMenuPosition: null; typedEditable: undefined; mouseOverOverlayUid: null; mouseTool: string; overTrackChooser: null; isDarkTheme: boolean; rangeSelection1dSize: number[]; rangeSelectionToInt: boolean; modal: null; sizeMode: any; }; attachedToDOM: boolean; api: { readonly version: string; setBroadcastMousePositionGlobally(isBroadcastMousePositionGlobally?: boolean): void; setShowGlobalMousePosition(isShowGlobalMousePosition?: boolean): void; setGlobalMousePosition(isGlobalMousePosition?: boolean): void; setAuthHeader(newHeader: string): void; getAuthHeader(): string | null; getComponent(): HiGlassComponent; reload(target: array): void; destroy(): void; setRangeSelectionToInt(): void; setRangeSelectionToFloat(): void; setRangeSelection1dSize(minSize?: number, maxSize?: number): void; setViewConfig(newViewConfig: obj, resolveImmediately?: boolean): Promise; getViewConfig(): any; validateViewConfig(viewConfig: any, { verbose }?: { verbose?: boolean | undefined; }): boolean | PromiseLike; getMinMaxValue(viewId: string, trackId: string, ignoreOffScreenValues?: bool, ignoreFixedScale?: bool): any[]; shareViewConfigAsLink(url: string): Object; showAvailableTrackPositions(track: obj): void; hideAvailableTrackPositions(): void; measureSize(): void; showTrackChooser(callback: Function): [type]; hideTrackChooser(): void; setTrackValueScaleLimits(viewId?: string, trackId?: string, minValue: any, maxValue: any): void; setDarkTheme(darkTheme: any): void; setTheme(theme: any): void; zoomTo(viewUid: string, start1Abs: number, end1Abs: number, start2Abs: number, end2Abs: number, animateTime?: number): void; zoomToGene(viewUid: string, geneName: string, padding?: string, animateTime?: number): void; suggestGene(viewUid: string, keyword: string, callback: Function): void; zoomToDataExtent(viewUid: string): void; resetViewport(viewId: string): void; activateTool(tool: any): void; setSizeMode(sizeMode: string): void; exportAsPngBlobPromise(): promise; exportAsSvg(): string; exportAsViewConfString(): string; getRangeSelection(): any[]; getLocation(viewId?: string): obj; getTrackObject(viewId: string, trackId: string): obj; option(key: string, value: any): obj; off(event: string, listenerId: any, viewId: string): void; on(event: string, callback: Function, viewId: string, callbackId: any): any; }; apiDestroy: () => void; apiPublish: any; apiStack: any; viewChangeListener: any[]; triggerViewChangeDb: { (...args: any[]): void; cancel(): void; }; rangeSelection: null[]; prevMouseHoverTrack: any; zooming: boolean; appClickHandlerBound: (data: any) => void; canvasClickHandlerBound: (evt: any) => void; keyDownHandlerBound: (event: any) => void; keyUpHandlerBound: (event: any) => void; resizeHandlerBound: () => void; dispatchEventBound: (e: any) => void; animateOnMouseMoveHandlerBound: (active: any) => void; zoomStartHandlerBound: () => void; zoomEndHandlerBound: () => void; zoomHandlerBound: (evt: any) => void; trackDroppedHandlerBound: () => void; trackDimensionsModifiedHandlerBound: (settings: { viewId: string; trackId: string; height: number; width: nmber; }) => void; animateBound: () => void; animateOnGlobalEventBound: ({ sourceUid }?: {}) => void; requestReceivedHandlerBound: () => void; wheelHandlerBound: (evt: any) => void; mouseMoveHandlerBound: (e: object) => void; onMouseLeaveHandlerBound: () => void; onBlurHandlerBound: () => void; openModalBound: (modal: any) => void; closeModalBound: () => void; handleEditViewConfigBound: () => void; onScrollHandlerBound: () => void; viewUidToNameBound: (viewUid: any) => string; typedText: string; typedTextTimeout: NodeJS.Timeout | null; modal: { open: (modal: any) => void; close: () => void; }; UNSAFE_componentWillMount(): void; get sizeMode(): any; setBroadcastMousePositionGlobally(isBroadcastMousePositionGlobally?: boolean): void; isBroadcastMousePositionGlobally: boolean | undefined; setShowGlobalMousePosition(isShowGlobalMousePosition?: boolean): void; isShowGlobalMousePosition: boolean | undefined; globalMousePositionListener: createPubSub.Subscription | undefined; zoomStartHandler(): void; zoomEndHandler(): void; zoomHandler(evt: any): void; waitForDOMAttachment(callback: any): void; componentDidMount(): void; pixiRenderer: any; getTrackObject(viewUid: any, trackUid: any): import("./types").TrackObject | undefined; getTrackRenderer(viewUid: any): import("./TrackRenderer").TrackRenderer | null; UNSAFE_componentWillReceiveProps(newProps: any): void; UNSAFE_componentWillUpdate(): void; reload(): void; componentDidUpdate(): void; componentWillUnmount(): void; setTheme(newTheme?: any, isDarkTheme?: any): void; theme: string | typeof THEME_LIGHT | typeof THEME_DARK | undefined; dispatchEvent(e: any): void; trackDroppedHandler(): void; requestReceivedHandler(): void; animateOnMouseMoveHandler(active: any): void; animateOnMouseMove: any; fitPixiToParentContainer(): void; /** * Add default track options. These can come from two places: * * 1. The track definitions (configs/tracks-info.js) * 2. The default options passed into the component * * Of these, #2 takes precendence over #1. * * @param {array} track The track to add default options to */ addDefaultTrackOptions(track: array): void; toggleTypedEditable(): void; /** Handle typed commands (e.g. e-d-i-t) */ typedTextHandler(event: any): void; keyDownHandler(event: any): void; keyUpHandler(event: any): void; openModal(modal: any): void; modalRef: any; closeModal(): void; handleEditViewConfig(): void; animate(): void; isRequestingAnimationFrame: boolean | undefined; animateOnGlobalEvent({ sourceUid }?: {}): void; measureSize(): void; updateAfterResize(): void; handleOverlayMouseEnter(uid: any): void; handleOverlayMouseLeave(): void; /** * We want to lock the zoom of this view to the zoom of another view. * * First we pick which other view we want to lock to. * * The we calculate the current zoom offset and center offset. The differences * between the center of the two views will always remain the same, as will the * different between the zoom levels. */ handleLockLocation(uid: any): void; /** * Can views be added, removed or rearranged and are the view headers * visible? */ isEditable(): any; /** * Can views be added, removed or rearranged and are the view headers * visible? */ isTrackMenuDisabled(): any; /** * Can views be added, removed or rearranged and are the view headers * visible? */ isViewHeaderDisabled(): any; /** * Iteratate over all of the views in this component */ iterateOverViews(): string[]; iterateOverTracksInView(viewId: any): { viewId: any; trackId: any; track: any; }[]; /** * Iterate over all the tracks in this component. */ iterateOverTracks(): { viewId: string; trackId: string; track: import("./types").UnknownTrackConfig; }[]; setMouseTool(mouseTool: any): void; setSizeMode(sizeMode: any): void; /** * Checks if a track's value scale is locked with another track */ isValueScaleLocked(viewUid: any, trackUid: any): boolean; /** * Computed the minimal and maximal values of all tracks that are in the same * lockGroup as a given track * @param {string} viewUid The id of the view containing the track * @param {string} trackUid The id of the track * @return {array} Tuple [min,max] containing the overall extrema - or null. */ getLockGroupExtrema(viewUid: string, trackUid: string): array; /** * Syncing the values of locked scales * * Arguments * --------- * viewUid: string * The id of the view containing the track whose value scale initially changed * trackUid: string * The id of the track that whose value scale changed * * Returns * ------- * Nothing */ syncValueScales(viewUid: any, trackUid: any): void; handleNewTilesLoaded(viewUid: any, trackUid: any): void; notifyDragChangedListeners(dragging: any): void; /** * Add a listener that will be called every time the view is updated. * * @param viewUid: The uid of the view being observed * @param listenerUid: The uid of the listener * @param eventHandler: The handler to be called when the scales change * Event handler is called with parameters (xScale, yScale) */ addDraggingChangedListener(viewUid: any, listenerUid: any, eventHandler: any): void; /** * Remove a scale change event listener * * @param viewUid: The view that it's listening on. * @param listenerUid: The uid of the listener itself. */ removeDraggingChangedListener(viewUid: any, listenerUid: any): void; /** * Add an event listener that will be called every time the scale * of the view with uid viewUid is changed. * * @param viewUid: The uid of the view being observed * @param listenerUid: The uid of the listener * @param eventHandler: The handler to be called when the scales change * Event handler is called with parameters (xScale, yScale) */ addScalesChangedListener(viewUid: any, listenerUid: any, eventHandler: any): void; /** * Remove a scale change event listener * * @param viewUid: The view that it's listening on. * @param listenerUid: The uid of the listener itself. */ removeScalesChangedListener(viewUid: any, listenerUid: any): void; createSVG(): any; createSVGString(): string; handleExportSVG(): void; offPostCreateSVG(): void; postCreateSVGCallback: any; onPostCreateSVG(callback: any): void; createPNGBlobPromise(): Promise; handleExportPNG(): void; handleScalesChanged(uid: any, xScale: any, yScale: any, notify?: boolean): void; handleProjectViewport(uid: any): void; /** * Adjust the zoom level so that all of the data is visible * * @param viewUid: The view uid for which to adjust the zoom level */ handleZoomToData(viewUid: any): void; /** * Reset the viewport to the initial x and y domain * @param {number} viewId - ID of the view for which the viewport should be * reset. */ resetViewport(viewId: number): void; /** * We want to yank some attributes from another view. * * This will create a view selection overlay and then call the selected * provided function. */ handleYankFunction(uid: any, yankFunction: any): void; /** * We want to unlock uid from the zoom group that it's in. * * @param uid: The uid of a view. */ handleUnlock(uid: any, lockGroups: any): void; viewScalesLockData(uid: any): [xCenter: number, yCenter: number, k: number] | null; addLock(uid1: any, uid2: any, lockGroups: any, lockData: any): void; handleLocationLockChosen(uid1: any, uid2: any): void; handleZoomLockChosen(uid1: any, uid2: any): void; /** * We want to project the viewport of fromView onto toTrack of toView. * * @param fromView: The uid of the view that we want to project * @param toView: The uid of the view that we want to project to * @param toTrack: The track we want to project to * * Returns * ------- * * newTrackUid: string * The uid of the newly created viewport projection track */ handleViewportProjected(fromView: any, toView: any, toTrack: any): string | null; /** * Uid1 is copying the center of uid2 */ handleLocationYanked(uid1: any, uid2: any): void; /** * Uid1 yanked the zoom of uid2, now make sure that they're synchronized. */ handleZoomYanked(uid1: any, uid2: any): void; /** * The user has chosen a position for the new track. The actual * track selection will be handled by TiledPlot * * We just need to close the menu here. */ handleTrackPositionChosen(viewUid: any, position: any, extent: any): void; /** * Update the height of each row in the layout so that it takes up all * of the available space in the div. */ updateRowHeight(): void; /** * Notify the children that the layout has changed so that they * know to redraw themselves */ handleLayoutChange(layout: any): void; /** * Maybe somebody started dragging again before the previous drag * timeout fired. In that case, we need to clear this timeout so * that it doesn't override a previously set one. */ clearDragTimeout(): void; dragTimeout: NodeJS.Timeout | null | undefined; getTrackInfo(trackType: any): any; forceRefreshView(): void; refreshView(timeout?: number): void; handleDragStart(): void; handleDragStop(): void; resizeHandler(): void; /** * Get the dimensions for this view, counting just the tracks * that are present in it * * @param view: A view containing a list of tracks as a member. * @return: A width and a height pair (e.g. [width, height]) */ calculateViewDimensions(view: any): { totalWidth: number; totalHeight: number; topHeight: number; bottomHeight: number; leftWidth: number; rightWidth: number; centerWidth: number; centerHeight: number; minNecessaryHeight: number; }; calculateZoomLimits(view: any, initialXDomain: any): number[]; generateViewLayout(view: any): any; /** * Remove all the tracks from a view * * @param {viewUid} Thie view's identifier */ handleClearView(viewUid: any): void; /** * A view needs to be closed. Remove it from from the viewConfig and then clean * up all of its connections (zoom links, workers, etc...) * * @param {uid} This view's identifier */ handleCloseView(uid: any): void; /** * We're adding a new dataset to an existing track * * @param newTrack: The new track to be added. * @param position: Where the new series should be placed. * (This could also be inferred from the hostTrack, but since * we already have it, we might as well use it) * @param hostTrack: The track that will host the new series. */ handleSeriesAdded(viewId: any, newTrack: any, position: any, hostTrack: any): void; handleNoTrackAdded(): void; /** * Add multiple new tracks (likely from the AddTrackModal dialog) * * @param trackInfo: A JSON object that can be used as a track * definition * @param position: The position the track is being added to * @param host: If this track is being added to another track */ handleTracksAdded(viewId: any, newTracks: any, position: any, extent: any, host: any): void; /** * Change the type of a track. For example, convert a line to a bar track. * * Parameters * ---------- * viewUid: string * The view containing the track to be changed * trackUid: string * The uid identifying the existin track * newType: string * The type to switch this track to. */ handleChangeTrackType(viewUid: any, trackUid: any, newType: any): void; /** * Change the data source for a track. E.g. when adding or * removing a divisor. * * Parameters * ---------- * viewUid: string * The view containing the track to be changed * trackUid: string * The uid identifying the existin track * newData: object * The new data source section */ handleChangeTrackData(viewUid: any, trackUid: any, newData: any): void; /** * A track was added from the AddTrackModal dialog. * * @param trackInfo: A JSON object that can be used as a track * definition * @param position: The position the track is being added to * @param host: If this track is being added to another track * * @returns {Object}: A trackConfig (\{ uid: "", width: x \}) * describing this track */ handleTrackAdded(viewId: any, newTrack: any, position: any, extent?: null, host?: null): Object; /** * We're adding a new heatmap to a combined track. We need to make sure that * their options are compatible. * * @param {object} newTrack New heatmap track * @param {object} combinedTrack Combined track the new heatmap is added to */ compatibilityfyStackedHeatmaps(newTrack: object, combinedTrack: object): void; /** * Go through each track and store its size in the viewconf. * * This is so that sizes don't get lost when the view is unbounded * and new tracks are added. * * Parameters * ---------- * * viewId : string * The id of the view whose tracks we're measuring * * Returns * ------- * * Nothing */ storeTrackSizes(viewId: any): void; adjustLayoutToTrackSizes(view: any): void; handleCloseTrack(viewId: any, uid: any): {}; handleLockValueScale(fromViewUid: any, fromTrackUid: any): void; combineViewAndTrackUid(viewUid: any, trackUid: any): any; /** * Update all locks involving this track to use a new track uid. * * @param {string} viewUid The view's uid * @param {string} oldTrackUid The track's old uid * @param {string} newTrackUid The track's new uid */ updateTrackLocks(viewUid: string, oldTrackUid: string, newTrackUid: string): void; handleUnlockValueScale(viewUid: any, trackUid: any): void; handleValueScaleLocked(fromViewUid: any, fromTrackUid: any, toViewUid: any, toTrackUid: any): void; /** * Add callbacks for functions that need them * * Done in place. * * @param {string} viewUid * @param {{ * type: string; * uid: string; * fromViewUid: string; * registerViewportChanged: (string: trackId, listener: () => void) => void; * removeViewportChanged: (string: trackId) => void; * removeScalesChangedListener: (string: trackId) => void; * }} track A view with tracks. */ addCallbacks(viewUid: string, track: { type: string; uid: string; fromViewUid: string; registerViewportChanged: (string: trackId, listener: () => void) => void; removeViewportChanged: (string: trackId) => void; removeScalesChangedListener: (string: trackId) => void; }): void; validateLocks(locks: any): void; deserializeLocationLocks(viewConfig: any): void; deserializeZoomLocks(viewConfig: any): void; deserializeValueScaleLocks(viewConfig: any): void; serializeLocks(locks: any): { locksByViewUid: {}; locksDict: {}; }; getViewsAsJson(views: any): any; getViewsAsString(): string; handleExportViewAsJSON(): void; handleExportViewsAsLink(url?: any, fromApi?: boolean): Promise<{ id: any; url: string; }>; handleDataDomainChanged(viewUid: any, newXDomain: any, newYDomain: any): void; /** * Check if we can place a view at this position */ viewPositionAvailable(pX: any, pY: any, w: any, h: any): boolean; /** * User clicked on the "Add View" button. We'll duplicate the last * view. */ handleAddView(view: any, newViewParams: any, noUpdate: any): { newViewUid: any; newViewconf: any; }; createGenomePostionSearchBoxEntry(existingGenomePositionSearchBox: any, suggestedAssembly: any): any; handleTogglePositionSearchBox(viewUid: any): void; handleTrackOptionsChanged(viewUid: any, trackUid: any, newOptions: any): void; /** * For convenience we adjust some options of split heatmap tracks when they are newly added. * This function has no effect when we get split heatmap tracks that are already correctly configured * (i.e. correctly set "lower-extend"/"upper-extend" options) * @param {object} track Track whose options have changed * @param {object} options New track options * @param {list} allTracks All tracks * @param {string} viewUid Related view UID */ adjustSplitHeatmapTrackOptions(track: object, options: object, allTracks: list, viewUid: string): void; handleViewOptionsChanged(viewUid: any, newOptions: any): void; /** * Determine whether a track is valid and can be displayed. * * Tracks can be invalid due to inconsistent input such as * referral to views that don't exist * * @param track (object): A track definition * @param viewUidsPresent (Set): The view uids which are available */ isTrackValid(track: any, viewUidsPresent: any): boolean; /** * Remove tracks which can no longer be shown (possibly because the views they * refer to no longer exist */ removeInvalidTracks(viewsByUid: any): any; processViewConfig(viewConfig: any): {}; handleWindowFocused(): void; /** * Handle range selection events. * * @description * Store active range selectio and forward the range selection event to the * API. * * @param {Array} range Double array of the selected range. */ rangeSelectionHandler(range: any[]): void; offViewChange(callback: any): void; onViewChange(callback: any): number; triggerViewChange(): void; getGenomeLocation(viewId: any): Promise<[startChromName: string, startChromPos: number, endChromName: string, endChromPos: number, startChromName: string, startChromPos: number, endChromName: string, endChromPos: number] | undefined>; offLocationChange(viewId: any, listenerId: any): void; zoomTo(viewUid: any, start1Abs: any, end1Abs: any, start2Abs: any, end2Abs: any, animateTime: any): void; zoomToGene(viewUid: any, geneName: any, padding: any, animateTime: any): void; suggestGene(viewUid: any, keyword: any, callback: any): void; onLocationChange(viewId: any, callback: any, callbackId: any): number | null; /** * List all the views that are at the given position view position */ getTiledPlotAtPosition(x: any, y: any): import("./TiledPlot").TiledPlot | undefined; /** * Handle mousemove events by republishing the event using pubSub. * * @param {object} e Event object. */ mouseMoveHandler(e: object): void; getMinMaxValue(viewId: any, trackId: any, ignoreOffScreenValues: any, ignoreFixedScale: any): any[] | undefined; showHoverUids(evt: any): void; /** * Show a menu displaying some information about the track under it */ showHoverMenu(evt: any): void; /** * Hide the hover menu when e.g. the user starts zooming */ hideHoverMenu(): void; /** * Close the custom dialog (e.g. when the close button is clicked) */ closeCustomDialog(): void; /** * Handle internally broadcasted click events */ appClickHandler(data: any): void; /** Handle click events on the canvas. The canvas is preferrable * to the top level div because the canvas's events aren't forwarded * so we only receive one click event */ canvasClickHandler(evt: any): void; /** * Handle mousemove and zoom events. */ mouseMoveZoomHandler(data: any): void; /** * Handle gene search events. */ geneSearchHandler(data: any): void; /** * Handle mousedown events/ */ mouseDownHandler(evt: any): void; onScrollHandler(): void; setTrackValueScaleLimits(viewId: any, trackId: any, minValue: any, maxValue: any): void; setChromInfo(chromInfoPath: any, callback: any): void; chromInfo: any; onMouseLeaveHandler(): void; onBlurHandler(): void; isZoomFixed(view: any): any; /** * Handle trackDimensionsModified events * @param {Object} settings * @param {string} settings.viewId = id of the view * @param {string} settings.trackId = id of the track * @param {number} settings.height = new height of the track or undefined if current height should remain * @param {nmber} settings.width = new width of the track or undefined if current width should remain */ trackDimensionsModifiedHandler(settings: { viewId: string; trackId: string; height: number; width: nmber; }): void; wheelHandler(evt: any): void; /** Convert a viewUid to a view name so that when we create * viewport projects, we can show which view they refer to. * The name is usually a single letter like 'A' * The view's name will also be visible in the header. */ viewUidToName(viewUid: any): string; render(): React.JSX.Element; tiledAreasDivs: {} | undefined; tiledAreas: React.JSX.Element | React.JSX.Element[] | undefined; canvasElement: HTMLCanvasElement | null | undefined; scrollContainer: HTMLDivElement | null | undefined; divDrawingSurface: HTMLDivElement | null | undefined; svgElement: SVGSVGElement | null | undefined; } declare namespace HiGlassComponent { namespace defaultProps { let options: {}; let zoomFixed: boolean; let compactLayout: boolean; } namespace propTypes { export let getApi: PropTypes.Requireable<(...args: any[]) => any>; let options_1: PropTypes.Requireable; export { options_1 as options }; export let viewConfig: PropTypes.Validator>>; let zoomFixed_1: PropTypes.Requireable; export { zoomFixed_1 as zoomFixed }; let compactLayout_1: PropTypes.Requireable; export { compactLayout_1 as compactLayout }; } } import React from 'react'; import { ResizeSensor } from 'css-element-queries'; import * as PIXI from 'pixi.js'; import createPubSub from 'pub-sub-es'; import { THEME_LIGHT } from './configs'; import { THEME_DARK } from './configs'; import PropTypes from 'prop-types';