void DraggingHandler(DragInfo dragInfo)
    {
        if (debug) Debug.Log("====DraggingHandler====\n|| fingercount: " + dragInfo.fingerCount +
                                        " || index: " + dragInfo.index +
                                        " || isFlick: " + dragInfo.isFlick +
                                        " || pos: " + dragInfo.pos );

        if (dragInfo.pos.x / Screen.width <= 0.3)
        {
            yTouchLeft = dragInfo.pos.y / Screen.height;
            Debug.Log("Left: " + yTouchLeft );
        }

        if (dragInfo.pos.x / Screen.width >= 0.7)
        {
            yTouchRight = dragInfo.pos.y / Screen.height;
            Debug.Log("Right: " + yTouchRight );
        }

        speedModifier = (yTouchLeft >= yTouchRight) ? yTouchLeft : yTouchRight;

        directionModifier = yTouchLeft - yTouchRight;
        Debug.Log("Direction: " + directionModifier );

        Debug.Log("speedModifier: " + speedModifier );

        Vector3 pos = Megaman.transform.localPosition;
        pos.x = megamanInitialX + directionModifier*-1;
        float offsettedSpeedModifier = speedModifier - 0.5f;
        pos.z = megamanInitialZ + offsettedSpeedModifier;
        Megaman.transform.localPosition = pos;
        //Debug.Log("orbit.XModifier: "+orbit.XModifier);
    }

 void DraggingStartHandler(DragInfo dragInfo)
 {
     if (debug) Debug.Log("====DraggingStartHandler====\n|| fingercount: " + dragInfo.fingerCount +
                          " || index: " + dragInfo.index +
                          " || isFlick: " + dragInfo.isFlick +
                          " || pos: " + dragInfo.pos );
 }

        void OnDraggingEnd(DragInfo drag)
        {
            pointer.enabled = false;

            IT_Gesture.onMouse1E -= OnTouch;

            IT_Gesture.onDraggingEndE -= OnDraggingEnd;
        }

        //スワイプによる移動操作検知
        void OnChargeForMove(DragInfo dragInfo)
        {
            //自分キャラ
            if (BCharacterManager.Instance.GetCharacterOnTile(dragInfo.pos) != this.character) return;

            //キャラクター移動用
            IT_Gesture.onDraggingEndE += OnDragMove;
        }

        //移動開始
        void OnDraggingStart(DragInfo drag)
        {
            //タッチ位置取得

            dragPosition = drag.pos;
            IT_Gesture.onMouse1E += OnTouch;

            IT_Gesture.onDraggingEndE += OnDraggingEnd;
        }

    void OnDrag(DragInfo info)
    {
        if (vertical) scrollDelta = info.delta.y;
        else scrollDelta = info.delta.x;

        MoveChildren(scrollDelta*scrollSpeed);

        scrollDelta /= Mathf.Abs(scrollDelta);
    }

 //called when one finger drag are detected
 void OnDragging(DragInfo dragInfo)
 {
     //apply the DPI scaling
     dragInfo.delta/=IT_Gesture.GetDPIFactor();
     //vertical movement is corresponded to rotation in x-axis
     this.orbitSpeedX=-dragInfo.delta.y* this.rotXSpeedModifier;
     //horizontal movement is corresponded to rotation in y-axis
     this.orbitSpeedY=dragInfo.delta.x* this.rotYSpeedModifier;
 }

        //移動開始
        void OnDraggingStart(DragInfo drag)
        {
            //タッチ位置取得
            pointer.enabled = true;
            DragPosition = drag.pos;
            IT_Gesture.onMouse1E += OnTouch;

            IT_Gesture.onDraggingEndE += OnDraggingEnd;
        }

 void HandleGestureonDraggingStartE(DragInfo dragInfo)
 {
     if (!isDragging) return;
     Transform puck = PickObject (dragInfo.pos);
     if (puck) {
         lastPuck = puck;
         baseHeight = puck.position.y;
         puck.renderer.material.color = Color.green;
     }
 }

 void HandleDragging(DragInfo dragInfo)
 {
     if (!isDragging) return;
     if (lastPuck) {
         DisplayText ("Dragging puck to: " + dragInfo.pos);
         Vector3 worldPos = GetWorldPos (dragInfo.pos);
         lastPuck.transform.position = worldPos;
     } else {
         DisplayText ("Dragging to: " + dragInfo.pos);
     }
 }

    //assign dragObj2 to the dragInfo position, and display the appropriate tooltip
    void Obj2ToCursor(DragInfo dragInfo)
    {
        Vector3 p=Camera.main.ScreenToWorldPoint(new Vector3(dragInfo.pos.x, dragInfo.pos.y, 30));
        dragObj2.position=p;

        if(dragInfo.isMouse){
            dragTextMesh2.text="Dragging with mouse"+(dragInfo.index+1);
        }
        else{
            dragTextMesh2.text="Dragging with finger"+(dragInfo.index+1);
        }
    }

 //called when one finger drag are detected
 void OnDragging(DragInfo dragInfo)
 {
     //if the drag is perform using mouse2, use it as a two finger drag
     if(dragInfo.isMouse && dragInfo.index==1) OnMFDragging(dragInfo);
     //else perform normal orbiting
     else{
         //vertical movement is corresponded to rotation in x-axis
         orbitSpeedX=-dragInfo.delta.y*rotXSpeedModifier;
         //horizontal movement is corresponded to rotation in y-axis
         orbitSpeedY=dragInfo.delta.x*rotYSpeedModifier;
     }
 }

    IEnumerator MouseRoutine(int index)
    {
        mouseIndex.Add(index);

        bool dragStarted=false;

        Vector2 startPos=Input.mousePosition;
        Vector2 lastPos=startPos;

        float timeStart=Mathf.Infinity;

        while(mouseIndex.Contains(index)){

            Vector2 curPos=Input.mousePosition;

            if(!dragStarted){
                if(Vector3.Distance(curPos, startPos)>minDragDistance){
                    dragStarted=true;
                    Vector2 delta=curPos-startPos;
                    DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
                    IT_Gesture.DraggingStart(dragInfo);

                    timeStart=Time.realtimeSinceStartup;
                }
            }
            else{
                if(curPos!=lastPos){
                    Vector2 delta=curPos-lastPos;
                    DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
                    IT_Gesture.Dragging(dragInfo);
                }
                else if(fireOnDraggingWhenNotMoving){
                    DragInfo dragInfo=new DragInfo(curPos, Vector2.zero, 1, index, true);
                    IT_Gesture.Dragging(dragInfo);
                }
            }

            lastPos=curPos;

            yield return null;
        }

        if(dragStarted){
            bool isFlick=false;
            if(Time.realtimeSinceStartup-timeStart<0.5f) isFlick=true;

            Vector2 delta=lastPos-startPos;
            DragInfo dragInfo=new DragInfo(lastPos, delta, 1, index, isFlick, true);

            IT_Gesture.DraggingEnd(dragInfo);
        }
    }

    //called when one finger drag are detected
    void OnDragging(DragInfo dragInfo)
    {
        Debug.Log("drag "+dragInfo.delta);
        if(dragInfo.type!=2){
            //vertical movement is corresponded to rotation in x-axis
            orbitSpeedX=-dragInfo.delta.y*rotXSpeedModifier;
            //horizontal movement is corresponded to rotation in y-axis
            orbitSpeedY=dragInfo.delta.x*rotYSpeedModifier;
        }

        //if the drag is perform using mouse2, use it as a two finger drag
        if(dragInfo.type==2) OnDFDragging(dragInfo);
    }

 //called when one finger drag are detected
 void OnDragging(DragInfo dragInfo)
 {
     //if the drag is perform using mouse2, use it as a two finger drag
     if(dragInfo.isMouse && dragInfo.index==1) this.OnMFDragging(dragInfo);
     //else perform normal orbiting
     else{
         //apply the DPI scaling
         dragInfo.delta/=IT_Gesture.GetDPIFactor();
         //vertical movement is corresponded to rotation in x-axis
         this.orbitSpeedX=-dragInfo.delta.y* this.rotXSpeedModifier;
         //horizontal movement is corresponded to rotation in y-axis
         this.orbitSpeedY=dragInfo.delta.x* this.rotYSpeedModifier;
     }
 }

 public static Directions ConvertDragToDirection(DragInfo drag)
 {
     Vector2 normalized = (drag.pos - dragStart).normalized;
     if (normalized.x > 0 && Math.Abs(normalized.y) < normalized.x)
         return Directions.Right;
     if (normalized.y > 0 && Math.Abs(normalized.x) < normalized.y)
         return Directions.Up;
     if (normalized.x < 0 && Math.Abs(normalized.y) > normalized.x)
         return Directions.Left;
     if (normalized.y < 0 && Math.Abs(normalized.x) > normalized.y)
         return Directions.Down;
     Debug.Log("Converting Drag to Directions Failed");
     return Directions.None;
 }

    //called when a dual finger or a right mouse drag is detected
    void OnMFDragging(DragInfo dragInfo)
    {
        //make a new direction, pointing horizontally at the direction of the camera y-rotation
        Quaternion direction=Quaternion.Euler(0, transform.parent.rotation.eulerAngles.y, 0);

        //calculate forward movement based on vertical input
        Vector3 moveDirZ=transform.parent.InverseTransformDirection(direction*Vector3.forward*-dragInfo.delta.y);
        //calculate sideway movement base on horizontal input
        Vector3 moveDirX=transform.parent.InverseTransformDirection(direction*Vector3.right*-dragInfo.delta.x);

        //move the cmera
        transform.parent.Translate(moveDirZ * panSpeedModifier * Time.deltaTime);
        transform.parent.Translate(moveDirX * panSpeedModifier * Time.deltaTime);
    }

    //assign dragObj1 to the dragInfo position, and display the appropriate tooltip
    void Obj1ToCursor(DragInfo dragInfo)
    {
        //~ LayerMask layer=~(1<<dragObj1.gameObject.layer);
        //~ Ray ray = Camera.main.ScreenPointToRay (dragInfo.pos);
        //~ RaycastHit hit;
        //~ if (Physics.Raycast (ray, out hit, Mathf.Infinity, layer)) {
            //~ dragObj1.position=hit.point;
        //~ }

        Vector3 p=Camera.main.ScreenToWorldPoint(new Vector3(dragInfo.pos.x, dragInfo.pos.y, 30));
        this.dragObj1.position=p+ this.dragOffset1;

        if(dragInfo.isMouse){
            this.dragTextMesh1.text="Dragging with mouse"+(dragInfo.index+1);
        }
        else{
            this.dragTextMesh1.text="Dragging with finger"+(dragInfo.index+1);
        }
    }

    IEnumerator MouseRoutine(int index)
    {
        mouseIndex.Add(index);

        bool dragStarted=false;

        Vector2 startPos=Input.mousePosition;
        Vector2 lastPos=startPos;

        while(mouseIndex.Contains(index)){

            Vector2 curPos=Input.mousePosition;

            if(!dragStarted){
                if(Vector3.Distance(curPos, startPos)>minDragDistance){
                    dragStarted=true;
                    Vector2 delta=curPos-startPos;
                    DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
                    Gesture.DraggingStart(dragInfo);
                }
            }
            else{
                if(curPos!=lastPos){
                    Vector2 delta=curPos-lastPos;
                    DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
                    Gesture.Dragging(dragInfo);
                }
            }

            lastPos=curPos;

            yield return null;
        }

        if(dragStarted){
            Vector2 delta=lastPos-startPos;
            DragInfo dragInfo=new DragInfo(lastPos, delta, 1, index, true);
            Gesture.DraggingEnd(dragInfo);
        }
    }

        public DropInfo(object sender, DragEventArgs e, DragInfo dragInfo, string dataFormat)
        {
            Data = (e.Data.GetDataPresent(dataFormat)) ? e.Data.GetData(dataFormat) : e.Data;
            DragInfo = dragInfo;

            VisualTarget = sender as UIElement;

            if (sender is ItemsControl)
            {
                ItemsControl itemsControl = (ItemsControl)sender;
                UIElement item = itemsControl.GetItemContainerAt(e.GetPosition(itemsControl));

                VisualTargetOrientation = itemsControl.GetItemsPanelOrientation();

                if (item != null)
                {
                    ItemsControl itemParent = ItemsControl.ItemsControlFromItemContainer(item);

                    InsertIndex = itemParent.ItemContainerGenerator.IndexFromContainer(item);
                    TargetCollection = itemParent.ItemsSource ?? itemParent.Items;
                    TargetItem = itemParent.ItemContainerGenerator.ItemFromContainer(item);
                    VisualTargetItem = item;

                    if (VisualTargetOrientation == Orientation.Vertical)
                    {
                        if (e.GetPosition(item).Y > item.RenderSize.Height / 2) InsertIndex++;
                    }
                    else
                    {
                        if (e.GetPosition(item).X > item.RenderSize.Width / 2) InsertIndex++;
                    }
                }
                else
                {
                    TargetCollection = itemsControl.ItemsSource ?? itemsControl.Items;
                    InsertIndex = itemsControl.Items.Count;
                }
            }
        }