QtCollider/style/routines.hpp

   1 #ifndef QC_STYLE_ROUTINES_H
   2 #define QC_STYLE_ROUTINES_H
   3
   4 #include <QPainter>
   5 #include <QPalette>
   6
   7 namespace QtCollider {
   8 namespace Style {
   9 #if 0
  10 namespace ReliefType {
  11   struct Hover;
  12   struct Raised;
  13   struct Flat;
  14   struct Sunken;
  15 };
  16 using namespace ReliefType;
  17
  18 namespace ShapeType {
  19   struct Rect;
  20   struct RoundRect;
  21   struct LeftRoundRect;
  22   struct RightRoundRect;
  23   struct TopRoundRect;
  24   struct BottomRoundRect;
  25   struct Ellipse;
  26 };
  27 using namespace ShapeType;
  28
  29 // drawShape //
  30
  31 template<typename Shape>
  32 void drawShape( QPainter *, const QRect & );
  33
  34 template<typename Shape>
  35 void drawShape( QPainter *, const QRect &, qreal param1 );
  36
  37 template<>
  38 void drawShape <Rect> ( QPainter *p, const QRect &r )
  39 {
  40   p->drawRect(r);
  41 }
  42
  43 template<>
  44 void drawShape <Ellipse> ( QPainter *p, const QRect &r )
  45 {
  46   p->drawEllipse(r);
  47 }
  48
  49 template<>
  50 void drawShape <RoundRect> ( QPainter *p, const QRect &r, qreal radius )
  51 {
  52   p->drawRoundedRect( r, radius, radius, Qt::RelativeSize );
  53 }
  54
  55 // drawReliefShape //
  56
  57 template<typename ShapeT> struct Shape
  58 {
  59   template<typename RectT> void draw();
  60 };
  61 #endif
  62
  63 struct Rect
  64 {
  65   Rect( QRectF rect ) :  _rect(rect) {}
  66   template<typename RectT> inline void draw( QPainter * p, const RectT &r ) const {
  67     p->drawRect(r);
  68   }
  69   QRectF _rect;
  70 };
  71
  72 struct RoundRect
  73 {
  74   RoundRect( QRectF rect, qreal radius ) : _rect(rect), _radius(radius) {}
  75   template<typename RectT> inline void draw( QPainter * p, const RectT &r ) const {
  76     p->drawRoundedRect(r, _radius, _radius, Qt::AbsoluteSize );
  77   }
  78   QRectF _rect;
  79   qreal _radius;
  80 };
  81
  82 struct Ellipse
  83 {
  84   Ellipse( QRectF rect ) :  _rect(rect) {}
  85   template<typename RectT> inline void draw( QPainter * p, const RectT &r ) const {
  86     p->drawEllipse(r);
  87   }
  88   QRectF _rect;
  89 };
  90
  91 template<typename ShapeT> void drawRaised (QPainter *p, const QPalette &plt, const ShapeT &shape,
  92                                            const QColor &color, const QColor &focusColor = QColor())
  93 {
  94   p->save();
  95
  96   bool focus = focusColor.isValid();
  97
  98   QRectF r( shape._rect );
  99
 100   p->setBrush(Qt::NoBrush);
 101
 102   // focus indication
 103
 104   QPen pen;
 105   pen.setWidth(2);
 106   if( focus ) {
 107     pen.setColor(focusColor);
 108     p->setPen(pen);
 109     shape.draw( p, r.adjusted(1,1,-1,-1) );
 110     r.adjust(2,2,-2,-2);
 111   }
 112   else {
 113     r.adjust(1,1,-1,-1);
 114   }
 115
 116   // edge
 117
 118   QColor edgeClr( focus ? plt.color(QPalette::Light) : plt.color(QPalette::Dark) );
 119   if(focus) edgeClr.setAlpha(100);
 120   else edgeClr.setAlpha( color.alpha() );
 121   pen.setColor(edgeClr);
 122   p->setPen(pen);
 123   shape.draw( p, r );
 124
 125   // center
 126
 127   double pos = shape._rect.height();
 128   pos = (pos - 3) / pos;
 129
 130   QLinearGradient lgrad( shape._rect.topLeft(), shape._rect.bottomLeft() );
 131   lgrad.setColorAt( 0, color.lighter(110) );
 132   lgrad.setColorAt( pos, color.darker(105) );
 133   lgrad.setColorAt( 1, color.darker(115) );
 134
 135   p->setPen(Qt::NoPen);
 136   p->setBrush( QBrush(lgrad) );
 137   shape.draw( p, r );
 138
 139   p->restore();
 140 }
 141
 142 template<typename ShapeT> void drawSunken (QPainter *p, const QPalette &plt, const ShapeT &shape,
 143                                            const QColor &color, const QColor &focusColor = QColor())
 144 {
 145   p->save();
 146
 147   QPen pen;
 148   pen.setWidth(2);
 149
 150   // outer border
 151
 152   QColor c = focusColor.isValid() ? focusColor : plt.color(QPalette::Window).lighter(105);
 153   pen.setColor(c);
 154   p->setPen(pen);
 155   p->setBrush(Qt::NoBrush);
 156   shape.draw( p, shape._rect.adjusted(1,1,-1,-1) );
 157
 158   // inner border
 159
 160   QColor c1( plt.color(QPalette::Shadow) );
 161   c1.setAlpha( 180 );
 162   pen.setColor(c1);
 163   p->setPen(pen);
 164   p->setBrush(Qt::NoBrush);
 165   shape.draw( p, shape._rect.adjusted(2,2,-2,-2) );
 166
 167   // shadow
 168
 169   QColor c2=color; c2.setAlpha(150);
 170   p->setPen(Qt::NoPen);
 171   p->setBrush(c2);
 172   shape.draw( p, shape._rect.adjusted(2,2,-2,-2) );
 173
 174   // background
 175
 176   p->setBrush(color);
 177   shape.draw( p, shape._rect.adjusted(2,3,-2,-2) );
 178
 179   p->restore();
 180 }
 181
 182 template<typename RectT> RectT sunkenContentsRect ( const RectT & r )
 183 {
 184   return r.adjusted(1, 1,-1,-1 );
 185 }
 186
 187 template<typename RectT>
 188 qreal xValue ( qreal x, const RectT & bounds )
 189 {
 190   return (x - bounds.x()) / bounds.width();
 191 }
 192
 193 template<typename RectT>
 194 qreal yValue ( qreal y, const RectT & bounds )
 195 {
 196   return (bounds.y() + bounds.height() - y) / bounds.height();
 197 }
 198
 199 template<typename RectT, typename SizeT>
 200 qreal xValue ( qreal x, const RectT & bounds, const SizeT & margin )
 201 {
 202   return margin.width() < bounds.width() ?
 203     (x - bounds.x() - (margin.width() * 0.5)) /
 204     (bounds.width() - margin.width())
 205     : 0.0;
 206 }
 207
 208 template<typename RectT, typename SizeT>
 209 qreal yValue ( qreal y, const RectT & bounds, const SizeT & margin )
 210 {
 211   return margin.height() < bounds.height() ?
 212     (bounds.y() + bounds.height() - y - (margin.height() * 0.5)) /
 213     (bounds.height() - margin.height())
 214     : 0.0;
 215 }
 216
 217 template<typename RectT, typename PointT>
 218 QPointF value ( const PointT & pos, const RectT & bounds )
 219 {
 220   return QPointF( xValue(pos.x(), bounds), yValue(pos.y(), bounds) );
 221 }
 222
 223 template<typename RectT, typename SizeT, typename PointT>
 224 QPointF value ( const PointT & pos, const RectT & bounds, const SizeT & margin )
 225 {
 226   return QPointF( xValue(pos.x(), bounds, margin), yValue(pos.y(), bounds, margin) );
 227 }
 228
 229 template<typename RectT, typename SizeT>
 230 RectT marginsRect ( const RectT & bounds, const SizeT & margin )
 231 {
 232   RectT r;
 233   r.setSize( SizeT( qMax((qreal)bounds.width() - margin.width(), qreal(0.0)),
 234                     qMax((qreal)bounds.height() - margin.height(), qreal(0.0)) ) );
 235   r.moveCenter( bounds.center() );
 236   return r;
 237 }
 238
 239 template<typename RectT, typename SizeT>
 240 RectT rect ( const QPointF & value, const RectT & bounds, const SizeT & size )
 241 {
 242   qreal x = value.x() * (bounds.width() - size.width()) + bounds.left();
 243   qreal y = bounds.top() + bounds.height() - size.height() - value.y() * (bounds.height() - size.height());
 244   return RectT( x, y, size.width(), size.height() );
 245 }
 246
 247 template<typename RectT, typename SizeT>
 248 QPointF pos ( const QPointF & value, const RectT & bounds, const SizeT & margin )
 249 {
 250   qreal x = value.x() * (bounds.width() - margin.width()) + bounds.left() + margin.x() * 0.5;
 251   qreal y = - value.y() * (bounds.height() - margin.height()) + bounds.top() + bounds.height() - margin.y() * 0.5;
 252   return QPointF(x,y);
 253 }
 254
 255 template<typename RectT>
 256 QPointF pos ( const QPointF & value, const RectT & bounds )
 257 {
 258   qreal x = value.x() * bounds.width() + bounds.left();
 259   qreal y = - value.y() * bounds.height() + bounds.top() + bounds.height();
 260   return QPointF(x,y);
 261 }
 262
 263 } // namespace QtCollider
 264 } // namespace Style
 265
 266 #endif