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/. */
6 #ifndef nsGUIEventIPC_h__
7 #define nsGUIEventIPC_h__
9 #include "ipc/EnumSerializer.h"
10 #include "ipc/IPCMessageUtils.h"
11 #include "mozilla/ContentCache.h"
12 #include "mozilla/GfxMessageUtils.h"
13 #include "mozilla/dom/Touch.h"
14 #include "mozilla/layers/LayersMessageUtils.h"
15 #include "mozilla/MiscEvents.h"
16 #include "mozilla/MouseEvents.h"
17 #include "mozilla/TextEvents.h"
18 #include "mozilla/TouchEvents.h"
19 #include "mozilla/WheelHandlingHelper.h" // for WheelDeltaAdjustmentStrategy
20 #include "mozilla/dom/Selection.h"
21 #include "InputData.h"
26 struct ParamTraits
<mozilla::EventMessage
>
27 : public ContiguousEnumSerializer
<
28 mozilla::EventMessage
, mozilla::EventMessage(0),
29 mozilla::EventMessage::eEventMessage_MaxValue
> {};
32 struct ParamTraits
<mozilla::BaseEventFlags
> {
33 typedef mozilla::BaseEventFlags paramType
;
35 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
36 aWriter
->WriteBytes(&aParam
, sizeof(aParam
));
39 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
40 return aReader
->ReadBytesInto(aResult
, sizeof(*aResult
));
45 struct ParamTraits
<mozilla::WidgetEvent
> {
46 typedef mozilla::WidgetEvent paramType
;
48 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
49 // Mark the event as posted to another process.
50 const_cast<mozilla::WidgetEvent
&>(aParam
).MarkAsPostedToRemoteProcess();
52 WriteParam(aWriter
, static_cast<mozilla::EventClassIDType
>(aParam
.mClass
));
53 WriteParam(aWriter
, aParam
.mMessage
);
54 WriteParam(aWriter
, aParam
.mRefPoint
);
55 WriteParam(aWriter
, aParam
.mFocusSequenceNumber
);
56 WriteParam(aWriter
, aParam
.mTime
);
57 WriteParam(aWriter
, aParam
.mTimeStamp
);
58 WriteParam(aWriter
, aParam
.mFlags
);
59 WriteParam(aWriter
, aParam
.mLayersId
);
62 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
63 mozilla::EventClassIDType eventClassID
= 0;
64 bool ret
= ReadParam(aReader
, &eventClassID
) &&
65 ReadParam(aReader
, &aResult
->mMessage
) &&
66 ReadParam(aReader
, &aResult
->mRefPoint
) &&
67 ReadParam(aReader
, &aResult
->mFocusSequenceNumber
) &&
68 ReadParam(aReader
, &aResult
->mTime
) &&
69 ReadParam(aReader
, &aResult
->mTimeStamp
) &&
70 ReadParam(aReader
, &aResult
->mFlags
) &&
71 ReadParam(aReader
, &aResult
->mLayersId
);
72 aResult
->mClass
= static_cast<mozilla::EventClassID
>(eventClassID
);
74 // Reset cross process dispatching state here because the event has not
75 // been dispatched to different process from current process.
76 aResult
->ResetCrossProcessDispatchingState();
77 // Mark the event comes from another process.
78 aResult
->MarkAsComingFromAnotherProcess();
85 struct ParamTraits
<mozilla::WidgetGUIEvent
> {
86 typedef mozilla::WidgetGUIEvent paramType
;
88 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
89 WriteParam(aWriter
, static_cast<const mozilla::WidgetEvent
&>(aParam
));
92 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
93 return ReadParam(aReader
, static_cast<mozilla::WidgetEvent
*>(aResult
));
98 struct ParamTraits
<mozilla::WidgetInputEvent
> {
99 typedef mozilla::WidgetInputEvent paramType
;
101 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
102 WriteParam(aWriter
, static_cast<const mozilla::WidgetGUIEvent
&>(aParam
));
103 WriteParam(aWriter
, aParam
.mModifiers
);
106 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
107 return ReadParam(aReader
, static_cast<mozilla::WidgetGUIEvent
*>(aResult
)) &&
108 ReadParam(aReader
, &aResult
->mModifiers
);
113 struct ParamTraits
<mozilla::WidgetMouseEventBase
> {
114 typedef mozilla::WidgetMouseEventBase paramType
;
116 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
117 WriteParam(aWriter
, static_cast<const mozilla::WidgetInputEvent
&>(aParam
));
118 WriteParam(aWriter
, aParam
.mButton
);
119 WriteParam(aWriter
, aParam
.mButtons
);
120 WriteParam(aWriter
, aParam
.mPressure
);
121 WriteParam(aWriter
, aParam
.mInputSource
);
124 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
125 return ReadParam(aReader
,
126 static_cast<mozilla::WidgetInputEvent
*>(aResult
)) &&
127 ReadParam(aReader
, &aResult
->mButton
) &&
128 ReadParam(aReader
, &aResult
->mButtons
) &&
129 ReadParam(aReader
, &aResult
->mPressure
) &&
130 ReadParam(aReader
, &aResult
->mInputSource
);
135 struct ParamTraits
<mozilla::WidgetWheelEvent
> {
136 typedef mozilla::WidgetWheelEvent paramType
;
138 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
140 static_cast<const mozilla::WidgetMouseEventBase
&>(aParam
));
141 WriteParam(aWriter
, aParam
.mDeltaX
);
142 WriteParam(aWriter
, aParam
.mDeltaY
);
143 WriteParam(aWriter
, aParam
.mDeltaZ
);
144 WriteParam(aWriter
, aParam
.mDeltaMode
);
145 WriteParam(aWriter
, aParam
.mWheelTicksX
);
146 WriteParam(aWriter
, aParam
.mWheelTicksY
);
147 WriteParam(aWriter
, aParam
.mCustomizedByUserPrefs
);
148 WriteParam(aWriter
, aParam
.mMayHaveMomentum
);
149 WriteParam(aWriter
, aParam
.mIsMomentum
);
150 WriteParam(aWriter
, aParam
.mIsNoLineOrPageDelta
);
151 WriteParam(aWriter
, aParam
.mLineOrPageDeltaX
);
152 WriteParam(aWriter
, aParam
.mLineOrPageDeltaY
);
153 WriteParam(aWriter
, static_cast<uint8_t>(aParam
.mScrollType
));
154 WriteParam(aWriter
, aParam
.mOverflowDeltaX
);
155 WriteParam(aWriter
, aParam
.mOverflowDeltaY
);
156 WriteParam(aWriter
, aParam
.mViewPortIsOverscrolled
);
157 WriteParam(aWriter
, aParam
.mCanTriggerSwipe
);
158 WriteParam(aWriter
, aParam
.mAllowToOverrideSystemScrollSpeed
);
159 WriteParam(aWriter
, aParam
.mDeltaValuesHorizontalizedForDefaultHandler
);
162 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
163 uint8_t scrollType
= 0;
164 bool rv
= ReadParam(aReader
,
165 static_cast<mozilla::WidgetMouseEventBase
*>(aResult
)) &&
166 ReadParam(aReader
, &aResult
->mDeltaX
) &&
167 ReadParam(aReader
, &aResult
->mDeltaY
) &&
168 ReadParam(aReader
, &aResult
->mDeltaZ
) &&
169 ReadParam(aReader
, &aResult
->mDeltaMode
) &&
170 ReadParam(aReader
, &aResult
->mWheelTicksX
) &&
171 ReadParam(aReader
, &aResult
->mWheelTicksY
) &&
172 ReadParam(aReader
, &aResult
->mCustomizedByUserPrefs
) &&
173 ReadParam(aReader
, &aResult
->mMayHaveMomentum
) &&
174 ReadParam(aReader
, &aResult
->mIsMomentum
) &&
175 ReadParam(aReader
, &aResult
->mIsNoLineOrPageDelta
) &&
176 ReadParam(aReader
, &aResult
->mLineOrPageDeltaX
) &&
177 ReadParam(aReader
, &aResult
->mLineOrPageDeltaY
) &&
178 ReadParam(aReader
, &scrollType
) &&
179 ReadParam(aReader
, &aResult
->mOverflowDeltaX
) &&
180 ReadParam(aReader
, &aResult
->mOverflowDeltaY
) &&
181 ReadParam(aReader
, &aResult
->mViewPortIsOverscrolled
) &&
182 ReadParam(aReader
, &aResult
->mCanTriggerSwipe
) &&
183 ReadParam(aReader
, &aResult
->mAllowToOverrideSystemScrollSpeed
) &&
185 &aResult
->mDeltaValuesHorizontalizedForDefaultHandler
);
186 aResult
->mScrollType
=
187 static_cast<mozilla::WidgetWheelEvent::ScrollType
>(scrollType
);
193 struct ParamTraits
<mozilla::WidgetPointerHelper
> {
194 typedef mozilla::WidgetPointerHelper paramType
;
196 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
197 WriteParam(aWriter
, aParam
.pointerId
);
198 WriteParam(aWriter
, aParam
.tiltX
);
199 WriteParam(aWriter
, aParam
.tiltY
);
200 WriteParam(aWriter
, aParam
.twist
);
201 WriteParam(aWriter
, aParam
.tangentialPressure
);
202 // We don't serialize convertToPointer since it's temporarily variable and
203 // should be reset to default.
206 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
208 rv
= ReadParam(aReader
, &aResult
->pointerId
) &&
209 ReadParam(aReader
, &aResult
->tiltX
) &&
210 ReadParam(aReader
, &aResult
->tiltY
) &&
211 ReadParam(aReader
, &aResult
->twist
) &&
212 ReadParam(aReader
, &aResult
->tangentialPressure
);
218 struct ParamTraits
<mozilla::WidgetMouseEvent
> {
219 typedef mozilla::WidgetMouseEvent paramType
;
221 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
223 static_cast<const mozilla::WidgetMouseEventBase
&>(aParam
));
225 static_cast<const mozilla::WidgetPointerHelper
&>(aParam
));
226 WriteParam(aWriter
, aParam
.mIgnoreRootScrollFrame
);
227 WriteParam(aWriter
, aParam
.mClickEventPrevented
);
228 WriteParam(aWriter
, static_cast<paramType::ReasonType
>(aParam
.mReason
));
229 WriteParam(aWriter
, static_cast<paramType::ContextMenuTriggerType
>(
230 aParam
.mContextMenuTrigger
));
231 WriteParam(aWriter
, aParam
.mExitFrom
.isSome());
232 if (aParam
.mExitFrom
.isSome()) {
233 WriteParam(aWriter
, static_cast<paramType::ExitFromType
>(
234 aParam
.mExitFrom
.value()));
236 WriteParam(aWriter
, aParam
.mClickCount
);
239 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
241 paramType::ReasonType reason
= 0;
242 paramType::ContextMenuTriggerType contextMenuTrigger
= 0;
243 bool hasExitFrom
= false;
244 rv
= ReadParam(aReader
,
245 static_cast<mozilla::WidgetMouseEventBase
*>(aResult
)) &&
247 static_cast<mozilla::WidgetPointerHelper
*>(aResult
)) &&
248 ReadParam(aReader
, &aResult
->mIgnoreRootScrollFrame
) &&
249 ReadParam(aReader
, &aResult
->mClickEventPrevented
) &&
250 ReadParam(aReader
, &reason
) && ReadParam(aReader
, &contextMenuTrigger
);
251 aResult
->mReason
= static_cast<paramType::Reason
>(reason
);
252 aResult
->mContextMenuTrigger
=
253 static_cast<paramType::ContextMenuTrigger
>(contextMenuTrigger
);
254 rv
= rv
&& ReadParam(aReader
, &hasExitFrom
);
256 paramType::ExitFromType exitFrom
= 0;
257 rv
= rv
&& ReadParam(aReader
, &exitFrom
);
258 aResult
->mExitFrom
= Some(static_cast<paramType::ExitFrom
>(exitFrom
));
260 rv
= rv
&& ReadParam(aReader
, &aResult
->mClickCount
);
266 struct ParamTraits
<mozilla::WidgetDragEvent
> {
267 typedef mozilla::WidgetDragEvent paramType
;
269 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
270 WriteParam(aWriter
, static_cast<const mozilla::WidgetMouseEvent
&>(aParam
));
271 WriteParam(aWriter
, aParam
.mUserCancelled
);
272 WriteParam(aWriter
, aParam
.mDefaultPreventedOnContent
);
275 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
277 ReadParam(aReader
, static_cast<mozilla::WidgetMouseEvent
*>(aResult
)) &&
278 ReadParam(aReader
, &aResult
->mUserCancelled
) &&
279 ReadParam(aReader
, &aResult
->mDefaultPreventedOnContent
);
285 struct ParamTraits
<mozilla::WidgetPointerEvent
> {
286 typedef mozilla::WidgetPointerEvent paramType
;
288 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
289 WriteParam(aWriter
, static_cast<const mozilla::WidgetMouseEvent
&>(aParam
));
290 WriteParam(aWriter
, aParam
.mWidth
);
291 WriteParam(aWriter
, aParam
.mHeight
);
292 WriteParam(aWriter
, aParam
.mIsPrimary
);
295 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
297 ReadParam(aReader
, static_cast<mozilla::WidgetMouseEvent
*>(aResult
)) &&
298 ReadParam(aReader
, &aResult
->mWidth
) &&
299 ReadParam(aReader
, &aResult
->mHeight
) &&
300 ReadParam(aReader
, &aResult
->mIsPrimary
);
306 struct ParamTraits
<mozilla::WidgetTouchEvent
> {
307 using paramType
= mozilla::WidgetTouchEvent
;
309 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
310 WriteParam(aWriter
, static_cast<const mozilla::WidgetInputEvent
&>(aParam
));
311 WriteParam(aWriter
, aParam
.mInputSource
);
312 WriteParam(aWriter
, aParam
.mButton
);
313 WriteParam(aWriter
, aParam
.mButtons
);
314 // Sigh, Touch bites us again! We want to be able to do
315 // WriteParam(aWriter, aParam.mTouches);
316 const paramType::TouchArray
& touches
= aParam
.mTouches
;
317 WriteParam(aWriter
, touches
.Length());
318 for (uint32_t i
= 0; i
< touches
.Length(); ++i
) {
319 mozilla::dom::Touch
* touch
= touches
[i
];
320 WriteParam(aWriter
, touch
->mIdentifier
);
321 WriteParam(aWriter
, touch
->mRefPoint
);
322 WriteParam(aWriter
, touch
->mRadius
);
323 WriteParam(aWriter
, touch
->mRotationAngle
);
324 WriteParam(aWriter
, touch
->mForce
);
325 WriteParam(aWriter
, touch
->tiltX
);
326 WriteParam(aWriter
, touch
->tiltY
);
327 WriteParam(aWriter
, touch
->twist
);
331 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
332 paramType::TouchArray::size_type numTouches
;
333 if (!ReadParam(aReader
, static_cast<mozilla::WidgetInputEvent
*>(aResult
)) ||
334 !ReadParam(aReader
, &aResult
->mInputSource
) ||
335 !ReadParam(aReader
, &aResult
->mButton
) ||
336 !ReadParam(aReader
, &aResult
->mButtons
) ||
337 !ReadParam(aReader
, &numTouches
)) {
340 for (uint32_t i
= 0; i
< numTouches
; ++i
) {
342 mozilla::LayoutDeviceIntPoint refPoint
;
343 mozilla::LayoutDeviceIntPoint radius
;
349 if (!ReadParam(aReader
, &identifier
) || !ReadParam(aReader
, &refPoint
) ||
350 !ReadParam(aReader
, &radius
) || !ReadParam(aReader
, &rotationAngle
) ||
351 !ReadParam(aReader
, &force
) || !ReadParam(aReader
, &tiltX
) ||
352 !ReadParam(aReader
, &tiltY
) || !ReadParam(aReader
, &twist
)) {
355 auto* touch
= new mozilla::dom::Touch(identifier
, refPoint
, radius
,
356 rotationAngle
, force
);
357 touch
->tiltX
= tiltX
;
358 touch
->tiltY
= tiltY
;
359 touch
->twist
= twist
;
360 aResult
->mTouches
.AppendElement(touch
);
367 struct ParamTraits
<mozilla::AlternativeCharCode
> {
368 typedef mozilla::AlternativeCharCode paramType
;
370 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
371 WriteParam(aWriter
, aParam
.mUnshiftedCharCode
);
372 WriteParam(aWriter
, aParam
.mShiftedCharCode
);
375 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
376 return ReadParam(aReader
, &aResult
->mUnshiftedCharCode
) &&
377 ReadParam(aReader
, &aResult
->mShiftedCharCode
);
382 struct ParamTraits
<mozilla::ShortcutKeyCandidate
> {
383 typedef mozilla::ShortcutKeyCandidate paramType
;
385 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
386 WriteParam(aWriter
, aParam
.mCharCode
);
387 WriteParam(aWriter
, aParam
.mIgnoreShift
);
390 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
391 return ReadParam(aReader
, &aResult
->mCharCode
) &&
392 ReadParam(aReader
, &aResult
->mIgnoreShift
);
397 struct ParamTraits
<mozilla::WidgetKeyboardEvent
> {
398 typedef mozilla::WidgetKeyboardEvent paramType
;
400 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
401 WriteParam(aWriter
, static_cast<const mozilla::WidgetInputEvent
&>(aParam
));
403 static_cast<mozilla::KeyNameIndexType
>(aParam
.mKeyNameIndex
));
405 static_cast<mozilla::CodeNameIndexType
>(aParam
.mCodeNameIndex
));
406 WriteParam(aWriter
, aParam
.mKeyValue
);
407 WriteParam(aWriter
, aParam
.mCodeValue
);
408 WriteParam(aWriter
, aParam
.mKeyCode
);
409 WriteParam(aWriter
, aParam
.mCharCode
);
410 WriteParam(aWriter
, aParam
.mPseudoCharCode
);
411 WriteParam(aWriter
, aParam
.mAlternativeCharCodes
);
412 WriteParam(aWriter
, aParam
.mIsRepeat
);
413 WriteParam(aWriter
, aParam
.mLocation
);
414 WriteParam(aWriter
, aParam
.mUniqueId
);
415 WriteParam(aWriter
, aParam
.mIsSynthesizedByTIP
);
416 WriteParam(aWriter
, aParam
.mMaybeSkippableInRemoteProcess
);
418 // An OS-specific native event might be attached in |mNativeKeyEvent|, but
419 // that cannot be copied across process boundaries.
421 WriteParam(aWriter
, aParam
.mEditCommandsForSingleLineEditor
);
422 WriteParam(aWriter
, aParam
.mEditCommandsForMultiLineEditor
);
423 WriteParam(aWriter
, aParam
.mEditCommandsForRichTextEditor
);
424 WriteParam(aWriter
, aParam
.mEditCommandsForSingleLineEditorInitialized
);
425 WriteParam(aWriter
, aParam
.mEditCommandsForMultiLineEditorInitialized
);
426 WriteParam(aWriter
, aParam
.mEditCommandsForRichTextEditorInitialized
);
429 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
430 mozilla::KeyNameIndexType keyNameIndex
= 0;
431 mozilla::CodeNameIndexType codeNameIndex
= 0;
432 if (ReadParam(aReader
, static_cast<mozilla::WidgetInputEvent
*>(aResult
)) &&
433 ReadParam(aReader
, &keyNameIndex
) &&
434 ReadParam(aReader
, &codeNameIndex
) &&
435 ReadParam(aReader
, &aResult
->mKeyValue
) &&
436 ReadParam(aReader
, &aResult
->mCodeValue
) &&
437 ReadParam(aReader
, &aResult
->mKeyCode
) &&
438 ReadParam(aReader
, &aResult
->mCharCode
) &&
439 ReadParam(aReader
, &aResult
->mPseudoCharCode
) &&
440 ReadParam(aReader
, &aResult
->mAlternativeCharCodes
) &&
441 ReadParam(aReader
, &aResult
->mIsRepeat
) &&
442 ReadParam(aReader
, &aResult
->mLocation
) &&
443 ReadParam(aReader
, &aResult
->mUniqueId
) &&
444 ReadParam(aReader
, &aResult
->mIsSynthesizedByTIP
) &&
445 ReadParam(aReader
, &aResult
->mMaybeSkippableInRemoteProcess
) &&
446 ReadParam(aReader
, &aResult
->mEditCommandsForSingleLineEditor
) &&
447 ReadParam(aReader
, &aResult
->mEditCommandsForMultiLineEditor
) &&
448 ReadParam(aReader
, &aResult
->mEditCommandsForRichTextEditor
) &&
450 &aResult
->mEditCommandsForSingleLineEditorInitialized
) &&
452 &aResult
->mEditCommandsForMultiLineEditorInitialized
) &&
454 &aResult
->mEditCommandsForRichTextEditorInitialized
)) {
455 aResult
->mKeyNameIndex
= static_cast<mozilla::KeyNameIndex
>(keyNameIndex
);
456 aResult
->mCodeNameIndex
=
457 static_cast<mozilla::CodeNameIndex
>(codeNameIndex
);
458 aResult
->mNativeKeyEvent
= nullptr;
466 struct ParamTraits
<mozilla::TextRangeStyle
> {
467 typedef mozilla::TextRangeStyle paramType
;
469 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
470 WriteParam(aWriter
, aParam
.mDefinedStyles
);
471 WriteParam(aWriter
, static_cast<mozilla::TextRangeStyle::LineStyleType
>(
473 WriteParam(aWriter
, aParam
.mIsBoldLine
);
474 WriteParam(aWriter
, aParam
.mForegroundColor
);
475 WriteParam(aWriter
, aParam
.mBackgroundColor
);
476 WriteParam(aWriter
, aParam
.mUnderlineColor
);
479 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
480 mozilla::TextRangeStyle::LineStyleType lineStyle
;
481 if (!ReadParam(aReader
, &aResult
->mDefinedStyles
) ||
482 !ReadParam(aReader
, &lineStyle
) ||
483 !ReadParam(aReader
, &aResult
->mIsBoldLine
) ||
484 !ReadParam(aReader
, &aResult
->mForegroundColor
) ||
485 !ReadParam(aReader
, &aResult
->mBackgroundColor
) ||
486 !ReadParam(aReader
, &aResult
->mUnderlineColor
)) {
489 aResult
->mLineStyle
= mozilla::TextRangeStyle::ToLineStyle(lineStyle
);
495 struct ParamTraits
<mozilla::TextRange
> {
496 typedef mozilla::TextRange paramType
;
498 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
499 WriteParam(aWriter
, aParam
.mStartOffset
);
500 WriteParam(aWriter
, aParam
.mEndOffset
);
501 WriteParam(aWriter
, mozilla::ToRawTextRangeType(aParam
.mRangeType
));
502 WriteParam(aWriter
, aParam
.mRangeStyle
);
505 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
506 mozilla::RawTextRangeType rawTextRangeType
;
507 if (ReadParam(aReader
, &aResult
->mStartOffset
) &&
508 ReadParam(aReader
, &aResult
->mEndOffset
) &&
509 ReadParam(aReader
, &rawTextRangeType
) &&
510 ReadParam(aReader
, &aResult
->mRangeStyle
)) {
511 aResult
->mRangeType
= mozilla::ToTextRangeType(rawTextRangeType
);
519 struct ParamTraits
<mozilla::TextRangeArray
> {
520 typedef mozilla::TextRangeArray paramType
;
522 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
523 WriteParam(aWriter
, aParam
.Length());
524 for (uint32_t index
= 0; index
< aParam
.Length(); index
++) {
525 WriteParam(aWriter
, aParam
[index
]);
529 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
530 paramType::size_type length
;
531 if (!ReadParam(aReader
, &length
)) {
534 for (uint32_t index
= 0; index
< length
; index
++) {
535 mozilla::TextRange textRange
;
536 if (!ReadParam(aReader
, &textRange
)) {
540 aResult
->AppendElement(textRange
);
547 struct ParamTraits
<mozilla::WidgetCompositionEvent
> {
548 typedef mozilla::WidgetCompositionEvent paramType
;
550 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
551 WriteParam(aWriter
, static_cast<const mozilla::WidgetGUIEvent
&>(aParam
));
552 WriteParam(aWriter
, aParam
.mData
);
553 WriteParam(aWriter
, aParam
.mNativeIMEContext
);
554 bool hasRanges
= !!aParam
.mRanges
;
555 WriteParam(aWriter
, hasRanges
);
557 WriteParam(aWriter
, *aParam
.mRanges
.get());
561 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
563 if (!ReadParam(aReader
, static_cast<mozilla::WidgetGUIEvent
*>(aResult
)) ||
564 !ReadParam(aReader
, &aResult
->mData
) ||
565 !ReadParam(aReader
, &aResult
->mNativeIMEContext
) ||
566 !ReadParam(aReader
, &hasRanges
)) {
571 aResult
->mRanges
= nullptr;
573 aResult
->mRanges
= new mozilla::TextRangeArray();
574 if (!ReadParam(aReader
, aResult
->mRanges
.get())) {
583 struct ParamTraits
<mozilla::FontRange
> {
584 typedef mozilla::FontRange paramType
;
586 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
587 WriteParam(aWriter
, aParam
.mStartOffset
);
588 WriteParam(aWriter
, aParam
.mFontName
);
589 WriteParam(aWriter
, aParam
.mFontSize
);
592 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
593 return ReadParam(aReader
, &aResult
->mStartOffset
) &&
594 ReadParam(aReader
, &aResult
->mFontName
) &&
595 ReadParam(aReader
, &aResult
->mFontSize
);
600 struct ParamTraits
<mozilla::WidgetSelectionEvent
> {
601 typedef mozilla::WidgetSelectionEvent paramType
;
603 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
604 WriteParam(aWriter
, static_cast<const mozilla::WidgetGUIEvent
&>(aParam
));
605 WriteParam(aWriter
, aParam
.mOffset
);
606 WriteParam(aWriter
, aParam
.mLength
);
607 WriteParam(aWriter
, aParam
.mReversed
);
608 WriteParam(aWriter
, aParam
.mExpandToClusterBoundary
);
609 WriteParam(aWriter
, aParam
.mSucceeded
);
610 WriteParam(aWriter
, aParam
.mUseNativeLineBreak
);
613 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
614 return ReadParam(aReader
, static_cast<mozilla::WidgetGUIEvent
*>(aResult
)) &&
615 ReadParam(aReader
, &aResult
->mOffset
) &&
616 ReadParam(aReader
, &aResult
->mLength
) &&
617 ReadParam(aReader
, &aResult
->mReversed
) &&
618 ReadParam(aReader
, &aResult
->mExpandToClusterBoundary
) &&
619 ReadParam(aReader
, &aResult
->mSucceeded
) &&
620 ReadParam(aReader
, &aResult
->mUseNativeLineBreak
);
625 struct ParamTraits
<mozilla::widget::IMENotificationRequests
> {
626 typedef mozilla::widget::IMENotificationRequests paramType
;
628 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
629 WriteParam(aWriter
, aParam
.mWantUpdates
);
632 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
633 return ReadParam(aReader
, &aResult
->mWantUpdates
);
638 struct ParamTraits
<mozilla::widget::NativeIMEContext
> {
639 typedef mozilla::widget::NativeIMEContext paramType
;
641 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
642 WriteParam(aWriter
, aParam
.mRawNativeIMEContext
);
643 WriteParam(aWriter
, aParam
.mOriginProcessID
);
646 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
647 return ReadParam(aReader
, &aResult
->mRawNativeIMEContext
) &&
648 ReadParam(aReader
, &aResult
->mOriginProcessID
);
653 struct ParamTraits
<mozilla::widget::IMENotification::SelectionChangeDataBase
> {
654 typedef mozilla::widget::IMENotification::SelectionChangeDataBase paramType
;
656 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
657 MOZ_RELEASE_ASSERT(aParam
.mString
);
658 WriteParam(aWriter
, aParam
.mOffset
);
659 WriteParam(aWriter
, *aParam
.mString
);
660 WriteParam(aWriter
, aParam
.mWritingModeBits
);
661 WriteParam(aWriter
, aParam
.mIsInitialized
);
662 WriteParam(aWriter
, aParam
.mHasRange
);
663 WriteParam(aWriter
, aParam
.mReversed
);
664 WriteParam(aWriter
, aParam
.mCausedByComposition
);
665 WriteParam(aWriter
, aParam
.mCausedBySelectionEvent
);
666 WriteParam(aWriter
, aParam
.mOccurredDuringComposition
);
669 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
670 aResult
->mString
= new nsString();
671 return ReadParam(aReader
, &aResult
->mOffset
) &&
672 ReadParam(aReader
, aResult
->mString
) &&
673 ReadParam(aReader
, &aResult
->mWritingModeBits
) &&
674 ReadParam(aReader
, &aResult
->mIsInitialized
) &&
675 ReadParam(aReader
, &aResult
->mHasRange
) &&
676 ReadParam(aReader
, &aResult
->mReversed
) &&
677 ReadParam(aReader
, &aResult
->mCausedByComposition
) &&
678 ReadParam(aReader
, &aResult
->mCausedBySelectionEvent
) &&
679 ReadParam(aReader
, &aResult
->mOccurredDuringComposition
);
684 struct ParamTraits
<mozilla::widget::IMENotification::TextChangeDataBase
> {
685 typedef mozilla::widget::IMENotification::TextChangeDataBase paramType
;
687 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
688 WriteParam(aWriter
, aParam
.mStartOffset
);
689 WriteParam(aWriter
, aParam
.mRemovedEndOffset
);
690 WriteParam(aWriter
, aParam
.mAddedEndOffset
);
691 WriteParam(aWriter
, aParam
.mCausedOnlyByComposition
);
692 WriteParam(aWriter
, aParam
.mIncludingChangesDuringComposition
);
693 WriteParam(aWriter
, aParam
.mIncludingChangesWithoutComposition
);
696 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
697 return ReadParam(aReader
, &aResult
->mStartOffset
) &&
698 ReadParam(aReader
, &aResult
->mRemovedEndOffset
) &&
699 ReadParam(aReader
, &aResult
->mAddedEndOffset
) &&
700 ReadParam(aReader
, &aResult
->mCausedOnlyByComposition
) &&
701 ReadParam(aReader
, &aResult
->mIncludingChangesDuringComposition
) &&
702 ReadParam(aReader
, &aResult
->mIncludingChangesWithoutComposition
);
707 struct ParamTraits
<mozilla::widget::IMENotification::MouseButtonEventData
> {
708 typedef mozilla::widget::IMENotification::MouseButtonEventData paramType
;
710 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
711 WriteParam(aWriter
, aParam
.mEventMessage
);
712 WriteParam(aWriter
, aParam
.mOffset
);
713 WriteParam(aWriter
, aParam
.mCursorPos
);
714 WriteParam(aWriter
, aParam
.mCharRect
);
715 WriteParam(aWriter
, aParam
.mButton
);
716 WriteParam(aWriter
, aParam
.mButtons
);
717 WriteParam(aWriter
, aParam
.mModifiers
);
720 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
721 return ReadParam(aReader
, &aResult
->mEventMessage
) &&
722 ReadParam(aReader
, &aResult
->mOffset
) &&
723 ReadParam(aReader
, &aResult
->mCursorPos
) &&
724 ReadParam(aReader
, &aResult
->mCharRect
) &&
725 ReadParam(aReader
, &aResult
->mButton
) &&
726 ReadParam(aReader
, &aResult
->mButtons
) &&
727 ReadParam(aReader
, &aResult
->mModifiers
);
732 struct ParamTraits
<mozilla::widget::IMENotification
> {
733 typedef mozilla::widget::IMENotification paramType
;
735 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
737 static_cast<mozilla::widget::IMEMessageType
>(aParam
.mMessage
));
738 switch (aParam
.mMessage
) {
739 case mozilla::widget::NOTIFY_IME_OF_SELECTION_CHANGE
:
740 WriteParam(aWriter
, aParam
.mSelectionChangeData
);
742 case mozilla::widget::NOTIFY_IME_OF_TEXT_CHANGE
:
743 WriteParam(aWriter
, aParam
.mTextChangeData
);
745 case mozilla::widget::NOTIFY_IME_OF_MOUSE_BUTTON_EVENT
:
746 WriteParam(aWriter
, aParam
.mMouseButtonEventData
);
753 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
754 mozilla::widget::IMEMessageType IMEMessage
= 0;
755 if (!ReadParam(aReader
, &IMEMessage
)) {
758 aResult
->mMessage
= static_cast<mozilla::widget::IMEMessage
>(IMEMessage
);
759 switch (aResult
->mMessage
) {
760 case mozilla::widget::NOTIFY_IME_OF_SELECTION_CHANGE
:
761 return ReadParam(aReader
, &aResult
->mSelectionChangeData
);
762 case mozilla::widget::NOTIFY_IME_OF_TEXT_CHANGE
:
763 return ReadParam(aReader
, &aResult
->mTextChangeData
);
764 case mozilla::widget::NOTIFY_IME_OF_MOUSE_BUTTON_EVENT
:
765 return ReadParam(aReader
, &aResult
->mMouseButtonEventData
);
773 struct ParamTraits
<mozilla::widget::IMEEnabled
>
774 : ContiguousEnumSerializer
<mozilla::widget::IMEEnabled
,
775 mozilla::widget::IMEEnabled::Disabled
,
776 mozilla::widget::IMEEnabled::Unknown
> {};
779 struct ParamTraits
<mozilla::widget::IMEState::Open
>
780 : ContiguousEnumSerializerInclusive
<
781 mozilla::widget::IMEState::Open
,
782 mozilla::widget::IMEState::Open::OPEN_STATE_NOT_SUPPORTED
,
783 mozilla::widget::IMEState::Open::CLOSED
> {};
786 struct ParamTraits
<mozilla::widget::IMEState
> {
787 typedef mozilla::widget::IMEState paramType
;
789 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
790 WriteParam(aWriter
, aParam
.mEnabled
);
791 WriteParam(aWriter
, aParam
.mOpen
);
794 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
795 return ReadParam(aReader
, &aResult
->mEnabled
) &&
796 ReadParam(aReader
, &aResult
->mOpen
);
801 struct ParamTraits
<mozilla::widget::InputContext::Origin
>
802 : ContiguousEnumSerializerInclusive
<
803 mozilla::widget::InputContext::Origin
,
804 mozilla::widget::InputContext::Origin::ORIGIN_MAIN
,
805 mozilla::widget::InputContext::Origin::ORIGIN_CONTENT
> {};
808 struct ParamTraits
<mozilla::widget::InputContext
> {
809 typedef mozilla::widget::InputContext paramType
;
811 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
812 WriteParam(aWriter
, aParam
.mIMEState
);
813 WriteParam(aWriter
, aParam
.mHTMLInputType
);
814 WriteParam(aWriter
, aParam
.mHTMLInputInputmode
);
815 WriteParam(aWriter
, aParam
.mActionHint
);
816 WriteParam(aWriter
, aParam
.mAutocapitalize
);
817 WriteParam(aWriter
, aParam
.mOrigin
);
818 WriteParam(aWriter
, aParam
.mMayBeIMEUnaware
);
819 WriteParam(aWriter
, aParam
.mHasHandledUserInput
);
820 WriteParam(aWriter
, aParam
.mInPrivateBrowsing
);
823 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
824 return ReadParam(aReader
, &aResult
->mIMEState
) &&
825 ReadParam(aReader
, &aResult
->mHTMLInputType
) &&
826 ReadParam(aReader
, &aResult
->mHTMLInputInputmode
) &&
827 ReadParam(aReader
, &aResult
->mActionHint
) &&
828 ReadParam(aReader
, &aResult
->mAutocapitalize
) &&
829 ReadParam(aReader
, &aResult
->mOrigin
) &&
830 ReadParam(aReader
, &aResult
->mMayBeIMEUnaware
) &&
831 ReadParam(aReader
, &aResult
->mHasHandledUserInput
) &&
832 ReadParam(aReader
, &aResult
->mInPrivateBrowsing
);
837 struct ParamTraits
<mozilla::widget::InputContextAction::Cause
>
838 : ContiguousEnumSerializerInclusive
<
839 mozilla::widget::InputContextAction::Cause
,
840 mozilla::widget::InputContextAction::Cause::CAUSE_UNKNOWN
,
841 mozilla::widget::InputContextAction::Cause::
842 CAUSE_UNKNOWN_DURING_KEYBOARD_INPUT
> {};
845 struct ParamTraits
<mozilla::widget::InputContextAction::FocusChange
>
846 : ContiguousEnumSerializerInclusive
<
847 mozilla::widget::InputContextAction::FocusChange
,
848 mozilla::widget::InputContextAction::FocusChange::FOCUS_NOT_CHANGED
,
849 mozilla::widget::InputContextAction::FocusChange::WIDGET_CREATED
> {};
852 struct ParamTraits
<mozilla::widget::InputContextAction
> {
853 typedef mozilla::widget::InputContextAction paramType
;
855 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
856 WriteParam(aWriter
, aParam
.mCause
);
857 WriteParam(aWriter
, aParam
.mFocusChange
);
860 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
861 return ReadParam(aReader
, &aResult
->mCause
) &&
862 ReadParam(aReader
, &aResult
->mFocusChange
);
867 struct ParamTraits
<mozilla::WritingMode
> {
868 typedef mozilla::WritingMode paramType
;
870 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
871 WriteParam(aWriter
, aParam
.mWritingMode
.bits
);
874 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
875 return ReadParam(aReader
, &aResult
->mWritingMode
.bits
);
880 struct ParamTraits
<mozilla::ContentCache::Selection
> {
881 typedef mozilla::ContentCache::Selection paramType
;
883 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
884 WriteParam(aWriter
, aParam
.mAnchor
);
885 WriteParam(aWriter
, aParam
.mFocus
);
886 WriteParam(aWriter
, aParam
.mWritingMode
);
887 WriteParam(aWriter
, aParam
.mHasRange
);
888 WriteParam(aWriter
, aParam
.mAnchorCharRects
[0]);
889 WriteParam(aWriter
, aParam
.mAnchorCharRects
[1]);
890 WriteParam(aWriter
, aParam
.mFocusCharRects
[0]);
891 WriteParam(aWriter
, aParam
.mFocusCharRects
[1]);
892 WriteParam(aWriter
, aParam
.mRect
);
895 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
896 return ReadParam(aReader
, &aResult
->mAnchor
) &&
897 ReadParam(aReader
, &aResult
->mFocus
) &&
898 ReadParam(aReader
, &aResult
->mWritingMode
) &&
899 ReadParam(aReader
, &aResult
->mHasRange
) &&
900 ReadParam(aReader
, &aResult
->mAnchorCharRects
[0]) &&
901 ReadParam(aReader
, &aResult
->mAnchorCharRects
[1]) &&
902 ReadParam(aReader
, &aResult
->mFocusCharRects
[0]) &&
903 ReadParam(aReader
, &aResult
->mFocusCharRects
[1]) &&
904 ReadParam(aReader
, &aResult
->mRect
);
909 struct ParamTraits
<mozilla::ContentCache::Caret
> {
910 typedef mozilla::ContentCache::Caret paramType
;
912 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
913 WriteParam(aWriter
, aParam
.mOffset
);
914 WriteParam(aWriter
, aParam
.mRect
);
917 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
918 return ReadParam(aReader
, &aResult
->mOffset
) &&
919 ReadParam(aReader
, &aResult
->mRect
);
924 struct ParamTraits
<mozilla::ContentCache::TextRectArray
> {
925 typedef mozilla::ContentCache::TextRectArray paramType
;
927 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
928 WriteParam(aWriter
, aParam
.mStart
);
929 WriteParam(aWriter
, aParam
.mRects
);
932 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
933 return ReadParam(aReader
, &aResult
->mStart
) &&
934 ReadParam(aReader
, &aResult
->mRects
);
939 struct ParamTraits
<mozilla::ContentCache
> {
940 typedef mozilla::ContentCache paramType
;
942 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
943 WriteParam(aWriter
, aParam
.mCompositionStart
);
944 WriteParam(aWriter
, aParam
.mText
);
945 WriteParam(aWriter
, aParam
.mSelection
);
946 WriteParam(aWriter
, aParam
.mFirstCharRect
);
947 WriteParam(aWriter
, aParam
.mCaret
);
948 WriteParam(aWriter
, aParam
.mTextRectArray
);
949 WriteParam(aWriter
, aParam
.mLastCommitStringTextRectArray
);
950 WriteParam(aWriter
, aParam
.mEditorRect
);
953 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
954 return ReadParam(aReader
, &aResult
->mCompositionStart
) &&
955 ReadParam(aReader
, &aResult
->mText
) &&
956 ReadParam(aReader
, &aResult
->mSelection
) &&
957 ReadParam(aReader
, &aResult
->mFirstCharRect
) &&
958 ReadParam(aReader
, &aResult
->mCaret
) &&
959 ReadParam(aReader
, &aResult
->mTextRectArray
) &&
960 ReadParam(aReader
, &aResult
->mLastCommitStringTextRectArray
) &&
961 ReadParam(aReader
, &aResult
->mEditorRect
);
966 struct ParamTraits
<mozilla::widget::CandidateWindowPosition
> {
967 typedef mozilla::widget::CandidateWindowPosition paramType
;
969 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
970 WriteParam(aWriter
, aParam
.mPoint
);
971 WriteParam(aWriter
, aParam
.mRect
);
972 WriteParam(aWriter
, aParam
.mExcludeRect
);
975 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
976 return ReadParam(aReader
, &aResult
->mPoint
) &&
977 ReadParam(aReader
, &aResult
->mRect
) &&
978 ReadParam(aReader
, &aResult
->mExcludeRect
);
985 struct ParamTraits
<mozilla::InputType
>
986 : public ContiguousEnumSerializerInclusive
<
987 mozilla::InputType
, mozilla::InputType::MULTITOUCH_INPUT
,
988 mozilla::kHighestInputType
> {};
991 struct ParamTraits
<mozilla::InputData
> {
992 typedef mozilla::InputData paramType
;
994 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
995 WriteParam(aWriter
, aParam
.mInputType
);
996 WriteParam(aWriter
, aParam
.mTime
);
997 WriteParam(aWriter
, aParam
.mTimeStamp
);
998 WriteParam(aWriter
, aParam
.modifiers
);
999 WriteParam(aWriter
, aParam
.mFocusSequenceNumber
);
1000 WriteParam(aWriter
, aParam
.mLayersId
);
1003 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1004 return ReadParam(aReader
, &aResult
->mInputType
) &&
1005 ReadParam(aReader
, &aResult
->mTime
) &&
1006 ReadParam(aReader
, &aResult
->mTimeStamp
) &&
1007 ReadParam(aReader
, &aResult
->modifiers
) &&
1008 ReadParam(aReader
, &aResult
->mFocusSequenceNumber
) &&
1009 ReadParam(aReader
, &aResult
->mLayersId
);
1014 struct ParamTraits
<mozilla::SingleTouchData::HistoricalTouchData
> {
1015 typedef mozilla::SingleTouchData::HistoricalTouchData paramType
;
1017 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1018 WriteParam(aWriter
, aParam
.mTimeStamp
);
1019 WriteParam(aWriter
, aParam
.mScreenPoint
);
1020 WriteParam(aWriter
, aParam
.mLocalScreenPoint
);
1021 WriteParam(aWriter
, aParam
.mRadius
);
1022 WriteParam(aWriter
, aParam
.mRotationAngle
);
1023 WriteParam(aWriter
, aParam
.mForce
);
1026 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1027 return (ReadParam(aReader
, &aResult
->mTimeStamp
) &&
1028 ReadParam(aReader
, &aResult
->mScreenPoint
) &&
1029 ReadParam(aReader
, &aResult
->mLocalScreenPoint
) &&
1030 ReadParam(aReader
, &aResult
->mRadius
) &&
1031 ReadParam(aReader
, &aResult
->mRotationAngle
) &&
1032 ReadParam(aReader
, &aResult
->mForce
));
1037 struct ParamTraits
<mozilla::SingleTouchData
> {
1038 using paramType
= mozilla::SingleTouchData
;
1040 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1041 WriteParam(aWriter
, aParam
.mHistoricalData
);
1042 WriteParam(aWriter
, aParam
.mIdentifier
);
1043 WriteParam(aWriter
, aParam
.mScreenPoint
);
1044 WriteParam(aWriter
, aParam
.mLocalScreenPoint
);
1045 WriteParam(aWriter
, aParam
.mRadius
);
1046 WriteParam(aWriter
, aParam
.mRotationAngle
);
1047 WriteParam(aWriter
, aParam
.mForce
);
1048 WriteParam(aWriter
, aParam
.mTiltX
);
1049 WriteParam(aWriter
, aParam
.mTiltY
);
1050 WriteParam(aWriter
, aParam
.mTwist
);
1053 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1054 return (ReadParam(aReader
, &aResult
->mHistoricalData
) &&
1055 ReadParam(aReader
, &aResult
->mIdentifier
) &&
1056 ReadParam(aReader
, &aResult
->mScreenPoint
) &&
1057 ReadParam(aReader
, &aResult
->mLocalScreenPoint
) &&
1058 ReadParam(aReader
, &aResult
->mRadius
) &&
1059 ReadParam(aReader
, &aResult
->mRotationAngle
) &&
1060 ReadParam(aReader
, &aResult
->mForce
) &&
1061 ReadParam(aReader
, &aResult
->mTiltX
) &&
1062 ReadParam(aReader
, &aResult
->mTiltY
) &&
1063 ReadParam(aReader
, &aResult
->mTwist
));
1068 struct ParamTraits
<mozilla::MultiTouchInput::MultiTouchType
>
1069 : public ContiguousEnumSerializerInclusive
<
1070 mozilla::MultiTouchInput::MultiTouchType
,
1071 mozilla::MultiTouchInput::MultiTouchType::MULTITOUCH_START
,
1072 mozilla::MultiTouchInput::sHighestMultiTouchType
> {};
1075 struct ParamTraits
<mozilla::MultiTouchInput
> {
1076 using paramType
= mozilla::MultiTouchInput
;
1078 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1079 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1080 WriteParam(aWriter
, aParam
.mType
);
1081 WriteParam(aWriter
, aParam
.mTouches
);
1082 WriteParam(aWriter
, aParam
.mHandledByAPZ
);
1083 WriteParam(aWriter
, aParam
.mScreenOffset
);
1084 WriteParam(aWriter
, aParam
.mButton
);
1085 WriteParam(aWriter
, aParam
.mButtons
);
1088 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1089 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1090 ReadParam(aReader
, &aResult
->mType
) &&
1091 ReadParam(aReader
, &aResult
->mTouches
) &&
1092 ReadParam(aReader
, &aResult
->mHandledByAPZ
) &&
1093 ReadParam(aReader
, &aResult
->mScreenOffset
) &&
1094 ReadParam(aReader
, &aResult
->mButton
) &&
1095 ReadParam(aReader
, &aResult
->mButtons
);
1100 struct ParamTraits
<mozilla::MouseInput::MouseType
>
1101 : public ContiguousEnumSerializerInclusive
<
1102 mozilla::MouseInput::MouseType
,
1103 mozilla::MouseInput::MouseType::MOUSE_NONE
,
1104 mozilla::MouseInput::sHighestMouseType
> {};
1107 struct ParamTraits
<mozilla::MouseInput::ButtonType
>
1108 : public ContiguousEnumSerializerInclusive
<
1109 mozilla::MouseInput::ButtonType
,
1110 mozilla::MouseInput::ButtonType::PRIMARY_BUTTON
,
1111 mozilla::MouseInput::sHighestButtonType
> {};
1114 struct ParamTraits
<mozilla::MouseInput
> {
1115 typedef mozilla::MouseInput paramType
;
1117 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1118 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1119 WriteParam(aWriter
, aParam
.mButtonType
);
1120 WriteParam(aWriter
, aParam
.mType
);
1121 WriteParam(aWriter
, aParam
.mInputSource
);
1122 WriteParam(aWriter
, aParam
.mButtons
);
1123 WriteParam(aWriter
, aParam
.mOrigin
);
1124 WriteParam(aWriter
, aParam
.mLocalOrigin
);
1125 WriteParam(aWriter
, aParam
.mHandledByAPZ
);
1126 WriteParam(aWriter
, aParam
.mPreventClickEvent
);
1129 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1130 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1131 ReadParam(aReader
, &aResult
->mButtonType
) &&
1132 ReadParam(aReader
, &aResult
->mType
) &&
1133 ReadParam(aReader
, &aResult
->mInputSource
) &&
1134 ReadParam(aReader
, &aResult
->mButtons
) &&
1135 ReadParam(aReader
, &aResult
->mOrigin
) &&
1136 ReadParam(aReader
, &aResult
->mLocalOrigin
) &&
1137 ReadParam(aReader
, &aResult
->mHandledByAPZ
) &&
1138 ReadParam(aReader
, &aResult
->mPreventClickEvent
);
1143 struct ParamTraits
<mozilla::PanGestureInput::PanGestureType
>
1144 : public ContiguousEnumSerializerInclusive
<
1145 mozilla::PanGestureInput::PanGestureType
,
1146 mozilla::PanGestureInput::PanGestureType::PANGESTURE_MAYSTART
,
1147 mozilla::PanGestureInput::sHighestPanGestureType
> {};
1150 struct ParamTraits
<mozilla::PanGestureInput::PanDeltaType
>
1151 : public ContiguousEnumSerializerInclusive
<
1152 mozilla::PanGestureInput::PanDeltaType
,
1153 mozilla::PanGestureInput::PanDeltaType::PANDELTA_PAGE
,
1154 mozilla::PanGestureInput::sHighestPanDeltaType
> {};
1157 struct ParamTraits
<mozilla::PanGestureInput
>
1158 : BitfieldHelper
<mozilla::PanGestureInput
> {
1159 typedef mozilla::PanGestureInput paramType
;
1161 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1162 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1163 WriteParam(aWriter
, aParam
.mType
);
1164 WriteParam(aWriter
, aParam
.mPanStartPoint
);
1165 WriteParam(aWriter
, aParam
.mPanDisplacement
);
1166 WriteParam(aWriter
, aParam
.mLocalPanStartPoint
);
1167 WriteParam(aWriter
, aParam
.mLocalPanDisplacement
);
1168 WriteParam(aWriter
, aParam
.mLineOrPageDeltaX
);
1169 WriteParam(aWriter
, aParam
.mLineOrPageDeltaY
);
1170 WriteParam(aWriter
, aParam
.mUserDeltaMultiplierX
);
1171 WriteParam(aWriter
, aParam
.mUserDeltaMultiplierY
);
1172 WriteParam(aWriter
, aParam
.mDeltaType
);
1173 WriteParam(aWriter
, aParam
.mHandledByAPZ
);
1177 .mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection
);
1178 WriteParam(aWriter
, aParam
.mOverscrollBehaviorAllowsSwipe
);
1179 WriteParam(aWriter
, aParam
.mSimulateMomentum
);
1180 WriteParam(aWriter
, aParam
.mIsNoLineOrPageDelta
);
1183 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1184 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1185 ReadParam(aReader
, &aResult
->mType
) &&
1186 ReadParam(aReader
, &aResult
->mPanStartPoint
) &&
1187 ReadParam(aReader
, &aResult
->mPanDisplacement
) &&
1188 ReadParam(aReader
, &aResult
->mLocalPanStartPoint
) &&
1189 ReadParam(aReader
, &aResult
->mLocalPanDisplacement
) &&
1190 ReadParam(aReader
, &aResult
->mLineOrPageDeltaX
) &&
1191 ReadParam(aReader
, &aResult
->mLineOrPageDeltaY
) &&
1192 ReadParam(aReader
, &aResult
->mUserDeltaMultiplierX
) &&
1193 ReadParam(aReader
, &aResult
->mUserDeltaMultiplierY
) &&
1194 ReadParam(aReader
, &aResult
->mDeltaType
) &&
1195 ReadBoolForBitfield(aReader
, aResult
, ¶mType::SetHandledByAPZ
) &&
1196 ReadBoolForBitfield(
1199 SetRequiresContentResponseIfCannotScrollHorizontallyInStartDirection
) &&
1200 ReadBoolForBitfield(aReader
, aResult
,
1201 ¶mType::SetOverscrollBehaviorAllowsSwipe
) &&
1202 ReadBoolForBitfield(aReader
, aResult
,
1203 ¶mType::SetSimulateMomentum
) &&
1204 ReadBoolForBitfield(aReader
, aResult
,
1205 ¶mType::SetIsNoLineOrPageDelta
);
1210 struct ParamTraits
<mozilla::PinchGestureInput::PinchGestureType
>
1211 : public ContiguousEnumSerializerInclusive
<
1212 mozilla::PinchGestureInput::PinchGestureType
,
1213 mozilla::PinchGestureInput::PinchGestureType::PINCHGESTURE_START
,
1214 mozilla::PinchGestureInput::sHighestPinchGestureType
> {};
1217 struct ParamTraits
<mozilla::PinchGestureInput::PinchGestureSource
>
1218 : public ContiguousEnumSerializerInclusive
<
1219 mozilla::PinchGestureInput::PinchGestureSource
,
1220 // Set the min to TOUCH, to ensure UNKNOWN is never sent over IPC
1221 mozilla::PinchGestureInput::PinchGestureSource::TOUCH
,
1222 mozilla::PinchGestureInput::sHighestPinchGestureSource
> {};
1225 struct ParamTraits
<mozilla::PinchGestureInput
> {
1226 typedef mozilla::PinchGestureInput paramType
;
1228 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1229 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1230 WriteParam(aWriter
, aParam
.mType
);
1231 WriteParam(aWriter
, aParam
.mSource
);
1232 WriteParam(aWriter
, aParam
.mScreenOffset
);
1233 WriteParam(aWriter
, aParam
.mFocusPoint
);
1234 WriteParam(aWriter
, aParam
.mLocalFocusPoint
);
1235 WriteParam(aWriter
, aParam
.mCurrentSpan
);
1236 WriteParam(aWriter
, aParam
.mPreviousSpan
);
1237 WriteParam(aWriter
, aParam
.mLineOrPageDeltaY
);
1238 WriteParam(aWriter
, aParam
.mHandledByAPZ
);
1241 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1242 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1243 ReadParam(aReader
, &aResult
->mType
) &&
1244 ReadParam(aReader
, &aResult
->mSource
) &&
1245 ReadParam(aReader
, &aResult
->mScreenOffset
) &&
1246 ReadParam(aReader
, &aResult
->mFocusPoint
) &&
1247 ReadParam(aReader
, &aResult
->mLocalFocusPoint
) &&
1248 ReadParam(aReader
, &aResult
->mCurrentSpan
) &&
1249 ReadParam(aReader
, &aResult
->mPreviousSpan
) &&
1250 ReadParam(aReader
, &aResult
->mLineOrPageDeltaY
) &&
1251 ReadParam(aReader
, &aResult
->mHandledByAPZ
);
1256 struct ParamTraits
<mozilla::TapGestureInput::TapGestureType
>
1257 : public ContiguousEnumSerializerInclusive
<
1258 mozilla::TapGestureInput::TapGestureType
,
1259 mozilla::TapGestureInput::TapGestureType::TAPGESTURE_LONG
,
1260 mozilla::TapGestureInput::sHighestTapGestureType
> {};
1263 struct ParamTraits
<mozilla::TapGestureInput
> {
1264 typedef mozilla::TapGestureInput paramType
;
1266 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1267 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1268 WriteParam(aWriter
, aParam
.mType
);
1269 WriteParam(aWriter
, aParam
.mPoint
);
1270 WriteParam(aWriter
, aParam
.mLocalPoint
);
1273 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1274 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1275 ReadParam(aReader
, &aResult
->mType
) &&
1276 ReadParam(aReader
, &aResult
->mPoint
) &&
1277 ReadParam(aReader
, &aResult
->mLocalPoint
);
1282 struct ParamTraits
<mozilla::ScrollWheelInput::ScrollDeltaType
>
1283 : public ContiguousEnumSerializerInclusive
<
1284 mozilla::ScrollWheelInput::ScrollDeltaType
,
1285 mozilla::ScrollWheelInput::ScrollDeltaType::SCROLLDELTA_LINE
,
1286 mozilla::ScrollWheelInput::sHighestScrollDeltaType
> {};
1289 struct ParamTraits
<mozilla::ScrollWheelInput::ScrollMode
>
1290 : public ContiguousEnumSerializerInclusive
<
1291 mozilla::ScrollWheelInput::ScrollMode
,
1292 mozilla::ScrollWheelInput::ScrollMode::SCROLLMODE_INSTANT
,
1293 mozilla::ScrollWheelInput::sHighestScrollMode
> {};
1296 struct ParamTraits
<mozilla::WheelDeltaAdjustmentStrategy
>
1297 : public ContiguousEnumSerializer
<
1298 mozilla::WheelDeltaAdjustmentStrategy
,
1299 mozilla::WheelDeltaAdjustmentStrategy(0),
1300 mozilla::WheelDeltaAdjustmentStrategy::eSentinel
> {};
1303 struct ParamTraits
<mozilla::layers::APZWheelAction
>
1304 : public ContiguousEnumSerializerInclusive
<
1305 mozilla::layers::APZWheelAction
,
1306 mozilla::layers::APZWheelAction::Scroll
,
1307 mozilla::layers::kHighestAPZWheelAction
> {};
1310 struct ParamTraits
<mozilla::ScrollWheelInput
> {
1311 typedef mozilla::ScrollWheelInput paramType
;
1313 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1314 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1315 WriteParam(aWriter
, aParam
.mDeltaType
);
1316 WriteParam(aWriter
, aParam
.mScrollMode
);
1317 WriteParam(aWriter
, aParam
.mOrigin
);
1318 WriteParam(aWriter
, aParam
.mHandledByAPZ
);
1319 WriteParam(aWriter
, aParam
.mDeltaX
);
1320 WriteParam(aWriter
, aParam
.mDeltaY
);
1321 WriteParam(aWriter
, aParam
.mWheelTicksX
);
1322 WriteParam(aWriter
, aParam
.mWheelTicksY
);
1323 WriteParam(aWriter
, aParam
.mLocalOrigin
);
1324 WriteParam(aWriter
, aParam
.mLineOrPageDeltaX
);
1325 WriteParam(aWriter
, aParam
.mLineOrPageDeltaY
);
1326 WriteParam(aWriter
, aParam
.mScrollSeriesNumber
);
1327 WriteParam(aWriter
, aParam
.mUserDeltaMultiplierX
);
1328 WriteParam(aWriter
, aParam
.mUserDeltaMultiplierY
);
1329 WriteParam(aWriter
, aParam
.mMayHaveMomentum
);
1330 WriteParam(aWriter
, aParam
.mIsMomentum
);
1331 WriteParam(aWriter
, aParam
.mAllowToOverrideSystemScrollSpeed
);
1332 WriteParam(aWriter
, aParam
.mWheelDeltaAdjustmentStrategy
);
1333 WriteParam(aWriter
, aParam
.mAPZAction
);
1336 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1337 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1338 ReadParam(aReader
, &aResult
->mDeltaType
) &&
1339 ReadParam(aReader
, &aResult
->mScrollMode
) &&
1340 ReadParam(aReader
, &aResult
->mOrigin
) &&
1341 ReadParam(aReader
, &aResult
->mHandledByAPZ
) &&
1342 ReadParam(aReader
, &aResult
->mDeltaX
) &&
1343 ReadParam(aReader
, &aResult
->mDeltaY
) &&
1344 ReadParam(aReader
, &aResult
->mWheelTicksX
) &&
1345 ReadParam(aReader
, &aResult
->mWheelTicksY
) &&
1346 ReadParam(aReader
, &aResult
->mLocalOrigin
) &&
1347 ReadParam(aReader
, &aResult
->mLineOrPageDeltaX
) &&
1348 ReadParam(aReader
, &aResult
->mLineOrPageDeltaY
) &&
1349 ReadParam(aReader
, &aResult
->mScrollSeriesNumber
) &&
1350 ReadParam(aReader
, &aResult
->mUserDeltaMultiplierX
) &&
1351 ReadParam(aReader
, &aResult
->mUserDeltaMultiplierY
) &&
1352 ReadParam(aReader
, &aResult
->mMayHaveMomentum
) &&
1353 ReadParam(aReader
, &aResult
->mIsMomentum
) &&
1354 ReadParam(aReader
, &aResult
->mAllowToOverrideSystemScrollSpeed
) &&
1355 ReadParam(aReader
, &aResult
->mWheelDeltaAdjustmentStrategy
) &&
1356 ReadParam(aReader
, &aResult
->mAPZAction
);
1361 struct ParamTraits
<mozilla::KeyboardInput::KeyboardEventType
>
1362 : public ContiguousEnumSerializer
<
1363 mozilla::KeyboardInput::KeyboardEventType
,
1364 mozilla::KeyboardInput::KeyboardEventType::KEY_DOWN
,
1365 mozilla::KeyboardInput::KeyboardEventType::KEY_SENTINEL
> {};
1368 struct ParamTraits
<mozilla::KeyboardInput
> {
1369 typedef mozilla::KeyboardInput paramType
;
1371 static void Write(MessageWriter
* aWriter
, const paramType
& aParam
) {
1372 WriteParam(aWriter
, static_cast<const mozilla::InputData
&>(aParam
));
1373 WriteParam(aWriter
, aParam
.mType
);
1374 WriteParam(aWriter
, aParam
.mKeyCode
);
1375 WriteParam(aWriter
, aParam
.mCharCode
);
1376 WriteParam(aWriter
, aParam
.mShortcutCandidates
);
1377 WriteParam(aWriter
, aParam
.mHandledByAPZ
);
1380 static bool Read(MessageReader
* aReader
, paramType
* aResult
) {
1381 return ReadParam(aReader
, static_cast<mozilla::InputData
*>(aResult
)) &&
1382 ReadParam(aReader
, &aResult
->mType
) &&
1383 ReadParam(aReader
, &aResult
->mKeyCode
) &&
1384 ReadParam(aReader
, &aResult
->mCharCode
) &&
1385 ReadParam(aReader
, &aResult
->mShortcutCandidates
) &&
1386 ReadParam(aReader
, &aResult
->mHandledByAPZ
);
1392 #endif // nsGUIEventIPC_h__