#!/usr/bin/env python

from Tkinter import *
from math import log, log10, pi, tan, sin

_SCALEWIDTH = 900 # from left index to right index
_MARGINWIDTH = 50 # white space to the left and right of the indices
_RULEWIDTH = _MARGINWIDTH + _SCALEWIDTH + _MARGINWIDTH
_SLIDESCROLLWIDTH = float(_SCALEWIDTH + _RULEWIDTH + _SCALEWIDTH)
_SCALEHEIGHT = 28
_TEXTHEIGHT = 7

### ----------------------------------------

class Mark(object):

    def __init__(self, value, height, labelled=False):
        """A mark, an element of a Scale's markList.

        value: either a number like 2.1, or a string like '2.1'

        height: maybe 10 for the major marks, 8 for the next, etc.

        labelled: If true, draw the value above or below the mark.
        """
        self.value = float(value)
        self.stringName = str(value) if labelled else None
        self.height = height

class GaugeMark(object):

    def __init__(self, value, marking=''):
        """Add a gauge mark."""
        self.value = float(value)
        self.stringName = marking
        self.height = 10

### markList for C, D, CI and DI
_markListC = []
for x in xrange(1, 11):
   _markListC.append(Mark(x, 10, True))
for d1 in xrange(1, 10):
    _markListC.append(Mark('1.%d' % d1, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListC.append(Mark('%d.%d' % (d0, d1), 10))
_markListC.append(Mark(2.5, 10, True))
_markListC.append(Mark(3.5, 10, True))
_markListC.append(Mark(4.5, 10, True))
for d1 in xrange(0, 10):
    for d2 in xrange(2, 10, 2):
        _markListC.append(Mark('1.%d%d' % (d1, d2), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListC.append(Mark('%d.%d5' % (d0, d1), 5))
for x in xrange(5, 10):
    _markListC.append(Mark('%d.5' % (x), 10))
for d0 in xrange(5, 10):
    for d1 in xrange(1, 5):
        _markListC.append(Mark(d0 + 0.1*d1, 5))
for d0 in xrange(5, 10):
    for d1 in xrange(6, 10):
        _markListC.append(Mark(d0 + 0.1*d1, 5))

_markListCC = list(_markListC)

_markListA = []
for x in xrange(1, 11):
    _markListA.append(Mark(x, 10, True))
    _markListA.append(Mark(x*10, 10, True))
for x in xrange(1, 4):
    _markListA.append(Mark(x+0.5, 10))
    _markListA.append(Mark(10*x+5, 10))
    for x1 in xrange(1,5):
        _markListA.append(Mark(x+0.1*x1, 5))
        _markListA.append(Mark(10*x+x1, 5))
        _markListA.append(Mark(x+0.1*x1+0.5, 5))
        _markListA.append(Mark(10*x+x1+5, 5))
for d0 in xrange(4, 10):
    for d1 in xrange(2, 10, 2):
        _markListA.append(Mark(d0+0.1*d1, 5))
        _markListA.append(Mark(10*d0+d1, 5))

_markListK = []
for x in xrange(1, 11):
    _markListK.append(Mark(x, 10, True))
    _markListK.append(Mark(x*10, 10, True))
    _markListK.append(Mark(x*100, 10))
for x in xrange(1, 6):
    _markListK.append(Mark(x*100, 10, True))
_markListK.append(Mark(1000, 10, True))
for d0 in xrange(1, 3):
    _markListK.append(Mark(d0+0.5, 10))
    _markListK.append(Mark(10*d0+5, 10))
    _markListK.append(Mark(100*d0+50, 10))
    for d1 in xrange(1, 5):
        _markListK.append(Mark(d0+0.1*d1, 5))
        _markListK.append(Mark(10*d0+d1, 5))
        _markListK.append(Mark(100*d0+10*d1, 5))
        _markListK.append(Mark(d0+0.1*d1+0.5, 5))
        _markListK.append(Mark(10*d0+d1+5, 5))
        _markListK.append(Mark(100*d0+10*d1+50, 5))
for d0 in xrange(3, 5):
    for d1 in xrange(2, 10, 2):
        _markListK.append(Mark(d0+0.1*d1, 5))
        _markListK.append(Mark(10*d0+d1, 5))
        _markListK.append(Mark(100*d0+10*d1, 5))
for x in xrange(5, 10):
    _markListK.append(Mark('%d.5' % (x), 5))
    _markListK.append(Mark('%d5' % (x), 5))
    _markListK.append(Mark('%d50' % (x), 5))

_markListEI0 = []
_markListEI1 = []
for x in xrange(1, 4):
    _markListEI0.append(Mark(x, 10, True))
for x in xrange(4, 11):
    _markListEI1.append(Mark(x, 10, True))
for x in xrange(1, 10):
    _markListEI0.append(Mark(1+0.1*x, 10, True))
for x in xrange(0, 10):
    _markListEI0.append(Mark(1+0.1*x+0.05, 10))
    for x1 in xrange(1, 5):
        _markListEI0.append(Mark(1+0.1*x+0.01*x1, 5))
        _markListEI0.append(Mark(1+0.1*x+0.01*x1+0.05, 5))
for x in xrange(1, 10):
    _markListEI0.append(Mark(2+0.1*x, 10))
_markListEI0.append(Mark(2.5, 10, True))
_markListEI0.append(Mark(3.1, 10))
_markListEI0.append(Mark(3.2, 10, True))
for d0 in xrange(20, 32):
    for d1 in xrange(2, 10, 2):
        _markListEI0.append(Mark(0.1*d0+0.01*d1, 5))
for d0 in xrange(3, 10):
    for d1 in xrange(1, 10):
        _markListEI1.append(Mark(d0+0.1*d1, 10))
for d0 in xrange(31, 50):
    for d1 in xrange(2, 10, 2):
        _markListEI1.append(Mark(0.1*d0+0.01*d1, 5))
for d0 in xrange(5, 10):
    for d1 in xrange(0, 10):
        _markListEI1.append(Mark(d0+0.1*d1+0.05, 5))
_markListEI1.append(Mark(3.1, 10, True))
_markListEI1.append(Mark(3.5, 10, True))
_markListEI1.append(Mark(4.5, 10, True))

_markListRI0 = []
_markListRI1 = []
_markListRI2 = []
for x in xrange(1, 3):
    _markListRI0.append(Mark(x, 10, True))
for x in xrange(3, 5):
    _markListRI1.append(Mark(x, 10, True))
for x in xrange(5, 11):
    _markListRI2.append(Mark(x, 10, True))

for x in xrange(1, 10):
    _markListRI0.append(Mark('1.%d' % (x), 10, True))
for x in xrange(0, 5):
    _markListRI0.append(Mark('1.%d5' % (x), 10, True))
for x in xrange(5, 10):
    _markListRI0.append(Mark('1.%d5' % (x), 10))
for d0 in xrange(0, 10):
    for d1 in xrange(1, 5):
        _markListRI0.append(Mark(1+0.1*d0+0.01*d1, 5))
        _markListRI0.append(Mark(1+0.1*d0+0.01*d1+0.05, 5))
_markListRI0.append(Mark(2.05, 10))
_markListRI0.append(Mark(2.1, 10, True))
_markListRI0.append(Mark(2.15, 10))
_markListRI0.append(Mark(2.2, 10))
for d0 in xrange(20, 22):
    for d1 in xrange(1, 5):
        _markListRI0.append(Mark(0.1*d0+0.01*d1, 5))
        _markListRI0.append(Mark(0.1*d0+0.01*d1+0.05, 5))
_markListRI1.append(Mark(2.1, 10, True))
_markListRI1.append(Mark(2.2, 10, True))
_markListRI1.append(Mark(2.3, 10, True))
_markListRI1.append(Mark(2.4, 10, True))
_markListRI1.append(Mark(2.5, 10, True))
_markListRI1.append(Mark(2.6, 10, True))
_markListRI1.append(Mark(2.7, 10, True))
_markListRI1.append(Mark(2.8, 10, True))
_markListRI1.append(Mark(2.9, 10, True))
for x in xrange(1, 10):
    _markListRI1.append(Mark('2.%d5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListRI1.append(Mark('2.%d%d' % (x, x1), 5))
        _markListRI1.append(Mark('2.%d%d' % (x, x1+5), 5))
for x in xrange(1, 10):
    _markListRI1.append(Mark('3.%d' % (x), 10))
_markListRI1.append(Mark(3.5, 10, True))
for d0 in xrange(0, 10):
    for d1 in xrange(2, 10, 2):
        _markListRI1.append(Mark('3.%d%d' % (d0, d1), 5))
_markListRI1.append(Mark(4.1, 10))
_markListRI1.append(Mark(4.2, 10))
_markListRI1.append(Mark(4.3, 10))
_markListRI1.append(Mark(4.4, 10))
_markListRI1.append(Mark(4.5, 10, True))
_markListRI1.append(Mark(4.6, 10))
_markListRI1.append(Mark(4.7, 10))
_markListRI2.append(Mark(4.6, 10, True))
_markListRI2.append(Mark(4.7, 10))
_markListRI2.append(Mark(4.8, 10))
_markListRI2.append(Mark(4.9, 10))
for d0 in xrange(0, 7):
    for d1 in xrange(2, 10, 2):
        _markListRI1.append(Mark('4.%d%d' % (d0, d1), 5))
for d0 in xrange(6, 10):
    for d1 in xrange(2, 10, 2):
        _markListRI2.append(Mark('4.%d%d' % (d0, d1), 5))
for x in xrange(5, 10):
    for x1 in xrange(1, 10):
        _markListRI2.append(Mark('%d.%d' % (x, x1), 10))
    _markListRI2.append(Mark('%d.5' % (x), 10, True))
    for x1 in xrange(0, 10):
        _markListRI2.append(Mark('%d.%d5' % (x, x1), 5))
        
_markListLL0 = []        
_markListLL1 = []        
_markListLL2 = []        
_markListLL3 = []

import math

_markListLL0.append(Mark(1.001, 10, True))
_markListLL0.append(Mark(1.01, 10, True))
_markListLL1.append(Mark(1.01, 10, True))
_markListLL1.append(Mark(1.105, 10))
_markListLL2.append(Mark(1.105, 10))
_markListLL2.append(Mark(2.72, 10, True))
_markListLL3.append(Mark(2.7, 10, True))
_markListLL3.append(Mark(22000, 10, True))

### ADD OTHER markLists HERE, DEPENDING ON WHAT YOU WANT.
### AS A MATTER OF FACT MR MCCONNELL DID

for x in xrange(2, 10):
   _markListLL0.append(Mark('1.00%d' % (x), 10, True))
for d1 in xrange(1, 10):
    _markListLL0.append(Mark('1.001%d' % d1, 10))
_markListLL0.append(Mark(1.0015, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListLL0.append(Mark('1.00%d%d' % (d0, d1), 10))
for d1 in xrange(0, 10):
    for d2 in xrange(2, 10, 2):
        _markListLL0.append(Mark('1.001%d%d' % (d1, d2), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListLL0.append(Mark('1.00%d%d5' % (d0, d1), 5))
for x in xrange(5, 10):
    _markListLL0.append(Mark('1.00%d5' % (x), 10))
for d0 in xrange(5, 10):
    for d1 in xrange(1, 5):
        _markListLL0.append(Mark(1 + 0.001*d0 + 0.0001*d1, 5))
for d0 in xrange(5, 10):
    for d1 in xrange(6, 10):
        _markListLL0.append(Mark(1 + 0.001*d0 + 0.0001*d1, 5))

for x in xrange(2, 10):
   _markListLL1.append(Mark('1.0%d' % (x), 10, True))
for d1 in xrange(1, 10):
    _markListLL1.append(Mark('1.01%d' % d1, 10))
_markListLL1.append(Mark(1.015, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListLL1.append(Mark('1.0%d%d' % (d0, d1), 10))
for d1 in xrange(0, 10):
    for d2 in xrange(2, 10, 2):
        _markListLL1.append(Mark('1.01%d%d' % (d1, d2), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListLL1.append(Mark('1.0%d%d5' % (d0, d1), 5))
for x in xrange(5, 10):
    _markListLL1.append(Mark('1.0%d5' % (x), 10))
for d0 in xrange(5, 10):
    for d1 in xrange(1, 5):
        _markListLL1.append(Mark(1 + 0.01*d0 + 0.001*d1, 5))
for d0 in xrange(5, 10):
    for d1 in xrange(6, 10):
        _markListLL1.append(Mark(1 + 0.01*d0 + 0.001*d1, 5))
_markListLL1.append(Mark(1.1, 10, True))
_markListLL1.append(Mark(1.102, 5))
_markListLL1.append(Mark(1.104, 5))

_markListLL2.append(Mark(1.106, 5))
_markListLL2.append(Mark(1.108, 5))
_markListLL2.append(Mark(1.11, 10, True))
for x in xrange(2, 10):
   _markListLL2.append(Mark('1.%d' % (x), 10, True))
for d1 in xrange(1, 10):
    _markListLL2.append(Mark('1.1%d' % d1, 10))
_markListLL2.append(Mark(1.15, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListLL2.append(Mark('1.%d%d' % (d0, d1), 10))
for d1 in xrange(1, 10):
    for d2 in xrange(2, 10, 2):
        _markListLL2.append(Mark('1.1%d%d' % (d1, d2), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListLL2.append(Mark('1.%d%d5' % (d0, d1), 5))
for x in xrange(5, 10):
    _markListLL2.append(Mark('1.%d5' % (x), 10))
for d0 in xrange(5, 10):
    for d1 in xrange(1, 5):
        _markListLL2.append(Mark(1 + 0.1*d0 + 0.01*d1, 5))
for d0 in xrange(5, 10):
    for d1 in xrange(6, 10):
        _markListLL2.append(Mark(1 + 0.1*d0 + 0.01*d1, 5))
_markListLL2.append(Mark(2, 10, True))
for x in xrange(1, 8):
    _markListLL2.append(Mark(2 + 0.1*x, 10))
_markListLL2.append(Mark(2.5, 10, True))
for x in xrange(0, 7):
    for x1 in xrange(2, 10, 2):
        _markListLL2.append(Mark('2.%d%d' % (x, x1), 5))

_markListLL3.append(Mark(2.8, 5))
_markListLL3.append(Mark(2.9, 5))
_markListLL3.append(Mark(3, 10, True))
for x in xrange(1, 10):
    _markListLL3.append(Mark(3+0.1*x, 5))
_markListLL3.append(Mark(3+0.5, 10, True))
_markListLL3.append(Mark(4, 10, True))
for x in xrange(1, 10):
    _markListLL3.append(Mark(4+0.1*x, 5))
_markListLL3.append(Mark(4+0.5, 10, True))
_markListLL3.append(Mark(5, 10, True))
_markListLL3.append(Mark(6, 10, True))
_markListLL3.append(Mark(7, 10, True))
_markListLL3.append(Mark(8, 10, True))
_markListLL3.append(Mark(9, 10, True))
for x in xrange(5, 10):
    for x1 in xrange(2, 10, 2):
        _markListLL3.append(Mark('%d.%d' % (x, x1), 5))
_markListLL3.append(Mark(10, 10, True))
_markListLL3.append(Mark(20, 10, True))
_markListLL3.append(Mark(30, 10, True))
_markListLL3.append(Mark(40, 10, True))
for x in xrange(10, 30, 10):
    _markListLL3.append(Mark(x+5, 10))
    for x1 in xrange(1, 5):
        _markListLL3.append(Mark(x+x1, 5))
        _markListLL3.append(Mark(x+x1+5, 5))
_markListLL3.append(Mark(50, 10, True))
_markListLL3.append(Mark(60, 10))
_markListLL3.append(Mark(70, 10))
_markListLL3.append(Mark(80, 10))
_markListLL3.append(Mark(90, 10))
for d0 in xrange(30, 50, 10):
    for d1 in xrange(2, 10, 2):
        _markListLL3.append(Mark(d0+d1, 5))
for x in xrange(50, 100, 10):
    _markListLL3.append(Mark(x+5, 5))
_markListLL3.append(Mark(100, 10, True))
_markListLL3.append(Mark(200, 10, True))
_markListLL3.append(Mark(300, 10, True))
_markListLL3.append(Mark(400, 10, True))
for x in xrange(100, 200, 100):
    _markListLL3.append(Mark(x+50, 10))
    for x1 in xrange(10, 50, 10):
        _markListLL3.append(Mark(x+x1, 5))
        _markListLL3.append(Mark(x+x1+50, 5))
_markListLL3.append(Mark(500, 10))
_markListLL3.append(Mark(600, 10))
_markListLL3.append(Mark(700, 10))
_markListLL3.append(Mark(800, 10))
_markListLL3.append(Mark(900, 10))
for d0 in xrange(200, 400, 100):
    for d1 in xrange(20, 100, 20):
        _markListLL3.append(Mark(d0+d1, 5))
for x in xrange(400, 1000, 100):
    _markListLL3.append(Mark(x+50, 5))
_markListLL3.append(Mark(1000, 10, True))
_markListLL3.append(Mark(2000, 10))
_markListLL3.append(Mark(3000, 10))
for d0 in xrange(1000, 3000, 1000):
    for d1 in xrange(200, 1000, 200):
        _markListLL3.append(Mark(d0+d1, 5))
_markListLL3.append(Mark(4000, 10))
_markListLL3.append(Mark(5000, 10))
_markListLL3.append(Mark(6000, 10))
_markListLL3.append(Mark(7000, 10))
_markListLL3.append(Mark(8000, 10))
_markListLL3.append(Mark(9000, 10))
for x in xrange(3000, 10000, 1000):
    _markListLL3.append(Mark(x+500, 5))
_markListLL3.append(Mark(10000, 10, True))
for d0 in xrange(10000, 20000, 10000):
    for d1 in xrange(2000, 10000, 2000):
        _markListLL3.append(Mark(d0+d1, 5))
_markListLL3.append(Mark(20000, 10))

_markListLLI0 = []
_markListLLI1 = []
_markListLLI2 = []
_markListLLI3 = []

_markListLLI0.append(Mark(0.999, 10, True))
_markListLLI0.append(Mark(0.99, 10, True))
_markListLLI1.append(Mark(0.99, 10, True))
_markListLLI1.append(Mark(0.905, 10))
_markListLLI2.append(Mark(0.905, 10))
_markListLLI2.append(Mark(0.36, 10, True))
_markListLLI3.append(Mark(0.37, 10, True))
_markListLLI3.append(Mark(0.0000454, 10))

for x in xrange(2, 10):
   _markListLLI0.append(Mark('0.99%d' % (10-int(x)), 10, True))
for d1 in xrange(1, 10):
    _markListLLI0.append(Mark('0.998%d' % (10-int(d1)), 10))
_markListLLI0.append(Mark(0.9985, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListLLI0.append(Mark('0.99%d%d' % (9-int(d0), 10-int(d1)), 10))
for d1 in xrange(0, 10):
    for d2 in xrange(2, 10, 2):
        _markListLLI0.append(Mark('0.998%d%d' % (9-int(d1), 10-int(d2)), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListLLI0.append(Mark('0.99%d%d5' % (9-int(d0), 9-int(d1)), 5))
for x in xrange(5, 10):
    _markListLLI0.append(Mark('0.99%d5' % (9-int(x)), 10))
for d0 in xrange(5, 10):
    for d1 in xrange(1, 5):
        _markListLLI0.append(Mark(1 - 0.001*d0 - 0.0001*d1, 5))
for d0 in xrange(5, 10):
    for d1 in xrange(6, 10):
        _markListLLI0.append(Mark(1 - 0.001*d0 - 0.0001*d1, 5))

for x in xrange(2, 10):
   _markListLLI1.append(Mark('0.9%d' % (10-int(x)), 10, True))
for d1 in xrange(1, 10):
    _markListLLI1.append(Mark('0.98%d' % (10-int(d1)), 10))
_markListLLI1.append(Mark(0.985, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListLLI1.append(Mark('0.9%d%d' % (9-int(d0), 10-int(d1)), 10))
for d1 in xrange(0, 10):
    for d2 in xrange(2, 10, 2):
        _markListLLI1.append(Mark('0.98%d%d' % (9-int(d1), 10-int(d2)), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListLLI1.append(Mark('0.9%d%d5' % (9-int(d0), 9-int(d1)), 5))
for x in xrange(5, 10):
    _markListLLI1.append(Mark('0.9%d5' % (9-int(x)), 10))
for d0 in xrange(5, 10):
    for d1 in xrange(1, 5):
        _markListLLI1.append(Mark(1 - 0.01*d0 - 0.001*d1, 5))
for d0 in xrange(5, 9):
    for d1 in xrange(6, 10):
        _markListLLI1.append(Mark(1 - 0.01*d0 - 0.001*d1, 5))
        
_markListLLI2.append(Mark(0.9, 10, True))
_markListLLI2.append(Mark(0.901, 5))
_markListLLI2.append(Mark(0.902, 5))
_markListLLI2.append(Mark(0.903, 5))
_markListLLI2.append(Mark(0.904, 5))

for x in xrange(2, 10):
    _markListLLI2.append(Mark('0.%d' % (10-int(x)), 10, True))
for d1 in xrange(1, 10):
    _markListLLI2.append(Mark('0.8%d' % (10-int(d1)), 10))
_markListLLI2.append(Mark(0.85, 10, True))
for d0 in xrange(2, 5):
    for d1 in xrange(1, 10):
        _markListLLI2.append(Mark('0.%d%d' % (9-int(d0), 10-int(d1)), 10))
for d1 in xrange(0, 10):
    for d2 in xrange(2, 10, 2):
        _markListLLI2.append(Mark('0.8%d%d' % (9-int(d1), 10-int(d2)), 5))
for d0 in xrange(2, 5):
    for d1 in xrange(0, 10):
        _markListLLI2.append(Mark('0.%d%d5' % (9-int(d0), 9-int(d1)), 5))
for x in xrange(5, 6):
    _markListLLI2.append(Mark('0.%d5' % (9-int(x)), 10))
for d0 in xrange(5, 7):
    for d1 in xrange(1, 5):
        _markListLLI2.append(Mark(1 - 0.1*d0 - 0.01*d1, 5))
for d0 in xrange(5, 6):
    for d1 in xrange(6, 10):
        _markListLLI2.append(Mark(1 - 0.1*d0 - 0.01*d1, 5))
        
_markListLLI3.append(Mark(0.36, 5))
_markListLLI3.append(Mark(0.35, 10, True))
_markListLLI3.append(Mark(0.34, 5))
_markListLLI3.append(Mark(0.33, 5))
_markListLLI3.append(Mark(0.32, 5))
_markListLLI3.append(Mark(0.31, 5))
_markListLLI3.append(Mark(0.3, 10, True))
_markListLLI3.append(Mark(0.25, 10, True))
for x in xrange(1, 10):
    _markListLLI3.append(Mark(0.2 + 0.01*x, 10))
    _markListLLI3.append(Mark(0.2 + 0.01*x + 0.005, 5))
_markListLLI3.append(Mark(0.205, 5))
_markListLLI3.append(Mark(0.2, 10, True))
_markListLLI3.append(Mark(0.15, 10, True))
_markListLLI3.append(Mark(0.1, 10, True))
for x in xrange(1, 10):
    _markListLLI3.append(Mark(0.1 + 0.01*x, 10))
    _markListLLI3.append(Mark(0.1 + 0.01*x + 0.005, 5))
_markListLLI3.append(Mark(0.105, 5))

_markListLLI3.append(Mark(0.01, 10, True))
_markListLLI3.append(Mark(0.001, 10, True))
_markListLLI3.append(Mark(0.0001, 10, True))
_markListLLI3.append(Mark(0.05, 10, True))
_markListLLI3.append(Mark(0.005, 10, True))
_markListLLI3.append(Mark(0.0005, 10, True))
_markListLLI3.append(Mark(0.02, 10, True))
_markListLLI3.append(Mark(0.015, 10))
for x in xrange(5, 10):
    _markListLLI3.append(Mark('0.0%d5' % (x), 5))
    _markListLLI3.append(Mark('0.00%d5' % (x), 5))
_markListLLI3.append(Mark(0.0045, 5))
_markListLLI3.append(Mark(0.042, 5))
_markListLLI3.append(Mark(0.044, 5))
_markListLLI3.append(Mark(0.046, 5))
_markListLLI3.append(Mark(0.048, 5))
for x in xrange(1, 5):
    _markListLLI3.append(Mark(0.01*x, 10))
    _markListLLI3.append(Mark(0.001*x, 10))
    _markListLLI3.append(Mark(0.0001*x, 10))
    _markListLLI3.append(Mark(0.01*x+0.05, 10))
    _markListLLI3.append(Mark(0.001*x+0.005, 10))
    _markListLLI3.append(Mark(0.0001*x+0.0005, 10))

for x in xrange(2, 4):
    for x1 in xrange(2, 10, 2):
        _markListLLI3.append(Mark('0.0%d%d' % (x, x1), 5))
        _markListLLI3.append(Mark('0.00%d%d' % (x, x1), 5))
        _markListLLI3.append(Mark('0.001%d' % (x1), 5))
for x in xrange(1, 10):
    _markListLLI3.append(Mark('0.01%d' % (x), 5))
_markListLLI3.append(Mark(0.00045, 5))
_markListLLI3.append(Mark(0.00035, 5))
_markListLLI3.append(Mark(0.00025, 5))
_markListLLI3.append(Mark(0.00015, 5))
_markListLLI3.append(Mark(0.00005, 10))
_markListLLI3.append(Mark(0.00006, 5))
_markListLLI3.append(Mark(0.00007, 5))
_markListLLI3.append(Mark(0.00008, 5))
_markListLLI3.append(Mark(0.00009, 5))

_markListL = []
for x in xrange(0, 11):
    _markListL.append(Mark(x/10.0, 10, True))
for x in xrange(0, 10):
    _markListL.append(Mark('0.%d5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListL.append(Mark('0.%d%d' % (x, x1), 10))
        _markListL.append(Mark('0.%d%d' % (x, x1+5), 10))
for x in xrange(0, 100):
    _markListL.append(Mark(0.01*x+0.005, 5))

_markListST = []
_markListT1 = []
_markListS1 = []
_markListT2 = []
_markListS2 = []
_markListT3 = []

_markListST.append(Mark(0.055, 10))
_markListST.append(Mark(0.6, 10))
_markListST.append(GaugeMark(0.6, '89.4/0.6'))
_markListS1.append(Mark(0.55, 10))
_markListS1.append(Mark(6, 10))
_markListS1.append(GaugeMark(6, '84/6'))
_markListS2.append(Mark(5.5, 10))
_markListS2.append(Mark(90, 10))
_markListS2.append(GaugeMark(90, ' 0/90'))

_markListT1.append(Mark(0.55, 10))
_markListT1.append(Mark(6, 10, True))
_markListT2.append(Mark(5.5, 10))
_markListT2.append(Mark(45, 10, True))
_markListT3.append(Mark(45, 10, True))
_markListT3.append(Mark(84.5, 10, True))

_markListST.append(Mark(0.056, 5))
_markListST.append(Mark(0.057, 5))
_markListST.append(Mark(0.058, 5))
_markListST.append(Mark(0.059, 5))
_markListST.append(Mark(0.06, 10))
_markListST.append(GaugeMark(0.06, '89.94/0.06'))
_markListST.append(Mark(0.07, 10))
_markListST.append(GaugeMark(0.07, '*'))
_markListST.append(Mark(0.08, 10))
_markListST.append(GaugeMark(0.08, '*'))
_markListST.append(Mark(0.09, 10))
_markListST.append(GaugeMark(0.09, '*'))
_markListST.append(Mark(0.1, 10))
_markListST.append(GaugeMark(0.1, '89.9/0.1'))
for x in xrange(6, 10):
    _markListST.append(Mark('0.0%d5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListST.append(Mark('0.0%d%d' % (x,x1), 5))
        _markListST.append(Mark('0.0%d%d' % (x,x1+5), 5))
_markListST.append(Mark(0.2, 10))
_markListST.append(GaugeMark(0.2, '89.8/0.2'))
for x in xrange(1,10):
    _markListST.append(Mark('0.1%d' % (x), 10))
_markListST.append(Mark(0.15, 10))
_markListST.append(GaugeMark(0.15, '89.85/0.15'))
for x in xrange(0,10):
    for x1 in xrange(2,10,2):
        _markListST.append(Mark('0.1%d%d' % (x,x1), 5))
_markListST.append(Mark(0.3, 10))
_markListST.append(GaugeMark(0.3, '89.7/0.3'))
for x in xrange(1,10):
    _markListST.append(Mark('0.2%d' % (x), 10))
_markListST.append(Mark(0.25, 10))
_markListST.append(GaugeMark(0.25, '89.75/0.25'))
for x in xrange(0,10):
    _markListST.append(Mark('0.2%d5' % (x), 5))
_markListST.append(Mark(0.4, 10))
_markListST.append(GaugeMark(0.4, '89.6/0.4'))
for x in xrange(1,10):
    _markListST.append(Mark('0.3%d' % (x), 10))
_markListST.append(Mark(0.35, 10))
_markListST.append(GaugeMark(0.35, '*'))
for x in xrange(0,10):
    _markListST.append(Mark('0.3%d5' % (x), 5))
_markListST.append(Mark(0.5, 10))
_markListST.append(GaugeMark(0.5, '89.5/0.5'))
for x in xrange(1,10):
    _markListST.append(Mark('0.4%d' % (x), 10))
_markListST.append(Mark(0.45, 10))
_markListST.append(GaugeMark(0.45, '*'))
for x in xrange(0,10):
    _markListST.append(Mark('0.4%d5' % (x), 5))
_markListST.append(Mark(0.55, 10))
for x1 in xrange(1, 5):
    _markListST.append(Mark('0.5%d' % (x1), 5))
    _markListST.append(Mark('0.5%d' % (x1+5), 5))

_markListS1.append(Mark(0.56, 5))
_markListS1.append(Mark(0.57, 5))
_markListS1.append(Mark(0.58, 5))
_markListS1.append(Mark(0.59, 5))
_markListS1.append(Mark(0.6, 10))
_markListS1.append(Mark(0.7, 10))
_markListS1.append(Mark(0.8, 10))
_markListS1.append(Mark(0.9, 10))
_markListS1.append(Mark(1, 10))
for x in xrange(6, 10):
    _markListS1.append(Mark('0.%d5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListS1.append(Mark('0.%d%d' % (x,x1), 5))
        _markListS1.append(Mark('0.%d%d' % (x,x1+5), 5))
_markListS1.append(Mark(2, 10))
_markListS1.append(GaugeMark(2, '88/2'))
for x in xrange(1,10):
    _markListS1.append(Mark('1.%d' % (x), 10))
_markListS1.append(Mark(1.5, 10))
_markListS1.append(GaugeMark(1.5, '88.5/1.5'))
for x in xrange(0,10):
    for x1 in xrange(2,10,2):
        _markListS1.append(Mark('1.%d%d' % (x,x1), 5))
_markListS1.append(Mark(3, 10))
_markListS1.append(GaugeMark(3, '87/3'))
for x in xrange(1,10):
    _markListS1.append(Mark('2.%d' % (x), 10))
_markListS1.append(Mark(2.5, 10))
_markListS1.append(GaugeMark(2.5, '87.5/2.5'))
for x in xrange(0,10):
    _markListS1.append(Mark('2.%d5' % (x), 5))
_markListS1.append(Mark(4, 10))
_markListS1.append(GaugeMark(4, '86/4'))
for x in xrange(1,10):
    _markListS1.append(Mark('3.%d' % (x), 10))
_markListS1.append(Mark(3.5, 10))
_markListS1.append(GaugeMark(3.5, '86.5/3.5'))
for x in xrange(0,10):
    _markListS1.append(Mark('3.%d5' % (x), 5))
_markListS1.append(Mark(5, 10))
_markListS1.append(GaugeMark(5, '85/5'))
for x in xrange(1,10):
    _markListS1.append(Mark('4.%d' % (x), 10))
_markListS1.append(Mark(4.5, 10))
_markListS1.append(GaugeMark(4.5, '85.5/4.5'))
for x in xrange(0,10):
    _markListS1.append(Mark('4.%d5' % (x), 5))
_markListS1.append(Mark(5.5, 10))
for x1 in xrange(1, 5):
    _markListS1.append(Mark('5.%d' % (x1), 5))
    _markListS1.append(Mark('5.%d' % (x1+5), 5))

_markListT1.append(Mark(0.56, 5))
_markListT1.append(Mark(0.57, 5))
_markListT1.append(Mark(0.58, 5))
_markListT1.append(Mark(0.59, 5))
_markListT1.append(Mark(0.6, 10, True))
_markListT1.append(Mark(0.7, 10, True))
_markListT1.append(Mark(0.8, 10, True))
_markListT1.append(Mark(0.9, 10, True))
_markListT1.append(Mark(1, 10, True))
for x in xrange(6, 10):
    _markListT1.append(Mark('0.%d5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListT1.append(Mark('0.%d%d' % (x,x1), 5))
        _markListT1.append(Mark('0.%d%d' % (x,x1+5), 5))
_markListT1.append(Mark(2, 10, True))
for x in xrange(1,10):
    _markListT1.append(Mark('1.%d' % (x), 10))
_markListT1.append(Mark(1.5, 10, True))
for x in xrange(0,10):
    for x1 in xrange(2,10,2):
        _markListT1.append(Mark('1.%d%d' % (x,x1), 5))
_markListT1.append(Mark(3, 10, True))
for x in xrange(1,10):
    _markListT1.append(Mark('2.%d' % (x), 10))
_markListT1.append(Mark(2.5, 10, True))
for x in xrange(0,10):
    _markListT1.append(Mark('2.%d5' % (x), 5))
_markListT1.append(Mark(4, 10, True))
for x in xrange(1,10):
    _markListT1.append(Mark('3.%d' % (x), 10))
_markListT1.append(Mark(3.5, 10, True))
for x in xrange(0,10):
    _markListT1.append(Mark('3.%d5' % (x), 5))
_markListT1.append(Mark(5, 10, True))
for x in xrange(1,10):
    _markListT1.append(Mark('4.%d' % (x), 10))
_markListT1.append(Mark(4.5, 10, True))
for x in xrange(0,10):
    _markListT1.append(Mark('4.%d5' % (x), 5))
_markListT1.append(Mark(5.5, 10))
for x1 in xrange(1, 5):
    _markListT1.append(Mark('5.%d' % (x1), 5))
    _markListT1.append(Mark('5.%d' % (x1+5), 5))
    
_markListS2.append(Mark(5.6, 5))
_markListS2.append(Mark(5.7, 5))
_markListS2.append(Mark(5.8, 5))
_markListS2.append(Mark(5.9, 5))
_markListS2.append(Mark(6, 10))
_markListS2.append(Mark(7, 10))
_markListS2.append(Mark(8, 10))
_markListS2.append(Mark(9, 10))
_markListS2.append(Mark(10, 10))
for x in xrange(6, 10):
    _markListS2.append(Mark('%d.5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListS2.append(Mark('%d.%d' % (x,x1), 5))
        _markListS2.append(Mark('%d.%d' % (x,x1+5), 5))
_markListS2.append(Mark(20, 10))
_markListS2.append(GaugeMark(20, '70/20'))
for x in xrange(1,10):
    _markListS2.append(Mark('1%d' % (x), 10))
_markListS2.append(Mark(15, 10))
_markListS2.append(GaugeMark(15, '75/15'))
for x in xrange(0,10):
    for x1 in xrange(2,10,2):
        _markListS2.append(Mark('1%d.%d' % (x,x1), 5))
_markListS2.append(Mark(30, 10))
_markListS2.append(GaugeMark(30, '60/30'))
for x in xrange(1,10):
    _markListS2.append(Mark('2%d' % (x), 10))
_markListS2.append(Mark(25, 10))
_markListS2.append(GaugeMark(25, '65/25'))
for x in xrange(0,10):
    _markListS2.append(Mark('2%d.5' % (x), 5))
_markListS2.append(Mark(40, 10))
_markListS2.append(GaugeMark(40, '50/40'))
for x in xrange(1,10):
    _markListS2.append(Mark('3%d' % (x), 10))
_markListS2.append(Mark(35, 10))
_markListS2.append(GaugeMark(35, '55/35'))
for x in xrange(0,10):
    _markListS2.append(Mark('3%d.5' % (x), 5))
_markListS2.append(Mark(50, 10))
_markListS2.append(GaugeMark(50, '40/50'))
for x in xrange(1,10):
    _markListS2.append(Mark('4%d' % (x), 10))
_markListS2.append(Mark(45, 10))
_markListS2.append(GaugeMark(45, '45/45'))
for x in xrange(0,10):
    _markListS2.append(Mark('4%d.5' % (x), 5))
_markListS2.append(Mark(60, 10))
_markListS2.append(GaugeMark(60, '30/60'))
_markListS2.append(Mark(70, 10))
_markListS2.append(GaugeMark(70, '20/70'))
_markListS2.append(Mark(80, 10))
for x in xrange(50,80,10):
    for x1 in xrange(2,10,2):
        _markListS2.append(Mark(x+x1,5))
    
_markListT2.append(Mark(5.6, 5))
_markListT2.append(Mark(5.7, 5))
_markListT2.append(Mark(5.8, 5))
_markListT2.append(Mark(5.9, 5))
_markListT2.append(Mark(6, 10, True))
_markListT2.append(Mark(7, 10, True))
_markListT2.append(Mark(8, 10, True))
_markListT2.append(Mark(9, 10, True))
_markListT2.append(Mark(10, 10, True))
for x in xrange(6, 10):
    _markListT2.append(Mark('%d.5' % (x), 10))
    for x1 in xrange(1, 5):
        _markListT2.append(Mark('%d.%d' % (x,x1), 5))
        _markListT2.append(Mark('%d.%d' % (x,x1+5), 5))
_markListT2.append(Mark(20, 10, True))
for x in xrange(1,10):
    _markListT2.append(Mark('1%d' % (x), 10))
_markListT2.append(Mark(15, 10, True))
for x in xrange(0,10):
    for x1 in xrange(2,10,2):
        _markListT2.append(Mark('1%d.%d' % (x,x1), 5))
_markListT2.append(Mark(30, 10, True))
for x in xrange(1,10):
    _markListT2.append(Mark('2%d' % (x), 10))
_markListT2.append(Mark(25, 10, True))
for x in xrange(0,10):
    _markListT2.append(Mark('2%d.5' % (x), 5))
_markListT2.append(Mark(40, 10, True))
for x in xrange(1,10):
    _markListT2.append(Mark('3%d' % (x), 10))
_markListT2.append(Mark(35, 10, True))
for x in xrange(0,10):
    _markListT2.append(Mark('3%d.5' % (x), 5))
for x in xrange(1,5):
    _markListT2.append(Mark('4%d' % (x), 10))
for x in xrange(0,5):
    _markListT2.append(Mark('4%d.5' % (x), 5))
    
_markListT3.append(Mark(84.4, 5))
_markListT3.append(Mark(84.3, 5))
_markListT3.append(Mark(84.2, 5))
_markListT3.append(Mark(84.1, 5))
_markListT3.append(Mark(84, 10, True))
_markListT3.append(Mark(83, 10, True))
_markListT3.append(Mark(82, 10, True))
_markListT3.append(Mark(81, 10, True))
_markListT3.append(Mark(80, 10, True))
for x in xrange(6, 10):
    _markListT3.append(Mark('%d.5' % (89-x), 10))
    for x1 in xrange(1, 5):
        _markListT3.append(Mark('%d.%d' % (89-x,10-x1), 5))
        _markListT3.append(Mark('%d.%d' % (89-x,(10-x1)-5), 5))
_markListT3.append(Mark(70, 10, True))
for x in xrange(1,10):
    _markListT3.append(Mark('7%d' % (10-x), 10))
_markListT3.append(Mark(75, 10, True))
for x in xrange(0,10):
    for x1 in xrange(2,10,2):
        _markListT3.append(Mark('7%d.%d' % (9-x,10-x1), 5))
_markListT3.append(Mark(60, 10, True))
for x in xrange(1,10):
    _markListT3.append(Mark('6%d' % (10-x), 10))
_markListT3.append(Mark(65, 10, True))
for x in xrange(0,10):
    _markListT3.append(Mark('6%d.5' % (9-x), 5))
_markListT3.append(Mark(50, 10, True))
for x in xrange(1,10):
    _markListT3.append(Mark('5%d' % (10-x), 10))
_markListT3.append(Mark(55, 10, True))
for x in xrange(0,10):
    _markListT3.append(Mark('5%d.5' % (9-x), 5))
for x in xrange(1,5):
    _markListT3.append(Mark('4%d' % (10-x), 10))
for x in xrange(0,5):
    _markListT3.append(Mark('4%d.5' % (9-x), 5))

### Gauge marks

_markListC.append(GaugeMark(math.pi, 'pi'))

_markListCC.append(GaugeMark(math.pi, 'pi'))

_markListCC.append(GaugeMark(3.937, 'M" '))

_markListCC.append(GaugeMark(3.29, "M'"))

_markListEI0.append(GaugeMark(math.pi, 'pi'))

_markListEI1.append(GaugeMark(math.pi, 'pi '))

_markListRI1.append(GaugeMark(math.pi, 'pi'))

_markListLL3.append(GaugeMark(math.e, '     e'))

### Special SS markings

_markListS2.append(GaugeMark(6, '84/6'))
_markListS2.append(GaugeMark(7, '83/7'))
_markListS2.append(GaugeMark(8, '82/8'))
_markListS2.append(GaugeMark(9, '81/9'))
_markListS2.append(GaugeMark(10, '80/10'))
_markListS1.append(GaugeMark(0.6, '89.4/0.6'))
_markListS1.append(GaugeMark(0.7, '89.3/0.7'))
_markListS1.append(GaugeMark(0.8, '89.2/0.8'))
_markListS1.append(GaugeMark(0.9, '89.1/0.9'))
_markListS1.append(GaugeMark(1, '89/1'))
        
### ----------------------------------------

class Scale(object):

    ### Most methods in Scale are abstract methods.  This means they
    ### are only defined in subclasses of Scale.  Never create a Scale
    ### directly.  Instead, create instances of a subclass.
    
    def toL(self, x):
        """Return the point on the L scale for x on this Scale."""
        raise NotImplementedError, 'Please use a subclass of Scale and define toL in the subclass.'   

    def getName(self):
        """Return the name of the Scale, like 'C', 'CI', or 'LL0'."""
        raise NotImplementedError, 'Please use a subclass of Scale and define getName() in the subclass.'   

    def getMarkList(self):
        """Return the list of Marks to draw for this scale."""
        raise NotImplementedError, 'Please use a subclass of Scale and define getMarkList() in the subclass.'   

    def againstEdge(self):
        """Return N for marks to line up flat on top, S on bottom, else CENTER.

        Note: it's not strings like 'N', but symbols like N.  These
        are symbols imported from Tkinter.

        The method in Scale returns CENTER because it is the default.
        Subclasses that want N or S should override the method.
        """
        return CENTER

### - - - - - - - - Subclasses of Scale - - - - - - - - 

class CScale(Scale):
    """A scale marked like C."""

    def toL(self, x):
        return log10(x)

    def getMarkList(self):
        return _markListCC

class DScale(Scale):
    """A scale marked like C or D."""

    def toL(self, x):
        return log10(x)

    def getMarkList(self):
        return _markListC

class CIDIScale(Scale):
    """A scale like CI or DI.  Its marks are like C, but backwards."""

    def toL(self, x):
        return 1.0 - log10(x)

    def getMarkList(self):
        return _markListC

class AScale(Scale):
    """A scale marked like A.  It is the halved D scale."""

    def toL(self, x):
        return log10(x)/2

    def getMarkList(self):
        return _markListA

    def getName(self):
        return 'A'

    def againstEdge(self):
        return N

class KScale(Scale):
    """A scale marked like K.  It is the thirded D scale."""

    def toL(self, x):
        return log10(x)/3

    def getMarkList(self):
        return _markListK

    def getName(self):
        return 'K'

    def againstEdge(self):
        return N

# We did A and K.  Now let's do the accurate-type EI and RI

class EI0Scale(Scale):
    """A scale marked like EI.  It is the doubled CI scale.  It takes two graduations."""

    def toL(self, x):
        return 1.0-(log10(x)*2)

    def getMarkList(self):
        return _markListEI0

    def getName(self):
        return 'EI'

    def againstEdge(self):
        return N

class EI1Scale(Scale):
    """A scale marked like EI.  It is the doubled CI scale.  It takes two graduations."""

    def toL(self, x):
        return 2.0-(log10(x)*2)

    def getMarkList(self):
        return _markListEI1

    def getName(self):
        return 'EI'

    def againstEdge(self):
        return S

class RI0Scale(Scale):
    """A scale marked like RI.  It is the tripled CI scale.  It takes three graduations."""

    def toL(self, x):
        return 1.0-(log10(x)*3)

    def getMarkList(self):
        return _markListRI0

    def getName(self):
        return 'RI'

    def againstEdge(self):
        return N

class RI1Scale(Scale):
    """A scale marked like RI.  It is the tripled CI scale.  It takes three graduations."""

    def toL(self, x):
        return 2.0-(log10(x)*3)

    def getMarkList(self):
        return _markListRI1

    def getName(self):
        return 'RI'

    def againstEdge(self):
        return S

class RI2Scale(Scale):
    """A scale marked like RI.  It is the tripled CI scale.  It takes three graduations."""

    def toL(self, x):
        return 3.0-(log10(x)*3)

    def getMarkList(self):
        return _markListRI2

    def getName(self):
        return 'RI'

    def againstEdge(self):
        return S

class CScale(CScale):

    def getName(self):
        return 'C'

    def againstEdge(self):
        return S

class DScale(DScale):

    def getName(self):
        return 'D'

    def againstEdge(self):
        return N

class DupScale(DScale):

    def getName(self):
        return 'D'

    def againstEdge(self):
        return S

class DIScale(CIDIScale):

    def getName(self):
        return 'DI'

    def againstEdge(self):
        return S

class CIScale(CIDIScale):

    def getName(self):
        return 'CI'

    def againstEdge(self):
        return S

## Bottom scales: LL, L-L, for VARIOUS powers

# In Python, log(x) is the natural log of x, and log10(x) is the log
# to base 10.  Both these functions are imported from math at the top
# of the file.

class LL0Scale(Scale):
    
    def toL(self, x):
        return 3.0+math.log10(log(x))

    def getMarkList(self):
        return _markListLL0

    def getName(self):
        return 'LL0'

    def againstEdge(self):
        return S

class LL1Scale(Scale):
    
    def toL(self, x):
        return 2.0+math.log10(log(x))

    def getMarkList(self):
        return _markListLL1

    def getName(self):
        return 'LL1'

    def againstEdge(self):
        return N

class LL2Scale(Scale):
    
    def toL(self, x):
        return 1.0+math.log10(log(x))

    def getMarkList(self):
        return _markListLL2

    def getName(self):
        return 'LL2'

    def againstEdge(self):
        return S

class LL3Scale(Scale):
    
    def toL(self, x):
        return math.log10(log(x))

    def getMarkList(self):
        return _markListLL3

    def getName(self):
        return 'LL3'

    def againstEdge(self):
        return N

class LLI3Scale(Scale):
    
    def toL(self, x):
        return math.log10(-1*(log(x)))

    def getMarkList(self):
        return _markListLLI3

    def getName(self):
        return 'L-L3'

    def againstEdge(self):
        return S

class LLI2Scale(Scale):
    
    def toL(self, x):
        return 1.0+math.log10(-1*(log(x)))

    def getMarkList(self):
        return _markListLLI2

    def getName(self):
        return 'L-L2'

    def againstEdge(self):
        return N

class LLI1Scale(Scale):
    
    def toL(self, x):
        return 2.0+math.log10(-1*(log(x)))

    def getMarkList(self):
        return _markListLLI1

    def getName(self):
        return 'L-L1'

    def againstEdge(self):
        return S

class LLI0Scale(Scale):
    
    def toL(self, x):
        return 3.0+math.log10(-1*(log(x)))

    def getMarkList(self):
        return _markListLLI0

    def getName(self):
        return 'L-L0'

    def againstEdge(self):
        return N

class LScale(Scale):
    
    def toL(self, x):
        return x # By the fundamental definition, this L scale is even like a ruler!  There must be a reason and there is

    def getMarkList(self):
        return _markListL

    def getName(self):
        return 'L'

    def againstEdge(self):
        return S

# Trig!

class STScale(Scale):
    
    def toL(self, x):
        return log10(math.sin(x*math.pi/180.0))+3

    def getMarkList(self):
        return _markListST

    def getName(self):
        return 'SST'

    def againstEdge(self):
        return N

class T1Scale(Scale):
    
    def toL(self, x):
        return log10(math.tan(x*math.pi/180.0))+2

    def getMarkList(self):
        return _markListT1

    def getName(self):
        return 'T'

    def againstEdge(self):
        return S

class S1Scale(Scale):
    
    def toL(self, x):
        return log10(math.sin(x*math.pi/180.0))+2

    def getMarkList(self):
        return _markListS1

    def getName(self):
        return 'SS'

    def againstEdge(self):
        return N

class T2Scale(Scale):
    
    def toL(self, x):
        return log10(math.tan(x*math.pi/180.0))+1

    def getMarkList(self):
        return _markListT2

    def getName(self):
        return 'T'

    def againstEdge(self):
        return S

class S2Scale(Scale):
    
    def toL(self, x):
        return log10(math.sin(x*math.pi/180.0))+1

    def getMarkList(self):
        return _markListS2

    def getName(self):
        return 'SS'

    def againstEdge(self):
        return N

class T3Scale(Scale):
    
    def toL(self, x):
        return log10(math.tan(x*math.pi/180.0))

    def getMarkList(self):
        return _markListT3

    def getName(self):
        return 'T'

    def againstEdge(self):
        return S

### ----------------------------------------

class Section(Canvas):
    """The top, slide or bottom of a slide rule."""

    def __init__(self, parent):
        Canvas.__init__(self, parent, width=_RULEWIDTH,
                        height=0, # will grow when we add scales
                        highlightthickness=0)
        self.numScales = 0

    def addScale(self, scale):
        """Add a Scale to this Section, below those already added.

        scale: an instance of some subclass of Scale.
        """
        yBase = self.numScales * _SCALEHEIGHT
        self.create_text(_MARGINWIDTH / 2, yBase + _SCALEHEIGHT / 2,
                         text=scale.getName(), justify=CENTER)
        against = scale.againstEdge()
        for mark in scale.getMarkList():
            if isinstance(mark, Mark):
                x = _MARGINWIDTH + _SCALEWIDTH * scale.toL(mark.value)
                if against == N:
                    y0 = yBase
                    y1 = y0 + mark.height
                    ytxt = y1 + _TEXTHEIGHT
                elif against == S:
                    y1 = yBase + _SCALEHEIGHT
                    y0 = y1 - mark.height
                    ytxt = y0 - _TEXTHEIGHT
                else:
                    y0 = yBase + (_SCALEHEIGHT - mark.height) / 2
                    y1 = y0 + mark.height
                    ytxt = y0 - _TEXTHEIGHT
                self.create_line(x, y0, x, y1)
                if mark.stringName:
                    self.create_text(x, ytxt, text=mark.stringName, justify=CENTER)
            elif isinstance(mark, GaugeMark):
                x = _MARGINWIDTH + _SCALEWIDTH * scale.toL(mark.value)
                if against == N:
                    y0 = yBase + 5
                    y1 = y0 + 5
                    ytxt = y1 + _TEXTHEIGHT
                elif against == S:
                    y1 = yBase + _SCALEHEIGHT - 5
                    y0 = (y1 - 10) + 5
                    ytxt = y0 - _TEXTHEIGHT
                else:
                    y0 = yBase + (_SCALEHEIGHT - mark.height) / 2
                    y1 = y0 + mark.height
                    ytxt = y0 - _TEXTHEIGHT
                self.create_line(x, y0, x, y1)
                if mark.stringName:
                    self.create_text(x, ytxt, text=mark.stringName, justify=CENTER)              
            else:
                raise RuntimeError, 'Unrecognized in markList: %s' % mark
        self.numScales += 1
        self.configure(height=(self.numScales * _SCALEHEIGHT))

### ----------------------------------------

class SlideRule(Frame):
    
    def __init__(self, master=None):
        Frame.__init__(self, master)
        
        ## 0.0 if slide is fully right, 1.0 if fully left
        self.scrollRatio = _SCALEWIDTH / _SLIDESCROLLWIDTH
        
        ## During a mouse drag, this is where the mouse started.
        self.mousePressX = None
        
        self.createSlideAndBody()
        self.grid() # put Frame into the master, after scales are added
        self.createHairline()
        self.registerMouseWithSlide()
        self.registerMouseForHairline()
        window = self.winfo_toplevel()
        window.resizable(False, False)

    def createSlideAndBody(self):
        self.bodyTop = Section(self)
        self.slide = Section(self)
        self.slide.configure(scrollregion=(-_SCALEWIDTH, 0, _RULEWIDTH+_SCALEWIDTH, 0))
        self.bodyBottom = Section(self)

        self.putInScales()

        for i, section in enumerate([self.bodyTop, self.slide, self.bodyBottom]):
            section.grid(row=i)

    def putInScales(self):
        self.bodyTop.addScale(STScale())
        self.bodyTop.addScale(T1Scale())
        self.bodyTop.addScale(S1Scale())
        self.bodyTop.addScale(T2Scale())
        self.bodyTop.addScale(S2Scale())
        self.bodyTop.addScale(T3Scale())
        self.bodyTop.addScale(DupScale())
        self.bodyTop.addScale(DIScale())
        self.bodyTop.addScale(LScale())
        self.slide.addScale(RI2Scale())
        self.slide.addScale(RI1Scale())
        self.slide.addScale(RI0Scale())
        self.slide.addScale(EI1Scale())
        self.slide.addScale(EI0Scale())
        self.slide.addScale(CIScale())
        self.slide.addScale(CScale())
        self.bodyBottom.addScale(DScale())
        self.bodyBottom.addScale(AScale())
        self.bodyBottom.addScale(KScale())
        self.bodyBottom.addScale(LL0Scale())
        self.bodyBottom.addScale(LL1Scale())
        self.bodyBottom.addScale(LL2Scale())
        self.bodyBottom.addScale(LL3Scale())
        self.bodyBottom.addScale(LLI3Scale())
        self.bodyBottom.addScale(LLI2Scale())
        self.bodyBottom.addScale(LLI1Scale())
        self.bodyBottom.addScale(LLI0Scale())

    def createHairline(self):
        hairX = _MARGINWIDTH + 3
        hairPi4 = hairX + (log10(math.pi/4)/2) * _SCALEWIDTH
        for section in [self.bodyTop, self.slide, self.bodyBottom]:
            section.create_line(hairX, 0, hairX, int(section['height']),
                                tags=['hairline'], fill='red')
        self.bodyBottom.create_line(hairPi4, _SCALEHEIGHT-5, hairPi4, _SCALEHEIGHT+15,
                                    tags=['hairlinepi4'], fill='blue')

    def mousePress(self, event):
        self.mousePressX = event.x
        
    def mouseDrag(self, event):
        ## Move the slide by resetting its scroll ratio.
        mouseDist = event.x - self.mousePressX
        newScrollRatio = self.scrollRatio - mouseDist / _SLIDESCROLLWIDTH
        self.slide.xview(MOVETO, newScrollRatio)
        ## TO DO: make next few lines clearer
        dHairlineCoords = self.bodyBottom.coords('hairline')
        hairX = self.slide.canvasx(dHairlineCoords[0])
        self.slide.coords('hairline', hairX, 0, hairX, int(self.slide['height']))
        hairPi4 = hairX + (log10(math.pi/4)/2) * _SCALEWIDTH
        self.slide.coords('hairlinepi4', hairPi4, _SCALEHEIGHT-5, hairPi4, _SCALEHEIGHT+15)
        
    def mouseRelease(self, event):
        ## Finish moving the slide by setting self.scrollRatio.
        mouseDist = event.x - self.mousePressX
        newScrollRatio = self.scrollRatio - mouseDist / _SLIDESCROLLWIDTH
        self.slide.xview(MOVETO, newScrollRatio)
        self.scrollRatio = newScrollRatio
        self.mousePressX = None

    def registerMouseWithSlide(self):
        self.slide.bind("<Button-1>", self.mousePress)
        self.slide.bind("<B1-Motion>", self.mouseDrag)
        self.slide.bind("<ButtonRelease-1>", self.mouseRelease)

    def moveHairline(self, event):
        for section in [self.bodyTop, self.slide, self.bodyBottom]:
            hairX = section.canvasx(event.x)
            section.coords('hairline', hairX, 0, hairX, int(section['height']))
        hairX = self.bodyBottom.canvasx(event.x)
        hairPi4 = hairX + (log10(math.pi/4)/2) * _SCALEWIDTH
        self.bodyBottom.coords('hairlinepi4', hairPi4, _SCALEHEIGHT-5, hairPi4, _SCALEHEIGHT+15)

    def registerMouseForHairline(self):
        for section in [self.bodyTop, self.slide, self.bodyBottom]:
            section.bind("<Button-3>", self.moveHairline)
            section.bind("<B3-Motion>", self.moveHairline)
            section.bind("<ButtonRelease-3>", self.moveHairline)
        
### ----------------------------------------

rule = SlideRule()

rule.master.title('Slide Rule')

rule.mainloop()