gradient_painter.cpp

// gradient_painter.cpp

// Copyright (C) 2004 Steven Weiß (steven11@gmx.de)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.


#include <background_wnd/painters/gradient_painter.hpp>
#include <math.h>


namespace win32 { namespace gui {

namespace detail {

     // Helper functions & classes

     const double PI = 3.141592654;

     double degree_to_rad(double n)
     {    
          return PI / 180.0 * n;
     }

     double rad_to_degree(double n)
     {    
          return (180.0 / PI) * n;
     }

     class triangle
     {
     public:
          triangle() : alpha_(0), beta_(0), a_(0), b_(0), c_(0)
          {}

          void set_a(double a)
          {
               a_ = a;
          }

          void set_b(double b)
          {
               b_ = b;
          }

          void set_hypotenuse(double c)
          {
               c_ = c;
          }

          void set_alpha(double alpha)
          {
               alpha_ = alpha;
          }

          void set_beta(double beta)
          {
               beta_ = beta;
          }

          double get_a() const
          {
               if (a_)
                    return a_;
               else if (b_)
                    return leg_from_pythagoras(b_, get_hypotenuse());
               else if (c_ && alpha_)
                    return cos(degree_to_rad(alpha_)) / c_;
               else if (c_ && beta_)
                    return sin(degree_to_rad(beta_)) / c_;       
               return 0;
          }

          double get_b() const
          {
               if (b_)
                    return b_;
               else if (a_)
                    return leg_from_pythagoras(a_, get_hypotenuse());
               else if (c_ && alpha_)
                    return sin(degree_to_rad(alpha_)) / c_;
               else if (c_ && beta_)
                    return cos(degree_to_rad(beta_)) / c_;       
               return 0;
          }

          double get_hypotenuse() const
          {
               if (c_)
                    return c_;
               else if (a_ && b_)
                    return hypotenuse_from_pythagoras(a_, b_);
               else if (a_ && alpha_)
                    return a_ / cos(degree_to_rad(alpha_));
               else if (a_ && beta_)
                    return a_ / sin(degree_to_rad(beta_));
               else if (b_ && alpha_)             
                    return b_ / sin(degree_to_rad(alpha_));      
               else if (b_ && beta_)
                    return b_ / cos(degree_to_rad(beta_));                 
               return 0;
          }

          double get_alpha() const
          {
               if (alpha_)
                    return alpha_;
               if (beta_)
                    return 90 - beta_;
               double hypo = get_hypotenuse();
               if (a_ && hypo)
                    return rad_to_degree(acos(a_ / hypo));
               else if (b_ && hypo)
                    return rad_to_degree(asin(b_ / hypo));
               return 0;
          }

          double get_beta() const
          {
               if (beta_)
                    return beta_;
               if (alpha_)
                    return 90 - alpha_;
               double hypo = get_hypotenuse();
               if (a_ && hypo)               
                    return rad_to_degree(asin(a_ / hypo));                      
               else if (b_ && hypo)
                    return rad_to_degree(acos(b_ / hypo));
               return 0;
          }



     private:
          static double leg_from_pythagoras(double leg, double hypotenuse)
          {
               double leg_square = hypotenuse * hypotenuse - leg * leg;
               return sqrt(leg_square);
          }

          static double hypotenuse_from_pythagoras(double adj_leg, double opp_leg)
          {
               double hyp_square = adj_leg * adj_leg + opp_leg * opp_leg;
               return sqrt(hyp_square);
          }

          double alpha_;
          double beta_;
          
