~iaz/unity/menubar-lp789979

// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
/*
 * Copyright (C) 2010 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: Jay Taoko <jay.taoko@canonical.com>
 * Authored by: Mirco Müller <mirco.mueller@canonical.com
 */

#include <gdk/gdk.h>
#include <gtk/gtk.h>

#include <Nux/Nux.h>
#include <Nux/Layout.h>
#include <Nux/HLayout.h>
#include <Nux/VLayout.h>
#include <Nux/Validator.h>

#include "CairoTexture.h"
#include "StaticCairoText.h"

using unity::texture_from_cairo_graphics;

// TODO: Tim Penhey 2011-05-16
// We shouldn't be pushing stuff into the nux namespace from the unity
// codebase, that is just rude.
namespace nux
{
  NUX_IMPLEMENT_OBJECT_TYPE (StaticCairoText);

StaticCairoText::StaticCairoText(std::string const& text,
                                 NUX_FILE_LINE_DECL) :
  View(NUX_FILE_LINE_PARAM),
  _cached_base_width(-1),
  _cached_base_height(-1),
  _baseline(0),
  _fontstring(NULL),
  _cairoGraphics(NULL),
  _texture2D(NULL),
  _lines(-2),
  _actual_lines(0)
{
  _textColor  = Color(1.0f, 1.0f, 1.0f, 1.0f);
  _text       = text;
  _texture2D  = 0;
  _need_new_extent_cache = true;
  _pre_layout_width = 0;
  _pre_layout_height = 0;

  SetMinimumSize(1, 1);
  _ellipsize = NUX_ELLIPSIZE_END;
  _align = NUX_ALIGN_LEFT;
  _valign = NUX_ALIGN_TOP;
  _fontstring = NULL;

  _accept_key_nav_focus = false;
  SetAcceptKeyNavFocusOnMouseDown(false);
}

StaticCairoText::~StaticCairoText()
{
  GtkSettings* settings = gtk_settings_get_default();  // not ref'ed
  g_signal_handlers_disconnect_by_func(settings,
                                       (void*) &StaticCairoText::OnFontChanged,
                                       this);
  if (_texture2D)
    _texture2D->UnReference();

  if (_fontstring)
    g_free(_fontstring);
}

void
StaticCairoText::SetTextEllipsize(EllipsizeState state)
{
  _ellipsize = state;
  NeedRedraw();
}

void
StaticCairoText::SetTextAlignment(AlignState state)
{
  _align = state;
  NeedRedraw();
}

void
StaticCairoText::SetTextVerticalAlignment(AlignState state)
{
  _valign = state;
  QueueDraw();
}

void
StaticCairoText::SetLines(int lines)
{
  _lines = lines;
  UpdateTexture();
  QueueDraw();
}

void StaticCairoText::PreLayoutManagement()
{
  int textWidth  = 0;
  int textHeight = 0;

  textWidth = _cached_extent_width;
  textHeight = _cached_extent_height;

  _pre_layout_width = GetBaseWidth();
  _pre_layout_height = GetBaseHeight();

  SetBaseSize(textWidth, textHeight);

  if ((_texture2D == 0))
  {
    GtkSettings* settings = gtk_settings_get_default();  // not ref'ed
    g_signal_connect(settings, "notify::gtk-font-name",
                     (GCallback) &StaticCairoText::OnFontChanged, this);
    g_signal_connect(settings, "notify::gtk-xft-dpi",
                     (GCallback) &StaticCairoText::OnFontChanged, this);

    UpdateTexture();
  }

  View::PreLayoutManagement();
}

long StaticCairoText::PostLayoutManagement(long layoutResult)
{
//  long result = View::PostLayoutManagement (layoutResult);

  long result = 0;

  int w = GetBaseWidth();
  int h = GetBaseHeight();

  if (_pre_layout_width < w)
    result |= eLargerWidth;
  else if (_pre_layout_width > w)
    result |= eSmallerWidth;
  else
    result |= eCompliantWidth;

  if (_pre_layout_height < h)
    result |= eLargerHeight;
  else if (_pre_layout_height > h)
    result |= eSmallerHeight;
  else
    result |= eCompliantHeight;

  return result;
}

void
StaticCairoText::Draw(GraphicsEngine& gfxContext,
                      bool             forceDraw)
{
  Geometry base = GetGeometry();

  if (!_texture2D || _cached_base_width != base.width || _cached_base_height != base.height)
  {
    _cached_base_width = base.width;
    _cached_base_height = base.height;
    UpdateTexture();
  }

  gfxContext.PushClippingRectangle(base);

  gPainter.PaintBackground(gfxContext, base);

  TexCoordXForm texxform;
  texxform.SetWrap(TEXWRAP_REPEAT, TEXWRAP_REPEAT);
  texxform.SetTexCoordType(TexCoordXForm::OFFSET_COORD);

  unsigned int alpha = 0, src = 0, dest = 0;

  gfxContext.GetRenderStates().GetBlend(alpha, src, dest);
  gfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

  Color col = color::Black;
  col.alpha = 0;
  gfxContext.QRP_Color(base.x,
                       base.y,
                       base.width,
                       base.height,
                       col);

  gfxContext.QRP_1Tex(base.x,
                      base.y + ((base.height - _cached_extent_height) / 2),
                      base.width,
                      base.height,
                      _texture2D->GetDeviceTexture(),
                      texxform,
                      _textColor);

  gfxContext.GetRenderStates().SetBlend(alpha, src, dest);

  gfxContext.PopClippingRectangle();
}

void
StaticCairoText::DrawContent(GraphicsEngine& gfxContext,
                             bool             forceDraw)
{
  // intentionally left empty
}

void
StaticCairoText::PostDraw(GraphicsEngine& gfxContext,
                          bool             forceDraw)
{
  // intentionally left empty
}

void
StaticCairoText::SetText(std::string const& text)
{
  if (_text != text)
  {
    _text = text;
    _need_new_extent_cache = true;
    int width = 0;
    int height = 0;
    GetTextExtents(width, height);
    UpdateTexture();
    sigTextChanged.emit(this);
  }
}

std::string
StaticCairoText::GetText() const
{
  return _text;
}

nux::Color StaticCairoText::GetTextColor() const
{
  return _textColor;
}


void
StaticCairoText::SetTextColor(Color const& textColor)
{
  if (_textColor != textColor)
  {
    _textColor = textColor;
    UpdateTexture();
    QueueDraw();

    sigTextColorChanged.emit(this);
  }
}

void
StaticCairoText::SetFont(const char* fontstring)
{
  g_free(_fontstring);
  _fontstring = g_strdup(fontstring);
  _need_new_extent_cache = true;
  int width = 0;
  int height = 0;
  GetTextExtents(width, height);
  SetMinimumHeight(height);
  NeedRedraw();
  sigFontChanged.emit(this);
}

int
StaticCairoText::GetLineCount()
{
  return _actual_lines;
}

int StaticCairoText::GetBaseline() const
{
  return _baseline;
}

void StaticCairoText::GetTextExtents(int& width, int& height)
{
  GtkSettings* settings = gtk_settings_get_default();  // not ref'ed
  gchar*       fontName = NULL;

  if (_fontstring == NULL)
  {
    g_object_get(settings, "gtk-font-name", &fontName, NULL);
  }
  else
  {
    fontName = g_strdup(_fontstring);
  }

  GetTextExtents(fontName, width, height);
  g_free(fontName);
}

void StaticCairoText::GetTextExtents(const TCHAR* font,
                                     int&  width,
                                     int&  height)
{
  cairo_surface_t*      surface  = NULL;
  cairo_t*              cr       = NULL;
  PangoLayout*          layout   = NULL;
  PangoFontDescription* desc     = NULL;
  PangoContext*         pangoCtx = NULL;
  PangoRectangle        inkRect  = {0, 0, 0, 0};
  PangoRectangle        logRect  = {0, 0, 0, 0};
  int                   dpi      = 0;
  GdkScreen*            screen   = gdk_screen_get_default();    // is not ref'ed
  GtkSettings*          settings = gtk_settings_get_default();  // is not ref'ed

  // sanity check
  if (!font)
    return;

  if (!_need_new_extent_cache)
  {
    width = _cached_extent_width;
    height = _cached_extent_height;
    return;
  }

  int maxwidth = GetMaximumWidth();

  surface = cairo_image_surface_create(CAIRO_FORMAT_A1, 1, 1);
  cr = cairo_create(surface);
  cairo_set_font_options(cr, gdk_screen_get_font_options(screen));

  layout = pango_cairo_create_layout(cr);
  desc = pango_font_description_from_string(font);
  pango_layout_set_font_description(layout, desc);
  pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);

