Статьи

Объединение Touch и Mouse с событиями указателя

Я часто получаю вопросы от разработчиков, например: « С таким большим количеством сенсорных устройств на телефонах и планшетах, с чего мне начать? И « какой самый простой способ создать для сенсорного ввода? Краткий ответ: «Это сложно».

Несомненно, существует более унифицированный способ обработки ввода с помощью мультисенсорного ввода в Интернете — в современных браузерах с сенсорным управлением или в качестве запасного варианта для старых браузеров. В этой статье я хотел бы показать вам некоторые эксперименты с браузерами, использующие MSPointers — новейшую технологию multi-touch и полифиллы, которые делают кросс-браузерную поддержку намного более сложной . Тип кода, который вы также можете экспериментировать и легко использовать на своем собственном сайте.

Во-первых, в Интернете развивается множество сенсорных технологий — для поддержки браузера вам нужно посмотреть модель событий касания iOS и модель событий мыши W3C в дополнение к MSPointers , чтобы поддерживать все браузеры. Тем не менее, растет поддержка (и готовность) к стандартизации. В сентябре Microsoft отправила MSPointers в W3C для стандартизации, и мы уже достигли проекта последнего вызова: http://www.w3.org/TR/pointerevents . Команда MS Open Tech также недавно выпустила первоначальный прототип Pointer Events для Webkit .

Причина, по которой я экспериментирую с MSPointers, основана не на общем устройстве, а на том, что подход Microsoft к базовой обработке ввода сильно отличается от того, что доступно в настоящее время в Интернете, и он заслуживает того, чтобы увидеть, каким он может стать .

Разница в том, что разработчики могут писать в более абстрактную форму ввода, называемую «Указатель». Указатель может быть любой точкой контакта на экране, созданной курсором мыши, ручкой, пальцем или несколькими пальцами. Таким образом, вы не тратите время на кодирование каждого типа ввода отдельно.

Концепции

Мы начнем с обзора приложений, работающих в Internet Explorer 10, которые предоставляют API-интерфейс событий MSPointer, а затем решений для поддержки всех браузеров. После этого мы увидим, как вы можете воспользоваться службами жестов IE10, которые помогут вам легко обрабатывать прикосновения в коде JavaScript. Поскольку Windows 8 и Windows Phone 8 используют один и тот же механизм браузера, код и концепции идентичны для обеих платформ. Более того, все, что вы узнаете на ощупь в этой статье, поможет вам выполнять те же самые задачи в приложениях Магазина Windows, созданных с использованием HTML5 / JS, поскольку это снова тот же движок, который используется.

Идея, лежащая в основе MSPointer, состоит в том, чтобы позволить вам обращаться к устройствам мыши, пера и сенсорного экрана через единую кодовую базу, используя шаблон, соответствующий классическим событиям мыши, которые вы уже знаете. Действительно, мышь, перо и касание имеют некоторые общие свойства: вы можете перемещать указатель с ними и, например, нажимать на элемент с ними. Давайте тогда рассмотрим эти сценарии с помощью одного и того же куска кода! Указатели будут объединять эти общие свойства и предоставлять их аналогично событиям мыши.

clip_image001

Наиболее очевидными общими событиями являются: MSPointerDown , MSPointerMove & MSPointerUp, которые напрямую сопоставляются с событиями мыши, эквивалентными. Вы будете иметь координаты X & Y экрана в качестве вывода.

У вас также есть определенные события, такие как: MSPointerOver , MSPointerOut , MSPointerHover или MSPointerCancel .

Но, конечно, могут быть и некоторые случаи, когда вы хотите адресовать прикосновение другим способом, чем поведение мыши по умолчанию, чтобы обеспечить другой UX. Более того, благодаря сенсорным экранам вы можете легко поворачивать, масштабировать или панорамировать некоторые элементы. Ручки / стилус может даже предоставить вам некоторую информацию о давлении, которую мышь не может. События указателя объединят эти различия и создадут некоторый пользовательский код для специфики каждого устройства.

Примечание: было бы лучше протестировать следующие встроенные примеры, если у вас есть сенсорный экран (конечно) на устройстве Windows 8 / RT или если вы используете Windows Phone 8. В противном случае у вас есть несколько вариантов:

