Pileus Git - ~andy/gtk/blob - gtk/gtkroundedbox.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2011 Benjamin Otte <otte@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gtkroundedboxprivate.h"
  21
  22 #include "gtkcsscornervalueprivate.h"
  23 #include "gtkcsstypesprivate.h"
  24 #include "gtkstylecontextprivate.h"
  25 #include "gtkthemingengineprivate.h"
  26
  27 #include <string.h>
  28
  29 /**
  30  * _gtk_rounded_box_init_rect:
  31  * @box: box to initialize
  32  * @x: x coordinate of box
  33  * @y: y coordinate of box
  34  * @width: width of box
  35  * @height: height of box
  36  *
  37  * Initializes the given @box to represent the given rectangle.
  38  * The
  39  **/
  40 void
  41 _gtk_rounded_box_init_rect (GtkRoundedBox *box,
  42                             double         x,
  43                             double         y,
  44                             double         width,
  45                             double         height)
  46 {
  47   memset (box, 0, sizeof (GtkRoundedBox));
  48
  49   box->box.x = x;
  50   box->box.y = y;
  51   box->box.width = width;
  52   box->box.height = height;
  53 }
  54
  55 /* clamp border radius, following CSS specs */
  56 static void
  57 gtk_rounded_box_clamp_border_radius (GtkRoundedBox *box)
  58 {
  59   gdouble factor = 1.0;
  60
  61   /* note: division by zero leads to +INF, which is > factor, so will be ignored */
  62   factor = MIN (factor, box->box.width / (box->corner[GTK_CSS_TOP_LEFT].horizontal +
  63                                           box->corner[GTK_CSS_TOP_RIGHT].horizontal));
  64   factor = MIN (factor, box->box.height / (box->corner[GTK_CSS_TOP_RIGHT].vertical +
  65                                            box->corner[GTK_CSS_BOTTOM_RIGHT].vertical));
  66   factor = MIN (factor, box->box.width / (box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal +
  67                                           box->corner[GTK_CSS_BOTTOM_LEFT].horizontal));
  68   factor = MIN (factor, box->box.height / (box->corner[GTK_CSS_TOP_LEFT].vertical +
  69                                            box->corner[GTK_CSS_BOTTOM_LEFT].vertical));
  70
  71   box->corner[GTK_CSS_TOP_LEFT].horizontal *= factor;
  72   box->corner[GTK_CSS_TOP_LEFT].vertical *= factor;
  73   box->corner[GTK_CSS_TOP_RIGHT].horizontal *= factor;
  74   box->corner[GTK_CSS_TOP_RIGHT].vertical *= factor;
  75   box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal *= factor;
  76   box->corner[GTK_CSS_BOTTOM_RIGHT].vertical *= factor;
  77   box->corner[GTK_CSS_BOTTOM_LEFT].horizontal *= factor;
  78   box->corner[GTK_CSS_BOTTOM_LEFT].vertical *= factor;
  79 }
  80
  81 static void
  82 _gtk_rounded_box_apply_border_radius (GtkRoundedBox *box,
  83                                       GtkCssValue **corner,
  84                                       GtkJunctionSides junction)
  85 {
  86   if (corner[GTK_CSS_TOP_LEFT] && (junction & GTK_JUNCTION_CORNER_TOPLEFT) == 0)
  87     {
  88       box->corner[GTK_CSS_TOP_LEFT].horizontal = _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_LEFT],
  89                                                                               box->box.width);
  90       box->corner[GTK_CSS_TOP_LEFT].vertical = _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_LEFT],
  91                                                                             box->box.height);
  92     }
  93   if (corner[GTK_CSS_TOP_RIGHT] && (junction & GTK_JUNCTION_CORNER_TOPRIGHT) == 0)
  94     {
  95       box->corner[GTK_CSS_TOP_RIGHT].horizontal = _gtk_css_corner_value_get_x (corner[GTK_CSS_TOP_RIGHT],
  96                                                                                box->box.width);
  97       box->corner[GTK_CSS_TOP_RIGHT].vertical = _gtk_css_corner_value_get_y (corner[GTK_CSS_TOP_RIGHT],
  98                                                                              box->box.height);
  99     }
 100   if (corner[GTK_CSS_BOTTOM_RIGHT] && (junction & GTK_JUNCTION_CORNER_BOTTOMRIGHT) == 0)
 101     {
 102       box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal = _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_RIGHT],
 103                                                                                   box->box.width);
 104       box->corner[GTK_CSS_BOTTOM_RIGHT].vertical = _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_RIGHT],
 105                                                                                 box->box.height);
 106     }
 107   if (corner[GTK_CSS_BOTTOM_LEFT] && (junction & GTK_JUNCTION_CORNER_BOTTOMLEFT) == 0)
 108     {
 109       box->corner[GTK_CSS_BOTTOM_LEFT].horizontal = _gtk_css_corner_value_get_x (corner[GTK_CSS_BOTTOM_LEFT],
 110                                                                                  box->box.width);
 111       box->corner[GTK_CSS_BOTTOM_LEFT].vertical = _gtk_css_corner_value_get_y (corner[GTK_CSS_BOTTOM_LEFT],
 112                                                                                box->box.height);
 113     }
 114
 115   gtk_rounded_box_clamp_border_radius (box);
 116 }
 117
 118 void
 119 _gtk_rounded_box_apply_border_radius_for_context (GtkRoundedBox    *box,
 120                                                   GtkStyleContext  *context,
 121                                                   GtkJunctionSides  junction)
 122 {
 123   GtkCssValue *corner[4];
 124
 125   corner[GTK_CSS_TOP_LEFT] = _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS);
 126   corner[GTK_CSS_TOP_RIGHT] = _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS);
 127   corner[GTK_CSS_BOTTOM_LEFT] = _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS);
 128   corner[GTK_CSS_BOTTOM_RIGHT] = _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS);
 129
 130   _gtk_rounded_box_apply_border_radius (box, corner, junction);
 131 }
 132
 133 void
 134 _gtk_rounded_box_apply_border_radius_for_engine (GtkRoundedBox    *box,
 135                                                  GtkThemingEngine *engine,
 136                                                  GtkJunctionSides  junction)
 137 {
 138   _gtk_rounded_box_apply_border_radius_for_context (box, _gtk_theming_engine_get_context (engine), junction);
 139 }
 140
 141 static void
 142 gtk_css_border_radius_grow (GtkRoundedBoxCorner *corner,
 143                             double               horizontal,
 144                             double               vertical)
 145 {
 146   corner->horizontal += horizontal;
 147   corner->vertical += vertical;
 148
 149   if (corner->horizontal <= 0 || corner->vertical <= 0)
 150     {
 151       corner->horizontal = 0;
 152       corner->vertical = 0;
 153     }
 154 }
 155 void
 156 _gtk_rounded_box_grow (GtkRoundedBox *box,
 157                        double         top,
 158                        double         right,
 159                        double         bottom,
 160                        double         left)
 161 {
 162   if (box->box.width + left + right < 0)
 163     {
 164       box->box.x -= left * box->box.width / (left + right);
 165       box->box.width = 0;
 166     }
 167   else
 168     {
 169       box->box.x -= left;
 170       box->box.width += left + right;
 171     }
 172
 173   if (box->box.height + bottom + right < 0)
 174     {
 175       box->box.y -= top * box->box.height / (top + bottom);
 176       box->box.height = 0;
 177     }
 178   else
 179     {
 180       box->box.y -= top;
 181       box->box.height += top + bottom;
 182     }
 183
 184   gtk_css_border_radius_grow (&box->corner[GTK_CSS_TOP_LEFT], left, top);
 185   gtk_css_border_radius_grow (&box->corner[GTK_CSS_TOP_RIGHT], right, bottom);
 186   gtk_css_border_radius_grow (&box->corner[GTK_CSS_BOTTOM_RIGHT], right, top);
 187   gtk_css_border_radius_grow (&box->corner[GTK_CSS_BOTTOM_LEFT], left, bottom);
 188 }
 189
 190 void
 191 _gtk_rounded_box_shrink (GtkRoundedBox *box,
 192                          double         top,
 193                          double         right,
 194                          double         bottom,
 195                          double         left)
 196 {
 197   _gtk_rounded_box_grow (box, -top, -right, -bottom, -left);
 198 }
 199
 200 void
 201 _gtk_rounded_box_move (GtkRoundedBox *box,
 202                        double         dx,
 203                        double         dy)
 204 {
 205   box->box.x += dx;
 206   box->box.y += dy;
 207 }
 208
 209 static void
 210 _cairo_ellipsis (cairo_t *cr,
 211                  double xc, double yc,
 212                  double xradius, double yradius,
 213                  double angle1, double angle2)
 214 {
 215   if (xradius <= 0.0 || yradius <= 0.0)
 216     {
 217       cairo_line_to (cr, xc, yc);
 218       return;
 219     }
 220
 221   cairo_save (cr);
 222   cairo_translate (cr, xc, yc);
 223   cairo_scale (cr, xradius, yradius);
 224   cairo_arc (cr, 0, 0, 1.0, angle1, angle2);
 225   cairo_restore (cr);
 226 }
 227
 228 static void
 229 _cairo_ellipsis_negative (cairo_t *cr,
 230                           double xc, double yc,
 231                           double xradius, double yradius,
 232                           double angle1, double angle2)
 233 {
 234   if (xradius <= 0.0 || yradius <= 0.0)
 235     {
 236       cairo_line_to (cr, xc, yc);
 237       return;
 238     }
 239
 240   cairo_save (cr);
 241   cairo_translate (cr, xc, yc);
 242   cairo_scale (cr, xradius, yradius);
 243   cairo_arc_negative (cr, 0, 0, 1.0, angle1, angle2);
 244   cairo_restore (cr);
 245 }
 246
 247 void
 248 _gtk_rounded_box_path (const GtkRoundedBox *box,
 249                        cairo_t             *cr)
 250 {
 251   cairo_new_sub_path (cr);
 252
 253   _cairo_ellipsis (cr,
 254                    box->box.x + box->corner[GTK_CSS_TOP_LEFT].horizontal,
 255                    box->box.y + box->corner[GTK_CSS_TOP_LEFT].vertical,
 256                    box->corner[GTK_CSS_TOP_LEFT].horizontal,
 257                    box->corner[GTK_CSS_TOP_LEFT].vertical,
 258                    G_PI, 3 * G_PI / 2);
 259   _cairo_ellipsis (cr,
 260                    box->box.x + box->box.width - box->corner[GTK_CSS_TOP_RIGHT].horizontal,
 261                    box->box.y + box->corner[GTK_CSS_TOP_RIGHT].vertical,
 262                    box->corner[GTK_CSS_TOP_RIGHT].horizontal,
 263                    box->corner[GTK_CSS_TOP_RIGHT].vertical,
 264                    - G_PI / 2, 0);
 265   _cairo_ellipsis (cr,
 266                    box->box.x + box->box.width - box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 267                    box->box.y + box->box.height - box->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 268                    box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 269                    box->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 270                    0, G_PI / 2);
 271   _cairo_ellipsis (cr,
 272                    box->box.x + box->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 273                    box->box.y + box->box.height - box->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 274                    box->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 275                    box->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 276                    G_PI / 2, G_PI);
 277
 278   cairo_close_path (cr);
 279 }
 280
 281 double
 282 _gtk_rounded_box_guess_length (const GtkRoundedBox *box,
 283                                GtkCssSide           side)
 284 {
 285   double length;
 286   GtkCssCorner before, after;
 287
 288   before = side;
 289   after = (side + 1) % 4;
 290
 291   if (side & 1)
 292     length = box->box.height
 293              - box->corner[before].vertical
 294              - box->corner[after].vertical;
 295   else
 296     length = box->box.width
 297              - box->corner[before].horizontal
 298              - box->corner[after].horizontal;
 299
 300   length += G_PI * 0.125 * (box->corner[before].horizontal
 301                             + box->corner[before].vertical
 302                             + box->corner[after].horizontal
 303                             + box->corner[after].vertical);
 304
 305   return length;
 306 }
 307
 308 void
 309 _gtk_rounded_box_path_side (const GtkRoundedBox *box,
 310                             cairo_t             *cr,
 311                             GtkCssSide           side)
 312 {
 313   switch (side)
 314     {
 315     case GTK_CSS_TOP:
 316       _cairo_ellipsis (cr,
 317                        box->box.x + box->corner[GTK_CSS_TOP_LEFT].horizontal,
 318                        box->box.y + box->corner[GTK_CSS_TOP_LEFT].vertical,
 319                        box->corner[GTK_CSS_TOP_LEFT].horizontal,
 320                        box->corner[GTK_CSS_TOP_LEFT].vertical,
 321                        5 * G_PI / 4, 3 * G_PI / 2);
 322       _cairo_ellipsis (cr,
 323                        box->box.x + box->box.width - box->corner[GTK_CSS_TOP_RIGHT].horizontal,
 324                        box->box.y + box->corner[GTK_CSS_TOP_RIGHT].vertical,
 325                        box->corner[GTK_CSS_TOP_RIGHT].horizontal,
 326                        box->corner[GTK_CSS_TOP_RIGHT].vertical,
 327                        - G_PI / 2, -G_PI / 4);
 328       break;
 329     case GTK_CSS_RIGHT:
 330       _cairo_ellipsis (cr,
 331                        box->box.x + box->box.width - box->corner[GTK_CSS_TOP_RIGHT].horizontal,
 332                        box->box.y + box->corner[GTK_CSS_TOP_RIGHT].vertical,
 333                        box->corner[GTK_CSS_TOP_RIGHT].horizontal,
 334                        box->corner[GTK_CSS_TOP_RIGHT].vertical,
 335                        - G_PI / 4, 0);
 336       _cairo_ellipsis (cr,
 337                        box->box.x + box->box.width - box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 338                        box->box.y + box->box.height - box->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 339                        box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 340                        box->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 341                        0, G_PI / 4);
 342       break;
 343     case GTK_CSS_BOTTOM:
 344       _cairo_ellipsis (cr,
 345                        box->box.x + box->box.width - box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 346                        box->box.y + box->box.height - box->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 347                        box->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 348                        box->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 349                        G_PI / 4, G_PI / 2);
 350       _cairo_ellipsis (cr,
 351                        box->box.x + box->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 352                        box->box.y + box->box.height - box->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 353                        box->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 354                        box->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 355                        G_PI / 2, 3 * G_PI / 4);
 356       break;
 357     case GTK_CSS_LEFT:
 358       _cairo_ellipsis (cr,
 359                        box->box.x + box->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 360                        box->box.y + box->box.height - box->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 361                        box->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 362                        box->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 363                        3 * G_PI / 4, G_PI);
 364       _cairo_ellipsis (cr,
 365                        box->box.x + box->corner[GTK_CSS_TOP_LEFT].horizontal,
 366                        box->box.y + box->corner[GTK_CSS_TOP_LEFT].vertical,
 367                        box->corner[GTK_CSS_TOP_LEFT].horizontal,
 368                        box->corner[GTK_CSS_TOP_LEFT].vertical,
 369                        G_PI, 5 * G_PI / 4);
 370       break;
 371     default:
 372       g_assert_not_reached ();
 373       break;
 374     }
 375 }
 376
 377 void
 378 _gtk_rounded_box_path_top (const GtkRoundedBox *outer,
 379                            const GtkRoundedBox *inner,
 380                            cairo_t             *cr)
 381 {
 382   cairo_new_sub_path (cr);
 383
 384   _cairo_ellipsis (cr,
 385                    outer->box.x + outer->corner[GTK_CSS_TOP_LEFT].horizontal,
 386                    outer->box.y + outer->corner[GTK_CSS_TOP_LEFT].vertical,
 387                    outer->corner[GTK_CSS_TOP_LEFT].horizontal,
 388                    outer->corner[GTK_CSS_TOP_LEFT].vertical,
 389                    5 * G_PI / 4, 3 * G_PI / 2);
 390   _cairo_ellipsis (cr,
 391                    outer->box.x + outer->box.width - outer->corner[GTK_CSS_TOP_RIGHT].horizontal,
 392                    outer->box.y + outer->corner[GTK_CSS_TOP_RIGHT].vertical,
 393                    outer->corner[GTK_CSS_TOP_RIGHT].horizontal,
 394                    outer->corner[GTK_CSS_TOP_RIGHT].vertical,
 395                    - G_PI / 2, -G_PI / 4);
 396
 397   _cairo_ellipsis_negative (cr,
 398                             inner->box.x + inner->box.width - inner->corner[GTK_CSS_TOP_RIGHT].horizontal,
 399                             inner->box.y + inner->corner[GTK_CSS_TOP_RIGHT].vertical,
 400                             inner->corner[GTK_CSS_TOP_RIGHT].horizontal,
 401                             inner->corner[GTK_CSS_TOP_RIGHT].vertical,
 402                             -G_PI / 4, - G_PI / 2);
 403   _cairo_ellipsis_negative (cr,
 404                             inner->box.x + inner->corner[GTK_CSS_TOP_LEFT].horizontal,
 405                             inner->box.y + inner->corner[GTK_CSS_TOP_LEFT].vertical,
 406                             inner->corner[GTK_CSS_TOP_LEFT].horizontal,
 407                             inner->corner[GTK_CSS_TOP_LEFT].vertical,
 408                             3 * G_PI / 2, 5 * G_PI / 4);
 409
 410   cairo_close_path (cr);
 411 }
 412
 413 void
 414 _gtk_rounded_box_path_right (const GtkRoundedBox *outer,
 415                              const GtkRoundedBox *inner,
 416                              cairo_t             *cr)
 417 {
 418   cairo_new_sub_path (cr);
 419
 420   _cairo_ellipsis (cr,
 421                    outer->box.x + outer->box.width - outer->corner[GTK_CSS_TOP_RIGHT].horizontal,
 422                    outer->box.y + outer->corner[GTK_CSS_TOP_RIGHT].vertical,
 423                    outer->corner[GTK_CSS_TOP_RIGHT].horizontal,
 424                    outer->corner[GTK_CSS_TOP_RIGHT].vertical,
 425                    - G_PI / 4, 0);
 426   _cairo_ellipsis (cr,
 427                    outer->box.x + outer->box.width - outer->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 428                    outer->box.y + outer->box.height - outer->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 429                    outer->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 430                    outer->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 431                    0, G_PI / 4);
 432
 433   _cairo_ellipsis_negative (cr,
 434                             inner->box.x + inner->box.width - inner->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 435                             inner->box.y + inner->box.height - inner->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 436                             inner->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 437                             inner->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 438                             G_PI / 4, 0);
 439   _cairo_ellipsis_negative (cr,
 440                             inner->box.x + inner->box.width - inner->corner[GTK_CSS_TOP_RIGHT].horizontal,
 441                             inner->box.y + inner->corner[GTK_CSS_TOP_RIGHT].vertical,
 442                             inner->corner[GTK_CSS_TOP_RIGHT].horizontal,
 443                             inner->corner[GTK_CSS_TOP_RIGHT].vertical,
 444                             0, - G_PI / 4);
 445
 446   cairo_close_path (cr);
 447 }
 448
 449 void
 450 _gtk_rounded_box_path_bottom (const GtkRoundedBox *outer,
 451                               const GtkRoundedBox *inner,
 452                               cairo_t             *cr)
 453 {
 454   cairo_new_sub_path (cr);
 455
 456   _cairo_ellipsis (cr,
 457                    outer->box.x + outer->box.width - outer->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 458                    outer->box.y + outer->box.height - outer->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 459                    outer->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 460                    outer->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 461                    G_PI / 4, G_PI / 2);
 462   _cairo_ellipsis (cr,
 463                    outer->box.x + outer->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 464                    outer->box.y + outer->box.height - outer->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 465                    outer->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 466                    outer->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 467                    G_PI / 2, 3 * G_PI / 4);
 468
 469   _cairo_ellipsis_negative (cr,
 470                             inner->box.x + inner->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 471                             inner->box.y + inner->box.height - inner->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 472                             inner->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 473                             inner->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 474                             3 * G_PI / 4, G_PI / 2);
 475   _cairo_ellipsis_negative (cr,
 476                             inner->box.x + inner->box.width - inner->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 477                             inner->box.y + inner->box.height - inner->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 478                             inner->corner[GTK_CSS_BOTTOM_RIGHT].horizontal,
 479                             inner->corner[GTK_CSS_BOTTOM_RIGHT].vertical,
 480                             G_PI / 2, G_PI / 4);
 481
 482   cairo_close_path (cr);
 483 }
 484
 485 void
 486 _gtk_rounded_box_path_left (const GtkRoundedBox *outer,
 487                             const GtkRoundedBox *inner,
 488                             cairo_t             *cr)
 489 {
 490   cairo_new_sub_path (cr);
 491
 492   _cairo_ellipsis (cr,
 493                    outer->box.x + outer->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 494                    outer->box.y + outer->box.height - outer->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 495                    outer->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 496                    outer->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 497                    3 * G_PI / 4, G_PI);
 498   _cairo_ellipsis (cr,
 499                    outer->box.x + outer->corner[GTK_CSS_TOP_LEFT].horizontal,
 500                    outer->box.y + outer->corner[GTK_CSS_TOP_LEFT].vertical,
 501                    outer->corner[GTK_CSS_TOP_LEFT].horizontal,
 502                    outer->corner[GTK_CSS_TOP_LEFT].vertical,
 503                    G_PI, 5 * G_PI / 4);
 504
 505   _cairo_ellipsis_negative (cr,
 506                             inner->box.x + inner->corner[GTK_CSS_TOP_LEFT].horizontal,
 507                             inner->box.y + inner->corner[GTK_CSS_TOP_LEFT].vertical,
 508                             inner->corner[GTK_CSS_TOP_LEFT].horizontal,
 509                             inner->corner[GTK_CSS_TOP_LEFT].vertical,
 510                             5 * G_PI / 4, G_PI);
 511   _cairo_ellipsis_negative (cr,
 512                             inner->box.x + inner->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 513                             inner->box.y + inner->box.height - inner->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 514                             inner->corner[GTK_CSS_BOTTOM_LEFT].horizontal,
 515                             inner->corner[GTK_CSS_BOTTOM_LEFT].vertical,
 516                             G_PI, 3 * G_PI / 4);
 517
 518   cairo_close_path (cr);
 519 }
 520
 521 void
 522 _gtk_rounded_box_clip_path (const GtkRoundedBox *box,
 523                             cairo_t             *cr)
 524 {
 525   cairo_rectangle (cr,
 526                    box->box.x, box->box.y,
 527                    box->box.width, box->box.height);
 528 }
 529