path: root/indra/llui/llxyvector.cpp

/**
* @file llxyvector.cpp
* @author Andrey Lihatskiy
* @brief Implementation for LLXYVector
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2018, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
* $/LicenseInfo$
*/

// A control that allows to set two related vector magnitudes by manipulating a single vector on a plane. 

#include "linden_common.h"

#include "llxyvector.h"

#include "llstring.h"
#include "llrect.h"

#include "lluictrlfactory.h"
#include "llrender.h"

#include "llmath.h"

// Globals
static LLDefaultChildRegistry::Register<LLXYVector> register_xy_vector("xy_vector");


const F32 CENTER_CIRCLE_RADIUS = 2;
const S32 ARROW_ANGLE = 30;
const S32 ARROW_LENGTH_LONG = 10;
const S32 ARROW_LENGTH_SHORT = 6;

LLXYVector::Params::Params()
  : x_entry("x_entry"),
    y_entry("y_entry"),
    touch_area("touch_area"),
    border("border"),
    edit_bar_height("edit_bar_height", 18),
    padding("padding", 4),
    min_val_x("min_val_x", -1.0f),
    max_val_x("max_val_x", 1.0f),
    increment_x("increment_x", 0.05f),
    min_val_y("min_val_y", -1.0f),
    max_val_y("max_val_y", 1.0f),
    increment_y("increment_y", 0.05f),
    label_width("label_width", 16),
    arrow_color("arrow_color", LLColor4::white),
    ghost_color("ghost_color"),
    area_color("area_color", LLColor4::grey4),
    grid_color("grid_color", LLColor4::grey % 0.25f),
    logarithmic("logarithmic", FALSE)
{
}

LLXYVector::LLXYVector(const LLXYVector::Params& p)
  : LLUICtrl(p),
    mArrowColor(p.arrow_color()),
    mAreaColor(p.area_color),
    mGridColor(p.grid_color),
    mMinValueX(p.min_val_x),
    mMaxValueX(p.max_val_x),
    mIncrementX(p.increment_x),
    mMinValueY(p.min_val_y),
    mMaxValueY(p.max_val_y),
    mIncrementY(p.increment_y),
    mLogarithmic(p.logarithmic),
    mValueX(0),
    mValueY(0)
{
    mGhostColor = p.ghost_color.isProvided() ? p.ghost_color() % 0.3f : p.arrow_color() % 0.3f;

    LLRect border_rect = getLocalRect();
    LLViewBorder::Params params = p.border;
    params.rect(border_rect);
    mBorder = LLUICtrlFactory::create<LLViewBorder>(params);
    addChild(mBorder);

    LLTextBox::Params x_label_params;
    x_label_params.initial_value(p.x_entry.label());
    x_label_params.rect = LLRect(p.padding,
                                 border_rect.mTop - p.padding,
                                 p.label_width,
                                 border_rect.getHeight() - p.edit_bar_height);
    mXLabel = LLUICtrlFactory::create<LLTextBox>(x_label_params);
    addChild(mXLabel);
    LLLineEditor::Params x_params = p.x_entry;
    x_params.rect = LLRect(p.padding + p.label_width,
                           border_rect.mTop - p.padding,
                           border_rect.getCenterX(),
                           border_rect.getHeight() - p.edit_bar_height);
    x_params.commit_callback.function(boost::bind(&LLXYVector::onEditChange, this));
    mXEntry = LLUICtrlFactory::create<LLLineEditor>(x_params);
    mXEntry->setPrevalidateInput(LLTextValidate::validateFloat);
    addChild(mXEntry);

    LLTextBox::Params y_label_params;
    y_label_params.initial_value(p.y_entry.label());
    y_label_params.rect = LLRect(border_rect.getCenterX() + p.padding,
                                 border_rect.mTop - p.padding,
                                 border_rect.getCenterX() + p.label_width,
                                 border_rect.getHeight() - p.edit_bar_height);
    mYLabel = LLUICtrlFactory::create<LLTextBox>(y_label_params);
    addChild(mYLabel);
    LLLineEditor::Params y_params = p.y_entry;
    y_params.rect = LLRect(border_rect.getCenterX() + p.padding + p.label_width,
                           border_rect.getHeight() - p.padding,
                           border_rect.getWidth() - p.padding,
                           border_rect.getHeight() - p.edit_bar_height);
    y_params.commit_callback.function(boost::bind(&LLXYVector::onEditChange, this));
    mYEntry = LLUICtrlFactory::create<LLLineEditor>(y_params);
    mYEntry->setPrevalidateInput(LLTextValidate::validateFloat);
    addChild(mYEntry);

    LLPanel::Params touch_area = p.touch_area;
    touch_area.rect = LLRect(p.padding,
                             border_rect.mTop - p.edit_bar_height - p.padding,
                             border_rect.getWidth() - p.padding,
                             p.padding);
    mTouchArea = LLUICtrlFactory::create<LLPanel>(touch_area);
    addChild(mTouchArea);
}

LLXYVector::~LLXYVector()
{
}

BOOL LLXYVector::postBuild()
{
    mLogScaleX = (2 * log(mMaxValueX)) / mTouchArea->getRect().getWidth();
    mLogScaleY = (2 * log(mMaxValueY)) / mTouchArea->getRect().getHeight();

    return TRUE;
}