1. Получите первый уровень опыта с помощью симулятора Windows 8, который поставляется с бесплатными инструментами разработки Visual Studio 2012 Express. Подробнее о том, как это работает, читайте в этой статье: Использование Windows 8 Simulator & VS 2012 для отладки сенсорных событий IE10 и адаптивного дизайна .
2. Посмотрите это видео, которое демонстрирует все приведенные ниже примеры на планшете Windows 8, поддерживающем сенсорный экран, перо и мышь.
3. Используйте виртуальную службу тестирования перекрестного просмотра, такую ​​как BrowserStack, для интерактивного тестирования, если у вас нет доступа к устройству Windows 8. Вы можете бесплатно использовать BrowserStack в течение 3 месяцев , предоставлено командой Internet Explorer на modern.IE .

Обработка простых сенсорных событий

Шаг 1: ничего не делать в JS, но добавить строку CSS

Давайте начнем с основ. Вы можете легко взять любой существующий код JavaScript, который обрабатывает события мыши, и он будет работать как есть, используя некоторые ручки или сенсорные устройства в Internet Explorer 10. Действительно, IE10 запускает события мыши как последнее средство, если вы не обрабатываете Pointer События в вашем коде. Вот почему вы можете «щелкнуть» по кнопке или по любому элементу любой веб-страницы, используя свои пальцы, даже если разработчик никогда не думал, что однажды кто-то сделает это таким образом. Поэтому любой код, регистрирующийся на события mousedown и / или mouseup, будет работать без каких-либо изменений. Но как насчет мышиного хода?

Давайте рассмотрим поведение по умолчанию, чтобы ответить на этот вопрос. Например, давайте возьмем этот кусок кода:

  <!  DOCTYPE html > 
  < html > 
  < голова > 
      < title > Коснитесь образца статьи 1 </ title > 
  </ head > 
  < тело > 
      < canvas id = "drawSurface" width = "400px" height = "400px" style = " border : 1px dashed black;"> 
      </ canvas > 
      < скрипт > 
          var canvas = document.getElementById ( "drawSurface" );
         var context = canvas.getContext ( "2d" );
         context.fillStyle = "rgba (0, 0, 255, 0.5)" ;

         canvas.addEventListener ( "mousemove" , paint, false );

         функция paint (событие) {
             context.fillRect (event.clientX, event.clientY, 10, 10);
         }
     </ script > 
  </ body > 
  </ html > 
 

Он просто рисует несколько синих квадратов 10 на 10 пикселей внутри элемента холста HTML5, отслеживая движения мыши. Чтобы проверить это, наведите курсор мыши на поле. Если у вас сенсорный экран, попробуйте поработать с холстом, чтобы самостоятельно проверить текущее поведение :

Образец по умолчанию : поведение по умолчанию, если вы ничего не делаете

Результат : только MouseDown / Up / Click работает с касанием. т.е. вы можете рисовать синие квадраты только касанием, когда вы нажимаете на экран, а не когда вы двигаете пальцем по экрану.

Вы увидите, что когда вы перемещаете мышь внутри элемента canvas, он нарисует серию синих квадратов. Но вместо этого, используя касание, он будет рисовать уникальный квадрат только в том месте, где вы касаетесь элемента canvas. Как только вы попытаетесь переместить палец в элементе canvas, браузер попытается выполнить панорамирование внутри страницы, так как это определено по умолчанию.

Поэтому вам нужно указать, что вы хотите переопределить поведение браузера по умолчанию и сказать ему перенаправлять события касания в ваш код JavaScript, а не пытаться его интерпретировать. Для этого нацелите элементы вашей страницы, которые больше не должны реагировать на поведение по умолчанию, и примените к ним следующее правило CSS:

  -ms-touch-action : авто |  нет |  манипуляция |  двойной тап-зум |  наследовать ; 

У вас есть различные доступные значения в зависимости от того, что вы хотите фильтровать или нет. Вы найдете значения, описанные в этой статье: Рекомендации по созданию сенсорных сайтов .

Классический вариант использования — это когда у вас на странице есть элемент управления картой. Вы хотите, чтобы пользователь мог перемещаться и масштабировать внутри области карты, но при этом оставалось поведение по умолчанию для остальной части страницы. В этом случае вы примените это правило CSS (-ms-touch-action: манипулирование) только к контейнеру HTML, отображающему карту.