  if (_ellipsize == NUX_ELLIPSIZE_START)
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_START);
  else if (_ellipsize == NUX_ELLIPSIZE_MIDDLE)
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_MIDDLE);
  else if (_ellipsize == NUX_ELLIPSIZE_END)
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
  else
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);

  if (_align == NUX_ALIGN_LEFT)
    pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
  else if (_align == NUX_ALIGN_CENTRE)
    pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
  else
    pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);

  pango_layout_set_markup(layout, _text.c_str(), -1);
  pango_layout_set_height(layout, _lines);
  pango_layout_set_width(layout, maxwidth * PANGO_SCALE);

  pangoCtx = pango_layout_get_context(layout);  // is not ref'ed
  pango_cairo_context_set_font_options(pangoCtx,
                                       gdk_screen_get_font_options(screen));
  g_object_get(settings, "gtk-xft-dpi", &dpi, NULL);
  if (dpi == -1)
  {
    // use some default DPI-value
    pango_cairo_context_set_resolution(pangoCtx, 96.0f);
  }
  else
  {
    pango_cairo_context_set_resolution(pangoCtx,
                                       (float) dpi / (float) PANGO_SCALE);
  }
  pango_layout_context_changed(layout);
  pango_layout_get_extents(layout, &inkRect, &logRect);

  // logRect has some issues using italic style
  if (inkRect.x + inkRect.width > logRect.x + logRect.width)
    width = std::ceil(static_cast<float>(inkRect.x + inkRect.width - logRect.x) / PANGO_SCALE);
  else
    width  = std::ceil(static_cast<float>(logRect.width) / PANGO_SCALE);

  height = std::ceil(static_cast<float>(logRect.height) / PANGO_SCALE);
  _cached_extent_height = height;
  _cached_extent_width = width;
  _baseline = pango_layout_get_baseline(layout) / PANGO_SCALE;

  // clean up
  pango_font_description_free(desc);
  g_object_unref(layout);
  cairo_destroy(cr);
  cairo_surface_destroy(surface);
}

