VuoRendererColors.cc

Go to the documentation of this file.

 
#include "VuoRendererColors.hh"
 
 
const qreal VuoRendererColors::minAlpha = 0.35;
 
const int VuoRendererColors::subtleHighlightingLighteningFactor = 140; // 100 means no change. @todo: Re-evaluate for https://b33p.net/kosada/node/6855 .
const int VuoRendererColors::activityFadeDuration = 400;
const int VuoRendererColors::activityAnimationFadeDuration = 950;
bool VuoRendererColors::_isDark = false;
 
VuoRendererColors::VuoRendererColors(VuoNode::TintColor tintColor, VuoRendererColors::SelectionType selectionType, bool isHovered, VuoRendererColors::HighlightType highlightType, qint64 timeOfLastActivity, bool isMissingImplementation)
{
    this->tintColor = tintColor;
    this->selectionType = selectionType;
    this->isHovered = isHovered;
    this->highlightType = highlightType;
    this->isMissingImplementation = isMissingImplementation;
 
    // Turn composition components opaque as they execute or fire events, then fade them back to their minimum transparency.
    qint64 timeNow = QDateTime::currentMSecsSinceEpoch();
 
    this->currentFadePercentage =   ((timeOfLastActivity == VuoRendererItem::notTrackingActivity)? 0 :
                                    ((timeOfLastActivity == VuoRendererItem::activityInProgress)? 0 :
                                    fmin(1, (timeNow - timeOfLastActivity)/(1.0*activityFadeDuration))));
}
 
VuoRendererColors *VuoRendererColors::sharedColors = NULL;
 
VuoRendererColors *VuoRendererColors::getSharedColors(void)
{
    if (!sharedColors)
        sharedColors = new VuoRendererColors();
 
    return sharedColors;
}
 
void VuoRendererColors::setDark(bool isDark)
{
    _isDark = isDark;
}
 
bool VuoRendererColors::isDark(void)
{
    return _isDark;
}
 
QColor VuoRendererColors::canvasFill(void)
{
    return QColor::fromHslF(0, 0, _isDark ? .19 : 1, 1);
}
 
QColor VuoRendererColors::nodeFill(void)
{
    return applyHighlighting(baseColor());
}
 
QColor VuoRendererColors::portFill(void)
{
    return nodeFill();
}
 
QColor VuoRendererColors::publishedPortFill(void)
{
    return nodeFill();
}
 
QColor VuoRendererColors::publishedPortTitle(void)
{
    if (highlightType == ineligibleHighlight)
        return Qt::transparent;
 
    return _isDark ? nodeClass() : portTitle();
}
 
QColor VuoRendererColors::publishedProtocolPortTitle(void)
{
    return portTitle();
}
 
QColor VuoRendererColors::nodeFrame(void)
{
    if (isMissingImplementation)
        return nodeFill();
    else
        return applyHighlighting(baseColor().darker(_isDark ? 160 : 130));
}
 
QColor VuoRendererColors::nodeTitle(void)
{
    QColor c = applyHighlighting(QColor::fromHslF(0, 0, 1, 1), .2);
    if (isMissingImplementation)
        c.setAlphaF(_isDark ? .5 : 1);
    return c;
}
 
QColor VuoRendererColors::nodeClass(void)
{
    QColor c = applyHighlighting(QColor::fromHslF(0, 0, 1, .6));
    if (isMissingImplementation)
        c.setAlphaF(_isDark ? .5 : 1);
    return c;
}
 
QColor VuoRendererColors::constantFill(void)
{
    return portFill();
}
 
QColor VuoRendererColors::constantText(void)
{
    return portTitle();
}
 
QColor VuoRendererColors::animatedPortFill(void)
{
    qreal adjustedAlpha = (1. - currentFadePercentage) * getCurrentAlpha();
    QColor c = portFill();
    c.setAlphaF(c.alphaF() * adjustedAlpha);
    return c;
}
 
QColor VuoRendererColors::portTitlebarFill(void)
{
    return nodeFrame();
}
 
QColor VuoRendererColors::eventBlockingBarrier(void)
{
    return nodeFrame();
}
 
QColor VuoRendererColors::animatedeventBlockingBarrier(void)
{
    qreal adjustedAlpha = (1. - currentFadePercentage) * getCurrentAlpha();
    QColor c = nodeFrame();
    c.setAlphaF(c.alphaF() * adjustedAlpha);
    return c;
}
 
QColor VuoRendererColors::actionIndicator(void)
{
    return nodeFrame();
}
 
QColor VuoRendererColors::portTitle(void)
{
    if (highlightType == ineligibleHighlight)
        return Qt::transparent;
 
    return applyHighlighting(QColor::fromHslF(0, 0, .2,
                                              highlightType == standardHighlight ? 1. : .8),
                             0);
}
 
QColor VuoRendererColors::portIcon()
{
    return actionIndicator();
}
 
QColor VuoRendererColors::cableMain(void)
{
    return nodeFill();
}
 
QColor VuoRendererColors::errorMark(void)
{
    return QColor::fromRgb(220, 50, 47, 160);
}
 
QColor VuoRendererColors::commentFrame(void)
{
    QColor darkColor = QColor(0.5*(nodeFrame().red()+nodeFill().red()),
                              0.5*(nodeFrame().green()+nodeFill().green()),
                              0.5*(nodeFrame().blue()+nodeFill().blue()),
                              0.5*(nodeFrame().alpha()+nodeFill().alpha())
                              );
 
    QColor frameColor = (_isDark? darkColor : nodeFill());
    frameColor.setAlpha(_isDark? 0.5*frameColor.alpha() : 0.82*frameColor.alpha());
 
    return frameColor;
}
 
