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 #ifdef XP_MACOSX
 335     WriteParam(aMsg, aParam.mNativeKeyCode);
 336     WriteParam(aMsg, aParam.mNativeModifierFlags);
 337     WriteParam(aMsg, aParam.mNativeCharacters);
 338     WriteParam(aMsg, aParam.mNativeCharactersIgnoringModifiers);
 339     WriteParam(aMsg, aParam.mPluginTextEventString);
 340 #endif
 341     // An OS-specific native event might be attached in |mNativeKeyEvent|,  but
 342     // that cannot be copied across process boundaries.
 343   }
 344
 345   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 346   {
 347     uint32_t keyNameIndex = 0, codeNameIndex = 0;
 348     if (ReadParam(aMsg, aIter,
 349                   static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 350         ReadParam(aMsg, aIter, &keyNameIndex) &&
 351         ReadParam(aMsg, aIter, &codeNameIndex) &&
 352         ReadParam(aMsg, aIter, &aResult->mKeyValue) &&
 353         ReadParam(aMsg, aIter, &aResult->mCodeValue) &&
 354         ReadParam(aMsg, aIter, &aResult->keyCode) &&
 355         ReadParam(aMsg, aIter, &aResult->charCode) &&
 356         ReadParam(aMsg, aIter, &aResult->alternativeCharCodes) &&
 357         ReadParam(aMsg, aIter, &aResult->isChar) &&
 358         ReadParam(aMsg, aIter, &aResult->mIsRepeat) &&
 359         ReadParam(aMsg, aIter, &aResult->location) &&
 360         ReadParam(aMsg, aIter, &aResult->mUniqueId)
 361 #ifdef XP_MACOSX
 362         && ReadParam(aMsg, aIter, &aResult->mNativeKeyCode)
 363         && ReadParam(aMsg, aIter, &aResult->mNativeModifierFlags)
 364         && ReadParam(aMsg, aIter, &aResult->mNativeCharacters)
 365         && ReadParam(aMsg, aIter, &aResult->mNativeCharactersIgnoringModifiers)
 366         && ReadParam(aMsg, aIter, &aResult->mPluginTextEventString)
 367 #endif
 368         )
 369     {
 370       aResult->mKeyNameIndex = static_cast<mozilla::KeyNameIndex>(keyNameIndex);
 371       aResult->mCodeNameIndex =
 372         static_cast<mozilla::CodeNameIndex>(codeNameIndex);
 373       aResult->mNativeKeyEvent = nullptr;
 374       return true;
 375     }
 376     return false;
 377   }
 378 };
 379
 380 template<>
 381 struct ParamTraits<mozilla::InternalBeforeAfterKeyboardEvent>
 382 {
 383   typedef mozilla::InternalBeforeAfterKeyboardEvent paramType;
 384
 385   static void Write(Message* aMsg, const paramType& aParam)
 386   {
 387     WriteParam(aMsg, static_cast<mozilla::WidgetKeyboardEvent>(aParam));
 388     WriteParam(aMsg, aParam.mEmbeddedCancelled.IsNull());
 389     WriteParam(aMsg, aParam.mEmbeddedCancelled.Value());
 390   }
 391
 392   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 393   {
 394     bool isNull;
 395     bool value;
 396     bool rv =
 397       ReadParam(aMsg, aIter,
 398                 static_cast<mozilla::WidgetKeyboardEvent*>(aResult)) &&
 399       ReadParam(aMsg, aIter, &isNull) &&
 400       ReadParam(aMsg, aIter, &value);
 401
 402     aResult->mEmbeddedCancelled = Nullable<bool>();
 403     if (rv && !isNull) {
 404       aResult->mEmbeddedCancelled.SetValue(value);
 405     }
 406
 407     return rv;
 408   }
 409 };
 410
 411 template<>
 412 struct ParamTraits<mozilla::TextRangeStyle>
 413 {
 414   typedef mozilla::TextRangeStyle paramType;
 415
 416   static void Write(Message* aMsg, const paramType& aParam)
 417   {
 418     WriteParam(aMsg, aParam.mDefinedStyles);
 419     WriteParam(aMsg, aParam.mLineStyle);
 420     WriteParam(aMsg, aParam.mIsBoldLine);
 421     WriteParam(aMsg, aParam.mForegroundColor);
 422     WriteParam(aMsg, aParam.mBackgroundColor);
 423     WriteParam(aMsg, aParam.mUnderlineColor);
 424   }
 425
 426   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 427   {
 428     return ReadParam(aMsg, aIter, &aResult->mDefinedStyles) &&
 429            ReadParam(aMsg, aIter, &aResult->mLineStyle) &&
 430            ReadParam(aMsg, aIter, &aResult->mIsBoldLine) &&
 431            ReadParam(aMsg, aIter, &aResult->mForegroundColor) &&
 432            ReadParam(aMsg, aIter, &aResult->mBackgroundColor) &&
 433            ReadParam(aMsg, aIter, &aResult->mUnderlineColor);
 434   }
 435 };
 436
 437 template<>
 438 struct ParamTraits<mozilla::TextRange>
 439 {
 440   typedef mozilla::TextRange paramType;
 441
 442   static void Write(Message* aMsg, const paramType& aParam)
 443   {
 444     WriteParam(aMsg, aParam.mStartOffset);
 445     WriteParam(aMsg, aParam.mEndOffset);
 446     WriteParam(aMsg, aParam.mRangeType);
 447     WriteParam(aMsg, aParam.mRangeStyle);
 448   }
 449
 450   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 451   {
 452     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 453            ReadParam(aMsg, aIter, &aResult->mEndOffset) &&
 454            ReadParam(aMsg, aIter, &aResult->mRangeType) &&
 455            ReadParam(aMsg, aIter, &aResult->mRangeStyle);
 456   }
 457 };
 458
 459 template<>
 460 struct ParamTraits<mozilla::TextRangeArray>
 461 {
 462   typedef mozilla::TextRangeArray paramType;
 463
 464   static void Write(Message* aMsg, const paramType& aParam)
 465   {
 466     WriteParam(aMsg, aParam.Length());
 467     for (uint32_t index = 0; index < aParam.Length(); index++) {
 468       WriteParam(aMsg, aParam[index]);
 469     }
 470   }
 471
 472   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 473   {
 474     paramType::size_type length;
 475     if (!ReadParam(aMsg, aIter, &length)) {
 476       return false;
 477     }
 478     for (uint32_t index = 0; index < length; index++) {
 479       mozilla::TextRange textRange;
 480       if (!ReadParam(aMsg, aIter, &textRange)) {
 481         aResult->Clear();
 482         return false;
 483       }
 484       aResult->AppendElement(textRange);
 485     }
 486     return true;
 487   }
 488 };
 489
 490 template<>
 491 struct ParamTraits<mozilla::WidgetCompositionEvent>
 492 {
 493   typedef mozilla::WidgetCompositionEvent paramType;
 494
 495   static void Write(Message* aMsg, const paramType& aParam)
 496   {
 497     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 498     WriteParam(aMsg, aParam.mSeqno);
 499     WriteParam(aMsg, aParam.mData);
 500     bool hasRanges = !!aParam.mRanges;
 501     WriteParam(aMsg, hasRanges);
 502     if (hasRanges) {
 503       WriteParam(aMsg, *aParam.mRanges.get());
 504     }
 505   }
 506
 507   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 508   {
 509     bool hasRanges;
 510     if (!ReadParam(aMsg, aIter,
 511                    static_cast<mozilla::WidgetGUIEvent*>(aResult)) ||
 512         !ReadParam(aMsg, aIter, &aResult->mSeqno) ||
 513         !ReadParam(aMsg, aIter, &aResult->mData) ||
 514         !ReadParam(aMsg, aIter, &hasRanges)) {
 515       return false;
 516     }
 517
 518     if (!hasRanges) {
 519       aResult->mRanges = nullptr;
 520     } else {
 521       aResult->mRanges = new mozilla::TextRangeArray();
 522       if (!ReadParam(aMsg, aIter, aResult->mRanges.get())) {
 523         return false;
 524       }
 525     }
 526     return true;
 527   }
 528 };
 529
 530 template<>
 531 struct ParamTraits<mozilla::WidgetQueryContentEvent>
 532 {
 533   typedef mozilla::WidgetQueryContentEvent paramType;
 534
 535   static void Write(Message* aMsg, const paramType& aParam)
 536   {
 537     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 538     WriteParam(aMsg, aParam.mSucceeded);
 539     WriteParam(aMsg, aParam.mUseNativeLineBreak);
 540     WriteParam(aMsg, aParam.mInput.mOffset);
 541     WriteParam(aMsg, aParam.mInput.mLength);
 542     WriteParam(aMsg, aParam.mReply.mOffset);
 543     WriteParam(aMsg, aParam.mReply.mString);
 544     WriteParam(aMsg, aParam.mReply.mRect);
 545     WriteParam(aMsg, aParam.mReply.mReversed);
 546     WriteParam(aMsg, aParam.mReply.mHasSelection);
 547     WriteParam(aMsg, aParam.mReply.mWidgetIsHit);
 548   }
 549
 550   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 551   {
 552     aResult->mWasAsync = true;
 553     return ReadParam(aMsg, aIter,
 554                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 555            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 556            ReadParam(aMsg, aIter, &aResult->mUseNativeLineBreak) &&
 557            ReadParam(aMsg, aIter, &aResult->mInput.mOffset) &&
 558            ReadParam(aMsg, aIter, &aResult->mInput.mLength) &&
 559            ReadParam(aMsg, aIter, &aResult->mReply.mOffset) &&
 560            ReadParam(aMsg, aIter, &aResult->mReply.mString) &&
 561            ReadParam(aMsg, aIter, &aResult->mReply.mRect) &&
 562            ReadParam(aMsg, aIter, &aResult->mReply.mReversed) &&
 563            ReadParam(aMsg, aIter, &aResult->mReply.mHasSelection) &&
 564            ReadParam(aMsg, aIter, &aResult->mReply.mWidgetIsHit);
 565   }
 566 };
 567
 568 template<>
 569 struct ParamTraits<mozilla::WidgetSelectionEvent>
 570 {
 571   typedef mozilla::WidgetSelectionEvent paramType;
 572
 573   static void Write(Message* aMsg, const paramType& aParam)
 574   {
 575     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 576     WriteParam(aMsg, aParam.mSeqno);
 577     WriteParam(aMsg, aParam.mOffset);
 578     WriteParam(aMsg, aParam.mLength);
 579     WriteParam(aMsg, aParam.mReversed);
 580     WriteParam(aMsg, aParam.mExpandToClusterBoundary);
 581     WriteParam(aMsg, aParam.mSucceeded);
 582     WriteParam(aMsg, aParam.mUseNativeLineBreak);
 583   }
 584
 585   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 586   {
 587     return ReadParam(aMsg, aIter,
 588                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 589            ReadParam(aMsg, aIter, &aResult->mSeqno) &&
 590            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 591            ReadParam(aMsg, aIter, &aResult->mLength) &&
 592            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 593            ReadParam(aMsg, aIter, &aResult->mExpandToClusterBoundary) &&
 594            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 595            ReadParam(aMsg, aIter, &aResult->mUseNativeLineBreak);
 596   }
 597 };
 598
 599 template<>
 600 struct ParamTraits<nsIMEUpdatePreference>
 601 {
 602   typedef nsIMEUpdatePreference paramType;
 603
 604   static void Write(Message* aMsg, const paramType& aParam)
 605   {
 606     WriteParam(aMsg, aParam.mWantUpdates);
 607   }
 608
 609   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 610   {
 611     return ReadParam(aMsg, aIter, &aResult->mWantUpdates);
 612   }
 613 };
 614
 615 template<>
 616 struct ParamTraits<mozilla::widget::IMENotification>
 617 {
 618   typedef mozilla::widget::IMENotification paramType;
 619
 620   static void Write(Message* aMsg, const paramType& aParam)
 621   {
 622     WriteParam(aMsg,
 623       static_cast<mozilla::widget::IMEMessageType>(aParam.mMessage));
 624     switch (aParam.mMessage) {
 625       case mozilla::widget::NOTIFY_IME_OF_SELECTION_CHANGE:
 626         WriteParam(aMsg, aParam.mSelectionChangeData.mCausedByComposition);
 627         return;
 628       case mozilla::widget::NOTIFY_IME_OF_TEXT_CHANGE:
 629         WriteParam(aMsg, aParam.mTextChangeData.mStartOffset);
 630         WriteParam(aMsg, aParam.mTextChangeData.mOldEndOffset);
 631         WriteParam(aMsg, aParam.mTextChangeData.mNewEndOffset);
 632         WriteParam(aMsg, aParam.mTextChangeData.mCausedByComposition);
 633         return;
 634       case mozilla::widget::NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
 635         WriteParam(aMsg, aParam.mMouseButtonEventData.mEventMessage);
 636         WriteParam(aMsg, aParam.mMouseButtonEventData.mOffset);
 637         WriteParam(aMsg, aParam.mMouseButtonEventData.mCursorPos.mX);
 638         WriteParam(aMsg, aParam.mMouseButtonEventData.mCursorPos.mY);
 639         WriteParam(aMsg, aParam.mMouseButtonEventData.mCharRect.mX);
 640         WriteParam(aMsg, aParam.mMouseButtonEventData.mCharRect.mY);
 641         WriteParam(aMsg, aParam.mMouseButtonEventData.mCharRect.mWidth);
 642         WriteParam(aMsg, aParam.mMouseButtonEventData.mCharRect.mHeight);
 643         WriteParam(aMsg, aParam.mMouseButtonEventData.mButton);
 644         WriteParam(aMsg, aParam.mMouseButtonEventData.mButtons);
 645         WriteParam(aMsg, aParam.mMouseButtonEventData.mModifiers);
 646         return;
 647       default:
 648         return;
 649     }
 650   }
 651
 652   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 653   {
 654     mozilla::widget::IMEMessageType IMEMessage = 0;
 655     if (!ReadParam(aMsg, aIter, &IMEMessage)) {
 656       return false;
 657     }
 658     aResult->mMessage = static_cast<mozilla::widget::IMEMessage>(IMEMessage);
 659     switch (aResult->mMessage) {
 660       case mozilla::widget::NOTIFY_IME_OF_SELECTION_CHANGE:
 661         return ReadParam(aMsg, aIter,
 662                          &aResult->mSelectionChangeData.mCausedByComposition);
 663       case mozilla::widget::NOTIFY_IME_OF_TEXT_CHANGE:
 664         return ReadParam(aMsg, aIter,
 665                          &aResult->mTextChangeData.mStartOffset) &&
 666                ReadParam(aMsg, aIter,
 667                          &aResult->mTextChangeData.mOldEndOffset) &&
 668                ReadParam(aMsg, aIter,
 669                          &aResult->mTextChangeData.mNewEndOffset) &&
 670                ReadParam(aMsg, aIter,
 671                          &aResult->mTextChangeData.mCausedByComposition);
 672       case mozilla::widget::NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
 673         return ReadParam(aMsg, aIter,
 674                          &aResult->mMouseButtonEventData.mEventMessage) &&
 675                ReadParam(aMsg, aIter,
 676                          &aResult->mMouseButtonEventData.mOffset) &&
 677                ReadParam(aMsg, aIter,
 678                          &aResult->mMouseButtonEventData.mCursorPos.mX) &&
 679                ReadParam(aMsg, aIter,
 680                          &aResult->mMouseButtonEventData.mCursorPos.mY) &&
 681                ReadParam(aMsg, aIter,
 682                          &aResult->mMouseButtonEventData.mCharRect.mX) &&
 683                ReadParam(aMsg, aIter,
 684                          &aResult->mMouseButtonEventData.mCharRect.mY) &&
 685                ReadParam(aMsg, aIter,
 686                          &aResult->mMouseButtonEventData.mCharRect.mWidth) &&
 687                ReadParam(aMsg, aIter,
 688                          &aResult->mMouseButtonEventData.mCharRect.mHeight) &&
 689                ReadParam(aMsg, aIter,
 690                          &aResult->mMouseButtonEventData.mButton) &&
 691                ReadParam(aMsg, aIter,
 692                          &aResult->mMouseButtonEventData.mButtons) &&
 693                ReadParam(aMsg, aIter,
 694                          &aResult->mMouseButtonEventData.mModifiers);
 695       default:
 696         return true;
 697     }
 698   }
 699 };
 700
 701 template<>
 702 struct ParamTraits<mozilla::WidgetPluginEvent>
 703 {
 704   typedef mozilla::WidgetPluginEvent paramType;
 705
 706   static void Write(Message* aMsg, const paramType& aParam)
 707   {
 708     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 709     WriteParam(aMsg, aParam.retargetToFocusedDocument);
 710   }
 711
 712   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 713   {
 714     return ReadParam(aMsg, aIter,
 715                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 716            ReadParam(aMsg, aIter, &aResult->retargetToFocusedDocument);
 717   }
 718 };
 719
 720 template<>
 721 struct ParamTraits<mozilla::WritingMode>
 722 {
 723   typedef mozilla::WritingMode paramType;
 724
 725   static void Write(Message* aMsg, const paramType& aParam)
 726   {
 727     WriteParam(aMsg, aParam.mWritingMode);
 728   }
 729
 730   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 731   {
 732     return ReadParam(aMsg, aIter, &aResult->mWritingMode);
 733   }
 734 };
 735
 736 } // namespace IPC
 737
 738 #endif // nsGUIEventIPC_h__
 739