src/third_party/WebKit/Source/core/events/FocusEvent.h

   1 /*
   2  * Copyright (C) 2013 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef FocusEvent_h
  27 #define FocusEvent_h
  28
  29 #include "core/events/EventTarget.h"
  30 #include "core/events/UIEvent.h"
  31
  32 namespace blink {
  33
  34 struct FocusEventInit : public UIEventInit {
  35     FocusEventInit();
  36
  37     RefPtrWillBeMember<EventTarget> relatedTarget;
  38 };
  39
  40 class FocusEvent final : public UIEvent {
  41     DEFINE_WRAPPERTYPEINFO();
  42 public:
  43     static PassRefPtrWillBeRawPtr<FocusEvent> create()
  44     {
  45         return adoptRefWillBeNoop(new FocusEvent);
  46     }
  47
  48     static PassRefPtrWillBeRawPtr<FocusEvent> create(const AtomicString& type, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view, int detail, EventTarget* relatedTarget)
  49     {
  50         return adoptRefWillBeNoop(new FocusEvent(type, canBubble, cancelable, view, detail, relatedTarget));
  51     }
  52
  53     static PassRefPtrWillBeRawPtr<FocusEvent> create(const AtomicString& type, const FocusEventInit& initializer)
  54     {
  55         return adoptRefWillBeNoop(new FocusEvent(type, initializer));
  56     }
  57
  58     EventTarget* relatedTarget() const { return m_relatedTarget.get(); }
  59     void setRelatedTarget(EventTarget* relatedTarget) { m_relatedTarget = relatedTarget; }
  60
  61     virtual const AtomicString& interfaceName() const override;
  62     virtual bool isFocusEvent() const override;
  63
  64     virtual void trace(Visitor*) override;
  65
  66 private:
  67     FocusEvent();
  68     FocusEvent(const AtomicString& type, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView>, int, EventTarget*);
  69     FocusEvent(const AtomicString& type, const FocusEventInit&);
  70
  71     RefPtrWillBeMember<EventTarget> m_relatedTarget;
  72 };
  73
  74 DEFINE_EVENT_TYPE_CASTS(FocusEvent);
  75
  76 class FocusEventDispatchMediator final : public EventDispatchMediator {
  77 public:
  78     static PassRefPtrWillBeRawPtr<FocusEventDispatchMediator> create(PassRefPtrWillBeRawPtr<FocusEvent>);
  79 private:
  80     explicit FocusEventDispatchMediator(PassRefPtrWillBeRawPtr<FocusEvent>);
  81     FocusEvent* event() const { return static_cast<FocusEvent*>(EventDispatchMediator::event()); }
  82     virtual bool dispatchEvent(EventDispatcher*) const override;
  83 };
  84
  85 class BlurEventDispatchMediator final : public EventDispatchMediator {
  86 public:
  87     static PassRefPtrWillBeRawPtr<BlurEventDispatchMediator> create(PassRefPtrWillBeRawPtr<FocusEvent>);
  88 private:
  89     explicit BlurEventDispatchMediator(PassRefPtrWillBeRawPtr<FocusEvent>);
  90     FocusEvent* event() const { return static_cast<FocusEvent*>(EventDispatchMediator::event()); }
  91     virtual bool dispatchEvent(EventDispatcher*) const override;
  92 };
  93
  94 class FocusInEventDispatchMediator final : public EventDispatchMediator {
  95 public:
  96     static PassRefPtrWillBeRawPtr<FocusInEventDispatchMediator> create(PassRefPtrWillBeRawPtr<FocusEvent>);
  97 private:
  98     explicit FocusInEventDispatchMediator(PassRefPtrWillBeRawPtr<FocusEvent>);
  99     FocusEvent* event() const { return static_cast<FocusEvent*>(EventDispatchMediator::event()); }
 100     virtual bool dispatchEvent(EventDispatcher*) const override;
 101 };
 102
 103 class FocusOutEventDispatchMediator final : public EventDispatchMediator {
 104 public:
 105     static PassRefPtrWillBeRawPtr<FocusOutEventDispatchMediator> create(PassRefPtrWillBeRawPtr<FocusEvent>);
 106 private:
 107     explicit FocusOutEventDispatchMediator(PassRefPtrWillBeRawPtr<FocusEvent>);
 108     FocusEvent* event() const { return static_cast<FocusEvent*>(EventDispatchMediator::event()); }
 109     virtual bool dispatchEvent(EventDispatcher*) const override;
 110 };
 111
 112 } // namespace blink
 113
 114 #endif // FocusEvent_h