rawTherapee/rtgui/coloredbar.cc

/*
 *  This file is part of RawTherapee.
 *
 *  Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
 *
 *  RawTherapee 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.
 *
 *  RawTherapee 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 RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "coloredbar.h"

ColoredBar::ColoredBar (eRTOrientation orient)
{
    orientation = orient;
    dirty = true;
    this->x = this->y = this->w = this->h = 0;
}

/*
 * Redraw the bar to a Cairo::ImageSurface
 */
void ColoredBar::expose(Cairo::RefPtr<Cairo::ImageSurface> destSurface)
{
    // look out if the Surface has to be redrawn
    if (!surfaceCreated() || !destSurface) {
        return;
    }

    draw();
    copySurface(destSurface);
}

/*
 * Redraw the bar to a Gdk::Window
 */
void ColoredBar::expose(Glib::RefPtr<Gdk::Window> destWindow)
{
    // look out if the Surface has to be redrawn
    if (!surfaceCreated() || !destWindow) {
        return;
    }

    draw();
    copySurface(destWindow);
}

/*
 * Redraw the bar to a Gdk::Window
 */
void ColoredBar::expose(BackBuffer *backBuffer)
{
    // look out if the Surface has to be redrawn
    if (!surfaceCreated() || !backBuffer) {
        return;
    }

    draw();
    copySurface(backBuffer);
}

void ColoredBar::draw()
{
    if (isDirty()) {
        Cairo::RefPtr<Cairo::Context> cr = getContext();

        // the bar has to be drawn to the Surface first
        if (!bgGradient.empty()) {
            // a gradient has been set, we use it
            cr->set_line_width(0.);

            // gradient background
            Cairo::RefPtr< Cairo::LinearGradient > bggradient;

            switch (orientation) {
            case (RTO_Left2Right):
                bggradient = Cairo::LinearGradient::create (0., 0., double(w), 0.);
                break;

            case (RTO_Right2Left):
                bggradient = Cairo::LinearGradient::create (double(w), 0., 0., 0.);
                break;

            case (RTO_Bottom2Top):
                bggradient = Cairo::LinearGradient::create (0., double(h), 0., 0.);
                break;

            case (RTO_Top2Bottom):
            default:
                bggradient = Cairo::LinearGradient::create (0., 0., 0., double(h));
                break;
            }

            for (std::vector<GradientMilestone>::iterator i = bgGradient.begin(); i != bgGradient.end(); i++) {
                bggradient->add_color_stop_rgb (i->position, i->r, i->g, i->b);
            }

            cr->set_source (bggradient);
            cr->rectangle(0, 0, w, h);
            cr->fill();
        } else {
            // ask the ColorProvider to provide colors :) for each pixels
            if (colorProvider) {
                cr->set_antialias(Cairo::ANTIALIAS_NONE);
                cr->set_line_width(1.);

                switch (orientation) {
                case (RTO_Left2Right):
                    for (int x = 0; x < w; x++) {
                        for (int y = 0; y < h; y++) {
                            double x_ = double(      x);
                            double y_ = double((h - 1) - y);
                            double x01 = x_       / double(w - 1);
                            double y01 = double(y) / double(h - 1);
                            colorProvider->colorForValue (x01, y01, CCET_BACKGROUND, colorCallerId, this);
                            cr->set_source_rgb(ccRed, ccGreen, ccBlue);
                            cr->rectangle(x_, y_, 1., 1.);
                            cr->fill();
                        }
                    }

                    break;

                case (RTO_Right2Left):
                    for (int x = 0; x < w; x++) {
                        for (int y = 0; y < h; y++) {
                            double x_ = double((w - 1) - x);
                            double y_ = double((h - 1) - y);
                            double x01 = double(x) / double(w - 1);
                            double y01 = double(y) / double(h - 1);
                            colorProvider->colorForValue (x01, y01, CCET_BACKGROUND, colorCallerId, this);
                            cr->set_source_rgb(ccRed, ccGreen, ccBlue);
                            cr->rectangle(x_, y_, 1., 1.);
                            cr->fill();
                        }
                    }

                    break;

                case (RTO_Bottom2Top):
                    for (int x = 0; x < w; x++) {
                        for (int y = 0; y < h; y++) {
                            double x_ = double((w - 1) - x);
                            double y_ = double((h - 1) - y);
                            double x01 = double(x) / double(w - 1);
                            double y01 = double(y) / double(h - 1);
                            colorProvider->colorForValue (y01, x01, CCET_BACKGROUND, colorCallerId, this);
                            cr->set_source_rgb(ccRed, ccGreen, ccBlue);
                            cr->rectangle(x_, y_, 1., 1.);
                            cr->fill();
                        }
                    }

                    break;

                case (RTO_Top2Bottom):
                default:
                    for (int x = 0; x < w; x++) {
                        for (int y = 0; y < h; y++) {
                            double x_ = double(      x);
                            double y_ = double(      y);
                            double x01 = x_ / double(w - 1);
                            double y01 = y_ / double(h - 1);
                            colorProvider->colorForValue (y01, x01, CCET_BACKGROUND, colorCallerId, this);
                            cr->set_source_rgb(ccRed, ccGreen, ccBlue);
                            cr->rectangle(x_, y_, 1., 1.);
                            cr->fill();
                        }
                    }

                    break;
                }
            }
        }

        // has it been updated or not, we assume that the Surface has been correctly set (we don't handle allocation error)
        setDirty(false);
    }
}

void ColoredBar::setBgGradient (const std::vector<GradientMilestone> &milestones)
{
    bgGradient = milestones;
    setDirty(true);
}

void ColoredBar::clearBgGradient ()
{
    bgGradient.clear();
    setDirty(true);
}

bool ColoredBar::canGetColors()
{
    return colorProvider != NULL || bgGradient.size() > 0;
}