include <units.inc>;
include <stock_parts.scad>;

frame_size = 20;
wall_thickness = 2;
corner_size=30;
// The length along each edge that the corner bracket takes.  I.e., if
// you construct a frame of four corner brackets and 4 tubes of length
// $L-$corner_size, the distance between opposite tubes' centerlines
// will be $L.
corner_offset = frame_size / 2 + wall_thickness;
rail_diam = 8;

ysled_extralen = frame_size; // on each end

// calculated

ysled_rail_spacing = (sled_ysize);




// Generates bar of length $l, centered on origin extending in +Z
module tslot(l) {
  colorize(stock_color) {
    translate([-frame_size/2, -frame_size/2, 0])
      cube([frame_size, frame_size, l]);
  }
}

// A corner, with tubes extending in +x and +y.
module corner_base() {
  odim = frame_size/2 + wall_thickness;
  ldim = frame_size/2 + corner_size;
  cap_points = [[-odim, -odim],
		[-odim,  ldim],
		[ odim,  ldim],
		[ ldim,  odim],
		[ ldim, -odim]];
  difference() {
    translate([0, 0, -odim])
      linear_extrude(odim * 2)
      polygon(points = cap_points);
    
    // two bars...
    translate([-frame_size/2, corner_offset, -frame_size/2])
      cube([frame_size, ldim, frame_size]);
    translate([corner_offset, -frame_size/2, -frame_size/2])
      cube([ldim, frame_size, frame_size]);
    translate([corner_offset, corner_offset, -frame_size/2])
      cube([ldim, ldim, frame_size]);
    //translate([-odim - 1, -odim - 1, 0])
    //cube(ldim*2);
  }
}

module rail_holder(in_x) {
  odim = frame_size/2 + wall_thickness;
  ldim = frame_size/2 + corner_size;
  tube_offset = (corner_size) / 2 + wall_thickness;
  tube_rotation = in_x ? 90 : 0;
  translate([frame_size/2, frame_size/2, -frame_size/2]) {
    difference() {
      linear_extrude(frame_size)
	polygon(points = [[wall_thickness, wall_thickness],
			  [wall_thickness, corner_size],
			  [corner_size, wall_thickness]]);
      translate([corner_size / 2, corner_size/2, frame_size/2])
	rotate([tube_rotation -90, tube_rotation, 0])
	translate([0, 0, -corner_size])
	cylinder(d = rail_diam, corner_size * 2);
		
    }
  }
}

// centered on 
module ysled_slider(spread, associated_parts = false) {
  sled_len = spread + frame_size;
  sled_height = frame_size;
  
  colorize("green")
  render()
  translate([0, -sled_len/2, 0])
  rotate([-90, 0, 0]) {
    difference() {
      union() {
	translate([-frame_size/2, -frame_size/2, 0])
	  cube([frame_size + 5, frame_size, sled_len]);
      }
      
      cylinder(d = bushing_id * 1.1, h = sled_len);
      
      translate([0,0,-1])
	cylinder(d = bushing_od, h = bushing_len+1);
      translate([0,0,sled_len - bushing_len])
	cylinder(d = bushing_od, h = bushing_len+1);

      for (zpos = [frame_size / 2, sled_len - frame_size / 2]) {
	translate([sled_height/2, 0, zpos]) 
	rotate([0,90,0]) {
	  cylinder(h = sled_height + 1, d = rail_diam);
	}
      }
    }
  }
  // TODO: add posts for the idlers
  
  translate([0, -sled_len/2, 0])
  rotate([-90, 0, 0])
  if (associated_parts) {
    bushing();
    translate([0,0,sled_len - bushing_len]) bushing();
  }
}

module flcorner() {
  translate([0, 0, 0])
  rotate([0, 0, 0]) {
    corner_base();
    rail_holder(false);
  }
}

module frcorner() {
  rotate([0, 0, 90]) {
    corner_base();
    rail_holder(true);
  }
}

module blcorner() {
  rotate([0, 0, 270]) {
    corner_base();
    rail_holder(true);
  }
}

module brcorner() {
  rotate([0, 0, 180]) {
    corner_base();
    rail_holder(false);
  }
}

module xsled_slider() {
  slider_len = bushing_len + 10;
  screw_tab_len = 20;
  screw_tab_thickness = 10;
  
  render()
    //translate([screw_tab_len, 0, 0])
  difference() {
    union() {
      rotate([0, 90, 0]) {
	cylinder(d = frame_size, h = slider_len);
      }

      translate([0, -frame_size/2, 0])
      cube([slider_len, frame_size, frame_size / 2]);

      *translate([-screw_tab_len, -frame_size/2, frame_size/2])
	cube([screw_tab_len * 2 + slider_len, frame_size, screw_tab_thickness]);
    }
    rotate([0, 90, 0]) {
      cylinder(d = bushing_od, h = bushing_len);
      cylinder(d = rail_diam * 1.1, slider_len * 2);
    }
    
  }
  rotate([0, 90, 0])
    *bushing();
}

module sled_cornera() {
  corner_base();
  translate([-frame_size/2 - wall_thickness, 0, -frame_size])
    xsled_slider();
}

module sled_cornerb() {
  corner_base();
  rotate([0,0,90])
  translate([-frame_size/2 - wall_thickness, 0, -frame_size])
    xsled_slider();
}

module xsled_frame() {
  translate([-sled_xsize / 2 + corner_offset, -ysled_rail_spacing/2, 0])
    rotate([0, 90, 0])
    tslot(sled_xsize - corner_offset * 2);
  translate([-sled_xsize / 2 + corner_offset, ysled_rail_spacing/2, 0])
    rotate([0, 90, 0])
    tslot(sled_xsize - corner_offset * 2);
  translate([-sled_xsize / 2, -ysled_rail_spacing/2 + corner_offset, 0])
    rotate([-90, 0, 0])
    tslot(sled_ysize - corner_offset * 2);
  translate([sled_xsize / 2, -ysled_rail_spacing/2 + corner_offset, 0])
    rotate([-90, 0, 0])
    tslot(sled_ysize - corner_offset * 2);

  translate([-sled_xsize / 2, -sled_ysize / 2, 0])
    sled_cornera();
  translate([sled_xsize / 2, sled_ysize / 2, 0])
    rotate([0,0,180])
    sled_cornera();
  
  translate([sled_xsize / 2, -sled_ysize / 2, 0])
    rotate([0,0,90])
    sled_cornerb();
  translate([-sled_xsize / 2, sled_ysize / 2, 0])
    rotate([0,0,270])
    sled_cornerb();
  
}