import { ElementRef, NgZone } from '@angular/core'; import { Subject, Observable } from 'rxjs'; import { OptionalType, OrientationEnum, PointModel, ViewportRulerService } from '@itix/core'; import { DragItemModel } from './drag-item.model'; import { DropListRefInternal } from './drop-list-ref-internal'; import { DragRefConfig } from './drag-ref.config'; import { DragPreviewTemplate } from './drag-preview.template'; import { DragHelperTemplate } from './drag-helper.template'; import { DragAndDropRegistryService } from '../drag-and-drop-registry.service'; import { DragDelayModel } from './drag-delay.model'; /** * Referência a um item arrastável. * Realiza a manipulação deste item. */ export declare class DragRef { private config; private document; private ngZone; private viewportRulerService; private dragAndDropRegistryService; /** * Eixo ao qual o arrastar está restrito (Veja: #ixsee[p:models/enums, i:OrientationEnum, l:core]). */ lockAxis?: OrientationEnum; /** * Tempo, em milisegundos, a aguardar após o usuário ter segurado um item para começar a arrastar. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragDelayModel]. */ dragStartDelay?: DragDelayModel | undefined; /** * Classe a ser adicionada ao elemento de pré-visualização. */ previewClass?: string | string[]; /** * Indica se deve bloquear o arrastar deste elemento. */ get isDisabled(): boolean; set isDisabled(value: boolean); /** * Dispara antes de iniciar o processo de arrastar o item. */ beforeStarted: Subject; /** * Dispara quando o usuário inicia o processo de arrastar o item. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ started: Subject; /** * Dispara quando o usuário solta o item, antes de qualquer animação ter iniciado. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ released: Subject; /** * Dispara quando o usuário para de arrastar um item no contêiner. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ ended: 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 enquanto o usuário estiver arrastando o item. * **Obs:** Use com cuidado. Este evento irá disparar para cada pixel que o usuário arrastar. * Veja: #ixsee[p:common/drag-and-drop/models, i:DragItemModel]. */ moved: Observable; /** * Dados anexados à essa instância. */ data: T; /** * Verifica se o elemento está sendo arrastado. */ get isDragging(): boolean; /** * Função usada para personalizar a lógica de como a posição do item arrastável é limitada * enquanto está sendo arrastado. É chamado com um ponto contendo a posição atual do ponteiro do * usuário na página e deveria retornar um ponto informando onde o item deveria ser renderizado. * @param point Posição (Veja: #ixsee[p:models/position, i:PointModel, l:core]). * @param dragRef Item arrastado. */ constrainPosition?: (point: PointModel, dragRef: DragRef) => PointModel; private passiveTransform; private activeTransform; private initialTransform?; private previewElement?; private previewRef?; private placeholderElement?; private placeholderRef?; private pickupPositionInElement; private pickupPositionOnPage; private anchor?; private hasStartedDragging; private hasMoved; private initialContainer?; private initialIndex?; private scrollPosition; private moveEvents; private pointerDirectionDelta; private pointerPositionAtLastDirectionChange; private rootElement?; private rootElementTapHighlight?; private pointerMoveSubscription; private pointerUpSubscription; private scrollSubscription; private resizeSubscription; private lastTouchEventTime; private dragStartTime; private boundaryElement?; private nativeInteractionsEnabled; private previewRect?; private boundaryRect?; private previewTemplate?; private placeholderTemplate?; private handles; private disabledHandles; private dropContainer?; private disabled; constructor(element: ElementRef | HTMLElement, config: DragRefConfig, document: Document, ngZone: NgZone, viewportRulerService: ViewportRulerService, dragAndDropRegistryService: DragAndDropRegistryService); /** * Obtém o elemento que está sendo usado como placeholder. */ getPlaceholderElement(): OptionalType; /** * Obtém o elemento arrastável pai. */ getRootElement(): OptionalType; /** * Obtém o elemento atualmente visível. * Enquanto estiver arrastando é o placeholder, caso contrário o elemento pai. */ getVisibleElement(): OptionalType; /** * Registra os handles que podem ser usados para arrastar o elemento. * @param handles Partes do elemento que podem ser usados para arrastar. */ withHandles(handles: (HTMLElement | ElementRef)[]): DragRef; /** * Registra o template que deve ser usado pela pré-visualização. * @param template Template no qual colocar a pré-visualização (Veja: #ixsee[p:common/drag-and-drop/models, i:DragPreviewTemplate]). */ withPreviewTemplate(template?: DragPreviewTemplate): DragRef; /** * Registra o template que deve ser usado como placeholder. * @param template Template no qual colocar o placeholder (Veja: #ixsee[p:common/drag-and-drop/models, i:DragHelperTemplate]). */ withPlaceholderTemplate(template?: DragHelperTemplate): DragRef; /** * Define um elemento alternativo como pai. * Este elemento é o que será movido pelo usuário. Essa funcionalidade é útil para habilitar o arrastar * em um elemento que você não tem acesso. * @param rootElement Elemento pai. */ withRootElement(rootElement: ElementRef | HTMLElement): DragRef; /** * Define o elemento que restringirá o tamanho do item arrastável. * @param boundaryElement Elemento que define o tamanho. */ withBoundaryElement(boundaryElement?: ElementRef | HTMLElement): DragRef; /** * Remove a funcionalidade de arrastar do DOM. */ dispose(): void; /** * Reinicia um item arrastável à sua posição inicial. */ reset(): void; /** * Define um handle como desabilitado. * @param handle Handle que deve ser desabilitado. */ disableHandle(handle: HTMLElement): void; /** * Habilita um handle, caso ele tenha sido desabilitado. * @param handle Handle a ser habilitado. */ enableHandle(handle: HTMLElement): void; /** * Define o contêiner que contém este item. * @param container Contêiner (Veja: #ixsee[p:common/drag-and-drop/models, i:DropListRef]). */ withDropContainer(container: DropListRefInternal): void; /** * Obtém a posição atual, em pixels, do item fora do contêiner. * @returns #ixsee[p:models/position, i:PointModel, l:core] */ getFreeDragPosition(): Readonly; /** * Define a posição, em pixels, do item fora do contêiner. * @param value Nova posição (Veja: #ixsee[p:models/position, i:PointModel, l:core]). */ setFreeDragPosition(value: PointModel): DragRef; /** * Atualiza a posição do item baseado na última posição conhecida do ponteiro. */ sortFromLastPointerPosition(): void; private pointerDown; private pointerMove; private pointerUp; /** * Finaliza a sequência e remove as subscriptions. * @param event Evento que finalizou a sequência. */ private endDragSequence; /** * Inicia a sequência de arrastar. * @param event Evento que iniciou a sequência. */ private startDragSequence; /** * Inicializa as variáveis e subscriptions necessárias para a sequência de arrastar. * @param referenceElement Elemento que iniciou a sequência. * @param event Evento que iniciou a sequência. */ private initializeDragSequence; private removeSubscriptions; private destroyPreview; private destroyPlaceholder; /** * Remove os itens adicionados para ajudar no arrastar do elemento. */ private cleanupDragArtifacts; /** * Atualiza a posição do item no contêiner ou move para uma nova. */ private updateActiveDropContainer; /** * Cria o elemento que será renderizado ao lado do ponteiro do usuário e será usado como pré-visualização. */ private createPreviewElement; private animatePreviewToPlaceholder; private createPlaceholderElement; /** * Determina a posição na página que recebeu o toque do ponteiro do usuário. * @param event Evento. */ private getPointerPositionOnPage; /** * Obtém a posição do ponteiro na página, validada por quaisquer restrições de posicionamento. * @param event Evento. */ private getConstrainedPointerPosition; /** * Atualiza a quantidade arrastada, com base na posição atual. * @param pointerPositionOnPage Posição atual do ponteiro na página. */ private updatePointerDirectionDelta; /** * Alterna as interações nativas de arrastar, baseado em quantos handles estão registrados. */ private toggleNativeDragInteractions; /** * Aplica um `transform` no elemento, levando em conta quaisquer `transform` que já existam. * @param x Novo valor para o eixo horizontal (X). * @param y Novo valor para o eixo vertical (Y). */ private applyRootElementTransform; private cleanupCachedDimensions; /** * Verifica se o elemento ainda está dentro dos limites após o viewport ter sido redimensionado. * Caso contrário, ajusta a posição para ele caiba novamente. */ private containInsideBoundaryOnResize; }