File indexing completed on 2024-05-12 09:52:48

 /*****************************************************************************
  *   Copyright 2003 - 2010 Craig Drummond <craig.p.drummond@gmail.com>       *
  *   Copyright 2013 - 2015 Yichao Yu <yyc1992@gmail.com>                     *
  *                                                                           *
  *   This program 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; either version 2.1 of the    *
  *   License, or (at your option) version 3, or any later version accepted   *
  *   by the membership of KDE e.V. (or its successor approved by the         *
  *   membership of KDE e.V.), which shall act as a proxy defined in          *
  *   Section 6 of version 3 of the license.                                  *
  *                                                                           *
  *   This program 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,                                *
  *   see <http://www.gnu.org/licenses/>.                                     *
  *****************************************************************************/
 
 #include "draw.h"
 #include "utils_p.h"
 #include <pango/pangocairo.h>
 
 namespace QtCurve {
 namespace Cairo {
 
 QTC_EXPORT void
 hLine(cairo_t *cr, int x, int y, int w, const GdkColor *col, double a)
 {
     Saver saver(cr);
     cairo_new_path(cr);
     setColor(cr, col, a);
     cairo_move_to(cr, x, y + 0.5);
     cairo_line_to(cr, x + w, y + 0.5);
     cairo_stroke(cr);
 }
 
 QTC_EXPORT void
 vLine(cairo_t *cr, int x, int y, int h, const GdkColor *col, double a)
 {
     Saver saver(cr);
     cairo_new_path(cr);
     setColor(cr, col, a);
     cairo_move_to(cr, x + 0.5, y);
     cairo_line_to(cr, x + 0.5, y + h);
     cairo_stroke(cr);
 }
 
 QTC_EXPORT void
 polygon(cairo_t *cr, const GdkColor *col, const QtcRect *area,
         const GdkPoint *points, int npoints, bool fill)
 {
     Saver saver(cr);
     cairo_set_line_width(cr, 1);
     clipRect(cr, area);
     setColor(cr, col);
     cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
     pathPoints(cr, points, npoints);
     cairo_close_path(cr);
     cairo_stroke_preserve(cr);
     if (fill) {
         cairo_fill(cr);
     }
 }
 
 QTC_EXPORT void
 rect(cairo_t *cr, const QtcRect *area, int x, int y, int width, int height,
      const GdkColor *col, double alpha)
 {
     Saver saver(cr);
     clipRect(cr, area);
     cairo_rectangle(cr, x, y, width, height);
     setColor(cr, col, alpha);
     cairo_fill(cr);
 }
 
 QTC_EXPORT void
 fadedLine(cairo_t *cr, int x, int y, int width, int height,
           const QtcRect *area, const QtcRect *gap, bool fadeStart,
           bool fadeEnd, double fadeSize, bool horiz,
           const GdkColor *col, double alpha)
 {
     double rx = x + 0.5;
     double ry = y + 0.5;
     cairo_pattern_t *pt =
         cairo_pattern_create_linear(rx, ry, horiz ? rx + width - 1 : rx + 1,
                                     horiz ? ry + 1 : ry + height - 1);
 
     Saver saver(cr);
     if (gap) {
         QtcRect r = {x, y, width, height};
         cairo_region_t *region =
             cairo_region_create_rectangle(area ? area : &r);
         cairo_region_xor_rectangle(region, gap);
         clipRegion(cr, region);
         cairo_region_destroy(region);
     } else {
         clipRect(cr, area);
     }
     patternAddColorStop(pt, 0, col, fadeStart ? 0.0 : alpha);
     patternAddColorStop(pt, fadeSize, col, alpha);
     patternAddColorStop(pt, 1 - fadeSize, col, alpha);
     patternAddColorStop(pt, 1, col, fadeEnd ? 0.0 : alpha);
     cairo_set_source(cr, pt);
     if (horiz) {
         cairo_move_to(cr, x, ry);
         cairo_line_to(cr, x + width - 1, ry);
     } else {
         cairo_move_to(cr, rx, y);
         cairo_line_to(cr, rx, y + height - 1);
     }
     cairo_stroke(cr);
     cairo_pattern_destroy(pt);
 }
 
 QTC_EXPORT void
 stripes(cairo_t *cr, int x, int y, int w, int h,
         bool horizontal, int stripeWidth)
 {
     int endx = horizontal ? stripeWidth : 0;
     int endy = horizontal ? 0 : stripeWidth;
     cairo_pattern_t *pat =
         cairo_pattern_create_linear(x, y, x + endx, y + endy);
     cairo_pattern_add_color_stop_rgba(pat, 0.0, 1.0, 1.0, 1.0, 0.0);
     cairo_pattern_add_color_stop_rgba(pat, 1, 1.0, 1.0, 1.0, 0.15);
     cairo_pattern_set_extend(pat, CAIRO_EXTEND_REFLECT);
 
     Saver saver(cr);
     cairo_set_source(cr, pat);
     cairo_rectangle(cr, x, y, w, h);
     cairo_fill(cr);
 
     cairo_pattern_destroy(pat);
 }
 
 QTC_EXPORT void
 dot(cairo_t *cr, int x, int y, int w, int h, const GdkColor *col)
 {
     double dx = x + (w - 5) / 2;
     double dy = y + (h - 5) / 2;
     cairo_pattern_t *p1 = cairo_pattern_create_linear(dx, dy, dx + 4, dy + 4);
     cairo_pattern_t *p2 = cairo_pattern_create_linear(dx + 2, dy + 2,
                                                       dx + 4, dx + 4);
 
     patternAddColorStop(p1, 0, col, 1);
     patternAddColorStop(p1, 1, col, 0.4);
     cairo_pattern_add_color_stop_rgba(p2, 1, 1, 1, 1, 0.9);
     cairo_pattern_add_color_stop_rgba(p2, 0, 1, 1, 1, 0.7);
 
     Saver saver(cr);
     cairo_new_path(cr);
     cairo_arc(cr, dx + 2.5, dy + 2.5, 2.5, 0, 2 * M_PI);
     cairo_clip(cr);
     cairo_set_source(cr, p1);
     cairo_rectangle(cr, dx, dy, 5, 5);
     cairo_fill(cr);
 
     cairo_new_path(cr);
     cairo_arc(cr, dx + 3, dy + 3, 2, 0, 2 * M_PI);
     cairo_clip(cr);
     cairo_set_source(cr, p2);
     cairo_rectangle(cr, dx + 1, dy + 1, 4, 4);
     cairo_fill(cr);
 
     cairo_pattern_destroy(p1);
     cairo_pattern_destroy(p2);
 }
 
 QTC_EXPORT void
 dots(cairo_t *cr, int rx, int ry, int rwidth, int rheight, bool horiz,
      int nLines, int offset, const QtcRect *area, int startOffset,
      const GdkColor *col1, const GdkColor *col2)
 {
     int space = nLines * 2 + nLines - 1;
     int x = horiz ? rx : rx + (rwidth - space) / 2;
     int y = horiz ? ry + (rheight - space) / 2 : ry;
     int numDots = ((horiz ? rwidth : rheight) - 2 * offset) / 3 + 1;
 
     Saver saver(cr);
     clipRect(cr, area);
     if (horiz) {
         if (startOffset && y + startOffset > 0) {
             y += startOffset;
         }
         cairo_new_path(cr);
         setColor(cr, col1);
         for (int i = 0;i < space;i += 3) {
             for (int j = 0;j < numDots;j++) {
                 cairo_rectangle(cr, x + offset + 3 * j, y + i, 1, 1);
             }
         }
         cairo_fill(cr);
 
         cairo_new_path(cr);
         setColor(cr, col2);
         for (int i = 1;i < space;i += 3) {
             for (int j = 0;j < numDots;j++) {
                 cairo_rectangle(cr, x + offset + 1 + 3 * j, y + i, 1, 1);
             }
         }
         cairo_fill(cr);
     } else {
         if (startOffset && x + startOffset > 0) {
             x += startOffset;
         }
         cairo_new_path(cr);
         setColor(cr, col1);
         for (int i = 0;i < space;i += 3) {
             for (int j = 0;j < numDots;j++) {
                 cairo_rectangle(cr, x + i, y + offset + 3 * j, 1, 1);
             }
         }
         cairo_fill(cr);
 
         cairo_new_path(cr);
         setColor(cr, col2);
         for (int i = 1;i < space;i += 3) {
             for(int j = 0;j < numDots;j++) {
                 cairo_rectangle(cr, x + i, y + offset + 1 + 3 * j, 1, 1);
             }
         }
         cairo_fill(cr);
     }
 }
 
 static void
 ge_transform_for_layout(cairo_t *cr, PangoLayout *layout, int x, int y)
 {
     const PangoMatrix *matrix =
         pango_context_get_matrix(pango_layout_get_context(layout));
     if (matrix) {
         cairo_matrix_t cairo_matrix;
         PangoRectangle _rect;
 
         cairo_matrix_init(&cairo_matrix, matrix->xx, matrix->yx,
                           matrix->xy, matrix->yy, matrix->x0, matrix->y0);
         pango_layout_get_extents(layout, nullptr, &_rect);
         pango_matrix_transform_rectangle(matrix, &_rect);
         pango_extents_to_pixels(&_rect, nullptr);
 
         cairo_matrix.x0 += x - _rect.x;
         cairo_matrix.y0 += y - _rect.y;
 
         cairo_set_matrix(cr, &cairo_matrix);
     } else {
         cairo_translate(cr, x, y);
     }
 }
 
 QTC_EXPORT void
 layout(cairo_t *cr, const QtcRect *area, int x, int y, PangoLayout *_layout,
        const GdkColor *col)
 {
     Saver saver(cr);
     clipRect(cr, area);
     cairo_set_line_width(cr, 1);
     setColor(cr, col);
     ge_transform_for_layout(cr, _layout, x, y);
     pango_cairo_show_layout(cr, _layout);
 }
 
 QTC_EXPORT void
 arrow(cairo_t *cr, const GdkColor *col, const QtcRect *area,
       ArrowType arrow_type, int x, int y, bool small, bool fill, bool varrow)
 {
     if (small) {
         switch (arrow_type) {
         case ArrowType::Up: {
             const GdkPoint a[] = {{x + 2, y}, {x, y - 2}, {x - 2, y},
                                   {x - 2, y + 1}, {x, y - 1}, {x + 2, y + 1}};
             polygon(cr, col, area, a, varrow ? 6 : 3, fill);
             break;
         }
         case ArrowType::Down: {
             const GdkPoint a[] = {{x + 2, y}, {x, y + 2}, {x - 2, y},
                                   {x - 2, y - 1}, {x, y + 1}, {x + 2, y - 1}};
             polygon(cr, col, area, a, varrow ? 6 : 3, fill);
             break;
         }
         case ArrowType::Right: {
             const GdkPoint a[] = {{x, y - 2}, {x + 2, y}, {x, y + 2},
                                   {x - 1, y + 2}, {x + 1, y}, {x - 1, y - 2}};
             polygon(cr, col, area, a, varrow ? 6 : 3, fill);
             break;
         }
         case ArrowType::Left: {
             const GdkPoint a[] = {{x, y - 2}, {x - 2, y}, {x, y + 2},
                                   {x + 1, y + 2}, {x - 1, y}, {x + 1, y - 2}};
             polygon(cr, col, area, a, varrow ? 6 : 3, fill);
             break;
         }
         default:
             break;
         }
     } else {
         /* Large arrows... */
         switch (arrow_type) {
         case ArrowType::Up: {
             const GdkPoint a[] = {{x + 3, y + 1}, {x, y - 2}, {x - 3, y + 1},
                                   {x - 3, y + 2}, {x - 2, y + 2}, {x, y},
                                   {x + 2, y + 2}, {x + 3, y + 2}};
             polygon(cr, col, area, a, varrow ? 8 : 3, fill);
             break;
         }
         case ArrowType::Down: {
             const GdkPoint a[] = {{x + 3, y - 1}, {x, y + 2}, {x - 3, y - 1},
                                   {x - 3, y - 2}, {x - 2, y - 2}, {x, y},
                                   {x + 2, y - 2}, {x + 3,y - 2}};
             polygon(cr, col, area, a, varrow ? 8 : 3, fill);
             break;
         }
         case ArrowType::Right: {
             const GdkPoint a[] = {{x - 1, y + 3}, {x + 2, y}, {x - 1, y - 3},
                                   {x - 2, y - 3}, {x - 2, y - 2}, {x, y},
                                   {x - 2, y + 2}, {x - 2, y + 3}};
             polygon(cr, col, area, a, varrow ? 8 : 3, fill);
             break;
         }
         case ArrowType::Left: {
             const GdkPoint a[] = {{x + 1, y - 3}, {x - 2, y}, {x + 1, y + 3},
                                   {x + 2, y + 3}, {x + 2, y + 2}, {x, y},
                                   {x + 2, y - 2}, {x + 2, y - 3}};
             polygon(cr, col, area, a, varrow ? 8 : 3, fill);
             break;
         }
         default:
             break;
         }
     }
 }
 
 }
 }