          double a_;
          double b_;
          double c_;          // hypotenuse
     };

}    // namespace detail


// ========================================================================================================= //
// gradient_painter

gradient_painter::gradient_painter(param0 colors, param1 angle) : colors_(colors), angle_(angle)
{}

gradient_painter* gradient_painter::clone() const
{
     return new gradient_painter(*this);
}

void gradient_painter::draw(HDC hDC, int cx, int cy)
{    
     if (cx == 0 || cy == 0)
          return;

     int r1 = GetRValue(colors_.first);
     int g1 = GetGValue(colors_.first);
     int b1 = GetBValue(colors_.first);
     int r2 = GetRValue(colors_.second);
     int g2 = GetGValue(colors_.second);
     int b2 = GetBValue(colors_.second);

     draw_linear (hDC, cx, cy, r1, g1, b1, r2, g2, b2);
}

// draws a linear gradient
void gradient_painter::draw_linear(HDC hDC, int cx, int cy, int r1, int g1, int b1, int r2, int g2, int b2)
{    
     double r, g, b;
     unsigned angle = angle_ % 360;               // normalize angle to 0° - 359°
     HPEN hOldPen = (HPEN) GetCurrentObject(hDC, OBJ_PEN);

     // vertical gradients
     if (angle % 180 == 0) {
          for (int x = 0; x < cx; ++x) {     
               // adjust colors if angle is 0°
               if (angle == 0) {
                    r = r1 + (x * (r2 - r1)) / cx;
                    g = g1 + (x * (g2 - g1)) / cx;
                    b = b1 + (x * (b2 - b1)) / cx;
               }
               // adjust colors if angle is 180°
               else {
                    r = r2 + (x * (r1 - r2)) / cx;
                    g = g2 + (x * (g1 - g2)) / cx;
                    b = b2 + (x * (b1 - b2)) / cx;
               }
                                             
               SelectObject( hDC, CreatePen(PS_SOLID, 1, RGB(r, g, b)) );
               MoveToEx(hDC, x, 0, NULL);         
               LineTo(hDC, x, cy);           
               DeleteObject( SelectObject(hDC, hOldPen) );
          }
     }
     // other angles
     else {         
          detail::triangle triangle;
          triangle.set_a(cx);
          triangle.set_beta(angle);
          double y_diff = triangle.get_b();
          double whole_cy = cy + y_diff;
          
          for (int y = 0; y <= whole_cy; ++y) {   
               // adjust colors if angle is less than 180°
               if (angle < 180) {
                    r = r1 + ( (whole_cy - y) * (r2 - r1) ) / whole_cy;
                    g = g1 + ( (whole_cy - y) * (g2 - g1) ) / whole_cy;
                    b = b1 + ( (whole_cy - y) * (b2 - b1) ) / whole_cy;
               }
               // adjust colors if angle greater than 180°
               else {
                    r = r2 + ( (whole_cy - y) * (r1 - r2) ) / whole_cy;
                    g = g2 + ( (whole_cy - y) * (g1 - g2) ) / whole_cy;
                    b = b2 + ( (whole_cy - y) * (b1 - b2) ) / whole_cy;
               }              
                    
               int y_from = (int) (y - y_diff);
               int y_to   = y;

               // rotate gradient if necessary
               if ( (angle / 90) % 2 == 1 )
                    std::swap(y_from, y_to);
                                   
               SelectObject( hDC, CreatePen(PS_SOLID, 1, RGB(r, g, b)) );
               MoveToEx(hDC, 0, y_from, NULL);         
               LineTo(hDC, cx, y_to);             
               DeleteObject( SelectObject(hDC, hOldPen) );
          }
     }
}    


bool gradient_painter::is_opaque(int, int) const
{
     return true;
}

void gradient_painter::gradient_colors(const GradientColors& colors)
{
     colors_ = colors;
}

gradient_painter::GradientColors gradient_painter::gradient_colors() const
{
     return colors_;
}

void gradient_painter::angle(unsigned angle)
{
     angle_ = angle;
}

unsigned gradient_painter::angle() const
{
     return angle_;
}

gradient_painter::GradientColors gradient_painter::make_gradient_colors(COLORREF crStart, COLORREF crEnd)
{
     return std::make_pair(crStart, crEnd);
}

} }  // namespace win32::gui

---