path: root/xfa_test/pdf/fading_controls.cc

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "pdf/fading_controls.h"

#include "base/logging.h"
#include "base/stl_util.h"
#include "pdf/draw_utils.h"
#include "pdf/resource_consts.h"
#include "ppapi/cpp/input_event.h"

namespace chrome_pdf {

const uint32 kFadingAlphaShift = 64;
const uint32 kSplashFadingAlphaShift = 16;

FadingControls::FadingControls()
    : state_(NONE), current_transparency_(kOpaqueAlpha), fading_timer_id_(0),
      current_capture_control_(kInvalidControlId),
      fading_timeout_(kFadingTimeoutMs), alpha_shift_(kFadingAlphaShift),
      splash_(false), splash_timeout_(0) {
}

FadingControls::~FadingControls() {
  STLDeleteElements(&controls_);
}

bool FadingControls::CreateFadingControls(
    uint32 id, const pp::Rect& rc, bool visible,
    Control::Owner* owner, uint8 transparency) {
  current_transparency_ = transparency;
  return Control::Create(id, rc, visible, owner);
}

void FadingControls::Paint(pp::ImageData* image_data, const pp::Rect& rc) {
  // When this control is set to invisible the individual controls are not.
  // So we need to check for visible() here.
  if (!visible())
    return;

  std::list<Control*>::iterator iter;
  for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
    (*iter)->Paint(image_data, rc);
  }
}

bool FadingControls::HandleEvent(const pp::InputEvent& event) {
  if (!visible())
    return false;

  pp::MouseInputEvent mouse_event(event);
  if (mouse_event.is_null())
    return NotifyControls(event);

  pp::Point pt = mouse_event.GetPosition();

  bool is_mouse_click =
      mouse_event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN ||
      mouse_event.GetType() == PP_INPUTEVENT_TYPE_MOUSEUP;

  if (rect().Contains(pt)) {
    CancelSplashMode();
    FadeIn();

    // Eat mouse click if are invisible or just fading in.
    // That prevents accidental clicks on the controls for touch devices.
    bool eat_mouse_click =
        (state_ == FADING_IN || current_transparency_ == kTransparentAlpha);
    if (eat_mouse_click && is_mouse_click &&
        mouse_event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_LEFT)
      return true;  // Eat this event here.
  }

  if ((!rect().Contains(pt)) ||
      event.GetType() == PP_INPUTEVENT_TYPE_MOUSELEAVE) {
    if (!splash_)
      FadeOut();
    pp::MouseInputEvent event_leave(pp::MouseInputEvent(
        owner()->GetInstance(),
        PP_INPUTEVENT_TYPE_MOUSELEAVE,
        event.GetTimeStamp(),
        event.GetModifiers(),
        mouse_event.GetButton(),
        mouse_event.GetPosition(),
        mouse_event.GetClickCount(),
        mouse_event.GetMovement()));
    return NotifyControls(event_leave);
  }

  return NotifyControls(event);
}

void FadingControls::OnTimerFired(uint32 timer_id) {
  if (timer_id == fading_timer_id_) {
    int32 current_alpha = static_cast<int32>(current_transparency_);
    if (state_ == FADING_IN)
      current_alpha += alpha_shift_;
    else if (state_ == FADING_OUT)
      current_alpha -= alpha_shift_;

    if (current_alpha >= kOpaqueAlpha) {
      state_ = NONE;
      current_alpha = kOpaqueAlpha;
    } else if (current_alpha <= kTransparentAlpha) {
      state_ = NONE;
      current_alpha = kTransparentAlpha;
    }
    current_transparency_ = static_cast<uint8>(current_alpha);

    // Invalidate controls with new alpha transparency.
    std::list<Control*>::iterator iter;
    for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
      // We are going to invalidate the whole FadingControls area, to
      // allow simultaneous drawing.
      (*iter)->AdjustTransparency(current_transparency_, false);
    }
    owner()->Invalidate(id(), GetControlsRect());

    if (state_ != NONE)  // Fading still in progress.
      fading_timer_id_ = owner()->ScheduleTimer(id(), fading_timeout_);
    else
      OnFadingComplete();
  } else {
    // Dispatch timer to controls.
    std::list<Control*>::iterator iter;
    for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
      (*iter)->OnTimerFired(timer_id);
    }
  }
}

void FadingControls::EventCaptureReleased() {
  if (current_capture_control_ != kInvalidControlId) {
    // Remove previous catpure.
    Control* ctrl = GetControl(current_capture_control_);
    if (ctrl)
      ctrl->EventCaptureReleased();
  }
}

void FadingControls::MoveBy(const pp::Point& offset, bool invalidate) {
  std::list<Control*>::iterator iter;
  for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
    // We invalidate entire FadingControl later if needed.
    (*iter)->MoveBy(offset, false);
  }
  Control::MoveBy(offset, invalidate);
}

void FadingControls::OnEvent(uint32 control_id, uint32 event_id, void* data) {
  owner()->OnEvent(control_id, event_id, data);
}

