result looks good, code looks TERRIBLE 8)

have a class (Digit) containing a two dimensional array for digits, each one containing booleans denoting which segments are lit for that digit.

then have a method that takes the digit number and lights up the relevant segments.

then this abomination:

Code:

void secSpot2(){
  pushMatrix();
  scale(0.8);
  translate(411,414);
  switch (s) {
  case 1:
  case 11:
  case 21:
  case 31:
  case 41:
  case 51:
    num1();
    break;
  case 2:
  case 12:
  case 22:
  case 32:
  case 42:
  case 52:
    num2();
    break;
  case 3:
  case 13:
  case 23:
  case 33:
  case 43:
  case 53:
    num3();
    break;
  case 4:
  case 14:
  case 24:
  case 34:
  case 44:
  case 54:
    num4();
    break;
  case 5:
  case 15:
  case 25:
  case 35:
  case 45:
  case 55:
    num5();
    break;
  case 6:
  case 16:
  case 26:
  case 36:
  case 46:
  case 56:
    num6();
    break;
  case 7:
  case 17:
  case 27:
  case 37:
  case 47:
  case 57:
    num7();
    break;
  case 8:
  case 18:
  case 28:
  case 38:
  case 48:
  case 58:
    num8();
    break;
  case 9:
  case 19:
  case 29:
  case 39:
  case 49:
  case 59:
    num9();
    break;
  case 0:
  case 10:
  case 20:
  case 30:
  case 40:
  case 50:
  case 60:
    num0();
    break;
  } 
  popMatrix();
}
 

can be replaced with
Code:

void secSpot2(){
  pushMatrix();
  scale(0.8);
  translate(411,414);
  Digit.draw(s % 10);  // the new digit class
  popMatrix();
}
 

% is modulo, or 'remainder' so 11 % 1 = 1.

(all the Spot1 code should use floor(s / 10) )

/ is divide and floor picks the integer part of the result

so 21 / 10 = 2.1 and floor(2.1) = 2

even if you move all the num0, num1... code into a method that takes a parameter, num(int digit) say, and use the above instead of those huge switch statements, that'd be a great improvement.

like i say, the result looks great but if you're repeating stuff over and over again like that it's a sign that something is wrong.

and replaced your timepieces file with the following Digit class (the variable definition at the top is because this is an inner class so i can't make everything static like i'd like to)

Code:

Digit digit = new Digit();

class Digit {
  
  public static final int SEG_TOP = (0x1 << 0);
  public static final int SEG_MID = (0x1 << 1);
  public static final int SEG_BOT = (0x1 << 2);
  public static final int SEG_TOP_L = (0x1 << 3);
  public static final int SEG_TOP_R = (0x1 << 4);
  public static final int SEG_BOT_L = (0x1 << 5);
  public static final int SEG_BOT_R = (0x1 << 6);
  
  // define which bars light for which digit (uses a bitfield)
  final int[] segments = {
    /* 0 */ SEG_TOP | SEG_TOP_L | SEG_TOP_R | SEG_BOT_L | SEG_BOT_R | SEG_BOT,
    /* 1 */ SEG_TOP_R | SEG_BOT_R,
    /* 2 */ SEG_TOP | SEG_TOP_R | SEG_MID | SEG_BOT_L | SEG_BOT,
    /* 3 */ SEG_TOP | SEG_TOP_R | SEG_MID | SEG_BOT_R | SEG_BOT,
    /* 4 */ SEG_TOP_L | SEG_TOP_R | SEG_MID | SEG_BOT_R,
    /* 5 */ SEG_TOP | SEG_TOP_L | SEG_MID | SEG_BOT_R | SEG_BOT,
    /* 6 */ SEG_TOP | SEG_TOP_L | SEG_MID | SEG_BOT_L | SEG_BOT_R | SEG_BOT,
    /* 7 */ SEG_TOP | SEG_TOP_R | SEG_BOT_R,
    /* 8 */ SEG_TOP | SEG_TOP_L | SEG_TOP_R | SEG_MID | SEG_BOT_L | SEG_BOT_R | SEG_BOT,
    /* 9 */ SEG_TOP | SEG_TOP_L | SEG_TOP_R | SEG_MID | SEG_BOT_R | SEG_BOT
  };
  
  // TODO move pushMatrix, translate and popMatrix to horizDashTop() etc
  public void draw(int digit) {
    // check whether this digit shows this segment
    // uses binary AND for testing individual bits
    if ((segments[digit] & SEG_TOP) != 0) {
	pushMatrix();
	translate(1, 0);
	horizDashTop();
	popMatrix();
    }
    if ((segments[digit] & SEG_MID) != 0) {
	pushMatrix();
	translate(2,19);
	horizDashMid();
	popMatrix();
    }
    if ((segments[digit] & SEG_BOT) != 0) {
	pushMatrix();
	translate(1, 38);
	horizDashBott();
	popMatrix();
    }
    if ((segments[digit] & SEG_TOP_L) != 0) {
	pushMatrix();
	translate(0,2);
	vertDashLTop();
	popMatrix();
    }
    if ((segments[digit] & SEG_TOP_R) != 0) {
	pushMatrix();
	translate(16,2);
	vertDashRTop();
	popMatrix();
    }
    if ((segments[digit] & SEG_BOT_L) != 0) {
	pushMatrix();
	translate(0,22);
	vertDashLBott();
	popMatrix();
    }
    if ((segments[digit] & SEG_BOT_R) != 0) {
	pushMatrix();
	translate(16,22);
	vertDashRBott();
	popMatrix();
    }
  }
}
 

(74 lines rather than 274)

same thing is possible with the date stuff.

oh, the other thing i meant to say was to use frameRate(2); in your setup - my processor usage went from 90+% to about 10% after i did this - there's no point updating the screen 60 times a second if what you're displaying only updates once a second 8)

the SEG_TOP things is the old C way of using integers to represent sets. you can represent as many boolean values as you have bits in an int

0x1 << 0 = 1 or 00000001
0x1 << 1 = 2 or 00000010
0x1 << 2 = 4 or 00000100

(you sometimes see these things defined as 0x1, 0x2, 0x4, 0x8 etc but that gets fiddly above 10 or so bits)

and you can OR these together to set as many bits as you like

00000001 | (SEG_TOP)
00000010 = (SEG_MID)
00000011 (SEG_TOP and SEG_MID both set)

which is what the segments array is setting up.

and this

Code:

if ((segments[digit] & SEG_BOT_R) != 0) {
 

checks to see if the relevant bit is set (is easier in C as you don't need the compare as anything that isn't 0 is taken as boolean true)

see Uses Of Bitmasks here
http://en.wikipedia.org/wiki/Mask_(computing)

it is a bit arcane these days, this stuff. when i started we didn't have the luxury of gigs of memory and got used to bit twiddling like this to save space 8)

public static final on a variable marks it out as a constant, something that can't be changed (the UPPERCASE name for constants is also a common thing)