~rsalveti/notify-osd/phablet-bump-epoch

////////////////////////////////////////////////////////////////////////////////
//3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789
//      10        20        30        40        50        60        70        80
//
// notify-osd
//
// notifications-view.cpp - implements all the nux-based rendering of a bubble
//
// Copyright 2012 Canonical Ltd.
//
// Authors:
//    Mirco "MacSlow" Mueller <mirco.mueller@canonical.com>
//
// self 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.
//
// self program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranties of
// MERCHANTABILITY, SATISFACTORY QUALITY, 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 self program.  If not, see <http://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////////////

#include <Nux/Nux.h>
#include <Nux/BaseWindow.h>
#include <Nux/HLayout.h>
#include <Nux/Layout.h>
#include <Nux/WindowCompositor.h>

#include <Nux/CairoWrapper.h>
#include <NuxGraphics/ImageSurface.h>
#include <NuxCore/Logger.h>

#include <NuxGraphics/GLThread.h>
#include <NuxGraphics/RenderingPipe.h>
#include <NuxGraphics/GraphicsDisplay.h>

#include <glib.h>

#include <hybris/ubuntu/ui/ubuntu_ui_session_service.h>

#include "notifications-view.h"

#define FPS 60.0
#define FADE_IN_DURATION  0.2
#define FADE_OUT_DURATION 0.1

void
NotificationsView::DrawCallback (nux::Geometry const& geom, cairo_t* cr)
{
  if (cairo_status (cr) != CAIRO_STATUS_SUCCESS)
    return;

  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
  cairo_paint (cr);
  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
  cairo_scale (cr, 1.0, 1.0);

  if (_source_surface)
  {
    cairo_set_source_surface (cr,
                              _source_surface,
                              1 * _units->getGU (),
                              4 * _units->getGU ());
    cairo_paint (cr);
  }
}

NUX_IMPLEMENT_OBJECT_TYPE(NotificationsView);

NotificationsView::NotificationsView(NUX_FILE_LINE_DECL)
  : View(NUX_FILE_LINE_PARAM)
{
  _dirty             = false;
  _source_surface    = NULL;
  _visible           = false;
  _alpha             = 1.0;
  height             = 0;
  _in_hiding         = false;
  _ignore_geo.x      = 0;
  _ignore_geo.y      = 0;
  _ignore_geo.width  = 0;
  _ignore_geo.height = 0;
  _accept_geo.x      = 0;
  _accept_geo.y      = 0;
  _accept_geo.width  = 0;
  _accept_geo.height = 0;
  _units             = Units::getInstance ();

  Units* units = Units::getInstance ();
  int gu = units->getGU ();
  nux::Geometry const& geo = {0, 0, nux::GetWindowThread()->GetGraphicsDisplay().GetScreenWidth(), 30 * gu};
  SetGeometry (geo);

  _canvas.reset (new nux::CairoWrapper (geo, sigc::mem_fun (this, &NotificationsView::DrawCallback)));
}

NotificationsView::~NotificationsView()
{
}

gboolean
NotificationsView::_fade_in_cb (gpointer data)
{
  NotificationsView* self = (NotificationsView*) data;

  self->SetOpacity (self->GetOpacity () + 1.0/ (1000.0 / FPS));

  if (self->GetOpacity () < 1.0)
    return true;
  else
    return false;
}

void
NotificationsView::EmitSignal()
{
    FadedOut.emit();
}

void
NotificationsView::SetIgnoreGeometry (nux::Geometry const& geo)
{
  _ignore_geo.x      = geo.x;
  _ignore_geo.y      = geo.y;
  _ignore_geo.width  = geo.width;
  _ignore_geo.height = geo.height;
}

void
NotificationsView::SetAcceptGeometry (nux::Geometry const& geo)
{
  _accept_geo.x      = geo.x;
  _accept_geo.y      = geo.y;
  _accept_geo.width  = geo.width;
  _accept_geo.height = geo.height;
}

bool
NotificationsView::IsIgnoreHit (gint x, gint y)
{
  nux::Point point = nux::Point (x,y);

  if (_ignore_geo.IsInside(point))
    return true;
  else
    return false;
}

bool
NotificationsView::IsAcceptHit (gint x, gint y)
{
  nux::Point point = nux::Point (x,y);

  if (_accept_geo.IsInside(point))
    return true;
  else
    return false;
}

gboolean
NotificationsView::_fade_out_cb (gpointer data)
{
  NotificationsView* self = (NotificationsView*) data;

  self->SetOpacity (self->GetOpacity () - 1.0 / (1000.0 / FPS));

  if (self->GetOpacity () > 0.0)
    return true;
  else
  {
    self->EmitSignal();
    self->SetVisible (false);
    nux::GetWindowThread()->GetGraphicsDisplay().Hide();
    ubuntu_ui_report_notification_invisible ();
    return false;
  }
}

void
NotificationsView::_fade_in ()
{
  _alpha = 0.0;
  _fade_in_id = g_timeout_add (1000.0 / FPS,
                               &NotificationsView::_fade_in_cb,
                               this);
}

void
NotificationsView::_fade_out ()
{
  _in_hiding = true;
  _alpha = 1.0;
  _fade_out_id = g_timeout_add (1000.0 / FPS,
                               &NotificationsView::_fade_out_cb,
                               this);
}

void
NotificationsView::Show ()
{
  _in_hiding = false;
  _visible = true;
  nux::GetWindowThread()->GetGraphicsDisplay().Show();
  ubuntu_ui_report_notification_visible ();
  _fade_in ();
}

void
NotificationsView::Hide ()
{
  if (!_in_hiding)
    _fade_out ();
}

void
NotificationsView::SetOpacity (double alpha)
{
  _alpha = alpha;
  QueueDraw ();
}

double
NotificationsView::GetOpacity ()
{
  return _alpha;
}

void
NotificationsView::SetVisible (bool visible)
{
  _visible = visible;
  QueueDraw ();
}

bool
NotificationsView::GetVisible ()
{
  return _visible;
}

void
NotificationsView::SetSourceSurface (cairo_surface_t* surface)
{
  if (surface)
  {
    _source_surface = surface;
    height = cairo_image_surface_get_height (surface);
    _dirty = true;
  }
}

void
NotificationsView::SetAppSwitchName(gchar* name)
{
  if (this->_app_name) { g_free(this->_app_name); }
  this->_app_name = g_strdup(name);
}

gchar*
NotificationsView::GetAppSwitchName()
{
  return this->_app_name;
}

void
NotificationsView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
  nux::Geometry const& geo = GetGeometry();

  GfxContext.PushClippingRectangle(geo);

  GfxContext.QRP_Color (geo.x,
                        geo.y,
                        geo.width,
                        geo.height,
                        nux::color::Transparent);

  if (_dirty)
  {
    _canvas->Recreate ();
    _dirty = false;
  }

  if (_visible)
  {
    _canvas->Invalidate (geo);
    _bubble_tex = _canvas->GetTexture();        
 
    nux::TexCoordXForm texxform;

    GfxContext.QRP_1Tex(geo.x,
                        geo.y,
                        _bubble_tex->GetWidth(), 
                        _bubble_tex->GetHeight(),
                        _bubble_tex->GetDeviceTexture(),
                        texxform,
                        nux::Color (_alpha, _alpha, _alpha, _alpha));
  }

  GfxContext.PopClippingRectangle();
}

void
NotificationsView::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
{
}