hasDataType: function ( type ) {
   return this.get( 'dataTypes' ).indexOf( type ) !== -1;
 },

getFiles: function ( typeRegExp ) {
   var files = [],
     dataTransfer = this.event.dataTransfer,
     items, i, l, item, itemType;
   if ( dataTransfer ) {
     // Current HTML5 DnD interface
     if ( items = dataTransfer.items ) {
       for ( i = 0, l = items.length; i < l; i += 1 ) {
         item = items[i];
         itemType = item.type;
         if ( item.kind === 'file' ) {
           // Ignore folders
           if ( !itemType ) {
             if ( item.getAsEntry &&
                 !item.getAsEntry().isFile ) {
               continue;
             }
             else if ( item.webkitGetAsEntry &&
                 !item.webkitGetAsEntry().isFile ) {
               continue;
             }
           }
           // Add to files if type matches.
           if ( !typeRegExp || typeRegExp.test( itemType ) ) {
             files.push( item.getAsFile() );
           }
         }
       }
     }
     // Deprecated HTML5 DnD interface (FF etc.)
     else if ( items = dataTransfer.files ) {
       for ( i = 0, l = items.length; i < l; i += 1 ) {
         item = items[i];
         itemType = item.type;
         // Check it's not a folder (size > 0) and it matches any
         // type requirements
         if ( item.size &&
             ( !typeRegExp || typeRegExp.test( itemType ) ) ) {
           files.push( item );
         }
       }
     }
   }
   return files;
 },

getDataOfType: function ( type, callback ) {
   var dataSource = this.get( 'dataSource' ) || this.get( 'dragSource' ),
     dataFound = false;
   if ( dataSource && dataSource.get( 'isDragDataSource' ) ) {
     callback( dataSource.getDragDataOfType( type, this ) );
     dataFound = true;
   }
   else if ( this.isNative ) {
     var dataTransfer = this.event.dataTransfer,
       items = dataTransfer.items,
       i, l, item;
     // Current HTML5 DnD interface
     if ( items ) {
       for ( i = 0, l = items.length; i < l; i += 1 ) {
         item = items[i];
         if ( item.type === type ) {
           item.getAsString( callback );
           dataFound = true;
           break;
         }
       }
     }
     // Deprecated HTML5 DnD interface
     else if ( dataTransfer.getData ) {
       callback( dataTransfer.getData( type ) );
       dataFound = true;
     }
   }
   if ( !dataFound ) {
     callback( null );
   }
   return this;
 },

startDrag: function () {
   NS.DragController.register( this );
   this.fire( 'dragStarted' );
   var dragSource = this.get( 'dragSource' ),
     allowedEffects, dataTransfer, dataSource, dataIsSet, data;
   // No drag source if drag started in another window/app.
   if ( dragSource ) {
     dragSource.set( 'isDragging', true ).dragStarted( this );

     allowedEffects = dragSource.get( 'allowedDragEffects' );
     this.set( 'allowedEffects', allowedEffects );

     // Native DnD support.
     if ( this.isNative ) {
       dataTransfer = this.event.dataTransfer;
       dataSource = this.get( 'dataSource' ) || dragSource;
       dataIsSet = false;

       dataTransfer.effectAllowed =
         effectToString[ this.get( 'allowedEffects' ) ];

       if ( dataSource.get( 'isDragDataSource' ) ) {
         dataSource.get( 'dragDataTypes' )
                .forEach( function ( type ) {
           if ( type.contains( '/' ) ) {
             data = dataSource.getDragDataOfType( type, this );
             // Current HTML5 DnD interface
             if ( dataTransfer.items ) {
               dataTransfer.items.add( data, type );
             }
             // Deprecated HTML5 DnD interface
             else if ( dataTransfer.setData ) {
               dataTransfer.setData( type, data );
             }
             dataIsSet = true;
           }
         });
       }

       // Need something to keep the drag alive
       if ( !dataIsSet ) {
         dataTransfer.setData( 'x-private', '' );
       }
     }
   }
   return this;
 },

endDrag: function () {
   var dropTarget = this.get( 'dropTarget' ),
     dragSource = this.get( 'dragSource' );
   if ( dropTarget ) {
     dropTarget.dropExited( this );
   }
   if ( dragSource ) {
     dragSource.set( 'isDragging', false ).dragEnded( this );
   }

   if ( this._dragCursor ) {
     document.body.removeChild( this._dragCursor );
     this._dragCursor = null;
   }
   if ( this._scrollInterval ) {
     NS.RunLoop.cancel( this._scrollInterval );
     this._scrollInterval = null;
   }
   this._setCursor( false );

   this.fire( 'dragEnded' );
   NS.DragController.deregister( this );

   return this;
 },

move: function ( event ) {
   this.event = event;

   // Find which view is currently under the cursor. If none, presume we've
   // moved the cursor over the drag image, so we're probably still over
   // the current drop.
   var view = event.targetView,
     x, y;
   if ( !view ) {
     view = this.get( 'dropTarget' );
   }

   // Update cursor location
   this.set( 'cursorPosition', {
     x: x = event.clientX,
     y: y = event.clientY
   });

   // Check if we're over any hotspots that should trigger a scroll.
   this._check( view, x, y );

   // Recalculate drop target and update.
   this._update( view );

   return this;
 },

drop: function ( event ) {
   this.event = event;
   var dropEffect = this.dropEffect;
   if ( this.dropTarget &&
       dropEffect !== NONE && dropEffect !== DEFAULT ) {
     this.dropTarget.drop( this );
   }
   return this;
 }
});

NS.Drag = Drag;

}( O ) );