void StaticCairoText::DrawText(cairo_t*   cr,
                               int        width,
                               int        height,
                               Color color)
{
  PangoLayout*          layout     = NULL;
  PangoFontDescription* desc       = NULL;
  PangoContext*         pangoCtx   = NULL;
  int                   dpi        = 0;
  GdkScreen*            screen     = gdk_screen_get_default();    // not ref'ed
  GtkSettings*          settings   = gtk_settings_get_default();  // not ref'ed
  gchar*                fontName   = NULL;

  if (_fontstring == NULL)
    g_object_get(settings, "gtk-font-name", &fontName, NULL);
  else
    fontName = g_strdup(_fontstring);

  cairo_set_font_options(cr, gdk_screen_get_font_options(screen));
  layout = pango_cairo_create_layout(cr);
  desc = pango_font_description_from_string(fontName);

  pango_layout_set_font_description(layout, desc);
  pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);

  if (_ellipsize == NUX_ELLIPSIZE_START)
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_START);
  else if (_ellipsize == NUX_ELLIPSIZE_MIDDLE)
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_MIDDLE);
  else if (_ellipsize == NUX_ELLIPSIZE_END)
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
  else
    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);

  if (_align == NUX_ALIGN_LEFT)
    pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
  else if (_align == NUX_ALIGN_CENTRE)
    pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
  else
    pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);

  pango_layout_set_markup(layout, _text.c_str(), -1);
  pango_layout_set_width(layout, width * PANGO_SCALE);
  pango_layout_set_height(layout, height * PANGO_SCALE);

  pango_layout_set_height(layout, _lines);
  pangoCtx = pango_layout_get_context(layout);  // is not ref'ed
  pango_cairo_context_set_font_options(pangoCtx,
                                       gdk_screen_get_font_options(screen));
  g_object_get(settings, "gtk-xft-dpi", &dpi, NULL);
  if (dpi == -1)
  {
    // use some default DPI-value
    pango_cairo_context_set_resolution(pangoCtx, 96.0f);
  }
  else
  {
    pango_cairo_context_set_resolution(pangoCtx,
                                       (float) dpi / (float) PANGO_SCALE);
  }

  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
  cairo_paint(cr);

  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
  cairo_set_source_rgba(cr, color.red, color.green, color.blue, color.alpha);

  pango_layout_context_changed(layout);

  cairo_move_to(cr, 0.0f, 0.0f);
  pango_cairo_show_layout(cr, layout);

  _actual_lines = pango_layout_get_line_count(layout);

  // clean up
  pango_font_description_free(desc);
  g_object_unref(layout);
  g_free(fontName);
}

void StaticCairoText::UpdateTexture()
{
  int width = 0;
  int height = 0;
  GetTextExtents(width, height);
  SetBaseSize(width, height);

  _cairoGraphics = new CairoGraphics(CAIRO_FORMAT_ARGB32,
                                     GetBaseWidth(),
                                     GetBaseHeight());
  cairo_t* cr = cairo_reference(_cairoGraphics->GetContext());

  DrawText(cr, GetBaseWidth(), GetBaseHeight(), _textColor);

  cairo_destroy(cr);

  // NTexture2D is the high level representation of an image that is backed by
  // an actual opengl texture.

  if (_texture2D)
  {
    _texture2D->UnReference();
  }

  _texture2D = texture_from_cairo_graphics(*_cairoGraphics);

  cairo_destroy(cr);

  delete _cairoGraphics;
}

void StaticCairoText::OnFontChanged(GObject* gobject, GParamSpec* pspec,
                                    gpointer data)
{
  StaticCairoText* self = (StaticCairoText*) data;
  self->_need_new_extent_cache = true;
  int width = 0;
  int height = 0;
  self->GetTextExtents(width, height);
  self->UpdateTexture();
  self->sigFontChanged.emit(self);
}

//
// Key navigation
//

void
StaticCairoText::SetAcceptKeyNavFocus(bool accept)
{
  _accept_key_nav_focus = accept;
}

bool
StaticCairoText::AcceptKeyNavFocus()
{
  return _accept_key_nav_focus;
}

}