В нашем случае добавьте этот блок CSS:

  < стиль > 
      #drawSurface 
      {
         -ms-touch-action : нет ;  / * Отключить сенсорное поведение, например, панорамирование и масштабирование * / 
      }
 </ style > 
 

Который сейчас генерирует этот результат:

Шаг 1 : сразу после добавления -ms-touch-action : нет

Результат : панорамирование браузера по умолчанию отключено и MouseMove работает, но только одним пальцем

Теперь, когда вы перемещаете палец внутри элемента canvas, он ведет себя как указатель мыши. Это классно! Но вы быстро зададите себе вопрос: «почему этот код отслеживает только один палец?». Ну, это потому, что мы просто впадаем в последнее, что IE10 делает, чтобы обеспечить очень простой сенсорный опыт: сопоставление одного из ваших пальцев симулировать мышь. И, насколько я знаю, мы используем только одну мышь за раз. Таким образом, одна мышь == один палец максимум, используя этот подход. Тогда как обрабатывать события мультитач?

Шаг 2: используйте события MSPointer вместо событий мыши

Возьмите любой существующий код и замените свою регистрацию на «mousedown / up / move» на «MSPointerDown / Up / Move», и ваш код будет напрямую поддерживать работу с несколькими касаниями в IE10!

Например, в предыдущем примере измените эту строку кода:

  canvas.addEventListener ( "mousemove" , paint, false ); 

к этому:

  canvas.addEventListener ( "MSPointerMove" , paint, false ); 

И вы получите такой результат:

Шаг 2 : использование MSPointerMove вместо mousemove

Результат : мультитач работает

Теперь вы можете нарисовать столько квадратов в серии, сколько точек касания поддерживает ваш экран! Более того, тот же код работает для касания, мыши и пера. Это означает, например, что вы можете использовать мышь для рисования некоторых линий в то же время, когда вы используете пальцы для рисования других линий.

Если вы хотите изменить поведение вашего кода в зависимости от типа ввода, вы можете проверить это с помощью pointerType свойства pointerType . Например, давайте представим, что мы хотим нарисовать красные квадраты размером 10 на 10 пикселей для пальцев, зеленые квадраты на 5 пикселей на 5 для пера и синие квадраты на 2 пикселя для мыши. Вам нужно заменить предыдущий обработчик (функцию рисования) следующим:

  функция paint (событие) {
     if (event.pointerType) {
         switch (event.pointerType) {
             case case.MSPOINTER_TYPE_TOUCH:
                 // Сенсорный экран был использован 
                  // Рисуем красным с квадратом 10 
                  context.fillStyle = "rgba (255, 0, 0, 0.5)" ;
                 квадрат = 10;
                 перерыв ;
             case case.MSPOINTER_TYPE_PEN:
                 // использовалась ручка 
                  // Рисуем зеленым с квадратом 5 
                  context.fillStyle = "rgba (0, 255, 0, 0.5)" ;
                 квадрат = 5;
                 перерыв ;
             case case.MSPOINTER_TYPE_MOUSE:
                 // была использована мышь 
                  // Рисуем синим с квадратом 2 
                  context.fillStyle = "rgba (0, 0, 255, 0.5)" ;
                 квадрат = 2;
                 перерыв ;
         }

         context.fillRect (event.clientX, event.clientY, squaresize, squaresize);
     }
 } 

И вы можете проверить результат здесь:

Шаг 2b : тестирование указателя типа для проверки касания / пера или мыши

Результат : вы можете изменить поведение мыши / пера / касания, но, поскольку 2а код теперь работает только в IE10 +

Если вам повезло иметь устройство, поддерживающее три типа входов (например, Sony Duo 11, Microsoft Surface Pro или планшет Samsung, которые некоторые из вас имели во время BUILD2011), вы сможете увидеть три вида рисунков на основе на тип ввода. Отлично, не правда ли?

Тем не менее, есть проблема с этим кодом. Теперь он корректно обрабатывает все типы входов в IE10, но совсем не работает для браузеров, которые не поддерживают события MSPointer, таких как IE9, Chrome, Firefox, Opera & Safari.

