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,
  49       static_cast<mozilla::EventClassIDType>(aParam.mClass));
  50     WriteParam(aMsg, aParam.message);
  51     WriteParam(aMsg, aParam.refPoint);
  52     WriteParam(aMsg, aParam.time);
  53     WriteParam(aMsg, aParam.timeStamp);
  54     WriteParam(aMsg, aParam.mFlags);
  55   }
  56
  57   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  58   {
  59     mozilla::EventClassIDType eventClassID = 0;
  60     bool ret = ReadParam(aMsg, aIter, &eventClassID) &&
  61                ReadParam(aMsg, aIter, &aResult->message) &&
  62                ReadParam(aMsg, aIter, &aResult->refPoint) &&
  63                ReadParam(aMsg, aIter, &aResult->time) &&
  64                ReadParam(aMsg, aIter, &aResult->timeStamp) &&
  65                ReadParam(aMsg, aIter, &aResult->mFlags);
  66     aResult->mClass = static_cast<mozilla::EventClassID>(eventClassID);
  67     return ret;
  68   }
  69 };
  70
  71 template<>
  72 struct ParamTraits<mozilla::WidgetGUIEvent>
  73 {
  74   typedef mozilla::WidgetGUIEvent paramType;
  75
  76   static void Write(Message* aMsg, const paramType& aParam)
  77   {
  78     WriteParam(aMsg, static_cast<mozilla::WidgetEvent>(aParam));
  79     WriteParam(aMsg, aParam.mPluginEvent.mBuffer);
  80   }
  81
  82   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  83   {
  84     return ReadParam(aMsg, aIter, static_cast<mozilla::WidgetEvent*>(aResult)) &&
  85            ReadParam(aMsg, aIter, &aResult->mPluginEvent.mBuffer);
  86   }
  87 };
  88
  89 template<>
  90 struct ParamTraits<mozilla::WidgetInputEvent>
  91 {
  92   typedef mozilla::WidgetInputEvent paramType;
  93
  94   static void Write(Message* aMsg, const paramType& aParam)
  95   {
  96     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
  97     WriteParam(aMsg, aParam.modifiers);
  98   }
  99
 100   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 101   {
 102     return ReadParam(aMsg, aIter,
 103                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 104            ReadParam(aMsg, aIter, &aResult->modifiers);
 105   }
 106 };
 107
 108 template<>
 109 struct ParamTraits<mozilla::WidgetMouseEventBase>
 110 {
 111   typedef mozilla::WidgetMouseEventBase paramType;
 112
 113   static void Write(Message* aMsg, const paramType& aParam)
 114   {
 115     WriteParam(aMsg, static_cast<mozilla::WidgetInputEvent>(aParam));
 116     WriteParam(aMsg, aParam.button);
 117     WriteParam(aMsg, aParam.buttons);
 118     WriteParam(aMsg, aParam.pressure);
 119     WriteParam(aMsg, aParam.inputSource);
 120   }
 121
 122   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 123   {
 124     return ReadParam(aMsg, aIter,
 125                      static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 126            ReadParam(aMsg, aIter, &aResult->button) &&
 127            ReadParam(aMsg, aIter, &aResult->buttons) &&
 128            ReadParam(aMsg, aIter, &aResult->pressure) &&
 129            ReadParam(aMsg, aIter, &aResult->inputSource);
 130   }
 131 };
 132
 133 template<>
 134 struct ParamTraits<mozilla::WidgetWheelEvent>
 135 {
 136   typedef mozilla::WidgetWheelEvent paramType;
 137
 138   static void Write(Message* aMsg, const paramType& aParam)
 139   {
 140     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEventBase>(aParam));
 141     WriteParam(aMsg, aParam.deltaX);
 142     WriteParam(aMsg, aParam.deltaY);
 143     WriteParam(aMsg, aParam.deltaZ);
 144     WriteParam(aMsg, aParam.deltaMode);
 145     WriteParam(aMsg, aParam.customizedByUserPrefs);
 146     WriteParam(aMsg, aParam.isMomentum);
 147     WriteParam(aMsg, aParam.mIsNoLineOrPageDelta);
 148     WriteParam(aMsg, aParam.lineOrPageDeltaX);
 149     WriteParam(aMsg, aParam.lineOrPageDeltaY);
 150     WriteParam(aMsg, static_cast<int32_t>(aParam.scrollType));
 151     WriteParam(aMsg, aParam.overflowDeltaX);
 152     WriteParam(aMsg, aParam.overflowDeltaY);
 153   }
 154
 155   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 156   {
 157     int32_t scrollType = 0;
 158     bool rv =
 159       ReadParam(aMsg, aIter,
 160                 static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 161       ReadParam(aMsg, aIter, &aResult->deltaX) &&
 162       ReadParam(aMsg, aIter, &aResult->deltaY) &&
 163       ReadParam(aMsg, aIter, &aResult->deltaZ) &&
 164       ReadParam(aMsg, aIter, &aResult->deltaMode) &&
 165       ReadParam(aMsg, aIter, &aResult->customizedByUserPrefs) &&
 166       ReadParam(aMsg, aIter, &aResult->isMomentum) &&
 167       ReadParam(aMsg, aIter, &aResult->mIsNoLineOrPageDelta) &&
 168       ReadParam(aMsg, aIter, &aResult->lineOrPageDeltaX) &&
 169       ReadParam(aMsg, aIter, &aResult->lineOrPageDeltaY) &&
 170       ReadParam(aMsg, aIter, &scrollType) &&
 171       ReadParam(aMsg, aIter, &aResult->overflowDeltaX) &&
 172       ReadParam(aMsg, aIter, &aResult->overflowDeltaY);
 173     aResult->scrollType =
 174       static_cast<mozilla::WidgetWheelEvent::ScrollType>(scrollType);
 175     return rv;
 176   }
 177 };
 178
 179 template<>
 180 struct ParamTraits<mozilla::WidgetMouseEvent>
 181 {
 182   typedef mozilla::WidgetMouseEvent paramType;
 183
 184   static void Write(Message* aMsg, const paramType& aParam)
 185   {
 186     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEventBase>(aParam));
 187     WriteParam(aMsg, aParam.ignoreRootScrollFrame);
 188     WriteParam(aMsg, (uint8_t) aParam.reason);
 189     WriteParam(aMsg, (uint8_t) aParam.context);
 190     WriteParam(aMsg, (uint8_t) aParam.exit);
 191     WriteParam(aMsg, aParam.clickCount);
 192   }
 193
 194   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 195   {
 196     bool rv;
 197     uint8_t reason = 0, context = 0, exit = 0;
 198     rv = ReadParam(aMsg, aIter,
 199                    static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 200          ReadParam(aMsg, aIter, &aResult->ignoreRootScrollFrame) &&
 201          ReadParam(aMsg, aIter, &reason) &&
 202          ReadParam(aMsg, aIter, &context) &&
 203          ReadParam(aMsg, aIter, &exit) &&
 204          ReadParam(aMsg, aIter, &aResult->clickCount);
 205     aResult->reason =
 206       static_cast<mozilla::WidgetMouseEvent::reasonType>(reason);
 207     aResult->context =
 208       static_cast<mozilla::WidgetMouseEvent::contextType>(context);
 209     aResult->exit = static_cast<mozilla::WidgetMouseEvent::exitType>(exit);
 210     return rv;
 211   }
 212 };
 213
 214 template<>
 215 struct ParamTraits<mozilla::WidgetPointerEvent>
 216 {
 217   typedef mozilla::WidgetPointerEvent paramType;
 218
 219   static void Write(Message* aMsg, const paramType& aParam)
 220   {
 221     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEvent>(aParam));
 222     WriteParam(aMsg, aParam.pointerId);
 223     WriteParam(aMsg, aParam.width);
 224     WriteParam(aMsg, aParam.height);
 225     WriteParam(aMsg, aParam.tiltX);
 226     WriteParam(aMsg, aParam.tiltY);
 227     WriteParam(aMsg, aParam.isPrimary);
 228   }
 229
 230   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 231   {
 232     bool rv =
 233       ReadParam(aMsg, aIter, static_cast<mozilla::WidgetMouseEvent*>(aResult)) &&
 234       ReadParam(aMsg, aIter, &aResult->pointerId) &&
 235       ReadParam(aMsg, aIter, &aResult->width) &&
 236       ReadParam(aMsg, aIter, &aResult->height) &&
 237       ReadParam(aMsg, aIter, &aResult->tiltX) &&
 238       ReadParam(aMsg, aIter, &aResult->tiltY) &&
 239       ReadParam(aMsg, aIter, &aResult->isPrimary);
 240     return rv;
 241   }
 242 };
 243
 244 template<>
 245 struct ParamTraits<mozilla::WidgetTouchEvent>
 246 {
 247   typedef mozilla::WidgetTouchEvent paramType;
 248
 249   static void Write(Message* aMsg, const paramType& aParam)
 250   {
 251     WriteParam(aMsg, static_cast<const mozilla::WidgetInputEvent&>(aParam));
 252     // Sigh, Touch bites us again!  We want to be able to do
 253     //   WriteParam(aMsg, aParam.touches);
 254     const paramType::TouchArray& touches = aParam.touches;
 255     WriteParam(aMsg, touches.Length());
 256     for (uint32_t i = 0; i < touches.Length(); ++i) {
 257       mozilla::dom::Touch* touch = touches[i];
 258       WriteParam(aMsg, touch->mIdentifier);
 259       WriteParam(aMsg, touch->mRefPoint);
 260       WriteParam(aMsg, touch->mRadius);
 261       WriteParam(aMsg, touch->mRotationAngle);
 262       WriteParam(aMsg, touch->mForce);
 263     }
 264   }
 265
 266   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 267   {
 268     paramType::TouchArray::size_type numTouches;
 269     if (!ReadParam(aMsg, aIter,
 270                    static_cast<mozilla::WidgetInputEvent*>(aResult)) ||
 271         !ReadParam(aMsg, aIter, &numTouches)) {
 272       return false;
 273     }
 274     for (uint32_t i = 0; i < numTouches; ++i) {
 275         int32_t identifier;
 276         mozilla::LayoutDeviceIntPoint refPoint;
 277         nsIntPoint radius;
 278         float rotationAngle;
 279         float force;
 280         if (!ReadParam(aMsg, aIter, &identifier) ||
 281             !ReadParam(aMsg, aIter, &refPoint) ||
 282             !ReadParam(aMsg, aIter, &radius) ||
 283             !ReadParam(aMsg, aIter, &rotationAngle) ||
 284             !ReadParam(aMsg, aIter, &force)) {
 285           return false;
 286         }
 287         aResult->touches.AppendElement(
 288           new mozilla::dom::Touch(
 289             identifier, mozilla::LayoutDeviceIntPoint::ToUntyped(refPoint),
 290             radius, rotationAngle, force));
 291     }
 292     return true;
 293   }
 294 };
 295
 296 template<>
 297 struct ParamTraits<mozilla::AlternativeCharCode>
 298 {
 299   typedef mozilla::AlternativeCharCode paramType;
 300
 301   static void Write(Message* aMsg, const paramType& aParam)
 302   {
 303     WriteParam(aMsg, aParam.mUnshiftedCharCode);
 304     WriteParam(aMsg, aParam.mShiftedCharCode);
 305   }
 306
 307   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 308   {
 309     return ReadParam(aMsg, aIter, &aResult->mUnshiftedCharCode) &&
 310            ReadParam(aMsg, aIter, &aResult->mShiftedCharCode);
 311   }
 312 };
 313
 314
 315 template<>
 316 struct ParamTraits<mozilla::WidgetKeyboardEvent>
 317 {
 318   typedef mozilla::WidgetKeyboardEvent paramType;
 319
 320   static void Write(Message* aMsg, const paramType& aParam)
 321   {
 322     WriteParam(aMsg, static_cast<mozilla::WidgetInputEvent>(aParam));
 323     WriteParam(aMsg, static_cast<uint32_t>(aParam.mKeyNameIndex));
 324     WriteParam(aMsg, static_cast<uint32_t>(aParam.mCodeNameIndex));
 325     WriteParam(aMsg, aParam.mKeyValue);
 326     WriteParam(aMsg, aParam.mCodeValue);
 327     WriteParam(aMsg, aParam.keyCode);
 328     WriteParam(aMsg, aParam.charCode);
 329     WriteParam(aMsg, aParam.alternativeCharCodes);
 330     WriteParam(aMsg, aParam.isChar);
 331     WriteParam(aMsg, aParam.mIsRepeat);
 332     WriteParam(aMsg, aParam.location);
 333     WriteParam(aMsg, aParam.mUniqueId);
 334     // An OS-specific native event might be attached in |mNativeKeyEvent|,  but
 335     // that cannot be copied across process boundaries.
 336   }
 337
 338   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 339   {
 340     uint32_t keyNameIndex = 0, codeNameIndex = 0;
 341     if (ReadParam(aMsg, aIter,
 342                   static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 343         ReadParam(aMsg, aIter, &keyNameIndex) &&
 344         ReadParam(aMsg, aIter, &codeNameIndex) &&
 345         ReadParam(aMsg, aIter, &aResult->mKeyValue) &&
 346         ReadParam(aMsg, aIter, &aResult->mCodeValue) &&
 347         ReadParam(aMsg, aIter, &aResult->keyCode) &&
 348         ReadParam(aMsg, aIter, &aResult->charCode) &&
 349         ReadParam(aMsg, aIter, &aResult->alternativeCharCodes) &&
 350         ReadParam(aMsg, aIter, &aResult->isChar) &&
 351         ReadParam(aMsg, aIter, &aResult->mIsRepeat) &&
 352         ReadParam(aMsg, aIter, &aResult->location) &&
 353         ReadParam(aMsg, aIter, &aResult->mUniqueId))
 354     {
 355       aResult->mKeyNameIndex = static_cast<mozilla::KeyNameIndex>(keyNameIndex);
 356       aResult->mCodeNameIndex =
 357         static_cast<mozilla::CodeNameIndex>(codeNameIndex);
 358       aResult->mNativeKeyEvent = nullptr;
 359       return true;
 360     }
 361     return false;
 362   }
 363 };
 364
 365 template<>
 366 struct ParamTraits<mozilla::TextRangeStyle>
 367 {
 368   typedef mozilla::TextRangeStyle paramType;
 369
 370   static void Write(Message* aMsg, const paramType& aParam)
 371   {
 372     WriteParam(aMsg, aParam.mDefinedStyles);
 373     WriteParam(aMsg, aParam.mLineStyle);
 374     WriteParam(aMsg, aParam.mIsBoldLine);
 375     WriteParam(aMsg, aParam.mForegroundColor);
 376     WriteParam(aMsg, aParam.mBackgroundColor);
 377     WriteParam(aMsg, aParam.mUnderlineColor);
 378   }
 379
 380   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 381   {
 382     return ReadParam(aMsg, aIter, &aResult->mDefinedStyles) &&
 383            ReadParam(aMsg, aIter, &aResult->mLineStyle) &&
 384            ReadParam(aMsg, aIter, &aResult->mIsBoldLine) &&
 385            ReadParam(aMsg, aIter, &aResult->mForegroundColor) &&
 386            ReadParam(aMsg, aIter, &aResult->mBackgroundColor) &&
 387            ReadParam(aMsg, aIter, &aResult->mUnderlineColor);
 388   }
 389 };
 390
 391 template<>
 392 struct ParamTraits<mozilla::TextRange>
 393 {
 394   typedef mozilla::TextRange paramType;
 395
 396   static void Write(Message* aMsg, const paramType& aParam)
 397   {
 398     WriteParam(aMsg, aParam.mStartOffset);
 399     WriteParam(aMsg, aParam.mEndOffset);
 400     WriteParam(aMsg, aParam.mRangeType);
 401     WriteParam(aMsg, aParam.mRangeStyle);
 402   }
 403
 404   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 405   {
 406     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 407            ReadParam(aMsg, aIter, &aResult->mEndOffset) &&
 408            ReadParam(aMsg, aIter, &aResult->mRangeType) &&
 409            ReadParam(aMsg, aIter, &aResult->mRangeStyle);
 410   }
 411 };
 412
 413 template<>
 414 struct ParamTraits<mozilla::TextRangeArray>
 415 {
 416   typedef mozilla::TextRangeArray paramType;
 417
 418   static void Write(Message* aMsg, const paramType& aParam)
 419   {
 420     WriteParam(aMsg, aParam.Length());
 421     for (uint32_t index = 0; index < aParam.Length(); index++) {
 422       WriteParam(aMsg, aParam[index]);
 423     }
 424   }
 425
 426   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 427   {
 428     paramType::size_type length;
 429     if (!ReadParam(aMsg, aIter, &length)) {
 430       return false;
 431     }
 432     for (uint32_t index = 0; index < length; index++) {
 433       mozilla::TextRange textRange;
 434       if (!ReadParam(aMsg, aIter, &textRange)) {
 435         aResult->Clear();
 436         return false;
 437       }
 438       aResult->AppendElement(textRange);
 439     }
 440     return true;
 441   }
 442 };
 443
 444 template<>
 445 struct ParamTraits<mozilla::WidgetTextEvent>
 446 {
 447   typedef mozilla::WidgetTextEvent paramType;
 448
 449   static void Write(Message* aMsg, const paramType& aParam)
 450   {
 451     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 452     WriteParam(aMsg, aParam.mSeqno);
 453     WriteParam(aMsg, aParam.theText);
 454     WriteParam(aMsg, aParam.isChar);
 455     bool hasRanges = !!aParam.mRanges;
 456     WriteParam(aMsg, hasRanges);
 457     if (hasRanges) {
 458       WriteParam(aMsg, *aParam.mRanges.get());
 459     }
 460   }
 461
 462   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 463   {
 464     bool hasRanges;
 465     if (!ReadParam(aMsg, aIter,
 466                    static_cast<mozilla::WidgetGUIEvent*>(aResult)) ||
 467         !ReadParam(aMsg, aIter, &aResult->mSeqno) ||
 468         !ReadParam(aMsg, aIter, &aResult->theText) ||
 469         !ReadParam(aMsg, aIter, &aResult->isChar) ||
 470         !ReadParam(aMsg, aIter, &hasRanges)) {
 471       return false;
 472     }
 473
 474     if (!hasRanges) {
 475       aResult->mRanges = nullptr;
 476     } else {
 477       aResult->mRanges = new mozilla::TextRangeArray();
 478       if (!aResult->mRanges) {
 479         return false;
 480       }
 481       if (!ReadParam(aMsg, aIter, aResult->mRanges.get())) {
 482         return false;
 483       }
 484     }
 485     return true;
 486   }
 487 };
 488
 489 template<>
 490 struct ParamTraits<mozilla::WidgetCompositionEvent>
 491 {
 492   typedef mozilla::WidgetCompositionEvent paramType;
 493
 494   static void Write(Message* aMsg, const paramType& aParam)
 495   {
 496     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 497     WriteParam(aMsg, aParam.mSeqno);
 498     WriteParam(aMsg, aParam.data);
 499   }
 500
 501   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 502   {
 503     return ReadParam(aMsg, aIter,
 504                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 505            ReadParam(aMsg, aIter, &aResult->mSeqno) &&
 506            ReadParam(aMsg, aIter, &aResult->data);
 507   }
 508 };
 509
 510 template<>
 511 struct ParamTraits<mozilla::WidgetQueryContentEvent>
 512 {
 513   typedef mozilla::WidgetQueryContentEvent paramType;
 514
 515   static void Write(Message* aMsg, const paramType& aParam)
 516   {
 517     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 518     WriteParam(aMsg, aParam.mSucceeded);
 519     WriteParam(aMsg, aParam.mUseNativeLineBreak);
 520     WriteParam(aMsg, aParam.mInput.mOffset);
 521     WriteParam(aMsg, aParam.mInput.mLength);
 522     WriteParam(aMsg, aParam.mReply.mOffset);
 523     WriteParam(aMsg, aParam.mReply.mString);
 524     WriteParam(aMsg, aParam.mReply.mRect);
 525     WriteParam(aMsg, aParam.mReply.mReversed);
 526     WriteParam(aMsg, aParam.mReply.mHasSelection);
 527     WriteParam(aMsg, aParam.mReply.mWidgetIsHit);
 528   }
 529
 530   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 531   {
 532     aResult->mWasAsync = true;
 533     return ReadParam(aMsg, aIter,
 534                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 535            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 536            ReadParam(aMsg, aIter, &aResult->mUseNativeLineBreak) &&
 537            ReadParam(aMsg, aIter, &aResult->mInput.mOffset) &&
 538            ReadParam(aMsg, aIter, &aResult->mInput.mLength) &&
 539            ReadParam(aMsg, aIter, &aResult->mReply.mOffset) &&
 540            ReadParam(aMsg, aIter, &aResult->mReply.mString) &&
 541            ReadParam(aMsg, aIter, &aResult->mReply.mRect) &&
 542            ReadParam(aMsg, aIter, &aResult->mReply.mReversed) &&
 543            ReadParam(aMsg, aIter, &aResult->mReply.mHasSelection) &&
 544            ReadParam(aMsg, aIter, &aResult->mReply.mWidgetIsHit);
 545   }
 546 };
 547
 548 template<>
 549 struct ParamTraits<mozilla::WidgetSelectionEvent>
 550 {
 551   typedef mozilla::WidgetSelectionEvent paramType;
 552
 553   static void Write(Message* aMsg, const paramType& aParam)
 554   {
 555     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 556     WriteParam(aMsg, aParam.mSeqno);
 557     WriteParam(aMsg, aParam.mOffset);
 558     WriteParam(aMsg, aParam.mLength);
 559     WriteParam(aMsg, aParam.mReversed);
 560     WriteParam(aMsg, aParam.mExpandToClusterBoundary);
 561     WriteParam(aMsg, aParam.mSucceeded);
 562     WriteParam(aMsg, aParam.mUseNativeLineBreak);
 563   }
 564
 565   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 566   {
 567     return ReadParam(aMsg, aIter,
 568                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 569            ReadParam(aMsg, aIter, &aResult->mSeqno) &&
 570            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 571            ReadParam(aMsg, aIter, &aResult->mLength) &&
 572            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 573            ReadParam(aMsg, aIter, &aResult->mExpandToClusterBoundary) &&
 574            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 575            ReadParam(aMsg, aIter, &aResult->mUseNativeLineBreak);
 576   }
 577 };
 578
 579 template<>
 580 struct ParamTraits<nsIMEUpdatePreference>
 581 {
 582   typedef nsIMEUpdatePreference paramType;
 583
 584   static void Write(Message* aMsg, const paramType& aParam)
 585   {
 586     WriteParam(aMsg, aParam.mWantUpdates);
 587   }
 588
 589   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 590   {
 591     return ReadParam(aMsg, aIter, &aResult->mWantUpdates);
 592   }
 593 };
 594
 595 template<>
 596 struct ParamTraits<mozilla::WidgetPluginEvent>
 597 {
 598   typedef mozilla::WidgetPluginEvent paramType;
 599
 600   static void Write(Message* aMsg, const paramType& aParam)
 601   {
 602     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 603     WriteParam(aMsg, aParam.retargetToFocusedDocument);
 604   }
 605
 606   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 607   {
 608     return ReadParam(aMsg, aIter,
 609                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 610            ReadParam(aMsg, aIter, &aResult->retargetToFocusedDocument);
 611   }
 612 };
 613
 614 } // namespace IPC
 615
 616 #endif // nsGUIEventIPC_h__
 617