1 : /* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /* ***** BEGIN LICENSE BLOCK *****
3 : * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4 : *
5 : * The contents of this file are subject to the Mozilla Public License Version
6 : * 1.1 (the "License"); you may not use this file except in compliance with
7 : * the License. You may obtain a copy of the License at
8 : * http://www.mozilla.org/MPL/
9 : *
10 : * Software distributed under the License is distributed on an "AS IS" basis,
11 : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 : * for the specific language governing rights and limitations under the
13 : * License.
14 : *
15 : * The Original Code is mozilla.org code.
16 : *
17 : * The Initial Developer of the Original Code is
18 : * Netscape Communications Corporation.
19 : * Portions created by the Initial Developer are Copyright (C) 1998
20 : * the Initial Developer. All Rights Reserved.
21 : *
22 : * Contributor(s):
23 : *
24 : * Alternatively, the contents of this file may be used under the terms of
25 : * either the GNU General Public License Version 2 or later (the "GPL"), or
26 : * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27 : * in which case the provisions of the GPL or the LGPL are applicable instead
28 : * of those above. If you wish to allow use of your version of this file only
29 : * under the terms of either the GPL or the LGPL, and not to allow others to
30 : * use your version of this file under the terms of the MPL, indicate your
31 : * decision by deleting the provisions above and replace them with the notice
32 : * and other provisions required by the GPL or the LGPL. If you do not delete
33 : * the provisions above, a recipient may use your version of this file under
34 : * the terms of any one of the MPL, the GPL or the LGPL.
35 : *
36 : * ***** END LICENSE BLOCK ***** */
37 :
38 : #ifndef nsIWidget_h__
39 : #define nsIWidget_h__
40 :
41 : #include "nsISupports.h"
42 : #include "nsColor.h"
43 : #include "nsCoord.h"
44 : #include "nsRect.h"
45 : #include "nsPoint.h"
46 : #include "nsRegion.h"
47 : #include "nsStringGlue.h"
48 :
49 : #include "prthread.h"
50 : #include "Layers.h"
51 : #include "nsEvent.h"
52 : #include "nsCOMPtr.h"
53 : #include "nsITheme.h"
54 : #include "nsNativeWidget.h"
55 : #include "nsWidgetInitData.h"
56 : #include "nsTArray.h"
57 : #include "nsXULAppAPI.h"
58 :
59 : // forward declarations
60 : class nsFontMetrics;
61 : class nsRenderingContext;
62 : class nsDeviceContext;
63 : struct nsFont;
64 : class nsIRollupListener;
65 : class nsGUIEvent;
66 : class imgIContainer;
67 : class gfxASurface;
68 : class nsIContent;
69 : class ViewWrapper;
70 :
71 : namespace mozilla {
72 : namespace dom {
73 : class PBrowserChild;
74 : }
75 : namespace layers {
76 : class PLayersChild;
77 : }
78 : }
79 :
80 : /**
81 : * Callback function that processes events.
82 : *
83 : * The argument is actually a subtype (subclass) of nsEvent which carries
84 : * platform specific information about the event. Platform specific code
85 : * knows how to deal with it.
86 : *
87 : * The return value determines whether or not the default action should take
88 : * place.
89 : */
90 : typedef nsEventStatus (* EVENT_CALLBACK)(nsGUIEvent *event);
91 :
92 : /**
93 : * Flags for the getNativeData function.
94 : * See getNativeData()
95 : */
96 : #define NS_NATIVE_WINDOW 0
97 : #define NS_NATIVE_GRAPHIC 1
98 : #define NS_NATIVE_TMP_WINDOW 2
99 : #define NS_NATIVE_WIDGET 3
100 : #define NS_NATIVE_DISPLAY 4
101 : #define NS_NATIVE_REGION 5
102 : #define NS_NATIVE_OFFSETX 6
103 : #define NS_NATIVE_OFFSETY 7
104 : #define NS_NATIVE_PLUGIN_PORT 8
105 : #define NS_NATIVE_SCREEN 9
106 : #define NS_NATIVE_SHELLWIDGET 10 // Get the shell GtkWidget
107 : // Has to match to NPNVnetscapeWindow, and shareable across processes
108 : // HWND on Windows and XID on X11
109 : #define NS_NATIVE_SHAREABLE_WINDOW 11
110 : #ifdef XP_MACOSX
111 : #define NS_NATIVE_PLUGIN_PORT_QD 100
112 : #define NS_NATIVE_PLUGIN_PORT_CG 101
113 : #endif
114 : #ifdef XP_WIN
115 : #define NS_NATIVE_TSF_THREAD_MGR 100
116 : #define NS_NATIVE_TSF_CATEGORY_MGR 101
117 : #define NS_NATIVE_TSF_DISPLAY_ATTR_MGR 102
118 : #endif
119 :
120 : #define NS_IWIDGET_IID \
121 : { 0x3fa36ce2, 0x472d, 0x4bff, \
122 : { 0xb1, 0xe4, 0xc3, 0xe3, 0x19, 0x24, 0xa1, 0xe4 } }
123 :
124 : /*
125 : * Window shadow styles
126 : * Also used for the -moz-window-shadow CSS property
127 : */
128 :
129 : #define NS_STYLE_WINDOW_SHADOW_NONE 0
130 : #define NS_STYLE_WINDOW_SHADOW_DEFAULT 1
131 : #define NS_STYLE_WINDOW_SHADOW_MENU 2
132 : #define NS_STYLE_WINDOW_SHADOW_TOOLTIP 3
133 : #define NS_STYLE_WINDOW_SHADOW_SHEET 4
134 :
135 : /**
136 : * nsIWidget::OnIMEFocusChange should be called during blur,
137 : * but other OnIME*Change methods should not be called
138 : */
139 : #define NS_SUCCESS_IME_NO_UPDATES \
140 : NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_WIDGET, 1)
141 :
142 : /**
143 : * Cursor types.
144 : */
145 :
146 : enum nsCursor { ///(normal cursor, usually rendered as an arrow)
147 : eCursor_standard,
148 : ///(system is busy, usually rendered as a hourglass or watch)
149 : eCursor_wait,
150 : ///(Selecting something, usually rendered as an IBeam)
151 : eCursor_select,
152 : ///(can hyper-link, usually rendered as a human hand)
153 : eCursor_hyperlink,
154 : ///(north/south/west/east edge sizing)
155 : eCursor_n_resize,
156 : eCursor_s_resize,
157 : eCursor_w_resize,
158 : eCursor_e_resize,
159 : ///(corner sizing)
160 : eCursor_nw_resize,
161 : eCursor_se_resize,
162 : eCursor_ne_resize,
163 : eCursor_sw_resize,
164 : eCursor_crosshair,
165 : eCursor_move,
166 : eCursor_help,
167 : eCursor_copy, // CSS3
168 : eCursor_alias,
169 : eCursor_context_menu,
170 : eCursor_cell,
171 : eCursor_grab,
172 : eCursor_grabbing,
173 : eCursor_spinning,
174 : eCursor_zoom_in,
175 : eCursor_zoom_out,
176 : eCursor_not_allowed,
177 : eCursor_col_resize,
178 : eCursor_row_resize,
179 : eCursor_no_drop,
180 : eCursor_vertical_text,
181 : eCursor_all_scroll,
182 : eCursor_nesw_resize,
183 : eCursor_nwse_resize,
184 : eCursor_ns_resize,
185 : eCursor_ew_resize,
186 : eCursor_none,
187 : // This one better be the last one in this list.
188 : eCursorCount
189 : };
190 :
191 : enum nsTopLevelWidgetZPlacement { // for PlaceBehind()
192 : eZPlacementBottom = 0, // bottom of the window stack
193 : eZPlacementBelow, // just below another widget
194 : eZPlacementTop // top of the window stack
195 : };
196 :
197 :
198 : /**
199 : * Preference for receiving IME updates
200 : *
201 : * If mWantUpdates is true, PuppetWidget will forward
202 : * nsIWidget::OnIMETextChange and nsIWidget::OnIMESelectionChange to the chrome
203 : * process. This incurs overhead from observers and IPDL. If the IME
204 : * implementation on a particular platform doesn't care about OnIMETextChange
205 : * and OnIMESelectionChange from content processes, they should set
206 : * mWantUpdates to false to avoid these overheads.
207 : *
208 : * If mWantHints is true, PuppetWidget will forward the content of text fields
209 : * to the chrome process to be cached. This way we return the cached content
210 : * during query events. (see comments in bug 583976). This only makes sense
211 : * for IME implementations that do use query events, otherwise there's a
212 : * significant overhead. Platforms that don't use query events should set
213 : * mWantHints to false.
214 : */
215 : struct nsIMEUpdatePreference {
216 :
217 0 : nsIMEUpdatePreference()
218 0 : : mWantUpdates(false), mWantHints(false)
219 : {
220 0 : }
221 0 : nsIMEUpdatePreference(bool aWantUpdates, bool aWantHints)
222 0 : : mWantUpdates(aWantUpdates), mWantHints(aWantHints)
223 : {
224 0 : }
225 : bool mWantUpdates;
226 : bool mWantHints;
227 : };
228 :
229 :
230 : /*
231 : * Contains IMEStatus plus information about the current
232 : * input context that the IME can use as hints if desired.
233 : */
234 :
235 : namespace mozilla {
236 : namespace widget {
237 :
238 : struct IMEState {
239 : /**
240 : * IME enabled states, the mEnabled value of
241 : * SetInputContext()/GetInputContext() should be one value of following
242 : * values.
243 : *
244 : * WARNING: If you change these values, you also need to edit:
245 : * nsIDOMWindowUtils.idl
246 : * nsContentUtils::GetWidgetStatusFromIMEStatus
247 : */
248 : enum Enabled {
249 : /**
250 : * 'Disabled' means the user cannot use IME. So, the IME open state should
251 : * be 'closed' during 'disabled'.
252 : */
253 : DISABLED,
254 : /**
255 : * 'Enabled' means the user can use IME.
256 : */
257 : ENABLED,
258 : /**
259 : * 'Password' state is a special case for the password editors.
260 : * E.g., on mac, the password editors should disable the non-Roman
261 : * keyboard layouts at getting focus. Thus, the password editor may have
262 : * special rules on some platforms.
263 : */
264 : PASSWORD,
265 : /**
266 : * This state is used when a plugin is focused.
267 : * When a plug-in is focused content, we should send native events
268 : * directly. Because we don't process some native events, but they may
269 : * be needed by the plug-in.
270 : */
271 : PLUGIN
272 : };
273 : Enabled mEnabled;
274 :
275 : /**
276 : * IME open states the mOpen value of SetInputContext() should be one value of
277 : * OPEN, CLOSE or DONT_CHANGE_OPEN_STATE. GetInputContext() should return
278 : * OPEN, CLOSE or OPEN_STATE_NOT_SUPPORTED.
279 : */
280 : enum Open {
281 : /**
282 : * 'Unsupported' means the platform cannot return actual IME open state.
283 : * This value is used only by GetInputContext().
284 : */
285 : OPEN_STATE_NOT_SUPPORTED,
286 : /**
287 : * 'Don't change' means the widget shouldn't change IME open state when
288 : * SetInputContext() is called.
289 : */
290 : DONT_CHANGE_OPEN_STATE = OPEN_STATE_NOT_SUPPORTED,
291 : /**
292 : * 'Open' means that IME should compose in its primary language (or latest
293 : * input mode except direct ASCII character input mode). Even if IME is
294 : * opened by this value, users should be able to close IME by theirselves.
295 : * Web contents can specify this value by |ime-mode: active;|.
296 : */
297 : OPEN,
298 : /**
299 : * 'Closed' means that IME shouldn't handle key events (or should handle
300 : * as ASCII character inputs on mobile device). Even if IME is closed by
301 : * this value, users should be able to open IME by theirselves.
302 : * Web contents can specify this value by |ime-mode: inactive;|.
303 : */
304 : CLOSED
305 : };
306 : Open mOpen;
307 :
308 0 : IMEState() : mEnabled(ENABLED), mOpen(DONT_CHANGE_OPEN_STATE) { }
309 :
310 0 : IMEState(Enabled aEnabled, Open aOpen = DONT_CHANGE_OPEN_STATE) :
311 0 : mEnabled(aEnabled), mOpen(aOpen)
312 : {
313 0 : }
314 : };
315 :
316 0 : struct InputContext {
317 : IMEState mIMEState;
318 :
319 : /* The type of the input if the input is a html input field */
320 : nsString mHTMLInputType;
321 :
322 : /* A hint for the action that is performed when the input is submitted */
323 : nsString mActionHint;
324 : };
325 :
326 : struct InputContextAction {
327 : /**
328 : * mCause indicates what action causes calling nsIWidget::SetInputContext().
329 : * It must be one of following values.
330 : */
331 : enum Cause {
332 : // The cause is unknown but originated from content. Focus might have been
333 : // changed by content script.
334 : CAUSE_UNKNOWN,
335 : // The cause is unknown but originated from chrome. Focus might have been
336 : // changed by chrome script.
337 : CAUSE_UNKNOWN_CHROME,
338 : // The cause is user's keyboard operation.
339 : CAUSE_KEY,
340 : // The cause is user's mouse operation.
341 : CAUSE_MOUSE
342 : };
343 : Cause mCause;
344 :
345 : /**
346 : * mFocusChange indicates what happened for focus.
347 : */
348 : enum FocusChange {
349 : FOCUS_NOT_CHANGED,
350 : // A content got focus.
351 : GOT_FOCUS,
352 : // Focused content lost focus.
353 : LOST_FOCUS,
354 : // Menu got pseudo focus that means focused content isn't changed but
355 : // keyboard events will be handled by menu.
356 : MENU_GOT_PSEUDO_FOCUS,
357 : // Menu lost pseudo focus that means focused content will handle keyboard
358 : // events.
359 : MENU_LOST_PSEUDO_FOCUS
360 : };
361 : FocusChange mFocusChange;
362 :
363 : bool ContentGotFocusByTrustedCause() const {
364 : return (mFocusChange == GOT_FOCUS &&
365 : mCause != CAUSE_UNKNOWN);
366 : }
367 :
368 : bool UserMightRequestOpenVKB() const {
369 : return (mFocusChange == FOCUS_NOT_CHANGED &&
370 : mCause == CAUSE_MOUSE);
371 : }
372 :
373 : InputContextAction() :
374 : mCause(CAUSE_UNKNOWN), mFocusChange(FOCUS_NOT_CHANGED)
375 : {
376 : }
377 :
378 0 : InputContextAction(Cause aCause,
379 : FocusChange aFocusChange = FOCUS_NOT_CHANGED) :
380 0 : mCause(aCause), mFocusChange(aFocusChange)
381 : {
382 0 : }
383 : };
384 :
385 : } // namespace widget
386 : } // namespace mozilla
387 :
388 : /**
389 : * The base class for all the widgets. It provides the interface for
390 : * all basic and necessary functionality.
391 : */
392 0 : class nsIWidget : public nsISupports {
393 : protected:
394 : typedef mozilla::dom::PBrowserChild PBrowserChild;
395 :
396 : public:
397 : typedef mozilla::layers::LayerManager LayerManager;
398 : typedef LayerManager::LayersBackend LayersBackend;
399 : typedef mozilla::layers::PLayersChild PLayersChild;
400 : typedef mozilla::widget::IMEState IMEState;
401 : typedef mozilla::widget::InputContext InputContext;
402 : typedef mozilla::widget::InputContextAction InputContextAction;
403 :
404 : // Used in UpdateThemeGeometries.
405 0 : struct ThemeGeometry {
406 : // The -moz-appearance value for the themed widget
407 : PRUint8 mWidgetType;
408 : // The device-pixel rect within the window for the themed widget
409 : nsIntRect mRect;
410 :
411 0 : ThemeGeometry(PRUint8 aWidgetType, const nsIntRect& aRect)
412 : : mWidgetType(aWidgetType)
413 0 : , mRect(aRect)
414 0 : { }
415 : };
416 :
417 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IWIDGET_IID)
418 :
419 0 : nsIWidget()
420 : : mLastChild(nsnull)
421 0 : , mPrevSibling(nsnull)
422 0 : {}
423 :
424 :
425 : /**
426 : * Create and initialize a widget.
427 : *
428 : * All the arguments can be NULL in which case a top level window
429 : * with size 0 is created. The event callback function has to be
430 : * provided only if the caller wants to deal with the events this
431 : * widget receives. The event callback is basically a preprocess
432 : * hook called synchronously. The return value determines whether
433 : * the event goes to the default window procedure or it is hidden
434 : * to the os. The assumption is that if the event handler returns
435 : * false the widget does not see the event. The widget should not
436 : * automatically clear the window to the background color. The
437 : * calling code must handle paint messages and clear the background
438 : * itself.
439 : *
440 : * In practice at least one of aParent and aNativeParent will be null. If
441 : * both are null the widget isn't parented (e.g. context menus or
442 : * independent top level windows).
443 : *
444 : * @param aParent parent nsIWidget
445 : * @param aNativeParent native parent widget
446 : * @param aRect the widget dimension
447 : * @param aHandleEventFunction the event handler callback function
448 : * @param aContext
449 : * @param aInitData data that is used for widget initialization
450 : *
451 : */
452 : NS_IMETHOD Create(nsIWidget *aParent,
453 : nsNativeWidget aNativeParent,
454 : const nsIntRect &aRect,
455 : EVENT_CALLBACK aHandleEventFunction,
456 : nsDeviceContext *aContext,
457 : nsWidgetInitData *aInitData = nsnull) = 0;
458 :
459 : /**
460 : * Allocate, initialize, and return a widget that is a child of
461 : * |this|. The returned widget (if nonnull) has gone through the
462 : * equivalent of CreateInstance(widgetCID) + Create(...).
463 : *
464 : * |CreateChild()| lets widget backends decide whether to parent
465 : * the new child widget to this, nonnatively parent it, or both.
466 : * This interface exists to support the PuppetWidget backend,
467 : * which is entirely non-native. All other params are the same as
468 : * for |Create()|.
469 : *
470 : * |aForceUseIWidgetParent| forces |CreateChild()| to only use the
471 : * |nsIWidget*| this, not its native widget (if it exists), when
472 : * calling |Create()|. This is a timid hack around poorly
473 : * understood code, and shouldn't be used in new code.
474 : */
475 : virtual already_AddRefed<nsIWidget>
476 : CreateChild(const nsIntRect &aRect,
477 : EVENT_CALLBACK aHandleEventFunction,
478 : nsDeviceContext *aContext,
479 : nsWidgetInitData *aInitData = nsnull,
480 : bool aForceUseIWidgetParent = false) = 0;
481 :
482 : /**
483 : * Set the event callback for a widget. If a device context is not
484 : * provided then the existing device context will remain, it will
485 : * not be nulled out.
486 : */
487 : NS_IMETHOD SetEventCallback(EVENT_CALLBACK aEventFunction,
488 : nsDeviceContext *aContext) = 0;
489 :
490 : /**
491 : * Attach to a top level widget.
492 : *
493 : * In cases where a top level chrome widget is being used as a content
494 : * container, attach a secondary event callback and update the device
495 : * context. The primary event callback will continue to be called, so the
496 : * owning base window will continue to function.
497 : *
498 : * aViewEventFunction Event callback that will receive mirrored
499 : * events.
500 : * aContext The new device context for the view
501 : */
502 : NS_IMETHOD AttachViewToTopLevel(EVENT_CALLBACK aViewEventFunction,
503 : nsDeviceContext *aContext) = 0;
504 :
505 : /**
506 : * Accessor functions to get and set secondary client data. Used by
507 : * nsIView in connection with AttachViewToTopLevel above.
508 : */
509 : NS_IMETHOD SetAttachedViewPtr(ViewWrapper* aViewWrapper) = 0;
510 : virtual ViewWrapper* GetAttachedViewPtr() = 0;
511 :
512 : /**
513 : * Accessor functions to get and set the client data associated with the
514 : * widget.
515 : */
516 : //@{
517 : NS_IMETHOD GetClientData(void*& aClientData) = 0;
518 : NS_IMETHOD SetClientData(void* aClientData) = 0;
519 : //@}
520 :
521 : /**
522 : * Close and destroy the internal native window.
523 : * This method does not delete the widget.
524 : */
525 :
526 : NS_IMETHOD Destroy(void) = 0;
527 :
528 :
529 : /**
530 : * Reparent a widget
531 : *
532 : * Change the widget's parent. Null parents are allowed.
533 : *
534 : * @param aNewParent new parent
535 : */
536 : NS_IMETHOD SetParent(nsIWidget* aNewParent) = 0;
537 :
538 : NS_IMETHOD RegisterTouchWindow() = 0;
539 : NS_IMETHOD UnregisterTouchWindow() = 0;
540 :
541 : /**
542 : * Return the parent Widget of this Widget or nsnull if this is a
543 : * top level window
544 : *
545 : * @return the parent widget or nsnull if it does not have a parent
546 : *
547 : */
548 : virtual nsIWidget* GetParent(void) = 0;
549 :
550 : /**
551 : * Return the top level Widget of this Widget
552 : *
553 : * @return the top level widget
554 : */
555 : virtual nsIWidget* GetTopLevelWidget() = 0;
556 :
557 : /**
558 : * Return the top (non-sheet) parent of this Widget if it's a sheet,
559 : * or nsnull if this isn't a sheet (or some other error occurred).
560 : * Sheets are only supported on some platforms (currently only OS X).
561 : *
562 : * @return the top (non-sheet) parent widget or nsnull
563 : *
564 : */
565 : virtual nsIWidget* GetSheetWindowParent(void) = 0;
566 :
567 : /**
568 : * Return the physical DPI of the screen containing the window ...
569 : * the number of device pixels per inch.
570 : */
571 : virtual float GetDPI() = 0;
572 :
573 : /**
574 : * Return the default scale factor for the window. This is the
575 : * default number of device pixels per CSS pixel to use. This should
576 : * depend on OS/platform settings such as the Mac's "UI scale factor"
577 : * or Windows' "font DPI".
578 : */
579 : virtual double GetDefaultScale() = 0;
580 :
581 : /**
582 : * Return the first child of this widget. Will return null if
583 : * there are no children.
584 : */
585 0 : nsIWidget* GetFirstChild() const {
586 0 : return mFirstChild;
587 : }
588 :
589 : /**
590 : * Return the last child of this widget. Will return null if
591 : * there are no children.
592 : */
593 : nsIWidget* GetLastChild() const {
594 : return mLastChild;
595 : }
596 :
597 : /**
598 : * Return the next sibling of this widget
599 : */
600 0 : nsIWidget* GetNextSibling() const {
601 0 : return mNextSibling;
602 : }
603 :
604 : /**
605 : * Set the next sibling of this widget
606 : */
607 0 : void SetNextSibling(nsIWidget* aSibling) {
608 0 : mNextSibling = aSibling;
609 0 : }
610 :
611 : /**
612 : * Return the previous sibling of this widget
613 : */
614 0 : nsIWidget* GetPrevSibling() const {
615 0 : return mPrevSibling;
616 : }
617 :
618 : /**
619 : * Set the previous sibling of this widget
620 : */
621 0 : void SetPrevSibling(nsIWidget* aSibling) {
622 0 : mPrevSibling = aSibling;
623 0 : }
624 :
625 : /**
626 : * Show or hide this widget
627 : *
628 : * @param aState true to show the Widget, false to hide it
629 : *
630 : */
631 : NS_IMETHOD Show(bool aState) = 0;
632 :
633 : /**
634 : * Make the window modal
635 : *
636 : */
637 : NS_IMETHOD SetModal(bool aModal) = 0;
638 :
639 : /**
640 : * Returns whether the window is visible
641 : *
642 : */
643 : NS_IMETHOD IsVisible(bool & aState) = 0;
644 :
645 : /**
646 : * Perform platform-dependent sanity check on a potential window position.
647 : * This is guaranteed to work only for top-level windows.
648 : *
649 : * @param aAllowSlop: if true, allow the window to slop offscreen;
650 : * the window should be partially visible. if false,
651 : * force the entire window onscreen (or at least
652 : * the upper-left corner, if it's too large).
653 : * @param aX in: an x position expressed in screen coordinates.
654 : * out: the x position constrained to fit on the screen(s).
655 : * @param aY in: an y position expressed in screen coordinates.
656 : * out: the y position constrained to fit on the screen(s).
657 : * @return vapid success indication. but see also the parameters.
658 : *
659 : **/
660 : NS_IMETHOD ConstrainPosition(bool aAllowSlop,
661 : PRInt32 *aX,
662 : PRInt32 *aY) = 0;
663 :
664 : /**
665 : * Move this widget.
666 : *
667 : * Coordinates refer to the top-left of the widget. For toplevel windows
668 : * with decorations, this is the top-left of the titlebar and frame .
669 : *
670 : * @param aX the new x position expressed in the parent's coordinate system
671 : * @param aY the new y position expressed in the parent's coordinate system
672 : *
673 : **/
674 : NS_IMETHOD Move(PRInt32 aX, PRInt32 aY) = 0;
675 :
676 : /**
677 : * Reposition this widget so that the client area has the given offset.
678 : *
679 : * @param aX the new x offset of the client area expressed as an
680 : * offset from the origin of the client area of the parent
681 : * widget (for root widgets and popup widgets it is in
682 : * screen coordinates)
683 : * @param aY the new y offset of the client area expressed as an
684 : * offset from the origin of the client area of the parent
685 : * widget (for root widgets and popup widgets it is in
686 : * screen coordinates)
687 : *
688 : **/
689 : NS_IMETHOD MoveClient(PRInt32 aX, PRInt32 aY) = 0;
690 :
691 : /**
692 : * Resize this widget.
693 : *
694 : * @param aWidth the new width expressed in the parent's coordinate system
695 : * @param aHeight the new height expressed in the parent's coordinate system
696 : * @param aRepaint whether the widget should be repainted
697 : *
698 : */
699 : NS_IMETHOD Resize(PRInt32 aWidth,
700 : PRInt32 aHeight,
701 : bool aRepaint) = 0;
702 :
703 : /**
704 : * Move or resize this widget.
705 : *
706 : * @param aX the new x position expressed in the parent's coordinate system
707 : * @param aY the new y position expressed in the parent's coordinate system
708 : * @param aWidth the new width expressed in the parent's coordinate system
709 : * @param aHeight the new height expressed in the parent's coordinate system
710 : * @param aRepaint whether the widget should be repainted if the size changes
711 : *
712 : */
713 : NS_IMETHOD Resize(PRInt32 aX,
714 : PRInt32 aY,
715 : PRInt32 aWidth,
716 : PRInt32 aHeight,
717 : bool aRepaint) = 0;
718 :
719 : /**
720 : * Resize the widget so that the inner client area has the given size.
721 : *
722 : * @param aWidth the new width of the client area.
723 : * @param aHeight the new height of the client area.
724 : * @param aRepaint whether the widget should be repainted
725 : *
726 : */
727 : NS_IMETHOD ResizeClient(PRInt32 aWidth,
728 : PRInt32 aHeight,
729 : bool aRepaint) = 0;
730 :
731 : /**
732 : * Resize and reposition the widget so tht inner client area has the given
733 : * offset and size.
734 : *
735 : * @param aX the new x offset of the client area expressed as an
736 : * offset from the origin of the client area of the parent
737 : * widget (for root widgets and popup widgets it is in
738 : * screen coordinates)
739 : * @param aY the new y offset of the client area expressed as an
740 : * offset from the origin of the client area of the parent
741 : * widget (for root widgets and popup widgets it is in
742 : * screen coordinates)
743 : * @param aWidth the new width of the client area.
744 : * @param aHeight the new height of the client area.
745 : * @param aRepaint whether the widget should be repainted
746 : *
747 : */
748 : NS_IMETHOD ResizeClient(PRInt32 aX,
749 : PRInt32 aY,
750 : PRInt32 aWidth,
751 : PRInt32 aHeight,
752 : bool aRepaint) = 0;
753 :
754 : /**
755 : * Sets the widget's z-index.
756 : */
757 : NS_IMETHOD SetZIndex(PRInt32 aZIndex) = 0;
758 :
759 : /**
760 : * Gets the widget's z-index.
761 : */
762 : NS_IMETHOD GetZIndex(PRInt32* aZIndex) = 0;
763 :
764 : /**
765 : * Position this widget just behind the given widget. (Used to
766 : * control z-order for top-level widgets. Get/SetZIndex by contrast
767 : * control z-order for child widgets of other widgets.)
768 : * @param aPlacement top, bottom, or below a widget
769 : * (if top or bottom, param aWidget is ignored)
770 : * @param aWidget widget to place this widget behind
771 : * (only if aPlacement is eZPlacementBelow).
772 : * null is equivalent to aPlacement of eZPlacementTop
773 : * @param aActivate true to activate the widget after placing it
774 : */
775 : NS_IMETHOD PlaceBehind(nsTopLevelWidgetZPlacement aPlacement,
776 : nsIWidget *aWidget, bool aActivate) = 0;
777 :
778 : /**
779 : * Minimize, maximize or normalize the window size.
780 : * Takes a value from nsSizeMode (see nsGUIEvent.h)
781 : */
782 : NS_IMETHOD SetSizeMode(PRInt32 aMode) = 0;
783 :
784 : /**
785 : * Return size mode (minimized, maximized, normalized).
786 : * Returns a value from nsSizeMode (see nsGUIEvent.h)
787 : */
788 : NS_IMETHOD GetSizeMode(PRInt32* aMode) = 0;
789 :
790 : /**
791 : * Enable or disable this Widget
792 : *
793 : * @param aState true to enable the Widget, false to disable it.
794 : *
795 : */
796 : NS_IMETHOD Enable(bool aState) = 0;
797 :
798 : /**
799 : * Ask whether the widget is enabled
800 : * @param aState returns true if the widget is enabled
801 : */
802 : NS_IMETHOD IsEnabled(bool *aState) = 0;
803 :
804 : /**
805 : * Request activation of this window or give focus to this widget.
806 : *
807 : * @param aRaise If true, this function requests activation of this
808 : * widget's toplevel window.
809 : * If false, the appropriate toplevel window (which in
810 : * the case of popups may not be this widget's toplevel
811 : * window) is already active, and this function indicates
812 : * that keyboard events should be reported through the
813 : * aHandleEventFunction provided to this->Create().
814 : */
815 : NS_IMETHOD SetFocus(bool aRaise = false) = 0;
816 :
817 : /**
818 : * Get this widget's outside dimensions relative to its parent widget. For
819 : * popup widgets the returned rect is in screen coordinates and not
820 : * relative to its parent widget.
821 : *
822 : * @param aRect On return it holds the x, y, width and height of
823 : * this widget.
824 : */
825 : NS_IMETHOD GetBounds(nsIntRect &aRect) = 0;
826 :
827 : /**
828 : * Get this widget's outside dimensions in global coordinates. This
829 : * includes any title bar on the window.
830 : *
831 : * @param aRect On return it holds the x, y, width and height of
832 : * this widget.
833 : */
834 : NS_IMETHOD GetScreenBounds(nsIntRect &aRect) = 0;
835 :
836 : /**
837 : * Get this widget's client area bounds, if the window has a 3D border
838 : * appearance this returns the area inside the border. The position is the
839 : * position of the client area relative to the client area of the parent
840 : * widget (for root widgets and popup widgets it is in screen coordinates).
841 : *
842 : * @param aRect On return it holds the x. y, width and height of
843 : * the client area of this widget.
844 : */
845 : NS_IMETHOD GetClientBounds(nsIntRect &aRect) = 0;
846 :
847 : /**
848 : * Get the non-client area dimensions of the window.
849 : *
850 : */
851 : NS_IMETHOD GetNonClientMargins(nsIntMargin &margins) = 0;
852 :
853 : /**
854 : * Sets the non-client area dimensions of the window. Pass -1 to restore
855 : * the system default frame size for that border. Pass zero to remove
856 : * a border, or pass a specific value adjust a border. Units are in
857 : * pixels. (DPI dependent)
858 : *
859 : * Platform notes:
860 : * Windows: shrinking top non-client height will remove application
861 : * icon and window title text. Glass desktops will refuse to set
862 : * dimensions between zero and size < system default.
863 : *
864 : */
865 : NS_IMETHOD SetNonClientMargins(nsIntMargin &margins) = 0;
866 :
867 : /**
868 : * Get the client offset from the window origin.
869 : *
870 : * @return the x and y of the offset.
871 : *
872 : */
873 : virtual nsIntPoint GetClientOffset() = 0;
874 :
875 : /**
876 : * Get the foreground color for this widget
877 : *
878 : * @return this widget's foreground color
879 : *
880 : */
881 : virtual nscolor GetForegroundColor(void) = 0;
882 :
883 : /**
884 : * Set the foreground color for this widget
885 : *
886 : * @param aColor the new foreground color
887 : *
888 : */
889 :
890 : NS_IMETHOD SetForegroundColor(const nscolor &aColor) = 0;
891 :
892 : /**
893 : * Get the background color for this widget
894 : *
895 : * @return this widget's background color
896 : *
897 : */
898 :
899 : virtual nscolor GetBackgroundColor(void) = 0;
900 :
901 : /**
902 : * Set the background color for this widget
903 : *
904 : * @param aColor the new background color
905 : *
906 : */
907 :
908 : NS_IMETHOD SetBackgroundColor(const nscolor &aColor) = 0;
909 :
910 : /**
911 : * Get the cursor for this widget.
912 : *
913 : * @return this widget's cursor.
914 : */
915 :
916 : virtual nsCursor GetCursor(void) = 0;
917 :
918 : /**
919 : * Set the cursor for this widget
920 : *
921 : * @param aCursor the new cursor for this widget
922 : */
923 :
924 : NS_IMETHOD SetCursor(nsCursor aCursor) = 0;
925 :
926 : /**
927 : * Sets an image as the cursor for this widget.
928 : *
929 : * @param aCursor the cursor to set
930 : * @param aX the X coordinate of the hotspot (from left).
931 : * @param aY the Y coordinate of the hotspot (from top).
932 : * @retval NS_ERROR_NOT_IMPLEMENTED if setting images as cursors is not
933 : * supported
934 : */
935 : NS_IMETHOD SetCursor(imgIContainer* aCursor,
936 : PRUint32 aHotspotX, PRUint32 aHotspotY) = 0;
937 :
938 : /**
939 : * Get the window type of this widget
940 : *
941 : * @param aWindowType the window type of the widget
942 : */
943 : NS_IMETHOD GetWindowType(nsWindowType& aWindowType) = 0;
944 :
945 : /**
946 : * Set the transparency mode of the top-level window containing this widget.
947 : * So, e.g., if you call this on the widget for an IFRAME, the top level
948 : * browser window containing the IFRAME actually gets set. Be careful.
949 : *
950 : * This can fail if the platform doesn't support
951 : * transparency/glass. By default widgets are not
952 : * transparent. This will also fail if the toplevel window is not
953 : * a Mozilla window, e.g., if the widget is in an embedded
954 : * context.
955 : *
956 : * After transparency/glass has been enabled, the initial alpha channel
957 : * value for all pixels is 1, i.e., opaque.
958 : * If the window is resized then the alpha channel values for
959 : * all pixels are reset to 1.
960 : * Pixel RGB color values are already premultiplied with alpha channel values.
961 : */
962 : virtual void SetTransparencyMode(nsTransparencyMode aMode) = 0;
963 :
964 : /**
965 : * Get the transparency mode of the top-level window that contains this
966 : * widget.
967 : */
968 : virtual nsTransparencyMode GetTransparencyMode() = 0;
969 :
970 : /**
971 : * This represents a command to set the bounds and clip region of
972 : * a child widget.
973 : */
974 0 : struct Configuration {
975 : nsIWidget* mChild;
976 : nsIntRect mBounds;
977 : nsTArray<nsIntRect> mClipRegion;
978 : };
979 :
980 : /**
981 : * Sets the clip region of each mChild (which must actually be a child
982 : * of this widget) to the union of the pixel rects given in
983 : * mClipRegion, all relative to the top-left of the child
984 : * widget. Clip regions are not implemented on all platforms and only
985 : * need to actually work for children that are plugins.
986 : *
987 : * Also sets the bounds of each child to mBounds.
988 : *
989 : * This will invalidate areas of the children that have changed, but
990 : * does not need to invalidate any part of this widget.
991 : *
992 : * Children should be moved in the order given; the array is
993 : * sorted so to minimize unnecessary invalidation if children are
994 : * moved in that order.
995 : */
996 : virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations) = 0;
997 :
998 : /**
999 : * Appends to aRects the rectangles constituting this widget's clip
1000 : * region. If this widget is not clipped, appends a single rectangle
1001 : * (0, 0, bounds.width, bounds.height).
1002 : */
1003 : virtual void GetWindowClipRegion(nsTArray<nsIntRect>* aRects) = 0;
1004 :
1005 : /**
1006 : * Set the shadow style of the window.
1007 : *
1008 : * Ignored on child widgets and on non-Mac platforms.
1009 : */
1010 : NS_IMETHOD SetWindowShadowStyle(PRInt32 aStyle) = 0;
1011 :
1012 : /*
1013 : * On Mac OS X, this method shows or hides the pill button in the titlebar
1014 : * that's used to collapse the toolbar.
1015 : *
1016 : * Ignored on child widgets and on non-Mac platforms.
1017 : */
1018 : virtual void SetShowsToolbarButton(bool aShow) = 0;
1019 :
1020 : enum WindowAnimationType {
1021 : eGenericWindowAnimation,
1022 : eDocumentWindowAnimation
1023 : };
1024 :
1025 : /**
1026 : * Sets the kind of top-level window animation this widget should have. On
1027 : * Mac OS X, this causes a particular kind of animation to be shown when the
1028 : * window is first made visible.
1029 : *
1030 : * Ignored on child widgets and on non-Mac platforms.
1031 : */
1032 : virtual void SetWindowAnimationType(WindowAnimationType aType) = 0;
1033 :
1034 : /**
1035 : * Hide window chrome (borders, buttons) for this widget.
1036 : *
1037 : */
1038 : NS_IMETHOD HideWindowChrome(bool aShouldHide) = 0;
1039 :
1040 : /**
1041 : * Put the toplevel window into or out of fullscreen mode.
1042 : *
1043 : */
1044 : NS_IMETHOD MakeFullScreen(bool aFullScreen) = 0;
1045 :
1046 : /**
1047 : * Invalidate a specified rect for a widget so that it will be repainted
1048 : * later.
1049 : */
1050 : NS_IMETHOD Invalidate(const nsIntRect & aRect) = 0;
1051 :
1052 : enum LayerManagerPersistence
1053 : {
1054 : LAYER_MANAGER_CURRENT = 0,
1055 : LAYER_MANAGER_PERSISTENT
1056 : };
1057 :
1058 : /**
1059 : * Return the widget's LayerManager. The layer tree for that
1060 : * LayerManager is what gets rendered to the widget.
1061 : *
1062 : * @param aAllowRetaining an outparam that states whether the returned
1063 : * layer manager should be used for retained layers
1064 : */
1065 0 : inline LayerManager* GetLayerManager(bool* aAllowRetaining = nsnull)
1066 : {
1067 : return GetLayerManager(nsnull, LayerManager::LAYERS_NONE,
1068 0 : LAYER_MANAGER_CURRENT, aAllowRetaining);
1069 : }
1070 :
1071 0 : inline LayerManager* GetLayerManager(LayerManagerPersistence aPersistence,
1072 : bool* aAllowRetaining = nsnull)
1073 : {
1074 : return GetLayerManager(nsnull, LayerManager::LAYERS_NONE,
1075 0 : aPersistence, aAllowRetaining);
1076 : }
1077 :
1078 : /**
1079 : * Like GetLayerManager(), but prefers creating a layer manager of
1080 : * type |aBackendHint| instead of what would normally be created.
1081 : * LAYERS_NONE means "no hint".
1082 : */
1083 : virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager,
1084 : LayersBackend aBackendHint,
1085 : LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
1086 : bool* aAllowRetaining = nsnull) = 0;
1087 :
1088 : /**
1089 : * Called after the LayerManager draws the layer tree
1090 : *
1091 : * @param aManager The drawing LayerManager.
1092 : * @param aRect Current widget rect that is being drawn.
1093 : */
1094 : virtual void DrawWindowOverlay(LayerManager* aManager, nsIntRect aRect) = 0;
1095 :
1096 : /**
1097 : * Called when Gecko knows which themed widgets exist in this window.
1098 : * The passed array contains an entry for every themed widget of the right
1099 : * type (currently only NS_THEME_MOZ_MAC_UNIFIED_TOOLBAR and
1100 : * NS_THEME_TOOLBAR) within the window, except for themed widgets which are
1101 : * transformed or have effects applied to them (e.g. CSS opacity or
1102 : * filters).
1103 : * This could sometimes be called during display list construction
1104 : * outside of painting.
1105 : * If called during painting, it will be called before we actually
1106 : * paint anything.
1107 : */
1108 : virtual void UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries) = 0;
1109 :
1110 : /**
1111 : * Informs the widget about the region of the window that is opaque.
1112 : *
1113 : * @param aOpaqueRegion the region of the window that is opaque.
1114 : */
1115 0 : virtual void UpdateOpaqueRegion(const nsIntRegion &aOpaqueRegion) {};
1116 :
1117 : /**
1118 : * Internal methods
1119 : */
1120 :
1121 : //@{
1122 : virtual void AddChild(nsIWidget* aChild) = 0;
1123 : virtual void RemoveChild(nsIWidget* aChild) = 0;
1124 : virtual void* GetNativeData(PRUint32 aDataType) = 0;
1125 : virtual void FreeNativeData(void * data, PRUint32 aDataType) = 0;//~~~
1126 :
1127 : // GetDeviceContext returns a weak pointer to this widget's device context
1128 : virtual nsDeviceContext* GetDeviceContext() = 0;
1129 :
1130 : //@}
1131 :
1132 : /**
1133 : * Set the widget's title.
1134 : * Must be called after Create.
1135 : *
1136 : * @param aTitle string displayed as the title of the widget
1137 : */
1138 :
1139 : NS_IMETHOD SetTitle(const nsAString& aTitle) = 0;
1140 :
1141 : /**
1142 : * Set the widget's icon.
1143 : * Must be called after Create.
1144 : *
1145 : * @param anIconSpec string specifying the icon to use; convention is to pass
1146 : * a resource: URL from which a platform-dependent resource
1147 : * file name will be constructed
1148 : */
1149 :
1150 : NS_IMETHOD SetIcon(const nsAString& anIconSpec) = 0;
1151 :
1152 : /**
1153 : * Return this widget's origin in screen coordinates.
1154 : *
1155 : * @return screen coordinates stored in the x,y members
1156 : */
1157 :
1158 : virtual nsIntPoint WidgetToScreenOffset() = 0;
1159 :
1160 : /**
1161 : * Given the specified client size, return the corresponding window size,
1162 : * which includes the area for the borders and titlebar. This method
1163 : * should work even when the window is not yet visible.
1164 : */
1165 : virtual nsIntSize ClientToWindowSize(const nsIntSize& aClientSize) = 0;
1166 :
1167 : /**
1168 : * Dispatches an event to the widget
1169 : *
1170 : */
1171 : NS_IMETHOD DispatchEvent(nsGUIEvent* event, nsEventStatus & aStatus) = 0;
1172 :
1173 : /**
1174 : * Enables the dropping of files to a widget (XXX this is temporary)
1175 : *
1176 : */
1177 : NS_IMETHOD EnableDragDrop(bool aEnable) = 0;
1178 :
1179 : /**
1180 : * Enables/Disables system mouse capture.
1181 : * @param aCapture true enables mouse capture, false disables mouse capture
1182 : *
1183 : */
1184 : NS_IMETHOD CaptureMouse(bool aCapture) = 0;
1185 :
1186 : /**
1187 : * Classify the window for the window manager. Mostly for X11.
1188 : */
1189 : NS_IMETHOD SetWindowClass(const nsAString& xulWinType) = 0;
1190 :
1191 : /**
1192 : * Enables/Disables system capture of any and all events that would cause a
1193 : * dropdown to be rolled up, This method ignores the aConsumeRollupEvent
1194 : * parameter when aDoCapture is FALSE
1195 : * @param aDoCapture true enables capture, false disables capture
1196 : * @param aConsumeRollupEvent true consumes the rollup event, false dispatches rollup event
1197 : *
1198 : */
1199 : NS_IMETHOD CaptureRollupEvents(nsIRollupListener * aListener, bool aDoCapture,
1200 : bool aConsumeRollupEvent) = 0;
1201 :
1202 : /**
1203 : * Bring this window to the user's attention. This is intended to be a more
1204 : * gentle notification than popping the window to the top or putting up an
1205 : * alert. See, for example, Win32 FlashWindow or the NotificationManager on
1206 : * the Mac. The notification should be suppressed if the window is already
1207 : * in the foreground and should be dismissed when the user brings this window
1208 : * to the foreground.
1209 : * @param aCycleCount Maximum number of times to animate the window per system
1210 : * conventions. If set to -1, cycles indefinitely until
1211 : * window is brought into the foreground.
1212 : */
1213 : NS_IMETHOD GetAttention(PRInt32 aCycleCount) = 0;
1214 :
1215 : /**
1216 : * Ask whether there user input events pending. All input events are
1217 : * included, including those not targeted at this nsIwidget instance.
1218 : */
1219 : virtual bool HasPendingInputEvent() = 0;
1220 :
1221 : /**
1222 : * Called when when we need to begin secure keyboard input, such as when a password field
1223 : * gets focus.
1224 : *
1225 : * NOTE: Calls to this method may not be nested and you can only enable secure keyboard input
1226 : * for one widget at a time.
1227 : */
1228 : NS_IMETHOD BeginSecureKeyboardInput() = 0;
1229 :
1230 : /**
1231 : * Called when when we need to end secure keyboard input, such as when a password field
1232 : * loses focus.
1233 : *
1234 : * NOTE: Calls to this method may not be nested and you can only enable secure keyboard input
1235 : * for one widget at a time.
1236 : */
1237 : NS_IMETHOD EndSecureKeyboardInput() = 0;
1238 :
1239 : /**
1240 : * Set the background color of the window titlebar for this widget. On Mac,
1241 : * for example, this will remove the grey gradient and bottom border and
1242 : * instead show a single, solid color.
1243 : *
1244 : * Ignored on any platform that does not support it. Ignored by widgets that
1245 : * do not represent windows.
1246 : *
1247 : * @param aColor The color to set the title bar background to. Alpha values
1248 : * other than fully transparent (0) are respected if possible
1249 : * on the platform. An alpha of 0 will cause the window to
1250 : * draw with the default style for the platform.
1251 : *
1252 : * @param aActive Whether the color should be applied to active or inactive
1253 : * windows.
1254 : */
1255 : NS_IMETHOD SetWindowTitlebarColor(nscolor aColor, bool aActive) = 0;
1256 :
1257 : /**
1258 : * If set to true, the window will draw its contents into the titlebar
1259 : * instead of below it.
1260 : *
1261 : * Ignored on any platform that does not support it. Ignored by widgets that
1262 : * do not represent windows.
1263 : * May result in a resize event, so should only be called from places where
1264 : * reflow and painting is allowed.
1265 : *
1266 : * @param aState Whether drawing into the titlebar should be activated.
1267 : */
1268 : virtual void SetDrawsInTitlebar(bool aState) = 0;
1269 :
1270 : /*
1271 : * Determine whether the widget shows a resize widget. If it does,
1272 : * aResizerRect returns the resizer's rect.
1273 : *
1274 : * Returns false on any platform that does not support it.
1275 : *
1276 : * @param aResizerRect The resizer's rect in device pixels.
1277 : * @return Whether a resize widget is shown.
1278 : */
1279 : virtual bool ShowsResizeIndicator(nsIntRect* aResizerRect) = 0;
1280 :
1281 : /**
1282 : * Get the Thebes surface associated with this widget.
1283 : */
1284 : virtual gfxASurface *GetThebesSurface() = 0;
1285 :
1286 : /**
1287 : * Return the popup that was last rolled up, or null if there isn't one.
1288 : */
1289 : virtual nsIContent* GetLastRollup() = 0;
1290 :
1291 : /**
1292 : * Begin a window resizing drag, based on the event passed in.
1293 : */
1294 : NS_IMETHOD BeginResizeDrag(nsGUIEvent* aEvent, PRInt32 aHorizontal, PRInt32 aVertical) = 0;
1295 :
1296 : /**
1297 : * Begin a window moving drag, based on the event passed in.
1298 : */
1299 : NS_IMETHOD BeginMoveDrag(nsMouseEvent* aEvent) = 0;
1300 :
1301 : enum Modifiers {
1302 : CAPS_LOCK = 0x01, // when CapsLock is active
1303 : NUM_LOCK = 0x02, // when NumLock is active
1304 : SHIFT_L = 0x0100,
1305 : SHIFT_R = 0x0200,
1306 : CTRL_L = 0x0400,
1307 : CTRL_R = 0x0800,
1308 : ALT_L = 0x1000, // includes Option
1309 : ALT_R = 0x2000,
1310 : COMMAND_L = 0x4000,
1311 : COMMAND_R = 0x8000,
1312 : HELP = 0x10000,
1313 : FUNCTION = 0x100000,
1314 : NUMERIC_KEY_PAD = 0x01000000 // when the key is coming from the keypad
1315 : };
1316 : /**
1317 : * Utility method intended for testing. Dispatches native key events
1318 : * to this widget to simulate the press and release of a key.
1319 : * @param aNativeKeyboardLayout a *platform-specific* constant.
1320 : * On Mac, this is the resource ID for a 'uchr' or 'kchr' resource.
1321 : * On Windows, it is converted to a hex string and passed to
1322 : * LoadKeyboardLayout, see
1323 : * http://msdn.microsoft.com/en-us/library/ms646305(VS.85).aspx
1324 : * @param aNativeKeyCode a *platform-specific* keycode.
1325 : * On Windows, this is the virtual key code.
1326 : * @param aModifiers some combination of the above 'Modifiers' flags;
1327 : * not all flags will apply to all platforms. Mac ignores the _R
1328 : * modifiers. Windows ignores COMMAND, NUMERIC_KEY_PAD, HELP and
1329 : * FUNCTION.
1330 : * @param aCharacters characters that the OS would decide to generate
1331 : * from the event. On Windows, this is the charCode passed by
1332 : * WM_CHAR.
1333 : * @param aUnmodifiedCharacters characters that the OS would decide
1334 : * to generate from the event if modifier keys (other than shift)
1335 : * were assumed inactive. Needed on Mac, ignored on Windows.
1336 : * @return NS_ERROR_NOT_AVAILABLE to indicate that the keyboard
1337 : * layout is not supported and the event was not fired
1338 : */
1339 : virtual nsresult SynthesizeNativeKeyEvent(PRInt32 aNativeKeyboardLayout,
1340 : PRInt32 aNativeKeyCode,
1341 : PRUint32 aModifierFlags,
1342 : const nsAString& aCharacters,
1343 : const nsAString& aUnmodifiedCharacters) = 0;
1344 :
1345 : /**
1346 : * Utility method intended for testing. Dispatches native mouse events
1347 : * may even move the mouse cursor. On Mac the events are guaranteed to
1348 : * be sent to the window containing this widget, but on Windows they'll go
1349 : * to whatever's topmost on the screen at that position, so for
1350 : * cross-platform testing ensure that your window is at the top of the
1351 : * z-order.
1352 : * @param aPoint screen location of the mouse, in device
1353 : * pixels, with origin at the top left
1354 : * @param aNativeMessage *platform-specific* event type (e.g. on Mac,
1355 : * NSMouseMoved; on Windows, MOUSEEVENTF_MOVE, MOUSEEVENTF_LEFTDOWN etc)
1356 : * @param aModifierFlags *platform-specific* modifier flags (ignored
1357 : * on Windows)
1358 : */
1359 : virtual nsresult SynthesizeNativeMouseEvent(nsIntPoint aPoint,
1360 : PRUint32 aNativeMessage,
1361 : PRUint32 aModifierFlags) = 0;
1362 :
1363 : /**
1364 : * Activates a native menu item at the position specified by the index
1365 : * string. The index string is a string of positive integers separated
1366 : * by the "|" (pipe) character. The last integer in the string represents
1367 : * the item index in a submenu located using the integers preceding it.
1368 : *
1369 : * Example: 1|0|4
1370 : * In this string, the first integer represents the top-level submenu
1371 : * in the native menu bar. Since the integer is 1, it is the second submeu
1372 : * in the native menu bar. Within that, the first item (index 0) is a
1373 : * submenu, and we want to activate the 5th item within that submenu.
1374 : */
1375 : virtual nsresult ActivateNativeMenuItemAt(const nsAString& indexString) = 0;
1376 :
1377 : /**
1378 : * This is used for native menu system testing.
1379 : *
1380 : * Updates a native menu at the position specified by the index string.
1381 : * The index string is a string of positive integers separated by the "|"
1382 : * (pipe) character.
1383 : *
1384 : * Example: 1|0|4
1385 : * In this string, the first integer represents the top-level submenu
1386 : * in the native menu bar. Since the integer is 1, it is the second submeu
1387 : * in the native menu bar. Within that, the first item (index 0) is a
1388 : * submenu, and we want to update submenu at index 4 within that submenu.
1389 : *
1390 : * If this is called with an empty string it forces a full reload of the
1391 : * menu system.
1392 : */
1393 : virtual nsresult ForceUpdateNativeMenuAt(const nsAString& indexString) = 0;
1394 :
1395 : /*
1396 : * Force Input Method Editor to commit the uncommitted input
1397 : */
1398 : NS_IMETHOD ResetInputState()=0;
1399 :
1400 : /*
1401 : * Following methods relates to IME 'Opened'/'Closed' state.
1402 : * 'Opened' means the user can input any character. I.e., users can input Japanese
1403 : * and other characters. The user can change the state to 'Closed'.
1404 : * 'Closed' means the user can input ASCII characters only. This is the same as a
1405 : * non-IME environment. The user can change the state to 'Opened'.
1406 : * For more information is here.
1407 : * http://bugzilla.mozilla.org/show_bug.cgi?id=16940#c48
1408 : */
1409 :
1410 : /*
1411 : * Destruct and don't commit the IME composition string.
1412 : */
1413 : NS_IMETHOD CancelIMEComposition() = 0;
1414 :
1415 : /*
1416 : * Notifies the input context changes.
1417 : */
1418 : NS_IMETHOD_(void) SetInputContext(const InputContext& aContext,
1419 : const InputContextAction& aAction) = 0;
1420 :
1421 : /*
1422 : * Get current input context.
1423 : */
1424 : NS_IMETHOD_(InputContext) GetInputContext() = 0;
1425 :
1426 : /**
1427 : * Set accelerated rendering to 'True' or 'False'
1428 : */
1429 : NS_IMETHOD SetAcceleratedRendering(bool aEnabled) = 0;
1430 :
1431 : /*
1432 : * Get toggled key states.
1433 : * aKeyCode should be NS_VK_CAPS_LOCK or NS_VK_NUM_LOCK or
1434 : * NS_VK_SCROLL_LOCK.
1435 : * aLEDState is the result for current LED state of the key.
1436 : * If the LED is 'ON', it returns TRUE, otherwise, FALSE.
1437 : * If the platform doesn't support the LED state (or we cannot get the
1438 : * state), this method returns NS_ERROR_NOT_IMPLEMENTED.
1439 : */
1440 : NS_IMETHOD GetToggledKeyState(PRUint32 aKeyCode, bool* aLEDState) = 0;
1441 :
1442 : /*
1443 : * An editable node (i.e. input/textarea/design mode document)
1444 : * is receiving or giving up focus
1445 : * aFocus is true if node is receiving focus
1446 : * aFocus is false if node is giving up focus (blur)
1447 : *
1448 : * If this returns NS_ERROR_*, OnIMETextChange and OnIMESelectionChange
1449 : * and OnIMEFocusChange(false) will be never called.
1450 : *
1451 : * If this returns NS_SUCCESS_IME_NO_UPDATES, OnIMEFocusChange(false)
1452 : * will be called but OnIMETextChange and OnIMESelectionChange will NOT.
1453 : */
1454 : NS_IMETHOD OnIMEFocusChange(bool aFocus) = 0;
1455 :
1456 : /*
1457 : * Text content of the focused node has changed
1458 : * aStart is the starting offset of the change
1459 : * aOldEnd is the ending offset of the change
1460 : * aNewEnd is the caret offset after the change
1461 : */
1462 : NS_IMETHOD OnIMETextChange(PRUint32 aStart,
1463 : PRUint32 aOldEnd,
1464 : PRUint32 aNewEnd) = 0;
1465 :
1466 : /*
1467 : * Selection has changed in the focused node
1468 : */
1469 : NS_IMETHOD OnIMESelectionChange(void) = 0;
1470 :
1471 : /*
1472 : * Retrieves preference for IME updates
1473 : */
1474 : virtual nsIMEUpdatePreference GetIMEUpdatePreference() = 0;
1475 :
1476 : /*
1477 : * Call this method when a dialog is opened which has a default button.
1478 : * The button's rectangle should be supplied in aButtonRect.
1479 : */
1480 : NS_IMETHOD OnDefaultButtonLoaded(const nsIntRect &aButtonRect) = 0;
1481 :
1482 : /**
1483 : * Compute the overridden system mouse scroll speed on the root content of
1484 : * web pages. The widget may set the same value as aOriginalDelta. E.g.,
1485 : * when the system scrolling settings were customized, widget can respect
1486 : * the will of the user.
1487 : *
1488 : * This is called only when the mouse wheel event scrolls the root content
1489 : * of the web pages by line. In other words, this isn't called when the
1490 : * mouse wheel event is used for zoom, page scroll and other special
1491 : * actions. And also this isn't called when the user doesn't use the
1492 : * system wheel speed settings.
1493 : *
1494 : * @param aOriginalDelta The delta value of the current mouse wheel
1495 : * scrolling event.
1496 : * @param aIsHorizontal If TRUE, the scrolling direction is horizontal.
1497 : * Otherwise, it's vertical.
1498 : * @param aOverriddenDelta The overridden mouse scrolling speed. This value
1499 : * may be same as aOriginalDelta.
1500 : */
1501 : NS_IMETHOD OverrideSystemMouseScrollSpeed(PRInt32 aOriginalDelta,
1502 : bool aIsHorizontal,
1503 : PRInt32 &aOverriddenDelta) = 0;
1504 :
1505 : /**
1506 : * Return true if this process shouldn't use platform widgets, and
1507 : * so should use PuppetWidgets instead. If this returns true, the
1508 : * result of creating and using a platform widget is undefined,
1509 : * and likely to end in crashes or other buggy behavior.
1510 : */
1511 : static bool
1512 0 : UsePuppetWidgets()
1513 : {
1514 0 : return XRE_GetProcessType() == GeckoProcessType_Content;
1515 : }
1516 :
1517 : /**
1518 : * Allocate and return a "puppet widget" that doesn't directly
1519 : * correlate to a platform widget; platform events and data must
1520 : * be fed to it. Currently used in content processes. NULL is
1521 : * returned if puppet widgets aren't supported in this build
1522 : * config, on this platform, or for this process type.
1523 : *
1524 : * This function is called "Create" to match CreateInstance().
1525 : * The returned widget must still be nsIWidget::Create()d.
1526 : */
1527 : static already_AddRefed<nsIWidget>
1528 : CreatePuppetWidget(PBrowserChild *aTabChild);
1529 :
1530 : /**
1531 : * Reparent this widget's native widget.
1532 : * @param aNewParent the native widget of aNewParent is the new native
1533 : * parent widget
1534 : */
1535 : NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent) = 0;
1536 :
1537 : /**
1538 : * Return the internal format of the default framebuffer for this
1539 : * widget.
1540 : */
1541 0 : virtual PRUint32 GetGLFrameBufferFormat() { return 0; /*GL_NONE*/ }
1542 : protected:
1543 :
1544 : // keep the list of children. We also keep track of our siblings.
1545 : // The ownership model is as follows: parent holds a strong ref to
1546 : // the first element of the list, and each element holds a strong
1547 : // ref to the next element in the list. The prevsibling and
1548 : // lastchild pointers are weak, which is fine as long as they are
1549 : // maintained properly.
1550 : nsCOMPtr<nsIWidget> mFirstChild;
1551 : nsIWidget* mLastChild;
1552 : nsCOMPtr<nsIWidget> mNextSibling;
1553 : nsIWidget* mPrevSibling;
1554 : };
1555 :
1556 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIWidget, NS_IWIDGET_IID)
1557 :
1558 : #endif // nsIWidget_h__
|