Шаг 3: сделать обнаружение функции, чтобы предоставить запасной код

Как вы, наверное, уже знаете, лучший подход для поддержки поддержки нескольких браузеров — это обнаружение функций. В нашем случае вам нужно проверить это:

  window.navigator.msPointerEnabled 

Имейте в виду, что это говорит только о том, поддерживает ли текущий браузер MSPointer. Он не говорит вам, поддерживается ли касание или нет. Чтобы проверить поддержку касания или нет, вам нужно проверить msMaxTouchPoints .

В заключение, чтобы иметь код, поддерживающий MSPointer в IE10 и правильно возвращающийся к событиям мыши в других браузерах, вам понадобится такой код:

  var canvas = document.getElementById ( "drawSurface" );
 var context = canvas.getContext ( "2d" );
 context.fillStyle = "rgba (0, 0, 255, 0.5)" ;
 if (window.navigator.msPointerEnabled) {
     // События указателя поддерживаются. 
      canvas.addEventListener ( "MSPointerMove" , paint, false );
 }
 еще {
     canvas.addEventListener ( "mousemove" , paint, false );
 }

 функция paint (событие) {
     // Поведение по умолчанию для мыши на устройствах, отличных от IE10
     var squaresize = 2;
     context.fillStyle = "rgba (0, 0, 255, 0.5)" ;
     // Проверка типа указателя на IE10
     if (event.pointerType) {
         switch (event.pointerType) {
             case case.MSPOINTER_TYPE_TOUCH:
                 // Сенсорный экран был использован 
                  // Рисуем красным с квадратом 10 
                  context.fillStyle = "rgba (255, 0, 0, 0.5)" ;
                 квадрат = 10;
                 перерыв ;
             case case.MSPOINTER_TYPE_PEN:
                 // использовалась ручка 
                  // Рисуем зеленым с квадратом 5 
                  context.fillStyle = "rgba (0, 255, 0, 0.5)" ;
                 квадрат = 5;
                 перерыв ;
             case case.MSPOINTER_TYPE_MOUSE:
                 // была использована мышь 
                  // Рисуем синим с квадратом 2 
                  context.fillStyle = "rgba (0, 0, 255, 0.5)" ;
                 квадрат = 2;
                 перерыв ;
         }
     }

     context.fillRect (event.clientX, event.clientY, squaresize, squaresize);
 } 

И снова вы можете проверить результат здесь:

Пример 3 : функция обнаружения msPointerEnabled для предоставления запасного варианта

Результат : полный набор функций в IE10 и события мыши по умолчанию в других браузерах

Шаг 4: поддержка всех сенсорных реализаций

Если вы хотите пойти еще дальше и поддержать все браузеры и все сенсорные реализации, у вас есть два варианта:

1 — Напишите код для параллельного обращения к обеим моделям событий, как описано в этой статье: Обработка мультитач и ввода с помощью мыши во всех браузерах

2 — Просто добавьте ссылку на HandJS, потрясающую библиотеку JavaScript-полифилла, написанную моим другом Дэвидом Катухе, как описано в его статье: HandJS-полифил для поддержки событий указателя в каждом браузере

Как я упоминал во введении к этой статье, Microsoft недавно представила W3C спецификацию MSPointer Events для стандартизации. W3C создал новую Рабочую группу, и он уже опубликовал рабочий проект последнего вызова, основанный на предложении Microsoft. Команда MS Open Tech также недавно выпустила первоначальный прототип Pointer Events для Webkit , который может вас заинтересовать.

Хотя спецификация Pointer Events еще не является стандартом, вы все еще можете реализовать код, который поддерживает его, используя Polyfill Дэвида, и быть готовым к тому, что Pointer Events станет стандартом, реализованным во всех современных браузерах. С помощью библиотеки Дэвида события будут распространяться в MSPointer в IE10, в Touch Events в браузерах на основе Webkit и, наконец, в событиях мыши в качестве крайней меры. Это чертовски круто! Проверьте его статью, чтобы узнать и понять, как это работает. Обратите внимание, что этот polyfill также будет очень полезен для поддержки старых браузеров с элегантными откатами к событиям мыши.