void FadingControls::Invalidate(uint32 control_id, const pp::Rect& rc) {
  owner()->Invalidate(control_id, rc);
}

uint32 FadingControls::ScheduleTimer(uint32 control_id, uint32 timeout_ms) {
  // TODO(gene): implement timer routine properly.
  NOTIMPLEMENTED();
  //owner()->ScheduleTimer(control_id);
  return 0;
}

void FadingControls::SetEventCapture(uint32 control_id, bool set_capture) {
  if (control_id == current_capture_control_) {
    if (!set_capture)  // Remove event capture.
      current_capture_control_ = kInvalidControlId;
  } else {
    EventCaptureReleased();
    current_capture_control_ = control_id;
  }
}

void FadingControls::SetCursor(uint32 control_id,
                               PP_CursorType_Dev cursor_type) {
  owner()->SetCursor(control_id, cursor_type);
}

pp::Instance* FadingControls::GetInstance() {
  return owner()->GetInstance();
}

bool FadingControls::AddControl(Control* control) {
  DCHECK(control);
  if (control->owner() != this)
    return false;
  if (!rect().Contains(control->rect()))
    return false;

  control->AdjustTransparency(current_transparency_, false);
  controls_.push_back(control);
  return true;
}

void FadingControls::RemoveControl(uint32 control_id) {
  if (current_capture_control_ == control_id) {
    current_capture_control_ = kInvalidControlId;
  }
  std::list<Control*>::iterator iter;
  for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
    if ((*iter)->id() == control_id) {
      delete (*iter);
      controls_.erase(iter);
      break;
    }
  }
}

Control* FadingControls::GetControl(uint32 id) {
  std::list<Control*>::iterator iter;
  for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
    if ((*iter)->id() == id)
      return *iter;
  }
  return NULL;
}

pp::Rect FadingControls::GetControlsRect() {
  pp::Rect rc;
  std::list<Control*>::iterator iter;
  for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
    rc = rc.Union((*iter)->rect());
  }
  return rc;
}

bool FadingControls::ExpandLeft(int offset) {
  pp::Rect rc = rect();
  rc.set_width(rc.width() + offset);
  rc.set_x(rc.x() - offset);
  if (!rc.Contains(GetControlsRect()))
    return false;
  // No need to invalidate since we are expanding triggering area only.
  SetRect(rc, false);
  return true;
}

void FadingControls::Splash(uint32 time_ms) {
  splash_ = true;
  splash_timeout_ = time_ms;
  alpha_shift_ = kSplashFadingAlphaShift;
  FadeIn();
}

bool FadingControls::NotifyControls(const pp::InputEvent& event) {
  // First pass event to a control that current capture is set to.
  Control* ctrl = GetControl(current_capture_control_);
  if (ctrl) {
    if (ctrl->HandleEvent(event))
      return true;
  }

  std::list<Control*>::iterator iter;
  for (iter = controls_.begin(); iter != controls_.end(); ++iter) {
    // Now pass event to all control except control with capture,
    // since we already passed to it above.
    if ((*iter) != ctrl && (*iter)->HandleEvent(event))
      return true;
  }
  return false;
}

void FadingControls::FadeIn() {
  bool already_visible =
      (state_ == NONE && current_transparency_ == kOpaqueAlpha);
  if (state_ != FADING_IN && !already_visible) {
    state_ = FADING_IN;
    fading_timer_id_ = owner()->ScheduleTimer(id(), fading_timeout_);
  }
  if (already_visible)
    OnFadingComplete();
}

void FadingControls::FadeOut() {
  bool already_invisible =
      (state_ == NONE && current_transparency_ == kTransparentAlpha);
  if (state_ != FADING_OUT && !already_invisible) {
    state_ = FADING_OUT;
    fading_timer_id_ = owner()->ScheduleTimer(id(), fading_timeout_);
  }
  if (already_invisible)
    OnFadingComplete();
}

void FadingControls::OnFadingComplete() {
  DCHECK(current_transparency_ == kOpaqueAlpha ||
      current_transparency_ == kTransparentAlpha);
  // In the splash mode following states are possible:
  // Fade-in complete: splash_==true, splash_timeout_ != 0
  //   We need to schedule timer for splash_timeout_.
  // Splash timeout complete: splash_==true, splash_timeout_ == 0
  //   We need to fade out still using splash settings.
  // Fade-out complete: current_transparency_ == kTransparentAlpha
  //   We need to cancel splash mode and go back to normal settings.
  if (splash_) {
    if (current_transparency_ == kOpaqueAlpha) {
      if (splash_timeout_) {
        fading_timer_id_ = owner()->ScheduleTimer(id(), splash_timeout_);
        splash_timeout_ = 0;
      } else {
        FadeOut();
      }
    } else {
      CancelSplashMode();
    }
  }
}

void FadingControls::CancelSplashMode() {
  splash_ = false;
  alpha_shift_ = kFadingAlphaShift;
}

}  // namespace chrome_pdf