~brandontschaefer/unity/alt-grave-ordering-fix

// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
/*
 * Copyright (C) 2012 Canonical Ltd
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authored by: Jason Smith <jason.smith@canonical.com>
 */

#include "CoverflowResultView.h"
#include <UnityCore/Variant.h>
#include "unity-shared/IconLoader.h"
#include "unity-shared/IconTexture.h"
#include "unity-shared/DashStyle.h"
#include "unity-shared/UBusMessages.h"
#include "unity-shared/UBusWrapper.h"
#include <Nux/Nux.h>
#include <Nux/View.h>
#include <Nux/Coverflow.h>
#include <Nux/CoverflowModel.h>
#include <Nux/CoverflowItem.h>
#include <Nux/HLayout.h>


namespace unity
{
namespace dash
{

NUX_IMPLEMENT_OBJECT_TYPE(CoverflowResultView);

class CoverflowResultItem : public nux::CoverflowItem
{
public:
  CoverflowResultItem(Result& result, CoverflowResultView *parent, nux::CoverflowModel::Ptr model);
  ~CoverflowResultItem();

  nux::ObjectPtr<nux::BaseTexture> GetTexture() const;
  virtual void Activate(int button);

  int Index();
  std::string Uri();

  Result result_;
  CoverflowResultView* parent_;
  nux::CoverflowModel::Ptr model_;
  IconTexture *icon_texture_;
  UBusManager ubus_;
};

class CoverflowResultView::Impl : public sigc::trackable
{
public:
  Impl(CoverflowResultView *parent);
  ~Impl();

  void ComputeFlatIcons();
  int GetIndexForUri(std::string uri);
  std::string GetUriForIndex(int index);

