import { AfterViewInit, OnChanges, OnDestroy, QueryList, ElementRef, NgZone, ViewContainerRef, ChangeDetectorRef, EventEmitter, SimpleChanges } from '@angular/core'; import { Observable } from 'rxjs'; import { OptionalType, OrientationEnum, PointModel } from '@itix/core'; import { DragHandleDirective } from './drag-handle.directive'; import { DragPreviewDirective } from './drag-preview.directive'; import { DragPlaceholderDirective } from './drag-placeholder.directive'; import { DropListDirective } from './drop-list.directive'; import { DragRef } from '../models/drag.ref'; import { DragStartEvent } from '../models/events/drag-start.event'; import { DragReleaseEvent } from '../models/events/drag-release.event'; import { DragEndEvent } from '../models/events/drag-end.event'; import { DragEnterEvent } from '../models/events/drag-enter.event'; import { DragExitEvent } from '../models/events/drag-exit.event'; import { DragAndDropEvent } from '../models/events/drag-and-drop.event'; import { DragMoveEvent } from '../models/events/drag-move.event'; import { DragAndDropConfig } from '../models/drag-and-drop.config'; import { DragDelayModel } from '../models/drag-delay.model'; import { DragAndDropService } from '../drag-and-drop.service'; import * as i0 from "@angular/core"; /** * Elemento que pode ser movido dentro de um contêiner ixDropList. */ export declare class DragDirective implements AfterViewInit, OnChanges, OnDestroy { element: ElementRef; dropContainer: DropListDirective; private document; private ngZone; private viewContainerRef; private dragAndDropService; private changeDetectorRef; classes: string; disabledClass: boolean; get isDragging(): boolean; /** * Elementos que podem ser usados para arrastar o item (Veja: #ixsee[p:common/drag-and-drop/directives, i:DragHandleDirective]). */ handles: QueryList; /** * Elemento que será usado como template para criar a pré-visualização do item arrastável. * Veja: #ixsee[p:common/drag-and-drop/directives, i:DragPreviewDirective]. */ previewTemplate?: DragPreviewDirective; /** * Template para o placeholder que exibe aonde o item será solto. * Veja: #ixsee[p:common/drag-and-drop/directives, i:DragPlaceholderDirective]. */ placeholderTemplate?: DragPlaceholderDirective; /** * Dados anexados à essa instância. */ data?: T; /** * Trava a posição do elemento dentro do contêiner no eixo informado. * Veja: #ixsee[p:models/enums, i:OrientationEnum, l:core]. */ lockAxis?: OrientationEnum; /** * Seletor que será usado para determinar o elemento arrastável pai, iniciando com o `ixDrag` * e subindo pelo DOM. Informar um elemento alternativo pode ser útil quando se deseja habilitar * o arrastar em um elemento que você pode não ter acesso. */ rootElement: string; /** * Nó que será usado para determinar qual elemento será usado como base para o tamanho * do item arrastável. */ boundaryElement?: ElementRef | HTMLElement; /** * Seletor que será usado para determinar qual elemento será usado como base para o tamanho * do item arrastável. Essa string será usada como seletor que irá começar do pai do elemento atual, * subindo até o DOM até encontrar uma compatibilidade. */ boundarySelector?: string; /** * 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]. */ startDelay?: DragDelayModel | undefined; /** * Define a posição de um `ixDrag` que está fora de um contêiner de soltura. * Pode ser usado para restaurar a posição de um elemento. * Veja: #ixsee[p:models/position, i:PointModel, l:core]. */ freeDragPosition?: PointModel; /** * Indica se deve bloquear o arrastar deste elemento. */ get isDisabled(): boolean; set isDisabled(value: 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; /** * Classe a ser adicionada ao elemento de pré-visualização. */ previewClass?: string | string[]; /** * Dispara quando o usuário inicia o processo de arrastar o item. * Veja: #ixsee[p:common/drag-and-drop/models/events, i:DragStartEvent]. */ readonly started: EventEmitter>; /** * Dispara quando o usuário solta o item, antes de qualquer animação ter iniciado. * Veja: #ixsee[p:common/drag-and-drop/models/events, i:DragReleaseEvent]. */ readonly released: EventEmitter>; /** * Dispara quando o usuário para de arrastar um item no contêiner. * Veja: #ixsee[p:common/drag-and-drop/models/events, i:DragEndEvent]. */ readonly ended: EventEmitter>; /** * Dispara quando o usuário move um novo item no contêiner. * Veja: #ixsee[p:common/drag-and-drop/models/events, i:DragEnterEvent]. */ readonly entered: EventEmitter>; /** * Dispara quando o usuário remove um item do contêiner por arrastá-lo para outro. * Veja: #ixsee[p:common/drag-and-drop/models/events, i:DragExitEvent]. */ readonly exited: EventEmitter>; /** * Dispara quando o usuário solta um item no contêiner. * Veja: #ixsee[p:common/drag-and-drop/models/events, i:DragAndDropEvent]. */ readonly dropped: EventEmitter>; /** * 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. */ readonly moved: Observable>; /** * Referência à instância (Veja: #ixsee[p:common/drag-and-drop/models, i:DragRef]). */ dragRef: DragRef>; private disabled; private destroyed; constructor(element: ElementRef, dropContainer: DropListDirective, document: any, ngZone: NgZone, viewContainerRef: ViewContainerRef, config: DragAndDropConfig, dragAndDropService: DragAndDropService, changeDetectorRef: ChangeDetectorRef); ngAfterViewInit(): void; ngOnChanges(changes: SimpleChanges): void; ngOnDestroy(): void; /** * Obtém o elemento que está sendo usado como placeholder. */ getPlaceholderElement(): OptionalType; /** * Obtém o elemento arrastável pai. */ getRootElement(): OptionalType; /** * Reinicia um item arrastável à sua posição inicial. */ reset(): void; /** * Obtém as coordenadas (pixel) do item fora do contêiner. * @returns #ixsee[p:models/position, i:PointModel, l:core] */ getFreeDragPosition(): Readonly; /** * Sincroniza o elemento pai com o DragRef. */ private updateRootElement; /** * Obtém o elemento que define a limitação de tamanho. */ private getBoundaryElement; /** * Sincroniza os inputs locais com as opções do DragRef. * @param ref Referência ao DragRef. */ private syncInputs; /** * Trata os eventos do DragRef. * @param ref Referência ao DragRef. */ private handleEvents; /** * Define os valores-padrão com base na configuração. * @param config Configuração. */ private assignDefaults; static ɵfac: i0.ɵɵFactoryDeclaration, [null, { optional: true; skipSelf: true; }, null, null, null, { optional: true; }, null, null]>; static ɵdir: i0.ɵɵDirectiveDeclaration, "[ixDrag]", ["ixDrag"], { "data": "ixDragData"; "lockAxis": "ixDragLockAxis"; "rootElement": "ixDragRootElement"; "boundaryElement": "ixDragBoundary"; "boundarySelector": "ixDragBoundarySelector"; "startDelay": "ixDragStartDelay"; "freeDragPosition": "ixDragFreeDragPosition"; "isDisabled": "ixDragDisabled"; "constrainPosition": "ixDragConstrainPosition"; "previewClass": "ixDragPreviewClass"; }, { "started": "ixDragStarted"; "released": "ixDragReleased"; "ended": "ixDragEnded"; "entered": "ixDragEntered"; "exited": "ixDragExited"; "dropped": "ixDragDropped"; "moved": "ixDragMoved"; }, ["previewTemplate", "placeholderTemplate", "handles"], never, false>; }