/*

Copyright (C) 2011-2014 Michael Goffioul

This file is part of Octave.

Octave is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.

Octave 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 Octave; see the file COPYING.  If not, see
<http://www.gnu.org/licenses/>.

*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <QEvent>
#include <QFrame>
#include <QLabel>
#include <QMouseEvent>
#include <QTimer>

#include "Canvas.h"
#include "Container.h"
#include "ContextMenu.h"
#include "Panel.h"
#include "QtHandlesUtils.h"

namespace QtHandles
{

static int frameStyleFromProperties (const uipanel::properties& pp)
{
  if (pp.bordertype_is ("none"))
    return QFrame::NoFrame;
  else if (pp.bordertype_is ("etchedin"))
    return (QFrame::Box | QFrame::Sunken);
  else if (pp.bordertype_is ("etchedout"))
    return (QFrame::Box | QFrame::Raised);
  else if (pp.bordertype_is ("beveledin"))
    return (QFrame::Panel | QFrame::Sunken);
  else if (pp.bordertype_is ("beveledout"))
    return (QFrame::Panel | QFrame::Raised);
  else
    return (QFrame::Panel | QFrame::Plain);
}

static void setupPalette (const uipanel::properties& pp, QPalette& p)
{
  p.setColor (QPalette::Window,
	      Utils::fromRgb (pp.get_backgroundcolor_rgb ()));
  p.setColor (QPalette::WindowText,
	      Utils::fromRgb (pp.get_foregroundcolor_rgb ()));
  p.setColor (QPalette::Light,
	      Utils::fromRgb (pp.get_highlightcolor_rgb ()));
  p.setColor (QPalette::Dark,
	      Utils::fromRgb (pp.get_shadowcolor_rgb ()));
}

static int borderWidthFromProperties (const uipanel::properties& pp)
{
  int bw = 0;

  if (! pp.bordertype_is ("none"))
    {
      bw = xround (pp.get_borderwidth ());
      if (pp.bordertype_is ("etchedin") || pp.bordertype_is ("etchedout"))
	bw *= 2;
    }

  return bw;
}

Panel* Panel::create (const graphics_object& go)
{
  Object* parent = Object::parentObject (go);

  if (parent)
    {
      Container* container = parent->innerContainer ();

      if (container)
	return new Panel (go, new QFrame (container));
    }

  return 0;
}

Panel::Panel (const graphics_object& go, QFrame* frame)
    : Object (go, frame), m_container (0), m_title (0), m_blockUpdates (false)
{
  uipanel::properties& pp = properties<uipanel> ();

  frame->setObjectName ("UIPanel");
  frame->setAutoFillBackground (true);
  Matrix bb = pp.get_boundingbox (false);
  frame->setGeometry (xround (bb(0)), xround (bb(1)),
		      xround (bb(2)), xround (bb(3)));
  frame->setFrameStyle (frameStyleFromProperties (pp));
  frame->setLineWidth (xround (pp.get_borderwidth ()));
  QPalette pal = frame->palette ();
  setupPalette (pp, pal);
  frame->setPalette (pal);

  m_container = new Container (frame);
  m_container->canvas (m_handle);

  if (frame->hasMouseTracking ())
    {
      foreach (QWidget* w, frame->findChildren<QWidget*> ())
        { w->setMouseTracking (true); }
    }

  QString title = Utils::fromStdString (pp.get_title ());
  if (! title.isEmpty ())
    {
      m_title = new QLabel (title, frame);
      m_title->setAutoFillBackground (true);
      m_title->setContentsMargins (4, 0, 4, 0);
      m_title->setPalette (pal);
      m_title->setFont (Utils::computeFont<uipanel> (pp, bb(3)));
    }

  frame->installEventFilter (this);
  m_container->installEventFilter (this);

  if (pp.is_visible ())
    QTimer::singleShot (0, frame, SLOT (show (void)));
  else
    frame->hide ();
}

Panel::~Panel (void)
{
}

bool Panel::eventFilter (QObject* watched, QEvent* ev)
{
  if (! m_blockUpdates)
    {
      if (watched == qObject ())
	{
	  switch (ev->type ())
	    {
	    case QEvent::Resize:
		{
		  gh_manager::auto_lock lock;
		  graphics_object go = object ();

		  if (go.valid_object ())
		    {
		      if (m_title)
			{
			  const uipanel::properties& pp =
			    Utils::properties<uipanel> (go);

			  if (pp.fontunits_is ("normalized"))
			    {
			      QFrame* frame = qWidget<QFrame> ();

			      m_title->setFont (Utils::computeFont<uipanel>
						(pp, frame->height ()));
			      m_title->resize (m_title->sizeHint ());
			    }
			}
		      updateLayout ();
		    }
		}
	      break;
	    case QEvent::MouseButtonPress:
		{
		  QMouseEvent* m = dynamic_cast<QMouseEvent*> (ev);

		  if (m->button () == Qt::RightButton)
		    {
		      gh_manager::auto_lock lock;

		      ContextMenu::executeAt (properties (), m->globalPos ());
		    }
		}
	      break;
	    default:
	      break;
	    }
	}
      else if (watched == m_container)
	{
	  switch (ev->type ())
	    {
	    case QEvent::Resize:
	      if (qWidget<QWidget> ()->isVisible ())
		{
		  gh_manager::auto_lock lock;

		  properties ().update_boundingbox ();
		}
	      break;
	    default:
	      break;
	    }
	}
    }

  return false;
}

void Panel::update (int pId)
{
  uipanel::properties& pp = properties<uipanel> ();
  QFrame* frame = qWidget<QFrame> ();

  m_blockUpdates = true;

  switch (pId)
    {
    case uipanel::properties::ID_POSITION:
	{
	  Matrix bb = pp.get_boundingbox (false);

	  frame->setGeometry (xround (bb(0)), xround (bb(1)),
			      xround (bb(2)), xround (bb(3)));
	  updateLayout ();
	}
      break;
    case uipanel::properties::ID_BORDERWIDTH:
      frame->setLineWidth (xround (pp.get_borderwidth ()));
      updateLayout ();
      break;
    case uipanel::properties::ID_BACKGROUNDCOLOR:
    case uipanel::properties::ID_FOREGROUNDCOLOR:
    case uipanel::properties::ID_HIGHLIGHTCOLOR:
    case uipanel::properties::ID_SHADOWCOLOR:
	{
	  QPalette pal = frame->palette ();

	  setupPalette (pp, pal);
	  frame->setPalette (pal);
	  if (m_title)
	    m_title->setPalette (pal);
	}
      break;
    case uipanel::properties::ID_TITLE:
	{
	  QString title = Utils::fromStdString (pp.get_title ());

	  if (title.isEmpty ())
	    {
	      if (m_title)
		delete m_title;
	      m_title = 0;
	    }
	  else
	    {
	      if (! m_title)
		{
		  QPalette pal = frame->palette ();

		  m_title = new QLabel (title, frame);
		  m_title->setAutoFillBackground (true);
		  m_title->setContentsMargins (4, 0, 4, 0);
		  m_title->setPalette (pal);
		  m_title->setFont (Utils::computeFont<uipanel> (pp));
		  m_title->show ();
		}
	      else
		{
		  m_title->setText (title);
		  m_title->resize (m_title->sizeHint ());
		}
	    }
	  updateLayout ();
	}
    case uipanel::properties::ID_TITLEPOSITION:
      updateLayout ();
      break;
    case uipanel::properties::ID_BORDERTYPE:
      frame->setFrameStyle (frameStyleFromProperties (pp));
      updateLayout ();
      break;
    case uipanel::properties::ID_FONTNAME:
    case uipanel::properties::ID_FONTSIZE:
    case uipanel::properties::ID_FONTWEIGHT:
    case uipanel::properties::ID_FONTANGLE:
      if (m_title)
	{
	  m_title->setFont (Utils::computeFont<uipanel> (pp));
	  m_title->resize (m_title->sizeHint ());
	  updateLayout ();
	}
      break;
    case uipanel::properties::ID_VISIBLE:
      frame->setVisible (pp.is_visible ());
      updateLayout ();
      break;
    default:
      break;
    }

  m_blockUpdates = false;
}

void Panel::redraw (void)
{
  Canvas* canvas = m_container->canvas (m_handle);

  if (canvas)
    canvas->redraw ();
}

void Panel::updateLayout (void)
{
  uipanel::properties& pp = properties<uipanel> ();
  QFrame* frame = qWidget<QFrame> ();

  Matrix bb = pp.get_boundingbox (true);
  int bw = borderWidthFromProperties (pp);

  frame->setFrameRect (QRect (xround (bb(0)) - bw, xround (bb(1)) - bw,
			      xround (bb(2)) + 2*bw, xround (bb(3)) + 2*bw));
  m_container->setGeometry (xround (bb(0)), xround (bb(1)),
			    xround (bb(2)), xround (bb(3)));

  if (m_blockUpdates)
    pp.update_boundingbox ();

  if (m_title)
    {
      QSize sz = m_title->sizeHint ();
      int offset = 5;

      if (pp.titleposition_is ("lefttop"))
	m_title->move (bw+offset, 0);
      else if (pp.titleposition_is ("righttop"))
	m_title->move (frame->width () - bw - offset - sz.width (), 0);
      else if (pp.titleposition_is ("leftbottom"))
	m_title->move (bw+offset, frame->height () - sz.height ());
      else if (pp.titleposition_is ("rightbottom"))
	m_title->move (frame->width () - bw - offset - sz.width (),
		       frame->height () - sz.height ());
      else if (pp.titleposition_is ("centertop"))
	m_title->move (frame->width () / 2 - sz.width () / 2, 0);
      else if (pp.titleposition_is ("centerbottom"))
	m_title->move (frame->width () / 2 - sz.width () / 2,
		       frame->height () - sz.height ());
    }
}

};