  CoverflowResultView *parent_;
  nux::Coverflow *coverflow_;
  nux::HLayout* layout_;
  UBusManager ubus_;
};

CoverflowResultItem::CoverflowResultItem(Result& result, CoverflowResultView *parent, nux::CoverflowModel::Ptr model)
  : CoverflowItem(result.name())
  , result_(result)
  , parent_(parent)
  , model_(model)
{
  Style& style = Style::Instance();
  std::string const& icon_hint = result.icon_hint;
  std::string icon_name = !icon_hint.empty() ? icon_hint : ". GThemedIcon text-x-preview";
  static const int element_size = style.GetTileHeight();
  
  icon_texture_ = new IconTexture(icon_name.c_str(), element_size, true);
  icon_texture_->SinkReference();
  icon_texture_->LoadIcon();
  
  icon_texture_->texture_updated.connect([&] (nux::BaseTexture *texture)
  {
    if (parent_)
      parent_->NeedRedraw();
  });
}

CoverflowResultItem::~CoverflowResultItem()
{
  icon_texture_->UnReference();
}

std::string CoverflowResultItem::Uri()
{
  return result_.uri();
}

int CoverflowResultItem::Index()
{
  int i = 0;
  for (auto item : model_->Items())
  {
    if (this == item.GetPointer())
      return i;
    i++;
  }
  return -1;
}

nux::ObjectPtr<nux::BaseTexture> CoverflowResultItem::GetTexture() const
{
  return nux::ObjectPtr<nux::BaseTexture>(icon_texture_->texture());
}

void CoverflowResultItem::Activate(int button)
{
  int index = Index();
  int size = model_->Items().size();

  glib::Variant data(g_variant_new("(iiii)", 0, 0, index, size - index));

  //Left and right click take you to previews.
  if (button == 1 || button == 3)
    parent_->Activate(result_.uri, index, ResultView::ActivateType::PREVIEW);
  //Scroll click opens up music player.
  else if (button == 2)
    parent_->Activate(result_.uri, index, ResultView::ActivateType::DIRECT);

}

CoverflowResultView::Impl::Impl(CoverflowResultView *parent)
  : parent_(parent)
  , coverflow_(new nux::Coverflow)
  , layout_(new nux::HLayout())
{
  layout_->AddView(coverflow_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
  parent_->SetLayout(layout_);

  coverflow_->SetCameraDistance(1.44);
  coverflow_->fov = 60;
  coverflow_->folding_angle = 45;
  coverflow_->true_perspective = false;
  coverflow_->camera_motion_drift_enabled = false;
  coverflow_->show_reflection = true;
  coverflow_->folding_depth = .25;
  coverflow_->reflection_strength = .2f;
  //coverflow_->folding_rate = 3.5;
  coverflow_->kinetic_scroll_rate = 0.05f;
  coverflow_->mouse_drag_rate = 1.5f;
  coverflow_->pinching = 0.2f;
  coverflow_->y_offset = 0.15f;
  coverflow_->reflection_size = .5f;

  ubus_.RegisterInterest(UBUS_DASH_PREVIEW_NAVIGATION_REQUEST, [&] (GVariant* data) {
    int nav_mode = 0;
    glib::String uri;
    glib::String proposed_unique_id;

    g_variant_get(data, "(iss)", &nav_mode, &uri, &proposed_unique_id);
   
    if (proposed_unique_id.Str() != parent_->unique_id())
      return;

    unsigned num_results = coverflow_->model()->Items().size();
    int current_index = GetIndexForUri(uri);
    if (nav_mode == -1) // left
    {
      current_index--;  
    }
    else if (nav_mode == 1) // right
    {
      current_index++;
    }

    if (current_index < 0 || static_cast<unsigned int>(current_index) >= num_results)
    {
      return;
    }
    
    if (nav_mode)
    {
      std::string uri = GetUriForIndex(current_index);
      parent_->Activate(uri, current_index, ActivateType::PREVIEW);
    }
  });
}

CoverflowResultView::Impl::~Impl()
{
  
}

int CoverflowResultView::Impl::GetIndexForUri(std::string uri)
{
  int i = 0;
  for (auto item : coverflow_->model()->Items())
  {
    if (uri == static_cast<CoverflowResultItem*>(item.GetPointer())->Uri())
      return i;
    i++;
  }
  return -1;
}

std::string CoverflowResultView::Impl::GetUriForIndex(int index)
{
  return static_cast<CoverflowResultItem*>(coverflow_->model()->Items()[index].GetPointer())->Uri();
}

CoverflowResultView::CoverflowResultView(NUX_FILE_LINE_DECL)
  : ResultView(NUX_FILE_LINE_PARAM)
  , pimpl(new CoverflowResultView::Impl(this))
{
  Style& style = Style::Instance();
  SetMinimumHeight(style.GetTileHeight());
}

CoverflowResultView::~CoverflowResultView()
{
  
}

void CoverflowResultView::SetModelRenderer(ResultRenderer* renderer)
{
  return; // abstracting breaks down here. Needs to be reworked.  
}

void CoverflowResultView::AddResult(Result& result)
{
  nux::CoverflowItem::Ptr result_item(new CoverflowResultItem(result, this, pimpl->coverflow_->model()));
  pimpl->coverflow_->model()->AddItem(result_item);
}

void CoverflowResultView::RemoveResult(Result& result)
{
  // Ineffecient, API needs to be improved in Coverflow?
  for (nux::CoverflowItem::Ptr item : pimpl->coverflow_->model()->Items())
  {
    CoverflowResultItem *result_item = static_cast<CoverflowResultItem*>(item.GetPointer());

    if (result_item->result_.uri == result.uri) // maybe?
    {
      pimpl->coverflow_->model()->RemoveItem(item);
      break;
    }
  }  
}

void CoverflowResultView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
  // do nothing here
}

void CoverflowResultView::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
{
  nux::Geometry base = GetGeometry();
  GfxContext.PushClippingRectangle(base);

  if (RedirectedAncestor())
  {
    // This is necessary when doing redirected rendering. Clean the area below this view.
    unsigned int current_alpha_blend;
    unsigned int current_src_blend_factor;
    unsigned int current_dest_blend_factor;
    GfxContext.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);

    GfxContext.GetRenderStates().SetBlend(false);
    GfxContext.QRP_Color(GetX(), GetY(), GetWidth(), GetHeight(), nux::Color(0.0f, 0.0f, 0.0f, 0.0f));

    GfxContext.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
  }
  
  if (GetCompositionLayout())
  {
    nux::Geometry geo = GetCompositionLayout()->GetGeometry();
    GetCompositionLayout()->ProcessDraw(GfxContext, force_draw);
  }

  GfxContext.PopClippingRectangle();
}

void CoverflowResultView::Impl::ComputeFlatIcons()
{
  float width = coverflow_->ViewportWidthAtDepth(0);
  width /= coverflow_->space_between_icons();

  int flat_icons = static_cast<int>(std::floor((width - 2.0f) / 2.0f));
  coverflow_->flat_icons = flat_icons;
}

long CoverflowResultView::ComputeContentSize()
{
  pimpl->ComputeFlatIcons();
  long ret = ResultView::ComputeContentSize();
  return ret;
}


void CoverflowResultView::Activate(std::string const& uri, int index, ResultView::ActivateType type)
{
  unsigned num_results = pimpl->coverflow_->model()->Items().size();

  int left_results = index;
  int right_results = num_results ? (num_results - index) - 1 : 0;
  int row_y = GetRootGeometry().y;
  int row_height = renderer_->height;

  glib::Variant data(g_variant_new("(iiii)", row_y, row_height, left_results, right_results));
  UriActivated.emit(uri, type, data);
}


}
}