   return mix(white, circleColor, circleColor.a);
 }
 
-vec4 draw_double_edge(float pos, float len, float pixelsPerFragment) {
-  float total_border_width = len;
-  float one_third_width = total_border_width / 3.0;
-
-  // Contribution of the outer border segment.
-  float alpha = alpha_for_solid_border(pos,
-                                       total_border_width - one_third_width,
-                                       total_border_width,
-                                       pixelsPerFragment);
-
-  // Contribution of the inner border segment.
-  alpha += alpha_for_solid_border(pos, 0, one_third_width, pixelsPerFragment);
-  return get_fragment_color(vDistanceFromMixLine, pixelsPerFragment) * vec4(1, 1, 1, alpha);
-}
-
-vec4 draw_double_edge_vertical(float pixelsPerFragment) {
-  // Get our position within this specific segment
-  float position = vLocalPos.x - vLocalRect.x;
-  return draw_double_edge(position, vLocalRect.z, pixelsPerFragment);
-}
-
-vec4 draw_double_edge_horizontal(float pixelsPerFragment) {
-  // Get our position within this specific segment
-  float position = vLocalPos.y - vLocalRect.y;
-  return draw_double_edge(position, vLocalRect.w, pixelsPerFragment);
-}
-
-vec4 draw_double_edge_corner_with_radius(float pixelsPerFragment) {
-  float total_border_width = vRadii.x - vRadii.z;
-  float one_third_width = total_border_width / 3.0;
-
-  // Contribution of the outer border segment.
-  float alpha = alpha_for_solid_border_corner(vLocalPos,
-                                              vRadii.x - one_third_width,
-                                              vRadii.x,
-                                              pixelsPerFragment);
-
-  // Contribution of the inner border segment.
-  alpha += alpha_for_solid_border_corner(vLocalPos,
-                                         vRadii.z,
-                                         vRadii.z + one_third_width,
-                                         pixelsPerFragment);
-  return get_fragment_color(vDistanceFromMixLine, pixelsPerFragment) * vec4(1, 1, 1, alpha);
-}
-
-vec4 draw_double_edge_corner(float pixelsPerFragment) {
-  if (vRadii.x > 0) {
-    return draw_double_edge_corner_with_radius(pixelsPerFragment);
-  }
-
-  bool is_vertical = (vBorderPart == PST_TOP_LEFT) ? vDistanceFromMixLine < 0 :
-                                                     vDistanceFromMixLine >= 0;
-  if (is_vertical) {
-    return draw_double_edge_vertical(pixelsPerFragment);
-  } else {
-    return draw_double_edge_horizontal(pixelsPerFragment);
-  }
-}
-
 // Our current edge calculation is based only on
 // the size of the border-size, but we need to draw
 // the dashes in the center of the segment we're drawing.

  }
}


// TODO: Investigate performance of this shader and see
//       if it's worthwhile splitting it / removing branches etc.
void main(void) {

    float distance_from_mix_line = (local_pos.x - vPieceRect.x) * vPieceRect.w -
                                   (local_pos.y - vPieceRect.y) * vPieceRect.z;
    distance_from_mix_line /= vPieceRectHypotenuseLength;

    switch (vBorderStyle) {
        case BORDER_STYLE_DASHED:
        case BORDER_STYLE_DOTTED:
        case BORDER_STYLE_OUTSET:
        case BORDER_STYLE_INSET:
        case BORDER_STYLE_SOLID:
        case BORDER_STYLE_NONE:
          draw_solid_border(distance_from_mix_line, local_pos);
          break;
        case BORDER_STYLE_DOUBLE:
          draw_double_border(distance_from_mix_line, local_pos);
          break;
        default:
          discard;

    }

    oFragColor *= vec4(1, 1, 1, alpha);
#else
    switch (vBorderStyle) {
        case BORDER_STYLE_DASHED:
