src/Fl_Cairo_Graphics_Driver.cxx

   1
   2 /*******************************************************************************/
   3 /* Copyright (C) 2012 Jonathan Moore Liles                                     */
   4 /*                                                                             */
   5 /* This program is free software; you can redistribute it and/or modify it     */
   6 /* under the terms of the GNU Library General Public License as published      */
   7 /* by the Free Software Foundation; either version 2 of the License, or (at    */
   8 /* your option) any later version.                                             */
   9 /*                                                                             */
  10 /* This program is distributed in the hope that it will be useful, but WITHOUT */
  11 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       */
  12 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for   */
  13 /* more details.                                                               */
  14 /*                                                                             */
  15 /* You should have received a copy of the GNU General Public License along     */
  16 /* with This program; see the file COPYING.  If not,write to the Free Software */
  17 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18 /*******************************************************************************/
  19
  20
  21 /* This class emulates the FLTK graphics drawing API using the Cairo
  22  * library. The advantage of doing this is that it provides
  23  * antialiasing and transparency on X11 for all FLTK widgets.
  24  *
  25  * The implementation inherits from the Xlib driver and attempts to
  26  * keep colors, clipping, and matrix transformations in sync, so that
  27  * calls to the base Xlib and Cairo routines can be mixed with the
  28  * expected results.
  29  *
  30  * Fonts are still rendered using XFT. And since the FLTK image
  31  * drawing implementation already uses XRender, there would seem to be
  32  * little advantage to using Cairo for that either.
  33  *
  34  * Alpha values can be encoded into Fl_Color values by using the new
  35  * fl_color_add_alpha function--with the caveat that 100% transparency
  36  * (an Alpha of 0) is unsupported. This allows existing boxes and
  37  * widgets to be drawn with transparency simply by setting their
  38  * color() to one with an alpha value encoded.
  39  *
  40  * Antialiasing can be turned on and off with the new
  41  * fl_set_antialias() function. However, it should be noted that, even
  42  * with antialiasing disabled drawing complex lines and polygons is
  43  * still significantly slower with Cairo than with the base FLTK
  44  * routines.
  45  *
  46  */
  47
  48 #include <config.h>
  49 #include <FL/Fl.H>
  50
  51 double fl_hxo = 0.0;
  52 double fl_hyo = 0.5;
  53 double fl_vxo = 0.5;
  54 double fl_vyo = 0.0;
  55 double fl_vho = 1.0;
  56 double fl_hwo = 1.0;
  57
  58 #define HXO(n) ( n + fl_hxo )
  59 #define HYO(n) ( n + fl_hyo )
  60 #define VXO(n) ( n + fl_vxo )
  61 #define VYO(n) ( n + fl_vyo )
  62 #define VHO(n) ( n + fl_vho )
  63 #define HWO(n) ( n + fl_hwo )
  64
  65 #define BSCALE 0.00392156862f
  66
  67 Fl_Color fl_color_add_alpha ( Fl_Color c, uchar alpha )
  68 {
  69     if ( !( c & 0xFFFFFF00 ) )
  70     {
  71         /* this is an indexed color or black */
  72         if ( c & 0x000000FF )
  73         {
  74             /* this is an indexed color */
  75             uchar r,g,b;
  76
  77             Fl::get_color( c, r, g, b );
  78
  79             c = fl_rgb_color( r, g, b );
  80         }
  81         else
  82         {
  83             /* this is black */
  84             if ( 0 == alpha )
  85             {
  86                 /* sorry, you can't have zero opacity because we don't
  87                  * have enough bits and it doesn't make much sense anyway */
  88                 alpha = 255;
  89             }
  90             /* hack to represent black */
  91             c = 0x01010100;
  92         }
  93     }
  94
  95     return ( c & 0xFFFFFF00 ) | alpha;
  96 }
  97
  98 #include <FL/x.H>
  99 #include <cairo/cairo.h>
 100 #include <FL/Fl_Cairo.H>
 101 #include <FL/fl_draw.H>
 102 #include <math.h>
 103 #include <FL/Fl_Device.H>
 104
 105 static double lw = 1;
 106 static double hlw;
 107 //static cairo_antialias_t aa = CAIRO_ANTIALIAS_GRAY;
 108
 109 static int npoints = 0;
 110
 111 cairo_matrix_t Fl_Cairo_Graphics_Driver::m;
 112 cairo_matrix_t  Fl_Cairo_Graphics_Driver::stack[FL_MATRIX_STACK_SIZE];
 113 int  Fl_Cairo_Graphics_Driver::sptr;
 114
 115 #define cairo_set_antialias( cr, aa )
 116
 117 Fl_Cairo_Graphics_Driver::Fl_Cairo_Graphics_Driver ( )   : Fl_Xlib_Graphics_Driver ()
 118 {
 119 //    rstackptr = 0;
 120 }
 121
 122 /* void Fl_Cairo_Graphics_Driver::set_current ( void ) */
 123 /* { */
 124 /*     Window root; */
 125
 126 /*     int x, y; */
 127 /*     unsigned int w, h, bw, d; */
 128
 129 /*     XGetGeometry( fl_display, fl_window, &root, &x, &y, &w, &h, &bw, &d ); */
 130
 131 /*     fl_cairo_surface = cairo_create_surface( fl_gc, w, h ); */
 132
 133 /*     /\* FIXME: how are we going to free this? *\/ */
 134 /*     fl_cairo_context = cairo_create( fl_cairo_surface ); */
 135
 136 /*     cairo_surface_destroy( fl_cairo_surface ); */
 137
 138 /*     fl_cairo_surface = 0; */
 139 /* } */
 140
 141
 142 #define set_cairo_matrix() \
 143 { \
 144     cairo_t *cr = fl_cairo_context; \
 145     if ( sptr ) \
 146          cairo_set_matrix( cr, &m );                     \
 147     else \
 148         cairo_identity_matrix( cr ); \
 149 }
 150
 151 #define restore_cairo_matrix() \
 152 { \
 153     cairo_t *cr = fl_cairo_context; \
 154     cairo_identity_matrix( cr ); \
 155 }
 156
 157
 158 void Fl_Cairo_Graphics_Driver::push_matrix ( void )
 159 {
 160     cairo_t *cr = Fl::cairo_cc();
 161
 162   cairo_get_matrix( cr, &m );
 163
 164   if (sptr==FL_MATRIX_STACK_SIZE)
 165     Fl::error("fl_push_matrix(): matrix stack overflow.");
 166   else
 167     stack[sptr++] = m;
 168 }
 169
 170 void Fl_Cairo_Graphics_Driver::pop_matrix ( void )
 171 {
 172     if (sptr==0)
 173         Fl::error("fl_pop_matrix(): matrix stack underflow.");
 174     else
 175         m = stack[--sptr];
 176
 177     set_cairo_matrix();
 178 }
 179
 180 void Fl_Cairo_Graphics_Driver::translate ( double x, double y )
 181 {
 182     cairo_matrix_translate( &m, x, y );
 183
 184     set_cairo_matrix();
 185 }
 186
 187 void Fl_Cairo_Graphics_Driver::scale ( double x, double y )
 188 {
 189     cairo_matrix_scale( &m, x, y );
 190
 191     set_cairo_matrix();
 192 }
 193
 194 void Fl_Cairo_Graphics_Driver::rotate ( double a )
 195 {
 196     cairo_matrix_rotate( &m, a * ( M_PI / 180.0 ) );
 197
 198     set_cairo_matrix();
 199 }
 200
 201 void Fl_Cairo_Graphics_Driver::mult_matrix ( double a, double b, double c, double d, double x, double y )
 202 {
 203     cairo_matrix_t m2;
 204
 205     cairo_matrix_init( &m2, a, b, c, d, x, y );
 206
 207     cairo_matrix_multiply( &m, &m2, &m );
 208
 209     set_cairo_matrix();
 210 }
 211
 212 void Fl_Cairo_Graphics_Driver::line_style ( int style, int t, char* )
 213 {
 214     cairo_t *cr = Fl::cairo_cc();
 215
 216     if ( t == 0 || t == 1 )
 217     {
 218         double w1, w2;
 219         w1 = w2 = 1.0;
 220         cairo_device_to_user_distance (cr, &w1, &w2);
 221         lw = w1 > w2 ? w1 : w2;
 222     }
 223     else
 224         lw = t;
 225
 226     hlw = lw / 2.0;
 227
 228     cairo_set_line_width( cr, lw );
 229
 230     cairo_set_line_cap( cr, CAIRO_LINE_CAP_BUTT );
 231
 232     if ( style & FL_DASH )
 233     {
 234         const double dash[] = { lw, lw };
 235         int len  = sizeof(dash) / sizeof(dash[0]);
 236
 237         cairo_set_dash( cr, dash, len, 0 );
 238     }
 239     else if ( style & FL_DOT )
 240     {
 241         const double dash[] = { lw, lw };
 242         int len  = sizeof(dash) / sizeof(dash[0]);
 243
 244         cairo_set_dash( cr, dash, len, 0 );
 245
 246         cairo_set_line_cap( cr, CAIRO_LINE_CAP_ROUND );
 247     }
 248     else
 249     {
 250         cairo_set_dash( cr, NULL, 0, 0 );
 251     }
 252 }
 253
 254 void Fl_Cairo_Graphics_Driver::color ( Fl_Color c )
 255 {
 256     uchar r,g,b;
 257
 258     Fl_Xlib_Graphics_Driver::color( c );
 259
 260     if ( ( c & 0x000000ff ) && ! ( c & 0xFFFFFF00 ) )
 261     {
 262         /* color is indexed, get the RGB value */
 263         Fl::get_color( c, r, g, b );
 264
 265         /* FIXME: temp! */
 266         color( r, g, b );
 267        /* color( 255, 0, 0, 50 ); */
 268     }
 269     else
 270     {
 271         Fl::get_color( c & 0xFFFFFF00, r, g, b );
 272
 273         /* lower 8 bits become alpha. */
 274         uchar a = c & 0x000000ff;
 275
 276         if ( ! a )
 277             a = 255;
 278
 279         /* /\* HACK to represent black *\/ */
 280         /* if ( ( c & 0xFFFFFF00 ) == 0x01010100 ) */
 281         /*     r = g = b = 0; */
 282
 283         color( r, g, b, a );
 284     }
 285 }
 286
 287 void Fl_Cairo_Graphics_Driver::color ( uchar r, uchar g, uchar b )
 288 {
 289     cairo_t *cr = Fl::cairo_cc();
 290
 291     Fl_Xlib_Graphics_Driver::color( r, g, b );
 292
 293     if ( ! cr )
 294         return;
 295
 296     cairo_set_source_rgb( cr, r * BSCALE, g * BSCALE, b * BSCALE );
 297 }
 298
 299 void fl_set_antialias ( int v )
 300 {
 301     switch ( v )
 302     {
 303         case FL_ANTIALIAS_DEFAULT:
 304             cairo_set_antialias( cr, aa = CAIRO_ANTIALIAS_DEFAULT );
 305             break;
 306         case FL_ANTIALIAS_ON:
 307             cairo_set_antialias( cr, aa = CAIRO_ANTIALIAS_GRAY );
 308             break;
 309         case FL_ANTIALIAS_OFF:
 310             cairo_set_antialias( cr, aa = CAIRO_ANTIALIAS_NONE );
 311             break;
 312     }
 313 }
 314
 315
 316 void Fl_Cairo_Graphics_Driver::color ( Fl_Color c, uchar a )
 317 {
 318     uchar r,g,b;
 319
 320     Fl::get_color( c, r, g, b );
 321
 322     Fl_Xlib_Graphics_Driver::color( c );
 323
 324     color( r, g, b, a);
 325 }
 326
 327 void Fl_Cairo_Graphics_Driver::color (uchar r, uchar g, uchar b, uchar a  )
 328 {
 329     cairo_t *cr = Fl::cairo_cc();
 330
 331 //    Fl_Xlib_Graphics_Driver::color( r, g, b );
 332
 333     if ( ! cr )
 334         return;
 335
 336     cairo_set_source_rgba( cr, r * BSCALE, g * BSCALE, b * BSCALE, a * BSCALE );
 337 }
 338
 339 void Fl_Cairo_Graphics_Driver::circle( double x, double y, double r )
 340 {
 341     cairo_t *cr = Fl::cairo_cc();
 342
 343     cairo_arc( cr, x, y, r, 0, 2.0f * M_PI );
 344
 345     restore_cairo_matrix();
 346
 347     if ( what == POLYGON )
 348         cairo_fill( cr );
 349     else
 350         cairo_stroke( cr );
 351
 352     set_cairo_matrix();
 353 }
 354
 355 /* static void add_arc( int x, int y, int w, int h, double a1, double a2 ) */
 356 /* { */
 357 /*     cairo_t *cr = Fl::cairo_cc(); */
 358
 359 /*     /\* const double line_width = cairo_get_line_width( cr ); *\/ */
 360
 361 /*     const double cx = x + ( 0.5f * w ); */
 362 /*     const double cy = y + ( 0.5f * h ); */
 363
 364 /*     /\* cairo_save( cr ); *\/ */
 365 /*     /\* cairo_translate( cr, cx, cy ); *\/ */
 366 /*     /\* cairo_scale( cr, w, h ); *\/ */
 367
 368 /*     /\* if ( a1 >  a2 ) *\/ */
 369 /*     /\*     cairo_arc( cr, 0.0, 0.0, 0.5, a1 * ( -M_PI / 180.0 ), a2 * ( -M_PI / 180.0 )); *\/ */
 370 /*     /\* else *\/ */
 371 /*     /\*     cairo_arc_negative( cr, 0.0, 0.0, 0.5, a1 * ( -M_PI / 180.0 ), a2 * ( -M_PI / 180.0 )); *\/ */
 372
 373
 374 /*     cairo_save( cr ); */
 375 /*     cairo_translate( cr, cx, cy ); */
 376 /*     cairo_scale( cr, w - 1, h - 1 ); */
 377
 378 /*     if ( a1 >  a2 ) */
 379 /*         cairo_arc( cr, 0.0, 0.0, 0.5, a1 * ( -M_PI / 180.0 ), a2 * ( -M_PI / 180.0 )); */
 380 /*     else */
 381 /*         cairo_arc_negative( cr, 0.0, 0.0, 0.5, a1 * ( -M_PI / 180.0 ), a2 * ( -M_PI / 180.0 )); */
 382
 383
 384 /*     cairo_restore( cr );  */
 385 /* } */
 386
 387 static void add_arc( int x, int y, int w, int h, double a1, double a2, bool pie )
 388 {
 389     cairo_t *cr = Fl::cairo_cc();
 390
 391     double a1R = a1 * ( M_PI / 180.0 );
 392     double a2R = a2 * ( M_PI / 180.0 );
 393
 394     double cx = x + 0.5 * w, cy = y + 0.5 * h;
 395
 396     cairo_save( cr );
 397
 398     cairo_translate( cr, cx, cy );
 399 //    cairo_scale( cr, (w - lw), 0 - ((h - lw) ));
 400     cairo_scale( cr, w, 0 - h );
 401
 402     if ( a1 > a2 )
 403         cairo_arc_negative( cr, 0.0, 0.0, 0.5, a1R, a2R );
 404     else
 405         cairo_arc( cr, 0.0, 0.0, 0.5, a1R, a2R );
 406
 407     if ( pie )
 408     {
 409         cairo_line_to( cr, 0, 0 );
 410         cairo_close_path( cr );
 411     }
 412
 413     cairo_restore( cr );
 414 }
 415
 416 void Fl_Cairo_Graphics_Driver::arc( int x, int y, int w, int h, double a1, double a2 )
 417 {
 418     cairo_t *cr = Fl::cairo_cc();
 419
 420     add_arc( x, y, w, h, a1, a2, false );
 421
 422     restore_cairo_matrix();
 423
 424     cairo_stroke( cr );
 425
 426     set_cairo_matrix();
 427 }
 428
 429 void Fl_Cairo_Graphics_Driver::arc( double x, double y, double r, double a1, double a2 )
 430 {
 431     cairo_t *cr = Fl::cairo_cc();
 432
 433     cairo_close_path( cr );
 434
 435     cairo_arc( cr, x, y, r, a1 * ( -M_PI / 180.0 ), a2 * ( -M_PI / 180.0 ));
 436 }
 437
 438 void Fl_Cairo_Graphics_Driver::pie( int x, int y, int w, int h, double a1, double a2 )
 439 {
 440     cairo_t *cr = Fl::cairo_cc();
 441
 442     add_arc( x, y, w, h, a1, a2, true );
 443
 444     restore_cairo_matrix();
 445
 446     cairo_fill( cr );
 447
 448     set_cairo_matrix();
 449 }
 450
 451 void Fl_Cairo_Graphics_Driver::line( int x1, int y1, int x2, int y2 )
 452 {
 453     cairo_t *cr = Fl::cairo_cc();
 454
 455     cairo_set_line_width( cr, lw );
 456
 457 //    restore_cairo_matrix();
 458
 459     if ( x1 == x2 )
 460     {
 461         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 462         /* vertical line */
 463
 464         if ( y1 > y2 )
 465         {
 466             int t = y2;
 467             y2 = y1;
 468             y1 = t;
 469         }
 470
 471         cairo_move_to( cr, VXO( x1 ), VYO( y1 ) );
 472         cairo_line_to( cr, VXO( x2 ), VHO( y2 ) );
 473     }
 474     else if ( y1 == y2 )
 475     {
 476         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 477         /* horizontal line */
 478         cairo_move_to( cr, HXO( x1 ), HYO( y1 ) );
 479         cairo_line_to( cr, HWO( x2 ), HYO( y2 ) );
 480     }
 481     else
 482     {
 483         /* diagonal line */
 484         cairo_move_to( cr, x1 , y1  );
 485         cairo_line_to( cr, x2 , y2  );
 486     }
 487
 488     cairo_stroke( cr );
 489
 490 //    set_cairo_matrix();
 491
 492     cairo_set_antialias( cr, aa );
 493 }
 494
 495 void Fl_Cairo_Graphics_Driver::line( int x1, int y1, int x2, int y2, int x3, int y3 )
 496 {
 497     cairo_t *cr = Fl::cairo_cc();
 498
 499     cairo_set_line_width( cr, lw );
 500
 501     if ( lw <= 1 )
 502     {
 503         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 504     }
 505
 506 //    restore_cairo_matrix();
 507
 508     cairo_move_to( cr, x1 , y1  );
 509     cairo_line_to( cr, x2 , y2  );
 510     cairo_line_to( cr, x3 , y3  );
 511
 512     cairo_stroke( cr );
 513
 514 //    set_cairo_matrix();
 515
 516     cairo_set_antialias( cr, aa );
 517 }
 518
 519
 520 void Fl_Cairo_Graphics_Driver::rect ( int x, int y, int w, int h )
 521 {
 522     cairo_t *cr = Fl::cairo_cc();
 523
 524     cairo_set_line_width( cr, lw );
 525
 526     /* cairo draws lines half inside and half outside of the path... */
 527
 528     /* const double line_width = cairo_get_line_width( cr ); */
 529     /* const double o = line_width / 2.0;     */
 530
 531     cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 532
 533 //    restore_cairo_matrix();
 534
 535 //    cairo_rectangle( cr, x + hlw, y + hlw, w - lw - 1, h - lw - 1);
 536     cairo_rectangle( cr, VXO( x ), HYO( y  ), w - 1, h - 1 );
 537
 538
 539     cairo_stroke( cr );
 540
 541 //    set_cairo_matrix();
 542
 543     cairo_set_antialias( cr, aa );
 544 }
 545
 546 void Fl_Cairo_Graphics_Driver::rectf ( int x, int y, int w, int h )
 547 {
 548     cairo_t *cr = Fl::cairo_cc();
 549
 550     cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 551
 552 //    restore_cairo_matrix();
 553
 554     /* cairo fills the inside of the path... */
 555     cairo_rectangle( cr, x, y, w, h );
 556
 557     cairo_fill( cr );
 558
 559 //    set_cairo_matrix();
 560
 561     cairo_set_antialias( cr, aa );
 562 }
 563
 564
 565 void Fl_Cairo_Graphics_Driver::begin_line ( void )
 566 {
 567     what = LINE;
 568     npoints = 0;
 569 }
 570
 571 void Fl_Cairo_Graphics_Driver::begin_points ( void )
 572 {
 573     what = POINT_;
 574     npoints = 0;
 575 }
 576
 577 void Fl_Cairo_Graphics_Driver::begin_polygon ( void )
 578 {
 579     what = POLYGON;
 580     npoints = 0;
 581 }
 582
 583 void Fl_Cairo_Graphics_Driver::begin_loop ( void )
 584 {
 585     what = LOOP;
 586     npoints = 0;
 587 }
 588
 589 void Fl_Cairo_Graphics_Driver::begin_complex_polygon ( void )
 590 {
 591     what = POLYGON;
 592     npoints = 0;
 593 }
 594
 595 void Fl_Cairo_Graphics_Driver::end_line ( void )
 596 {
 597    cairo_t *cr = Fl::cairo_cc();
 598
 599    if ( lw <= 1 )
 600    {
 601        cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 602    }
 603
 604    cairo_set_line_width( cr, lw );
 605
 606    restore_cairo_matrix();
 607
 608    cairo_stroke( cr );
 609
 610    set_cairo_matrix();
 611
 612    cairo_set_antialias( cr, aa );
 613 }
 614
 615 void Fl_Cairo_Graphics_Driver::end_points ( void )
 616 {
 617    cairo_t *cr = Fl::cairo_cc();
 618
 619    cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 620
 621    cairo_fill( cr );
 622
 623    cairo_set_antialias( cr, aa );
 624 }
 625
 626 void Fl_Cairo_Graphics_Driver::end_loop ( void )
 627 {
 628     if ( npoints < 3 )
 629     {
 630         end_line();
 631         return;
 632     }
 633
 634    cairo_t *cr = Fl::cairo_cc();
 635    cairo_close_path( cr );
 636    end_line();
 637 }
 638
 639
 640 /* static double last_vertex_x; */
 641 /* static double last_vertex_y; */
 642
 643 void Fl_Cairo_Graphics_Driver::vertex ( double x, double y )
 644 {
 645     cairo_t *cr = Fl::cairo_cc();
 646
 647     if ( !npoints )
 648         cairo_move_to( cr, x, y );
 649     else
 650         cairo_line_to( cr, x, y );
 651
 652     ++npoints;
 653 }
 654
 655 void Fl_Cairo_Graphics_Driver::gap ( void )
 656 {
 657     npoints = 0;
 658 }
 659
 660 void Fl_Cairo_Graphics_Driver::end_complex_polygon ( void )
 661 {
 662     if ( npoints < 3 )
 663     {
 664         end_line();
 665         return;
 666     }
 667
 668    cairo_t *cr = Fl::cairo_cc();
 669
 670    cairo_close_path( cr );
 671
 672    restore_cairo_matrix();
 673
 674    cairo_fill( cr );
 675
 676    set_cairo_matrix();
 677 }
 678
 679 void Fl_Cairo_Graphics_Driver::end_polygon ( void )
 680 {
 681     if ( npoints < 3 )
 682     {
 683         end_line();
 684         return;
 685     }
 686
 687    cairo_t *cr = Fl::cairo_cc();
 688
 689    cairo_close_path( cr );
 690
 691    restore_cairo_matrix();
 692
 693    cairo_fill( cr );
 694
 695    set_cairo_matrix();
 696 }
 697
 698 void Fl_Cairo_Graphics_Driver::curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 )
 699 {
 700     cairo_t *cr = Fl::cairo_cc();
 701
 702     cairo_move_to( cr, x, y );
 703     cairo_curve_to( cr, x1, y1, x2, y2, x3, y3 );
 704 }
 705
 706 void Fl_Cairo_Graphics_Driver::polygon ( int x, int y, int x1, int y1, int x2, int y2 )
 707 {
 708     cairo_t *cr = Fl::cairo_cc();
 709
 710     cairo_move_to( cr, x , y  );
 711     cairo_line_to( cr, x1 , y1  );
 712     cairo_line_to( cr, x2 , y2  );
 713     cairo_close_path( cr );
 714     cairo_fill( cr );
 715 }
 716
 717 void Fl_Cairo_Graphics_Driver::polygon ( int x, int y, int x1, int y1, int x2, int y2, int x3, int y3 )
 718 {
 719     cairo_t *cr = Fl::cairo_cc();
 720
 721     cairo_move_to( cr, x , y  );
 722     cairo_line_to( cr, x1 , y1  );
 723     cairo_line_to( cr, x2 , y2  );
 724     cairo_line_to( cr, x3 , y3  );
 725     cairo_close_path( cr );
 726     cairo_fill( cr );
 727 }
 728
 729 void Fl_Cairo_Graphics_Driver::loop ( int x, int y, int x1, int y1, int x2, int y2 )
 730 {
 731     cairo_t *cr = Fl::cairo_cc();
 732
 733     cairo_move_to( cr, x , y  );
 734     cairo_line_to( cr, x1 , y1  );
 735     cairo_line_to( cr, x2 , y2  );
 736     cairo_close_path( cr );
 737     cairo_stroke( cr );
 738 }
 739
 740 void Fl_Cairo_Graphics_Driver::loop ( int x, int y, int x1, int y1, int x2, int y2, int x3, int y3 )
 741 {
 742     cairo_t *cr = Fl::cairo_cc();
 743
 744     cairo_move_to( cr, x , y  );
 745     cairo_line_to( cr, x1 , y1  );
 746     cairo_line_to( cr, x2 , y2  );
 747     cairo_line_to( cr, x3 , y3  );
 748     cairo_close_path( cr );
 749     cairo_stroke( cr );
 750 }
 751
 752
 753 void Fl_Cairo_Graphics_Driver::xyline ( int x, int y, int x1 )
 754 {
 755     cairo_t *cr = Fl::cairo_cc();
 756
 757     cairo_set_line_width( cr, lw );
 758
 759
 760     if ( lw <= 1 )
 761     {
 762         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 763     }
 764
 765     cairo_move_to( cr, HXO( x ), HYO( y ) );
 766     cairo_line_to( cr, HWO( x1 ), HYO( y ) );
 767
 768     cairo_stroke( cr );
 769
 770     cairo_set_antialias( cr, aa );
 771 }
 772
 773 void Fl_Cairo_Graphics_Driver::xyline ( int x, int y, int x1, int y2 )
 774 {
 775     cairo_t *cr = Fl::cairo_cc();
 776
 777     cairo_set_line_width( cr, lw );
 778
 779     if ( lw <= 1 )
 780     {
 781         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 782     }
 783
 784     /* horizontal line */
 785     cairo_move_to( cr, HXO( x ) , HYO( y ) );
 786     cairo_line_to( cr, HWO( x1 ), HYO( y ) );
 787     /* then vertical line */
 788     cairo_line_to( cr, HWO( x1 ) , VYO( y2 ) );
 789
 790     cairo_stroke( cr );
 791
 792     cairo_set_antialias( cr, aa );
 793
 794 }
 795
 796 void Fl_Cairo_Graphics_Driver::xyline ( int x, int y, int x1, int y2, int x3 )
 797 {
 798     cairo_t *cr = Fl::cairo_cc();
 799
 800     if ( lw <= 1 )
 801     {
 802         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 803     }
 804
 805     cairo_move_to( cr, x , y  );
 806     cairo_line_to( cr, x1 , y  );
 807     cairo_line_to( cr, x1 , y2  );
 808     cairo_line_to( cr, x3 , y2  );
 809
 810     cairo_stroke( cr );
 811
 812     cairo_set_antialias( cr, aa );
 813 }
 814
 815 void Fl_Cairo_Graphics_Driver::yxline ( int x, int y, int y1 )
 816 {
 817     cairo_t *cr = Fl::cairo_cc();
 818
 819     cairo_set_line_width( cr, lw );
 820
 821     if ( lw <= 1 )
 822     {
 823         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 824     }
 825
 826     cairo_move_to( cr, VXO( x ), VHO( y ) );
 827     cairo_line_to( cr, VXO( x ), VYO( y1 ) );
 828
 829     cairo_stroke( cr );
 830
 831     cairo_set_antialias( cr, aa );
 832 }
 833
 834 void Fl_Cairo_Graphics_Driver::yxline ( int x, int y, int y1, int x2 )
 835 {
 836     cairo_t *cr = Fl::cairo_cc();
 837
 838     if ( lw <= 1 )
 839     {
 840         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 841     }
 842
 843     cairo_move_to( cr, x , y );
 844     cairo_line_to( cr, x, y1  );
 845     cairo_line_to( cr, x2, y1  );
 846
 847     cairo_stroke( cr );
 848
 849     cairo_set_antialias( cr, aa );
 850 }
 851
 852 void Fl_Cairo_Graphics_Driver::yxline ( int x, int y, int y1, int x2, int y3 )
 853 {
 854     cairo_t *cr = Fl::cairo_cc();
 855
 856     if ( lw <= 1 )
 857     {
 858         cairo_set_antialias( cr, CAIRO_ANTIALIAS_NONE );
 859     }
 860
 861     cairo_move_to( cr, x , y  );
 862     cairo_line_to( cr, x , y1  );
 863     cairo_line_to( cr, x2 , y1  );
 864     cairo_line_to( cr, x2 , y3  );
 865
 866     cairo_stroke( cr );
 867
 868     cairo_set_antialias( cr, aa );
 869 }
 870
 871 static int start(Fl_RGB_Image *img, int XP, int YP, int WP, int HP, int w, int h, int &cx, int &cy,
 872                  int &X, int &Y, int &W, int &H)
 873 {
 874   fl_clip_box(XP,YP,WP,HP,X,Y,W,H);
 875
 876   cx += X-XP; cy += Y-YP;
 877   // clip the box down to the size of image, quit if empty:
 878   if (cx < 0) {W += cx; X -= cx; cx = 0;}
 879   if (cx+W > w) W = w-cx;
 880   if (W <= 0) return 1;
 881   if (cy < 0) {H += cy; Y -= cy; cy = 0;}
 882   if (cy+H > h) H = h-cy;
 883   if (H <= 0) return 1;
 884
 885   return 0;
 886 }
 887
 888 void
 889 Fl_Cairo_Graphics_Driver::draw(Fl_RGB_Image *img, int XP, int YP, int WP, int HP, int cx, int cy)
 890 {
 891   int X, Y, W, H;
 892
 893   // Don't draw an empty image...
 894   if (!img->d() || !img->array) {
 895 //    img->draw_empty(XP, YP);
 896     return;
 897   }
 898
 899   if (start(img, XP, YP, WP, HP, img->w(), img->h(), cx, cy, X, Y, W, H)) {
 900       return;
 901   }
 902
 903   /* if (!img->id_) { */
 904   /*   img->id_ = fl_create_offscreen(img->w(), img->h()); */
 905   /*   if ((img->d() == 2 || img->d() == 4) ) { */
 906   /*     fl_begin_offscreen((Fl_Offscreen)img->id_); */
 907   /*     fl_draw_image(img->array, 0, 0, img->w(), img->h(), img->d()|FL_IMAGE_WITH_ALPHA, img->ld()); */
 908   /*     fl_end_offscreen(); */
 909   /*   } */
 910   /* } */
 911
 912   cairo_t *cr = Fl::cairo_cc();
 913
 914   cairo_format_t fmt = CAIRO_FORMAT_ARGB32;
 915
 916   switch (img->d() )
 917   {
 918       case 4:
 919           fmt = CAIRO_FORMAT_ARGB32;
 920           break;
 921       case 3:
 922           fmt = CAIRO_FORMAT_RGB24;
 923           break;
 924       case 1:
 925           fmt = CAIRO_FORMAT_A8;
 926           break;
 927   }
 928
 929   /* cairo_save( cr ); */
 930
 931   /* cairo_reset_clip( cr ); */
 932
 933   cairo_surface_t *image = cairo_image_surface_create_for_data( (unsigned char *)img->array, fmt, img->w(), img->h( ),
 934                                                                 cairo_format_stride_for_width( fmt, img->w() ) );
 935
 936   /* cairo_surface_t *image = cairo_image_surface_create_for_data( (unsigned char *)img->array, fmt, img->w(), img->h(), img->ld() ); */
 937
 938
 939   /* cairo_patter_t *pat = cairo_surface_pattern( image ); */
 940
 941   /* cairo_matrix_t matr; */
 942
 943   /* cairo_matrix_scale( &matr,   */
 944
 945   cairo_set_source_surface( cr, image, X - cx, Y - cy );
 946
 947   cairo_rectangle( cr, X, Y, W, H );
 948
 949   cairo_fill(cr);
 950
 951   cairo_surface_destroy( image );
 952
 953   /* cairo_restore( cr ); */
 954 }
 955