Чтобы получить представление о том, как использовать эту библиотеку, ознакомьтесь с этой статьей: Создание универсального виртуального сенсорного джойстика, работающего для всех моделей Touch, благодаря Hand.JS, который показывает вам, как написать виртуальный сенсорный джойстик, используя события указателя. Благодаря HandJS он будет работать на IE10 на устройствах Windows 8 / RT, Windows Phone 8, iPad / iPhone и Android с той же кодовой базой!

Распознавание простых жестов

Теперь, когда мы увидели, как обрабатывать мультитач, давайте посмотрим, как распознавать простые жесты, такие как нажатие или удержание элемента, а затем некоторые более сложные жесты, такие как перевод или масштабирование элемента.

IE10 предоставляет объект MSGesture, который нам поможет. Обратите внимание, что этот объект в настоящее время специфичен для IE10 и не является частью представления W3C. В сочетании с элементом MSCSSMatrix (наш аналог элемента WebKitCSSMatrix ) вы увидите, что вы можете создавать очень интересные мультисенсорные приложения очень простым способом. MSCSSMatrix действительно представляет собой однородную матрицу 4 × 4, которая позволяет сценариям Document Object Model (DOM) получать доступ к функциям CSS 2-D и 3-D Transforms. Но прежде чем играть с этим, давайте начнем с основ.

Основная концепция заключается в том, чтобы сначала зарегистрировать обработчик события в MSPointerDown . Затем внутри обработчика, заботящегося о MSPointerDown, вам нужно выбрать, какие указатели вы хотите отправить объекту MSGesture, чтобы он мог обнаруживать определенный жест. Затем он вызовет одно из следующих событий: MSGestureTap , MSGestureHold , MSGestureStart , MSGestureChange , MSGestureEnd , MSInertiaStart . Затем объект MSGesture примет все указатели, представленные в качестве входных параметров, и применяет распознаватель жестов поверх них, чтобы предоставить некоторые отформатированные данные в качестве вывода. Единственное, что вам нужно сделать, это выбрать / отфильтровать, какие указатели вы бы хотели использовать в жесте (на основе их идентификатора, координат на экране и т. Д.). Объект MSGesture сделает всю магию за вас после этого.

Пример 1: обработка жеста удержания

Мы увидим, как хранить элемент (простой div, содержащий изображение в качестве фона). Как только элемент удерживается, мы добавим несколько углов, чтобы указать пользователю, что он в данный момент выбрал этот элемент. Углы будут генерироваться путем динамического создания четырех делений, добавляемых в верхней части каждого угла изображения. Наконец, некоторые трюки CSS будут использовать умное преобразование и линейные градиенты, чтобы получить что-то вроде этого:

image

Последовательность будет следующей:

1 — зарегистрируйтесь в событиях MSPointerDown и MSPointerHold для интересующего вас HTML-элемента

2 — создать объект MSGesture, который будет нацелен на этот же элемент HTML
3 — внутри обработчика MSPointerDown добавьте к объекту MSGesture различные идентификаторы PointerID, которые вы хотите отслеживать (все они или их подмножества в зависимости от того, чего вы хотите достичь)

4 — внутри обработчика события MSPointerHold проверьте детали, если пользователь только что запустил жест удержания (флаг MSGESTURE_FLAG_BEGIN). Если так, добавьте углы. Если нет, удалите их.

