~azzar1/unity/fix-1028810

 

  ubus_.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &Launcher::OnOverlayShown));

  ubus_.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &Launcher::OnOverlayHidden));

  ubus_.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, sigc::mem_fun(this, &Launcher::OnBGColorChanged));

  ubus_.RegisterInterest(UBUS_LAUNCHER_LOCK_HIDE, sigc::mem_fun(this, &Launcher::OnLockHideChanged));

 

 

bool Launcher::IconNeedsAnimation(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  if (unity::TimeUtil::TimeDelta(&current, &time) < (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2))

    return true;

 

  if (unity::TimeUtil::TimeDelta(&current, &time) < (ANIM_DURATION_LONG * URGENT_BLINKS * 2))

    return true;

 

  if (unity::TimeUtil::TimeDelta(&current, &time) < (ANIM_DURATION_LONG * PULSE_BLINK_LAMBDA * 2))

    return true;

 

  if (unity::TimeUtil::TimeDelta(&current, &time) < ANIM_DURATION)

    return true;

 

  if (unity::TimeUtil::TimeDelta(&current, &time) < ANIM_DURATION_LONG)

    return true;

 

  if (unity::TimeUtil::TimeDelta(&current, &time) < ANIM_DURATION_SHORT_SHORT)

    return true;

 

  if (unity::TimeUtil::TimeDelta(&current, &time) < ANIM_DURATION)

    return true;

 

  if (!icon->IsVisibleOnMonitor(monitor))

    return 0.0f;

 

  {

  }

 

  {

    int enter_ms = unity::TimeUtil::TimeDelta(&current, &icon_visible_time);

    return CLAMP((float) enter_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);

  }

  else

  {

    int hide_ms = unity::TimeUtil::TimeDelta(&current, &icon_hide_time);

    return 1.0f - CLAMP((float) hide_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);

  }

 

float Launcher::IconPresentProgress(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int ms = unity::TimeUtil::TimeDelta(&current, &icon_present_time);

  float result = CLAMP((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);

 

    return result;

  else

    return 1.0f - result;

 

float Launcher::IconUrgentProgress(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int urgent_ms = unity::TimeUtil::TimeDelta(&current, &urgent_time);

  float result;

 

  else

    result = CLAMP((float) urgent_ms / (float)(ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);

 

    return result;

  else

    return 1.0f - result;

 

float Launcher::IconDropDimValue(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int dim_ms = unity::TimeUtil::TimeDelta(&current, &dim_time);

  float result = CLAMP((float) dim_ms / (float) ANIM_DURATION, 0.0f, 1.0f);

 

    return 1.0f - result;

  else

    return result;

 

float Launcher::IconDesatValue(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int ms = unity::TimeUtil::TimeDelta(&current, &dim_time);

  float result = CLAMP((float) ms / (float) ANIM_DURATION_SHORT_SHORT, 0.0f, 1.0f);

 

    return 1.0f - result;

  else

    return result;

 

float Launcher::IconShimmerProgress(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int shimmer_ms = unity::TimeUtil::TimeDelta(&current, &shimmer_time);

  return CLAMP((float) shimmer_ms / (float) ANIM_DURATION_LONG, 0.0f, 1.0f);

}

 

float Launcher::IconCenterTransitionProgress(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int save_ms = unity::TimeUtil::TimeDelta(&current, &save_time);

  return CLAMP((float) save_ms / (float) ANIM_DURATION, 0.0f, 1.0f);

}

 

float Launcher::IconUrgentPulseValue(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

    return 1.0f; // we are full on in a normal condition

 

  double urgent_progress = (double) IconUrgentProgress(icon, current);

 

float Launcher::IconPulseOnceValue(AbstractLauncherIcon::Ptr icon, struct timespec const &current) const

{

  int pulse_ms = unity::TimeUtil::TimeDelta(&current, &pulse_time);

  double pulse_progress = (double) CLAMP((float) pulse_ms / (ANIM_DURATION_LONG * PULSE_BLINK_LAMBDA * 2), 0.0f, 1.0f);

 

  if (pulse_progress == 1.0f)

 

  return 0.5f + (float) (std::cos(M_PI * 2.0 * pulse_progress)) * 0.5f;

}

 

float Launcher::IconUrgentWiggleValue(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

    return 0.0f; // we are full on in a normal condition

 

  double urgent_progress = (double) IconUrgentProgress(icon, current);

 

float Launcher::IconStartingBlinkValue(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int starting_ms = unity::TimeUtil::TimeDelta(&current, &starting_time);

  double starting_progress = (double) CLAMP((float) starting_ms / (float)(ANIM_DURATION_LONG * STARTING_BLINK_LAMBDA), 0.0f, 1.0f);

  double val = IsBackLightModeToggles() ? 3.0f : 4.0f;

 

float Launcher::IconStartingPulseValue(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int starting_ms = unity::TimeUtil::TimeDelta(&current, &starting_time);

  double starting_progress = (double) CLAMP((float) starting_ms / (float)(ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2), 0.0f, 1.0f);

 

  {

  }

 

  return 0.5f + (float)(std::cos(M_PI * (float)(MAX_STARTING_BLINKS * 2) * starting_progress)) * 0.5f;

{

  float result = 0.0f;

 

  int running_ms = unity::TimeUtil::TimeDelta(&current, &running_time);

  float running_progress = CLAMP((float) running_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);

 

    running_progress = 1.0f - running_progress;

 

  // After we finish a fade in from running, we can reset the quirk

 

  float backlight_strength;

  if (options()->backlight_mode() == BACKLIGHT_ALWAYS_ON)

        result = backlight_strength; // The blink concept is a failure in this case (it just doesn't work right)

      break;

    case LAUNCH_ANIMATION_PULSE:

 

      result = backlight_strength;

      if (options()->backlight_mode() == BACKLIGHT_ALWAYS_ON)

      break;

  }

 

  {

    if (options()->backlight_mode() == BACKLIGHT_ALWAYS_ON)

      result *= CLAMP(running_progress + IconPulseOnceValue(icon, current), 0.0f, 1.0f);

  }

 

  // urgent serves to bring the total down only

    result *= 0.2f + 0.8f * IconUrgentPulseValue(icon, current);

 

  return result;

 

float Launcher::IconProgressBias(AbstractLauncherIcon::Ptr icon, struct timespec const& current) const

{

  int ms = unity::TimeUtil::TimeDelta(&current, &icon_progress_time);

  float result = CLAMP((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);

 

    return -1.0f + result;

  else

    return result;

  arg.alpha               = 0.2f + 0.8f * desat_value;

  arg.saturation          = desat_value;

  arg.colorify            = nux::color::White;

  arg.draw_edge_only      = IconDrawEdgeOnly(icon);

  arg.active_colored      = false;

  arg.x_rotation          = 0.0f;

  arg.progress_bias       = IconProgressBias(icon, current);

  arg.progress            = CLAMP(icon->GetProgress(), 0.0f, 1.0f);

  arg.draw_shortcut       = _shortcuts_shown && !_hide_machine.GetQuirk(LauncherHideMachine::PLACES_VISIBLE);

 

  // trying to protect against flickering when icon is dragged from dash LP: #863230

  if (arg.alpha < 0.2)

    arg.saturation = 0.0;

  }

 

 

  /* BFB or HUD icons don't need the active arrow if the overaly is opened

   * in another monitor */

  if (arg.active_arrow && !IsOverlayOpen() &&

  {

    arg.active_arrow = false;

  }

    arg.shortcut_label = 0;

 

  // we dont need to show strays

  {

    {

      arg.running_arrow = true;

      arg.window_indicators = 1;

 

  float urgent_progress = IconUrgentProgress(icon, current);

 

    urgent_progress = CLAMP(urgent_progress * 3.0f, 0.0f, 1.0f);  // we want to go 3x faster than the urgent normal cycle

  else

    urgent_progress = CLAMP(urgent_progress * 3.0f - 2.0f, 0.0f, 1.0f);  // we want to go 3x faster than the urgent normal cycle

  arg.glow_intensity = urgent_progress;

 

  {

    arg.z_rotation = IconUrgentWiggleValue(icon, current);

  }

  last_geo = box_geo;

  _enter_y = 0;

 

  if (hover_progress > 0.0f && _launcher_drag_delta != 0)

  {

    float delta_y = _launcher_drag_delta;

 

    if (_launcher_drag_delta > _launcher_drag_delta_max)

      delta_y = _launcher_drag_delta_max + DragLimiter(delta_y - _launcher_drag_delta_max);

    else if (_launcher_drag_delta < _launcher_drag_delta_min)

{

  for (auto icon : *_model)

  {

    {

    }

 

    icon->HideTooltip();

{

  for (auto icon : *_model)

  {

  }

}

 

  return _dash_is_open || _hud_is_open;

}

 

    return;

 

  {

    _hide_machine.SetQuirk(LauncherHideMachine::MOUSE_MOVE_POST_REVEAL, false);

    _hide_machine.SetQuirk(LauncherHideMachine::MT_DRAG_OUT, false);

 

  TimeUtil::SetTimeStruct(&_times[TIME_AUTOHIDE], &_times[TIME_AUTOHIDE], ANIM_DURATION_SHORT);

 

 

    DndReset();

 

  EnsureAnimation();

  hidden_changed.emit();

}

 

int Launcher::GetMouseX() const

{

  return _mouse_position.x;

 

void Launcher::UpdateOptions(Options::Ptr options)

{

  SetHideMode(options->hide_mode);

 

  ConfigureBarrier();

  EnsureAnimation();

  }

  else

  {

    _parent->EnableInputWindow(true, launcher::window_title, false, false);

 

    {

      sources_.AddTimeout(1000, sigc::mem_fun(this, &Launcher::StrutHack), STRUT_HACK_TIMEOUT);

    }

 

    _parent->InputWindowEnableStruts(true);

  }

}

 

{

  return _active_tooltip;

}

 

void Launcher::SetActionState(LauncherActionState actionstate)

{

  if (_launcher_action_state == actionstate)

  int natural_y = 0;

  for (auto icon : *_model)

  {

      continue;

 

    if (icon == selection)

 

  // FIXME: nux doesn't give nux::GetEventButton (button_flags) there, relying

  // on an internal Launcher property then

  {

    SetActionState(ACTION_DRAG_ICON);

    StartIconDrag(drag_icon);

  {

    AbstractLauncherIcon::Ptr hovered_icon = MouseIconIntersection(_mouse_position.x, _mouse_position.y);

 

    {

 

      launcher_removerequest.emit(_drag_icon);

 

          LauncherModel::iterator prevIt = _model->end();

          for (it = _model->begin(); it != _model->end(); ++it)

          {

              continue;

 

            if ((*it) == hovered_icon) {

          }

        }

      }

    }

  }

}

void Launcher::RecvMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)

{

  SetStateMouseOverLauncher(false);

  EventLogic();

  EnsureAnimation();

}

  SetMousePosition(x, y);

 

  if (!_hidden)

 

  // Every time the mouse moves, we check if it is inside an icon...

  EventLogic();

  {

    launcher_icon->mouse_enter.emit(monitor);

    _icon_under_mouse = launcher_icon;

  }

}

 

  AbstractLauncherIcon::Ptr launcher_icon;

  launcher_icon = MouseIconIntersection(_mouse_position.x, _mouse_position.y);

 

  if (launcher_icon)

  {

    _icon_mouse_down = launcher_icon;

 

  for (it = _model->begin(); it != _model->end(); ++it)

  {

      continue;

 

    nux::Point2 screen_coord [4];

    {

      if (it->ShouldHighlightOnDrag(_dnd_data))

      {

      }

      else

      {

      }

    }

  }

 

  for (auto it : *_model)

  {

  }

 

  DndHoveredIconReset();

 

  if (_steal_drag && _dnd_hovered_icon)

  {

    _dnd_hovered_icon->remove.emit(_dnd_hovered_icon);

  }

 

      for (auto it : *_model)

      {

        if (it->ShouldHighlightOnDrag(_dnd_data))

        else

      }

    }

  }

  bool hovered_icon_is_appropriate = false;

  if (hovered_icon)

  {

      _steal_drag = false;

 

      hovered_icon_is_appropriate = true;

  }

 

        }

        else

        {

          _dnd_hovered_icon->remove.emit(_dnd_hovered_icon);

          _dnd_hovered_icon = nullptr;

        }