import { ElementRef, NgZone } from '@angular/core'; import { Subject } from 'rxjs'; import { DeltaModel, OptionalType, OrientationEnum, PointModel, ViewportRulerService } from '@itix/core'; import { DragRef } from './drag.ref'; import { DragItemModel } from './drag-item.model'; import { DragAndDropRegistryService } from '../drag-and-drop-registry.service'; /** * Referência a um contêiner passível de soltura. * Usada para manipular o contêiner. */ export declare class DropListRef { private dragAndDropRegistryService; private ngZone; private viewportRulerService; /** * Elemento ao qual a lista está anexada. */ element: HTMLElement | ElementRef; /** * Indica se o arrastar a partir deste contêiner está desabilitado. */ isDisabled?: boolean | undefined; /** * Indica se a reordenação de itens dentro da lista está desabilitada. */ isSortingDisabled?: boolean | undefined; /** * Trava a posição dos elementos dentro do contêiner no eixo informado. * Veja: #ixsee[p:models/enums, i:OrientationEnum, l:core]. */ lockAxis?: OrientationEnum; /** * Indica se deve bloquear a auto-rolagem quando o usuário move o ponteiro para perto das bordas. */ isAutoScrollDisabled?: boolean | undefined; /** * Dispara antes de iniciar a sequência de arrastar. */ beforeStarted: Subject; /** * Dispara quando o usuário move um novo item no contêiner. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ entered: Subject; /** * Dispara quando o usuário remove um item do contêiner por arrastá-lo para outro. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ exited: Subject; /** * Dispara quando o usuário solta um item no contêiner. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ dropped: Subject; /** * Dispara quando o usuário troca itens de posição enquanto arrastando. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ sorted: Subject; /** * Dados associados a esse contêiner. */ data: T; /** * Indica se um elemento da lista está sendo arrastado. */ isDragging?: boolean | undefined; /** * Indica se a lista pode receber o item que está sendo arrastado para ela. */ get isReceiving(): boolean; /** * Itens atualmente ativos no contêiner. * Inclui os itens de `draggables` e os que foram arrastados para dentro, mas não soltos. */ private activeDraggables; /** * Item que foi trocado por último com o item sendo arrastado, bem como a direção na qual o * ponteiro está se movendo quando os itens foram trocados. */ private previousSwap; private parentPositions; private itemDimensions; private draggables; private siblings; private activeSiblings; private viewportScrollSubscription; private scrollNode?; private stopScrollTimers; private scrollableElements; private cachedShadowRoot; private verticalScrollDirection; private horizontalScrollDirection; private orientation; private domRect; private initialScrollSnap; private readonly document; constructor(element: ElementRef | HTMLElement, document: any, dragAndDropRegistryService: DragAndDropRegistryService, ngZone: NgZone, viewportRulerService: ViewportRulerService); /** * Função para determinar se um item pode ser movido para um contêiner. * @param drag Item arrastável (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). * @param drop Contêiner passível de soltura. */ enterPredicate: (drag: DragRef, drop: DropListRef) => boolean; /** * Remove a funcionalidade do DOM. */ dispose(): void; /** * Inicia o arrastar de um item. */ start(): void; /** * Dispara um evento para indicar que o usuário moveu um item no contêiner. * @param item Item movido para o contêiner (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). * @param pointerX Posição do item no eixo horizontal (X). * @param pointerY Posição do item no eixo vertical (Y). * @param index Índice no qual o item entrou. Se não informado, tentaremos descobrir. */ enter(item: DragRef, pointerX: number, pointerY: number, index?: number): void; /** * Remove um item do contêiner após ele ter sido arrastado para outro contêiner. * @param item Item removido (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). */ exit(item: DragRef): void; /** * Adiciona um item neste contêiner. * @param item Item sendo adicionado (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). * @param currentIndex Índice no qual o item deveria ser inserido. * @param previousContainer Contêiner de origem do item. * @param isPointerOverContainer Indica se o ponteiro estava sobre o contêiner quando o item foi solto. * @param distance Distância percorrida pelo usuário desde o início do processo de arrastar * (Veja: #ixsee[p:models/position, i:PointModel, l:core]). * @param previousIndex Índice do item quando o processo de arrastar iniciou. */ drop(item: DragRef, currentIndex: number, previousContainer: DropListRef, isPointerOverContainer: boolean, distance: PointModel, previousIndex: number): void; /** * Define os itens arrastáveis que são parte desta lista. * @param items Itens parte desta lista (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). */ withItems(items: DragRef[]): DropListRef; /** * Define os contêineres conectados a este. Quando dois ou mais contêineres são conectados, o usuário * pode transferir itens entre eles. * @param connectedTo Contêineres aos quais este deve ser conectado. */ connectedTo(connectedTo: DropListRef[]): DropListRef; /** * Define a orientação do contêiner. * @param orientation Nova orientação (Veja: #ixsee[p:models/enums, i:OrientationEnum, l:core]). */ withOrientation(orientation: OrientationEnum): DropListRef; /** * Define quais elementos-pai podem ser rolados enquanto o usuário estiver arrastando. * @param elements Elementos que podem ser rolados. */ withScrollableParents(elements: HTMLElement[]): DropListRef; /** * Obtém o índice do item informado. * @param item Item a obter o índice (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). */ getItemIndex(item: DragRef): number; /** * Ordena um item dentro do contêiner, baseado na sua posição. * @param item Item a ser ordenado (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). * @param pointerX Posição do item no eixo horizontal (X). * @param pointerY Posição do item no eixo vertical (Y). * @param pointerDelta Direção na qual o ponteiro está se movendo em cada eixo (Veja: #ixsee[p:models, i:DeltaModel, l:core]). */ sortItem(item: DragRef, pointerX: number, pointerY: number, pointerDelta: DeltaModel): void; /** * Verifica se a posição do usuário está próxima das bordas do viewport ou de alguma lista * e inicia a sequência de auto-rolagem. * @param pointerX Posição no eixo horizontal (X). * @param pointerY Posição no eixo vertical (Y). */ startScrollingIfNecessary(pointerX: number, pointerY: number): void; /** * Para todas as sequências de auto-rolagem atuais. */ stopScrolling(): void; /** * Verifica se o ponteiro está posicionado sobre o contêiner. * @param x Posição no eixo horizontal (X). * @param y Posição no eixo vertical (Y). */ isOverContainer(x: number, y: number): boolean; /** * Verifica se um item pode ser movido para outro contêiner com base em sua posição atual. * @param item Item sendo movido (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). * @param x Posição no eixo horizontal (X). * @param y Posição no eixo vertical (Y). */ getSiblingContainerFromPosition(item: DragRef, x: number, y: number): OptionalType; /** * Verifica se a lista pode receber o item informado. * @param item Item sendo solto na lista (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). * @param x Posição no eixo horizontal (X). * @param y Posição no eixo vertical (Y). */ canReceive(item: DragRef, x: number, y: number): boolean; /** * Chamado por um dos contêineres conectados para informar que uma sequência iniciou. * @param sibling Contêiner no qual a sequência iniciou. */ startReceiving(sibling: DropListRef): void; /** * Chamado por um dos contêineres conectados para informar que uma sequência parou. * @param sibling Contêiner no qual a sequência parou. */ stopReceiving(sibling: DropListRef): void; /** * Reinicia a condição do contêiner. */ private reset; /** * Armazena as posições dos itens-pai configurados como roláveis. */ private cacheParentPositions; /** * Armazena as dimensões dos itens e contêineres conectados. */ private cacheItemDimensions; /** * Armazena os itens da lista e suas posições. */ private cacheItems; /** * Atualiza o estado interno do contêiner após o disparo de um evento scroll. * @param scrolledParent Elemento que foi rolado. * @param newTop Nova posição top da rolagem. * @param newLeft Nova posição left da rolagem. */ private updateAfterScroll; /** * Inicia a escuta aos eventos de rolagem no viewport. */ private listenToScrollEvents; /** * Inicia o `interval` que irá realizar a auto-rolagem do elemento. */ private startScrollInterval; /** * Obtém o shadow root do elemento usando lazy. * Fazemos isso nessa função em vez de em uma propriedade no init, por que queremos deixar para resolver * o mais tarde possível, para garantir que o elemento tenha sido movido para o shadow DOM. Fazer isso no * construtor poderia ser cedo demais se o elemento estivesse dentro de algo como `ngFor` ou `ngIf`. */ private getShadowRoot; }