Это приводит к следующему коду:

  <!  DOCTYPE html > 
  < html > 
  < голова > 
      < title > Сенсорный образец статьи 5: простой обработчик жестов </ title > 
      < link rel = "stylesheet" type = "text / css" href = "toucharticle.css" /> 
      < script src = "Corners.js"> </ script > 
  </ head > 
  < тело > 
      < div id = "myGreatPicture" class = "container" /> 
      < скрипт > 
          var myGreatPic = document.getElementById ( "myGreatPicture" );
         // Создание нового MSGesture, который будет контролировать элемент DOM myGreatPic 
          var myGreatPicAssociatedGesture = new MSGesture ();
         myGreatPicAssociatedGesture.target = myGreatPic;

         // Вы должны сначала зарегистрироваться в MSPointerDown, чтобы иметь возможность 
          // иметь доступ к более сложным событиям жестов 
          myGreatPic.addEventListener ( "MSPointerDown" , указатель вниз, false );
         myGreatPic.addEventListener ( "MSGestureHold" , holded, false );

         // После поднятия указателя мы отправляем все указатели на объект MSGesture 
          указатель на функцию (событие) {
             myGreatPicAssociatedGesture.addPointer (event.pointerId);
         }

         // Это событие будет вызвано объектом MSGesture 
          // на основе указателей, предоставленных во время события MSPointerDown 
          функция holded (событие) {
             // Жест начинается, мы добавляем углы 
              if (event.detail === event.MSGESTURE_FLAG_BEGIN) {
                 Corners.append (myGreatPic);
             }
             еще {
                 // Пользователь отпустил палец, жест заканчивается 
                  // Удаляем углы 
                  Corners.remove (myGreatPic);
             }
         }

         // Чтобы не было эквивалента контекстуального   
          // меню "правой кнопкой мыши", отображаемое в событии MSPointerUp,  
          // мы предотвращаем поведение по умолчанию 
          myGreatPic.addEventListener ( "contextmenu" , function (e) {
             e.preventDefault ();  // Отключаем системное меню 
          }, ложно );
     </ script > 
  </ body > 
  </ html > 

И вот результат:

Попробуйте просто нажать или щелкнуть мышью по элементу, ничего не происходит. Нажмите и удерживайте только один палец на изображении или сделайте длинный щелчок мышью по нему, появятся углы. Отпустите палец, углы исчезнут.

Прикоснитесь и удерживайте два или более пальца на изображении, ничего не происходит, поскольку жест удержания срабатывает, только если элемент удерживается одним уникальным пальцем.

Примечание: белая рамка, углы и фоновое изображение задаются с помощью CSS, определенного в toucharticle.css . Corners.js просто создает четыре элемента div (с функцией append) и размещает их поверх основного элемента в каждом углу с помощью соответствующих классов CSS.

Тем не менее, есть кое-что, что меня не устраивает в текущем результате. Как только вы удерживаете изображение, как только вы слегка двигаете пальцем, флаг MSGESTURE_FLAG_CANCEL поднимается и захватывается обработчиком, который удаляет углы. Я бы предпочел убирать углы только тогда, когда пользователь отпускает палец в любом месте над изображением или как только он перемещает палец из поля, ограниченного изображением. Чтобы сделать это, мы собираемся удалить углы только в MSPointerUp или MSPointerOut. Это дает этот код вместо этого:

  var myGreatPic = document.getElementById ( "myGreatPicture" );
 // Создание нового MSGesture, который будет контролировать элемент DOM myGreatPic 
  var myGreatPicAssociatedGesture = new MSGesture ();
 myGreatPicAssociatedGesture.target = myGreatPic;

 // Вы должны сначала зарегистрироваться в MSPointerDown, чтобы иметь возможность 
  // иметь доступ к более сложным событиям жестов 
  myGreatPic.addEventListener ( "MSPointerDown" , указатель вниз, false );
 myGreatPic.addEventListener ( "MSGestureHold" , holded, false );
 myGreatPic.addEventListener ( "MSPointerUp" , removecorners, false );
 myGreatPic.addEventListener ( "MSPointerOut" , removecorners, false );

 // После касания мы отправляем все указатели на объект MSGesture 
  указатель на функцию (событие) {
     myGreatPicAssociatedGesture.addPointer (event.pointerId);
 }

 // Это событие будет вызвано объектом MSGesture 
  // на основе указателей, предоставленных во время события MSPointerDown 
  функция holded (событие) {
     // Жест начинается, мы добавляем углы 
      if (event.detail === event.MSGESTURE_FLAG_BEGIN) {
         Corners.append (myGreatPic);
     }
 }

 // Удаляем углы на указателе вверх или наружу 
  функция removecorners (событие) {
     Corners.remove (myGreatPic);
 }

 // Чтобы не было эквивалента контекстуального   
  // меню "правой кнопкой мыши", отображаемое в событии MSPointerUp,  
  // мы предотвращаем поведение по умолчанию 
  myGreatPic.addEventListener ( "contextmenu" , function (e) {
     e.preventDefault ();  // Отключаем системное меню 
  }, ложно ); 

который теперь обеспечивает поведение, которое я искал:

Пример 2: масштабирование, перемещение и вращение