void drawArrow(S32 tailX, S32 tailY, S32 tipX, S32 tipY, LLColor4 color)
{
    gl_line_2d(tailX, tailY, tipX, tipY, color);

    S32 dx = tipX - tailX;
    S32 dy = tipY - tailY;

    S32 arrowLength = (abs(dx) < ARROW_LENGTH_LONG && abs(dy) < ARROW_LENGTH_LONG) ? ARROW_LENGTH_SHORT : ARROW_LENGTH_LONG;
   
    F32 theta = std::atan2(dy, dx);

    F32 rad = ARROW_ANGLE * std::atan(1) * 4 / 180;
    F32 x = tipX - arrowLength * cos(theta + rad);
    F32 y = tipY - arrowLength * sin(theta + rad);
    F32 rad2 = -1 * ARROW_ANGLE * std::atan(1) * 4 / 180;
    F32 x2 = tipX - arrowLength * cos(theta + rad2);
    F32 y2 = tipY - arrowLength * sin(theta + rad2);
    gl_triangle_2d(tipX, tipY, x, y, x2, y2, color, true);
}

void LLXYVector::draw()
{
    S32 centerX = mTouchArea->getRect().getCenterX();
    S32 centerY = mTouchArea->getRect().getCenterY();
    S32 pointX;
    S32 pointY;

    if (mLogarithmic)
    {
        pointX = (log(llabs(mValueX) + 1)) / mLogScaleX;
        pointX *= (mValueX < 0) ? -1 : 1;
        pointX += centerX;

        pointY = (log(llabs(mValueY) + 1)) / mLogScaleY;
        pointY *= (mValueY < 0) ? -1 : 1;
        pointY += centerY;
    }
    else // linear
    {
        pointX = centerX + (mValueX * mTouchArea->getRect().getWidth() / (2 * mMaxValueX));
        pointY = centerY + (mValueY * mTouchArea->getRect().getHeight() / (2 * mMaxValueY));
    }

    // fill
    gl_rect_2d(mTouchArea->getRect(), mAreaColor, true);

    // draw grid
    gl_line_2d(centerX, mTouchArea->getRect().mTop, centerX, mTouchArea->getRect().mBottom, mGridColor);
    gl_line_2d(mTouchArea->getRect().mLeft, centerY, mTouchArea->getRect().mRight, centerY, mGridColor);

    // draw ghost
    if (hasMouseCapture())
    {
        drawArrow(centerX, centerY, mGhostX, mGhostY, mGhostColor);
    }
    else
    {
        mGhostX = pointX;
        mGhostY = pointY;
    }

    if (abs(mValueX) >= mIncrementX || abs(mValueY) >= mIncrementY)
    {
        // draw the vector arrow
        drawArrow(centerX, centerY, pointX, pointY, mArrowColor);
    }
    else
    {
        // skip the arrow, set color for center circle
        gGL.color4fv(mArrowColor.get().mV);
    }

    // draw center circle
    gl_circle_2d(centerX, centerY, CENTER_CIRCLE_RADIUS, 12, true);

    LLView::draw();
}

void LLXYVector::onEditChange()
{
    if (getEnabled())
    {
        setValueAndCommit(mXEntry->getValue().asReal(), mYEntry->getValue().asReal());
    }
}

void LLXYVector::setValue(const LLSD& value)
{
    if (value.isArray())
    {
        setValue(value[0].asReal(), value[1].asReal());
    }
}

void LLXYVector::setValue(F32 x, F32 y)
{
    mValueX = ll_round(llclamp(x, mMinValueX, mMaxValueX), mIncrementX);
    mValueY = ll_round(llclamp(y, mMinValueY, mMaxValueY), mIncrementY);

    update();
}

void LLXYVector::setValueAndCommit(F32 x, F32 y)
{
    if (mValueX != x || mValueY != y)
    {
        setValue(x, y);
        onCommit();
    }
}

LLSD LLXYVector::getValue() const
{
    LLSD value;
    value.append(mValueX);
    value.append(mValueY);
    return value;
}

void LLXYVector::update()
{
    mXEntry->setValue(mValueX);
    mYEntry->setValue(mValueY);
}

bool LLXYVector::handleHover(S32 x, S32 y, MASK mask)
{
    if (hasMouseCapture())
    {
        if (mLogarithmic)
        {
            F32 valueX = llfastpow(F_E, mLogScaleX*(llabs(x - mTouchArea->getRect().getCenterX()))) - 1;
            valueX *= (x < mTouchArea->getRect().getCenterX()) ? -1 : 1;

            F32 valueY = llfastpow(F_E, mLogScaleY*(llabs(y - mTouchArea->getRect().getCenterY()))) - 1;
            valueY *= (y < mTouchArea->getRect().getCenterY()) ? -1 : 1;

            setValueAndCommit(valueX, valueY);
        }
        else //linear
        {
            F32 valueX = 2 * mMaxValueX * F32(x - mTouchArea->getRect().getCenterX()) / mTouchArea->getRect().getWidth();
            F32 valueY = 2 * mMaxValueY * F32(y - mTouchArea->getRect().getCenterY()) / mTouchArea->getRect().getHeight();

            setValueAndCommit(valueX, valueY);
        }
    }

    return true;
}

bool LLXYVector::handleMouseUp(S32 x, S32 y, MASK mask)
{
    if (hasMouseCapture())
    {
        gFocusMgr.setMouseCapture(NULL);
        make_ui_sound("UISndClickRelease");
    }

    if (mTouchArea->getRect().pointInRect(x, y))
    {
        return true;
    }
    else
    {
        return LLUICtrl::handleMouseUp(x, y, mask);
    }
}

bool LLXYVector::handleMouseDown(S32 x, S32 y, MASK mask)
{

    if (mTouchArea->getRect().pointInRect(x, y))
    {
        gFocusMgr.setMouseCapture(this);
        make_ui_sound("UISndClick");

        return true;
    }
    else
    {
        return LLUICtrl::handleMouseDown(x, y, mask);
    }
}