QColor VuoRendererColors::commentFill(void)
{
    QColor c = nodeFill();
    if (_isDark)
    {
        float darkenFactor = .8;
        QColor b = canvasFill();
        c.setRedF  (c.redF()   * (1-darkenFactor) + b.redF()   * darkenFactor);
        c.setGreenF(c.greenF() * (1-darkenFactor) + b.greenF() * darkenFactor);
        c.setBlueF (c.blueF()  * (1-darkenFactor) + b.blueF()  * darkenFactor);
    }
    else
    {
        int lightenFactor = 113;
        if (tintColor == VuoNode::TintYellow)
            lightenFactor = 140;
        else if (tintColor == VuoNode::TintCyan
              || tintColor == VuoNode::TintGreen
              || tintColor == VuoNode::TintLime)
            lightenFactor = 125;
        c = c.lighter(lightenFactor);
    }
 
    int h,s,v,a;
    c.getHsv(&h, &s, &v, &a);
    return (QColor::fromHsv(h, (_isDark? s*4/3 : s/3), v, a)); // Desaturate.
}
 
QColor VuoRendererColors::commentText(void)
{
    QColor c = applyHighlighting(QColor::fromHslF(0, 0, 1, .8));
    return (_isDark? c : portTitle());
}
 
QColor VuoRendererColors::selection()
{
    return _isDark ? "#1d6ae5" : "#74acec";
}
 
QColor VuoRendererColors::lerpColor(QColor v0, QColor v1, float t)
{
    qreal r0,g0,b0,a;
    v0.getRgbF(&r0,&g0,&b0,&a);
 
    qreal r1,g1,b1;
    v1.getRgbF(&r1,&g1,&b1);
 
    return QColor::fromRgbF(
                fmin(r0 + (r1 - r0)*t, 1.),
                fmin(g0 + (g1 - g0)*t, 1.),
                fmin(b0 + (b1 - b0)*t, 1.),
                a
                );
}
 
QColor VuoRendererColors::baseColor(bool useTintColor)
{
    if (!useTintColor
           || tintColor == VuoNode::TintNone     )  return QColor::fromHslF(  0./360., 0, getNodeFillLightness(), 1);
    else  if (tintColor == VuoNode::TintYellow   )  return QColor::fromHslF( 57./360., 1, .49, 1);
    else  if (tintColor == VuoNode::TintTangerine)  return QColor::fromHslF( 41./360., 1, .67, 1);
    else  if (tintColor == VuoNode::TintOrange   )  return QColor::fromHslF( 19./360., 1, .73, 1);
    else  if (tintColor == VuoNode::TintMagenta  )  return QColor::fromHslF(323./360., 1, .78, 1);
    else  if (tintColor == VuoNode::TintViolet   )  return QColor::fromHslF(275./360., 1, .81, 1);
    else  if (tintColor == VuoNode::TintBlue     )  return QColor::fromHslF(213./360., 1, .77, 1);
    else  if (tintColor == VuoNode::TintCyan     )  return QColor::fromHslF(165./360., 1, .68, 1);
    else  if (tintColor == VuoNode::TintGreen    )  return QColor::fromHslF( 99./360., 1, .70, 1);
    else/*if (tintColor == VuoNode::TintLime     )*/return QColor::fromHslF( 70./360., 1, .48, 1);
}
 
QColor VuoRendererColors::applyHighlighting(QColor baseColor, qreal selectionIntensity)
{
    qreal alpha = baseColor.alphaF() * getCurrentAlpha();
    int highlight = 0;
 
    if (isHovered)
        ++highlight;
 
    if (selectionType != VuoRendererColors::noSelection)
        baseColor = lerpColor(baseColor, selection(), selectionIntensity);
 
    if (highlightType == VuoRendererColors::standardHighlight)
        ++highlight;
    else if (highlightType == VuoRendererColors::subtleHighlight)
    {
        if (isHovered)
        {
            alpha *= .8;
            ++highlight;
        }
        else
            alpha *= .6;
    }
    else if (highlightType == VuoRendererColors::ineligibleHighlight)
        alpha *= _isDark ? .1 : .2;
 
    if (tintColor != VuoNode::TintNone)
        highlight *= 2;
 
    baseColor = baseColor.lighter(100. + (_isDark ? 10. : -6.) * highlight);
 
    baseColor.setAlphaF(alpha);
    return baseColor;
}
 
qint64 VuoRendererColors::getVirtualNodeExecutionOrigin(void)
{
    return QDateTime::currentMSecsSinceEpoch();
}
 
qint64 VuoRendererColors::getVirtualFiredEventOrigin(void)
{
    return QDateTime::currentMSecsSinceEpoch();
}
 
qint64 VuoRendererColors::getVirtualFiredEventOriginForAnimationFadePercentage(qreal percentage)
{
    qint64 timeNow = QDateTime::currentMSecsSinceEpoch();
    qint64 virtualFiredEventOrigin = timeNow - percentage*activityAnimationFadeDuration;
 
    return virtualFiredEventOrigin;
}
 
qint64 VuoRendererColors::getVirtualPropagatedEventOrigin(void)
{
    return QDateTime::currentMSecsSinceEpoch();
}
 
qreal VuoRendererColors::getCurrentAlpha(void)
{
    return 1 - currentFadePercentage * (1 - minAlpha);
}
 
qreal VuoRendererColors::getNodeFillLightness(void)
{
    return _isDark ? .62 : .83;
}
 
VuoNode::TintColor VuoRendererColors::getActiveProtocolTint(int protocolIndex, bool isInput)
{
    // @todo: Account for multiple simultaneous active protocols. https://b33p.net/kosada/node/9585
    return isInput ? VuoNode::TintBlue : VuoNode::TintLime;
}