Наконец, если вы хотите масштабировать, переводить или вращать элемент, вам просто нужно написать очень мало строк кода. Сначала вам нужно зарегистрироваться на событие MSGestureChange . Это событие отправит вас через различные атрибуты, описанные в документации по объекту MSGestureEvent, такие как вращение , масштабирование , translationX , translationY, которые в настоящее время применяются к вашему HTML-элементу.

Более того, по умолчанию объект MSGesture предоставляет алгоритм инерции бесплатно. Это означает, что вы можете взять HTML-элемент и выбросить его на экран пальцами, и анимация будет обработана для вас.

Наконец, чтобы отразить эти изменения, отправленные MSGesture, вам необходимо соответствующим образом переместить элемент. Самый простой способ сделать это — применить CSS-трансформацию, отображающую детали поворота, масштаба и перевода, соответствующие жесту ваших пальцев. Для этого используйте элемент MSCSSMatrix .

В заключение, если вы хотите обработать все эти крутые жесты с предыдущими примерами, зарегистрируйтесь на событие следующим образом:

  myGreatPic.addEventListener ( "MSGestureChange" , манипулировать элементом , false ); 

И используйте следующий обработчик:

  function manageulateElement (e) {
     // Раскомментируем следующий код, если вы хотите отключить встроенную инерцию  
      // обеспечивается динамическим распознаванием жестов 
      // if (e.detail == e.MSGESTURE_FLAG_INERTIA) 
      // возвращение; 

      // Получить последнюю CSS-трансформацию для элемента 
      var m = new MSCSSMatrix (e.target.currentStyle.transform); 
     e.target.style.transform = m
     .translate (e.offsetX, e.offsetY) // Переместить начало преобразования под центр жеста 
      .rotate (e.rotation * 180 / Math.PI) // Применить вращение 
      .scale (e.scale) // Применить масштаб 
      .translate (e.translationX, e.translationY) // Применить перевод 
      .translate (-e.offsetX, -e.offsetY);  // Переместить источник преобразования назад 
  } 

который дает вам этот последний образец:

Попробуйте переместить и бросить изображение внутри черной области одним или несколькими пальцами. Попробуйте также масштабировать или вращать элемент двумя или более пальцами. Результат потрясающий, а код очень простой, поскольку вся сложность обрабатывается в IE10.

Прямая ссылка на все образцы

Если у вас нет сенсорного экрана для IE10, и вам интересно, как работают примеры на этой странице, вы можете взглянуть на каждый из них по отдельности здесь:

Простой сенсорный образец по умолчанию с ничего не сделано
Простой пример касания, шаг 1 с помощью CSS -ms-touch-action
Простой пример касания, шаг 2а с базовой реализацией MSPointerMove
Простой пример касания, шаг 2b, с указанием типа указателя
Простой сенсорный пример, шаг 3, с MSPointers и запасным вариантом мыши
MSGesture образец 1: обработчик MSGestureHold
MSGesture образец 1b: обработчик MSGestureHold
MSGesture образец 2: MSGestureChange

Связанные ресурсы:

Спецификация событий указателя W3C

Обработка ввода с помощью Multi-Touch и мыши во всех браузерах: библиотека polyfill, которая должна помочь многим разработчикам в будущем
Указатель и жест события

Пойдите вне панорамирования, масштабирования и касания, используя события жестов

IE Test Drive Browser Surface, который сильно вдохновил множество встроенных демонстраций

— Попробуйте классные игры в IE10 с Touch:

Contre Jour и прочитайте очень интересную статью за кулисами

Atari Arcade Games и прочтите также эту очень информативную статью: Сборка Atari с CreateJS, в которой подробно описывается выбор поддержки Touch на всех платформах.

— Запись сессии BUILD 3-140: сенсорный экран, стилус и мышь, о боже!

Логически, со всеми подробностями, представленными в этой статье, и связанными ссылками на другие ресурсы, вы теперь готовы реализовать модель MSPointer Events на своих веб-сайтах и в приложениях Магазина Windows. Затем у вас есть возможность легко улучшить работу ваших пользователей в Internet Explorer 10.


Эта статья является частью технической серии HTML5 от команды Internet Explorer. Испытайте концепции этой статьи с тремя месяцами бесплатного кросс-браузерного тестирования BrowserStack @ http://modern.IE