widget/nsGUIEventIPC.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef nsGUIEventIPC_h__
   7 #define nsGUIEventIPC_h__
   8
   9 #include "ipc/IPCMessageUtils.h"
  10 #include "mozilla/GfxMessageUtils.h"
  11 #include "mozilla/dom/Touch.h"
  12 #include "mozilla/MiscEvents.h"
  13 #include "mozilla/MouseEvents.h"
  14 #include "mozilla/TextEvents.h"
  15 #include "mozilla/TouchEvents.h"
  16
  17 namespace IPC
  18 {
  19
  20 template<>
  21 struct ParamTraits<mozilla::BaseEventFlags>
  22 {
  23   typedef mozilla::BaseEventFlags paramType;
  24
  25   static void Write(Message* aMsg, const paramType& aParam)
  26   {
  27     aMsg->WriteBytes(&aParam, sizeof(aParam));
  28   }
  29
  30   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  31   {
  32     const char* outp;
  33     if (!aMsg->ReadBytes(aIter, &outp, sizeof(*aResult))) {
  34       return false;
  35     }
  36     *aResult = *reinterpret_cast<const paramType*>(outp);
  37     return true;
  38   }
  39 };
  40
  41 template<>
  42 struct ParamTraits<mozilla::WidgetEvent>
  43 {
  44   typedef mozilla::WidgetEvent paramType;
  45
  46   static void Write(Message* aMsg, const paramType& aParam)
  47   {
  48     WriteParam(aMsg, (uint8_t) aParam.eventStructType);
  49     WriteParam(aMsg, aParam.message);
  50     WriteParam(aMsg, aParam.refPoint);
  51     WriteParam(aMsg, aParam.time);
  52     WriteParam(aMsg, aParam.mFlags);
  53   }
  54
  55   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  56   {
  57     uint8_t eventStructType = 0;
  58     bool ret = ReadParam(aMsg, aIter, &eventStructType) &&
  59                ReadParam(aMsg, aIter, &aResult->message) &&
  60                ReadParam(aMsg, aIter, &aResult->refPoint) &&
  61                ReadParam(aMsg, aIter, &aResult->time) &&
  62                ReadParam(aMsg, aIter, &aResult->mFlags);
  63     aResult->eventStructType = static_cast<nsEventStructType>(eventStructType);
  64     return ret;
  65   }
  66 };
  67
  68 template<>
  69 struct ParamTraits<mozilla::WidgetGUIEvent>
  70 {
  71   typedef mozilla::WidgetGUIEvent paramType;
  72
  73   static void Write(Message* aMsg, const paramType& aParam)
  74   {
  75     WriteParam(aMsg, static_cast<mozilla::WidgetEvent>(aParam));
  76   }
  77
  78   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  79   {
  80     return ReadParam(aMsg, aIter, static_cast<mozilla::WidgetEvent*>(aResult));
  81   }
  82 };
  83
  84 template<>
  85 struct ParamTraits<mozilla::WidgetInputEvent>
  86 {
  87   typedef mozilla::WidgetInputEvent paramType;
  88
  89   static void Write(Message* aMsg, const paramType& aParam)
  90   {
  91     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
  92     WriteParam(aMsg, aParam.modifiers);
  93   }
  94
  95   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  96   {
  97     return ReadParam(aMsg, aIter,
  98                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
  99            ReadParam(aMsg, aIter, &aResult->modifiers);
 100   }
 101 };
 102
 103 template<>
 104 struct ParamTraits<mozilla::WidgetMouseEventBase>
 105 {
 106   typedef mozilla::WidgetMouseEventBase paramType;
 107
 108   static void Write(Message* aMsg, const paramType& aParam)
 109   {
 110     WriteParam(aMsg, static_cast<mozilla::WidgetInputEvent>(aParam));
 111     WriteParam(aMsg, aParam.button);
 112     WriteParam(aMsg, aParam.buttons);
 113     WriteParam(aMsg, aParam.pressure);
 114     WriteParam(aMsg, aParam.inputSource);
 115   }
 116
 117   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 118   {
 119     return ReadParam(aMsg, aIter,
 120                      static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 121            ReadParam(aMsg, aIter, &aResult->button) &&
 122            ReadParam(aMsg, aIter, &aResult->buttons) &&
 123            ReadParam(aMsg, aIter, &aResult->pressure) &&
 124            ReadParam(aMsg, aIter, &aResult->inputSource);
 125   }
 126 };
 127
 128 template<>
 129 struct ParamTraits<mozilla::WheelEvent>
 130 {
 131   typedef mozilla::WheelEvent paramType;
 132
 133   static void Write(Message* aMsg, const paramType& aParam)
 134   {
 135     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEventBase>(aParam));
 136     WriteParam(aMsg, aParam.deltaX);
 137     WriteParam(aMsg, aParam.deltaY);
 138     WriteParam(aMsg, aParam.deltaZ);
 139     WriteParam(aMsg, aParam.deltaMode);
 140     WriteParam(aMsg, aParam.customizedByUserPrefs);
 141     WriteParam(aMsg, aParam.isMomentum);
 142     WriteParam(aMsg, aParam.isPixelOnlyDevice);
 143     WriteParam(aMsg, aParam.lineOrPageDeltaX);
 144     WriteParam(aMsg, aParam.lineOrPageDeltaY);
 145     WriteParam(aMsg, static_cast<int32_t>(aParam.scrollType));
 146     WriteParam(aMsg, aParam.overflowDeltaX);
 147     WriteParam(aMsg, aParam.overflowDeltaY);
 148   }
 149
 150   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 151   {
 152     int32_t scrollType = 0;
 153     bool rv =
 154       ReadParam(aMsg, aIter,
 155                 static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 156       ReadParam(aMsg, aIter, &aResult->deltaX) &&
 157       ReadParam(aMsg, aIter, &aResult->deltaY) &&
 158       ReadParam(aMsg, aIter, &aResult->deltaZ) &&
 159       ReadParam(aMsg, aIter, &aResult->deltaMode) &&
 160       ReadParam(aMsg, aIter, &aResult->customizedByUserPrefs) &&
 161       ReadParam(aMsg, aIter, &aResult->isMomentum) &&
 162       ReadParam(aMsg, aIter, &aResult->isPixelOnlyDevice) &&
 163       ReadParam(aMsg, aIter, &aResult->lineOrPageDeltaX) &&
 164       ReadParam(aMsg, aIter, &aResult->lineOrPageDeltaY) &&
 165       ReadParam(aMsg, aIter, &scrollType) &&
 166       ReadParam(aMsg, aIter, &aResult->overflowDeltaX) &&
 167       ReadParam(aMsg, aIter, &aResult->overflowDeltaY);
 168     aResult->scrollType =
 169       static_cast<mozilla::WheelEvent::ScrollType>(scrollType);
 170     return rv;
 171   }
 172 };
 173
 174 template<>
 175 struct ParamTraits<mozilla::WidgetMouseEvent>
 176 {
 177   typedef mozilla::WidgetMouseEvent paramType;
 178
 179   static void Write(Message* aMsg, const paramType& aParam)
 180   {
 181     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEventBase>(aParam));
 182     WriteParam(aMsg, aParam.ignoreRootScrollFrame);
 183     WriteParam(aMsg, (uint8_t) aParam.reason);
 184     WriteParam(aMsg, (uint8_t) aParam.context);
 185     WriteParam(aMsg, (uint8_t) aParam.exit);
 186     WriteParam(aMsg, aParam.clickCount);
 187   }
 188
 189   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 190   {
 191     bool rv;
 192     uint8_t reason = 0, context = 0, exit = 0;
 193     rv = ReadParam(aMsg, aIter,
 194                    static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 195          ReadParam(aMsg, aIter, &aResult->ignoreRootScrollFrame) &&
 196          ReadParam(aMsg, aIter, &reason) &&
 197          ReadParam(aMsg, aIter, &context) &&
 198          ReadParam(aMsg, aIter, &exit) &&
 199          ReadParam(aMsg, aIter, &aResult->clickCount);
 200     aResult->reason =
 201       static_cast<mozilla::WidgetMouseEvent::reasonType>(reason);
 202     aResult->context =
 203       static_cast<mozilla::WidgetMouseEvent::contextType>(context);
 204     aResult->exit = static_cast<mozilla::WidgetMouseEvent::exitType>(exit);
 205     return rv;
 206   }
 207 };
 208
 209 template<>
 210 struct ParamTraits<mozilla::WidgetTouchEvent>
 211 {
 212   typedef mozilla::WidgetTouchEvent paramType;
 213
 214   static void Write(Message* aMsg, const paramType& aParam)
 215   {
 216     WriteParam(aMsg, static_cast<const mozilla::WidgetInputEvent&>(aParam));
 217     // Sigh, Touch bites us again!  We want to be able to do
 218     //   WriteParam(aMsg, aParam.touches);
 219     const nsTArray< nsRefPtr<mozilla::dom::Touch> >& touches = aParam.touches;
 220     WriteParam(aMsg, touches.Length());
 221     for (uint32_t i = 0; i < touches.Length(); ++i) {
 222       mozilla::dom::Touch* touch = touches[i];
 223       WriteParam(aMsg, touch->mIdentifier);
 224       WriteParam(aMsg, touch->mRefPoint);
 225       WriteParam(aMsg, touch->mRadius);
 226       WriteParam(aMsg, touch->mRotationAngle);
 227       WriteParam(aMsg, touch->mForce);
 228     }
 229   }
 230
 231   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 232   {
 233     uint32_t numTouches;
 234     if (!ReadParam(aMsg, aIter,
 235                    static_cast<mozilla::WidgetInputEvent*>(aResult)) ||
 236         !ReadParam(aMsg, aIter, &numTouches)) {
 237       return false;
 238     }
 239     for (uint32_t i = 0; i < numTouches; ++i) {
 240         int32_t identifier;
 241         mozilla::LayoutDeviceIntPoint refPoint;
 242         nsIntPoint radius;
 243         float rotationAngle;
 244         float force;
 245         if (!ReadParam(aMsg, aIter, &identifier) ||
 246             !ReadParam(aMsg, aIter, &refPoint) ||
 247             !ReadParam(aMsg, aIter, &radius) ||
 248             !ReadParam(aMsg, aIter, &rotationAngle) ||
 249             !ReadParam(aMsg, aIter, &force)) {
 250           return false;
 251         }
 252         aResult->touches.AppendElement(
 253           new mozilla::dom::Touch(
 254             identifier, mozilla::LayoutDeviceIntPoint::ToUntyped(refPoint),
 255             radius, rotationAngle, force));
 256     }
 257     return true;
 258   }
 259 };
 260
 261 template<>
 262 struct ParamTraits<mozilla::WidgetKeyboardEvent>
 263 {
 264   typedef mozilla::WidgetKeyboardEvent paramType;
 265
 266   static void Write(Message* aMsg, const paramType& aParam)
 267   {
 268     WriteParam(aMsg, static_cast<mozilla::WidgetInputEvent>(aParam));
 269     WriteParam(aMsg, static_cast<uint32_t>(aParam.mKeyNameIndex));
 270     WriteParam(aMsg, aParam.keyCode);
 271     WriteParam(aMsg, aParam.charCode);
 272     WriteParam(aMsg, aParam.isChar);
 273     WriteParam(aMsg, aParam.location);
 274     WriteParam(aMsg, aParam.mUniqueId);
 275     // An OS-specific native event might be attached in |mNativeKeyEvent|,  but
 276     // that cannot be copied across process boundaries.
 277   }
 278
 279   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 280   {
 281     uint32_t keyNameIndex = 0;
 282     if (ReadParam(aMsg, aIter,
 283                   static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 284         ReadParam(aMsg, aIter, &keyNameIndex) &&
 285         ReadParam(aMsg, aIter, &aResult->keyCode) &&
 286         ReadParam(aMsg, aIter, &aResult->charCode) &&
 287         ReadParam(aMsg, aIter, &aResult->isChar) &&
 288         ReadParam(aMsg, aIter, &aResult->location) &&
 289         ReadParam(aMsg, aIter, &aResult->mUniqueId))
 290     {
 291       aResult->mKeyNameIndex = static_cast<mozilla::KeyNameIndex>(keyNameIndex);
 292       aResult->mNativeKeyEvent = NULL;
 293       return true;
 294     }
 295     return false;
 296   }
 297 };
 298
 299 template<>
 300 struct ParamTraits<mozilla::TextRangeStyle>
 301 {
 302   typedef mozilla::TextRangeStyle paramType;
 303
 304   static void Write(Message* aMsg, const paramType& aParam)
 305   {
 306     WriteParam(aMsg, aParam.mDefinedStyles);
 307     WriteParam(aMsg, aParam.mLineStyle);
 308     WriteParam(aMsg, aParam.mIsBoldLine);
 309     WriteParam(aMsg, aParam.mForegroundColor);
 310     WriteParam(aMsg, aParam.mBackgroundColor);
 311     WriteParam(aMsg, aParam.mUnderlineColor);
 312   }
 313
 314   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 315   {
 316     return ReadParam(aMsg, aIter, &aResult->mDefinedStyles) &&
 317            ReadParam(aMsg, aIter, &aResult->mLineStyle) &&
 318            ReadParam(aMsg, aIter, &aResult->mIsBoldLine) &&
 319            ReadParam(aMsg, aIter, &aResult->mForegroundColor) &&
 320            ReadParam(aMsg, aIter, &aResult->mBackgroundColor) &&
 321            ReadParam(aMsg, aIter, &aResult->mUnderlineColor);
 322   }
 323 };
 324
 325 template<>
 326 struct ParamTraits<mozilla::TextRange>
 327 {
 328   typedef mozilla::TextRange paramType;
 329
 330   static void Write(Message* aMsg, const paramType& aParam)
 331   {
 332     WriteParam(aMsg, aParam.mStartOffset);
 333     WriteParam(aMsg, aParam.mEndOffset);
 334     WriteParam(aMsg, aParam.mRangeType);
 335     WriteParam(aMsg, aParam.mRangeStyle);
 336   }
 337
 338   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 339   {
 340     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 341            ReadParam(aMsg, aIter, &aResult->mEndOffset) &&
 342            ReadParam(aMsg, aIter, &aResult->mRangeType) &&
 343            ReadParam(aMsg, aIter, &aResult->mRangeStyle);
 344   }
 345 };
 346
 347 template<>
 348 struct ParamTraits<mozilla::WidgetTextEvent>
 349 {
 350   typedef mozilla::WidgetTextEvent paramType;
 351
 352   static void Write(Message* aMsg, const paramType& aParam)
 353   {
 354     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 355     WriteParam(aMsg, aParam.seqno);
 356     WriteParam(aMsg, aParam.theText);
 357     WriteParam(aMsg, aParam.isChar);
 358     WriteParam(aMsg, aParam.rangeCount);
 359     for (uint32_t index = 0; index < aParam.rangeCount; index++)
 360       WriteParam(aMsg, aParam.rangeArray[index]);
 361   }
 362
 363   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 364   {
 365     if (!ReadParam(aMsg, aIter,
 366                    static_cast<mozilla::WidgetGUIEvent*>(aResult)) ||
 367         !ReadParam(aMsg, aIter, &aResult->seqno) ||
 368         !ReadParam(aMsg, aIter, &aResult->theText) ||
 369         !ReadParam(aMsg, aIter, &aResult->isChar) ||
 370         !ReadParam(aMsg, aIter, &aResult->rangeCount))
 371       return false;
 372
 373     if (!aResult->rangeCount) {
 374       aResult->rangeArray = nullptr;
 375       return true;
 376     }
 377
 378     aResult->rangeArray = new mozilla::TextRange[aResult->rangeCount];
 379     if (!aResult->rangeArray)
 380       return false;
 381
 382     for (uint32_t index = 0; index < aResult->rangeCount; index++)
 383       if (!ReadParam(aMsg, aIter, &aResult->rangeArray[index])) {
 384         Free(*aResult);
 385         return false;
 386       }
 387     return true;
 388   }
 389
 390   static void Free(const paramType& aResult)
 391   {
 392     if (aResult.rangeArray)
 393       delete [] aResult.rangeArray;
 394   }
 395 };
 396
 397 template<>
 398 struct ParamTraits<mozilla::WidgetCompositionEvent>
 399 {
 400   typedef mozilla::WidgetCompositionEvent paramType;
 401
 402   static void Write(Message* aMsg, const paramType& aParam)
 403   {
 404     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 405     WriteParam(aMsg, aParam.seqno);
 406     WriteParam(aMsg, aParam.data);
 407   }
 408
 409   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 410   {
 411     return ReadParam(aMsg, aIter,
 412                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 413            ReadParam(aMsg, aIter, &aResult->seqno) &&
 414            ReadParam(aMsg, aIter, &aResult->data);
 415   }
 416 };
 417
 418 template<>
 419 struct ParamTraits<mozilla::WidgetQueryContentEvent>
 420 {
 421   typedef mozilla::WidgetQueryContentEvent paramType;
 422
 423   static void Write(Message* aMsg, const paramType& aParam)
 424   {
 425     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 426     WriteParam(aMsg, aParam.mSucceeded);
 427     WriteParam(aMsg, aParam.mInput.mOffset);
 428     WriteParam(aMsg, aParam.mInput.mLength);
 429     WriteParam(aMsg, aParam.mReply.mOffset);
 430     WriteParam(aMsg, aParam.mReply.mString);
 431     WriteParam(aMsg, aParam.mReply.mRect);
 432     WriteParam(aMsg, aParam.mReply.mReversed);
 433     WriteParam(aMsg, aParam.mReply.mHasSelection);
 434     WriteParam(aMsg, aParam.mReply.mWidgetIsHit);
 435   }
 436
 437   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 438   {
 439     aResult->mWasAsync = true;
 440     return ReadParam(aMsg, aIter,
 441                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 442            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 443            ReadParam(aMsg, aIter, &aResult->mInput.mOffset) &&
 444            ReadParam(aMsg, aIter, &aResult->mInput.mLength) &&
 445            ReadParam(aMsg, aIter, &aResult->mReply.mOffset) &&
 446            ReadParam(aMsg, aIter, &aResult->mReply.mString) &&
 447            ReadParam(aMsg, aIter, &aResult->mReply.mRect) &&
 448            ReadParam(aMsg, aIter, &aResult->mReply.mReversed) &&
 449            ReadParam(aMsg, aIter, &aResult->mReply.mHasSelection) &&
 450            ReadParam(aMsg, aIter, &aResult->mReply.mWidgetIsHit);
 451   }
 452 };
 453
 454 template<>
 455 struct ParamTraits<mozilla::WidgetSelectionEvent>
 456 {
 457   typedef mozilla::WidgetSelectionEvent paramType;
 458
 459   static void Write(Message* aMsg, const paramType& aParam)
 460   {
 461     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 462     WriteParam(aMsg, aParam.seqno);
 463     WriteParam(aMsg, aParam.mOffset);
 464     WriteParam(aMsg, aParam.mLength);
 465     WriteParam(aMsg, aParam.mReversed);
 466     WriteParam(aMsg, aParam.mExpandToClusterBoundary);
 467     WriteParam(aMsg, aParam.mSucceeded);
 468   }
 469
 470   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 471   {
 472     return ReadParam(aMsg, aIter,
 473                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 474            ReadParam(aMsg, aIter, &aResult->seqno) &&
 475            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 476            ReadParam(aMsg, aIter, &aResult->mLength) &&
 477            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 478            ReadParam(aMsg, aIter, &aResult->mExpandToClusterBoundary) &&
 479            ReadParam(aMsg, aIter, &aResult->mSucceeded);
 480   }
 481 };
 482
 483 template<>
 484 struct ParamTraits<nsIMEUpdatePreference>
 485 {
 486   typedef nsIMEUpdatePreference paramType;
 487
 488   static void Write(Message* aMsg, const paramType& aParam)
 489   {
 490     WriteParam(aMsg, aParam.mWantUpdates);
 491     WriteParam(aMsg, aParam.mWantHints);
 492   }
 493
 494   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 495   {
 496     return ReadParam(aMsg, aIter, &aResult->mWantUpdates) &&
 497            ReadParam(aMsg, aIter, &aResult->mWantHints);
 498   }
 499 };
 500
 501 template<>
 502 struct ParamTraits<mozilla::WidgetPluginEvent>
 503 {
 504   typedef mozilla::WidgetPluginEvent paramType;
 505
 506   static void Write(Message* aMsg, const paramType& aParam)
 507   {
 508     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 509     WriteParam(aMsg, aParam.retargetToFocusedDocument);
 510   }
 511
 512   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 513   {
 514     return ReadParam(aMsg, aIter,
 515                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 516            ReadParam(aMsg, aIter, &aResult->retargetToFocusedDocument);
 517   }
 518 };
 519
 520 } // namespace IPC
 521
 522 #endif // nsGUIEventIPC_h__
 523