The gram package

from gram import Gram
gr1 = Gram()
gr1.font = 'fira'
gr1.baseName = 'gramInGram'
gr1.text("Embedding gram", 0,0)
gr2 = Gram()
g = gr2.text("Embedded gram",0,0)
gr2.gX = 0.3
gr2.gY = 0.5
gr1.grams.append(gr2)
gr1.pdf()
gr1.font = 'lms'
# gr1.svg()
gr1.png()

from gram import Gram
gr = Gram()
gr.baseName = 'line'
gr.font = 'Helvetica'
gr.grid(0,0,4,4)
g = gr.line(1,1,2,3)
g.color = 'black!20'
g.color.transparent = True
g.lineThickness = 28. # pts
g = gr.line(3, 3.5, 2, 1)
g.lineThickness = 'semithick'
g.lineStyle = 'dashed'
# A default, un-modified line
gr.line(1, 3, 1.5, 0.5)

g = gr.line(2.5, 0.5, 3.0, 0.5)
g.lineThickness = 28.4

g = gr.line(3.5, 1, 3.5, 2)
g.lineThickness = 10
g.color = "blue!15"
g.cap = 'rect'  # default butt

g = gr.text('some lines', 3,3)
g.anchor = 'north west'
g.textSize = 'normalsize'
gr.png()
gr.cat()
gr.svg()

from gram import Gram
gr = Gram()
gr.font = 'helvetica'
gr.baseName = 'rect'
gr.grid(2,2,6,5)
g = gr.rect(2,3,5,4)
g.lineThickness = 5
g.draw = 'teal'
g.fill = 'cyan!10'
g = gr.text("xXy", 4,5)
g.textSize = 'Large'
gr.png()
gr.svg()

from gram import Gram,GramCoord,GramGrid,GramText

Gram.latexOutputGoesToDevNull = True

gr = Gram()
gr.pdfViewer = 'open'
gr.baseName = 'anchors'
gr.font = 'lms'
# gr.defaultInnerSep = 0.1
g = GramGrid(0, 1, 6, 10)
gr.graphics.append(g)

anchors = [
    "south east",
    "south",
    "south west",
    "base east",
    "base",
    "base west",
    "mid east",
    "mid",
    "mid west",
    "east",
    "center",
    "west",
    "north east",
    "north",
    "north west"
]

nnDict = {}
nn = []
for rNum in range(5):
    for cNum in range(3):
        indx = (rNum * 3) + cNum
        try:
            refPt = anchors[indx]
        except IndexError:
            break
        print(indx, refPt)
        n = GramCoord((2 * cNum) + 1,
                      (2 * rNum) + 1,
                      refPt)
        nnDict[refPt] = n
        nn.append(n)
        gr.graphics.append(n)

myStr = r'Xxy'
theTextSize = 'normalsize'
for i in range(15):
    anch = gr.goodAnchors[i]
    print("i=%i, anch=%s" % (i, anch))
    g = GramText(anch)
    g.cA = nnDict[anch]
    g.anchor = 'base'
    g.textSize = 'small'
    g.textFamily = 'ttfamily'
    g.yShift = 0.1
    gr.graphics.append(g)


    gB = GramText(myStr)
    gB.cA = GramCoord()
    gB.cA.xPosn = g.cA.xPosn
    gB.cA.yPosn = g.cA.yPosn + 1
    gB.anchor = anch
    gB.color = 'cyan'
    gB.draw = 'blue!20'
    gB.lineThickness = 2
    gB.textAlign = "center"
    gB.textSize = theTextSize
    # gB.rotate = 55
    gr.graphics.append(gB)

    if 0:
        gB = GramText(myStr)
        gB.cA = GramCoord()
        gB.cA.xPosn = g.cA.xPosn
        gB.cA.yPosn = g.cA.yPosn + 1
        gB.anchor = anch
        gB.draw = True
        gB.textSize = theTextSize
        gB.rotate = 15
        gr.graphics.append(gB)


# gr.showTextBB = True
gr.showTextAnchor = True

gr.png()
gr.svg()

from gram import Gram

gr = Gram()
gr.baseName = "textAlign"
# gr.grid(0,6,10,10)

boxX = 6
topY = 10

#-----------------------------
myStr = "No wrapping"
g = gr.text(myStr, boxX, topY)
g.anchor = "west"
g.fill = "black!8"

g = gr.text("default", 0.0, topY)
g.anchor = "west"

#------------------------------
dY = 1.5
myStr = r"A bit of text\\that is somewhat long,\\to show wrapping"
g = gr.text(myStr, boxX, topY - dY)
g.anchor = "west"
g.textAlign = "flush center"
g.fill = "black!8"

explainText = r"""with explicit line 
breaks using double backslashes, 
no \texttt{textWrapWidth}, 
with \texttt{g.textAlign="flush center"}"""
g = gr.text(explainText, 0, topY - dY)
g.textWrapWidth = 5.5
g.anchor = "west"
g.textAlign = 'left'

#------------------------------
dY += 2.
myStr = r"A bit of text that is somewhat long, to show wrapping"
g = gr.text(myStr, boxX, topY - dY)
g.anchor = "west"
g.textWrapWidth = 3.
g.textAlign = "left"
g.fill = "black!8"

explainText = r"""no explicit line breaks, with\\
\texttt{g.textWrapWidth=3}\\
\texttt{g.textAlign="left"}"""
g = gr.text(explainText, 0, topY - dY)
g.anchor = "west"
g.textAlign = 'left'


# gr.latexOutputGoesToDevNull = False
# gr.showTextBB = True
# gr.pdf()
gr.png()
# gr.cat()

from gram import Gram


gr = Gram()
gr.baseName = "wrap"
gr.font = "lms"
# gr.grid(0,2,4,9)

if 1:
    # explicit linendings "\\" and textWrapWidth, works
    myStr = r"This\\ text has\\ both \texttt{textWrapWidth} and explicit line endings (using double backslashes)."
    g = gr.text(myStr, 0, 6)
    g.anchor = "south west"
    g.textWrapWidth = 4.0
    g.textAlign = "left"
    g.fill = "black!8"

if 1:
    # no explicit linendings "\\" but with textWrapWidth, works
    myStr = r"This text has \texttt{textWrapWidth} set, but has no line endings."
    g = gr.text(myStr, 0, 4)
    g.anchor = "south west"
    g.textWrapWidth = 4.
    g.textAlign = "left"
    g.fill = "black!8"

if 1:
    myStr = r"This\\ text has line endings, but\\ no \texttt{textWrapWidth}."
    g = gr.text(myStr, 0, 2)
    g.anchor = "south west"
    # g.textWrapWidth = 4.
    g.textAlign = "left"
    g.fill = "black!8"

# gr.showTextBB = True
# gr.latexOutputGoesToDevNull = False
# gr.pdf()
gr.png()
# gr.cat()

from gram import Gram

gr = Gram()
gr.baseName = "symbolsT"
gr.font = "lmr"
dY = -0.5

# Don't forget the r"\something" format
gr.text(r"$\alpha \Leftrightarrow \beta \Sigma \Gamma$", 0, -1 * dY)
gr.text("£ 100 €", 0,0)  # works
gr.text(r"\pounds", 0, 1 * dY)
gr.text(r"\textsterling", 0, 2 * dY)
gr.text(r"\texteuro", 0, 3 * dY)
gr.text(r"100\textdegree", 0, 4 * dY)

gr.text(r"this \textrightarrow\ that", 0, 5 * dY)

gr.latexUsePackages.append("pifont")
gr.text(r"\ding{108} \ding{110} \textcolor{blue}{\ding{110}}", 0, 6 * dY)

gr.latexUsePackages.append("fontawesome")
gr.text(r"\faSquare\ \textcolor{orange}{\faSquare}\ \faSquareO", 0, 7 * dY)

g = gr.text(r"\~{}/myFile", 4.0, 0 * dY)
g.textFamily = "ttFamily"

g = gr.text(r"\textasciitilde/myFile", 4.0, 1 * dY)
g.textFamily = "ttFamily"

gr.latexUsePackages.append("url")
gr.text(r"\url{~/myFile}", 4.0, 2 * dY)

#g = gr.text(r"\raisebox{-0.5ex}{\textasciitilde}/myFile", 4.0, 3 * dY)
# g.textFamily = "ttFamily"

g = gr.text(r'\char`~/myFile', 4.0, 4 * dY)
g.textFamily = "ttFamily"

gr.png()

from gram import Gram

gr = Gram()
gr.baseName = "symbolsS"
gr.font = "helvetica"
dY = -0.5
myAnchor = "base west"

# From W3schools
# https://www.w3schools.com/html/html_symbols.asp
g = gr.text(r"Using the html entity € does not work", 0, 2 * dY)   # € does not work
g.anchor = myAnchor
g = gr.text(r"Display € using the decimal code € works", 0, 3 * dY)  # works
g.anchor = myAnchor
g = gr.text(r"Display € using the hex code € works", 0, 4 * dY) # works
g.anchor = myAnchor

g = gr.text("Unicode characters typed into your text editor work: α ⇔ β ∑Γ£€°→◻︎◼︎", 0, 5 * dY)
g.anchor = myAnchor
g = gr.text(r"The tilde looks good with ttFamily: ~/myFile", 0, 6 * dY)
g.textFamily = "ttFamily"
g.anchor = myAnchor

g = gr.text("blue text and a blue unicode square: ◼", 0, 7 * dY)
g.color = "blue"
g.anchor = myAnchor


g = gr.text("black text, but a blue square: ", 0, 8 * dY)
g.anchor = myAnchor
gt = g.append("◼")
gt.color = "blue"
g.append("using")
gt = g.append("<tspan>")
gt.textFamily = "ttFamily"

gr.svg()

from gram import Gram
gr = Gram()
gr.baseName = 'bunnies'
gr.grid(0,0,4,2)
gr.font = 'lms'

# Define a style.
from gram import GramText
st = GramText('Xy')
st.name = 'bunny1'
st.textShape = 'itshape'
st.color = 'violet'
st.anchor = "base"
gr.styleDict[st.name] = st

dY = 0.2
g = gr.text("Flopsy", 1,1 + dY)
g.style = 'bunny1'

g = gr.text("Mopsy", 3,1 + dY)
g.style = 'bunny1'

g = gr.text("Cottontail", 1,0 + dY)
g.style = 'bunny1'
g.color = "orange"

g = gr.text("Peter", 3, 0 + dY)
g.style = 'bunny1'
g.draw = "blue"
g.textSeries = "bfSeries"
g.lineThickness = "thin"
g.textShape = None

# gr.latexOutputGoesToDevNull = False
#gr.pdf()
gr.png()
gr.svg()

\tikzset{bunny1/.style={font=\itshape,color=Violet,anchor=base}}
\begin{tikzpicture}
\draw[gray,very thin] (0,0) grid (4,2);
\node [bunny1] at (1.000,1.200) {Flopsy};
\node [bunny1] at (3.000,1.200) {Mopsy};
\node [bunny1,color=Orange] at (1.000,0.200) {Cottontail};
\node [bunny1,font=\bfseries\upshape,draw=Blue,thin] at (3.000,0.200) {Peter};
\end{tikzpicture}

t1 = """This is
some
usual
text.
"""

t2 = r"""This \\ is
some \\ text in a box
with
line endings, but no \\ text width specified
"""

t3 = r"""\begin{minipage}{100pt} This is some
text that is put
in a minipage
that is 100 pt wide. \end{minipage}
"""

t3x = r"""\begin{minipage}{120pt}
\begin{enumerate}
\item This is the first item of an
enumerate list, in a minipage
\item This is the second item
\item And the third.
\end{enumerate}
\end{minipage}
"""

t4 = r"""\begin{minipage}{170pt}
\begin{center}
\begin{tabular}{@{}llr@{}} \toprule 
\multicolumn{2}{c}{Item} \\ \cmidrule(r){1-2} 
Animal & Description & Price (\$)\\ \midrule 
Gnat & per gram & 13.65 \\ 
& each & 0.01 \\ 
Gnu & stuffed & 92.50 \\ 
Emu & stuffed & 33.33 \\ 
Armadillo & frozen & 8.99 \\ \addlinespace
Total &           & 56.23 \\ \bottomrule 
\end{tabular}
\end{center}
\end{minipage}
"""

t5 = r"""\includegraphics[scale = 0.40]
{../../frownie_tongue2.png}"""

from gram import Gram
gr = Gram()
gr.font = "palatino"
gr.latexUsePackages.append('booktabs')
#gr.latexUsePackages.append('graphicx')
# gr.showTextAnchor=True
# gr.showTextBB=True

bNames = ['t1',  't2', 't3', 't3x', 't4', 't5']
tt = [t1, t2, t3, t3x, t4, t5]

for dNum in range(6):
#for dNum in [5]:
    gr.graphics = []
    gr.baseName = bNames[dNum]
    gr.text(tt[dNum],0,0)
    #gr.pdf()
    gr.png()

from gram import Gram
gr = Gram()
gr.baseName = 'rotatedText'
gr.showTextBB = True
gr.showTextAnchor = True
g = gr.text("short", 1,2)
g.rotate = 30
g.draw = 'blue'
g.lineThickness = 'thick'
g = gr.grid(0,0, 3, 3)
g = gr.text("Another bit of text.", 2,3)
g.anchor = 'south west'
g.rotate = -120
g.draw = 'cyan'
gr.png()
gr.svg()

from gram import TreeGram,TreeGramRadial

tString = "((A, (B, (C, ((D, E), F)))), G, H);"
read(tString)
t = var.trees[0]
t2 = t.dupe()

tg = TreeGram(t)
tg.baseName = 'parallelAndRadial'
#tg.grid(0,-2,10,6)

if os.path.isfile("intree"):
    os.remove("intree")

tgr = TreeGramRadial(t2, maxLinesDim=3.8, equalDaylight=True)
tgr.gX = 5.0
tgr.gY = -1.0
tg.grams.append(tgr)

if 1:
    # I am planning svg output, so no wrapping.
    g = tg.text("Parallel, using the", 0.5, -1.)
    g.anchor = 'west'
    g = tg.text("TreeGram class", 0.5, -1.6)
    g.anchor = 'west'

    g = tg.text("Radial, using the", 6.5, -1.)
    g.anchor = 'west'
    g = tg.text("TreeGramRadial class", 6.5, -1.6)
    g.anchor = 'west'

tg.png()
# tg.svg()

from gram import TreeGram
read("((A,B)89,C,(D,E)96);")
read("((H, I)73, (J, K)98, L);")
t = var.trees[0]
tg = TreeGram(t)
tg.font = 'palatino'
tg.documentFontSize = 10
tg.baseName = 'twoTrees'
t = var.trees[1]
tgB = TreeGram(t)
tgB.baseName = 'doesntMatter'
tgB.gX = 4.
tg.grams.append(tgB)
tg.png()
tg.svg()

from gram import TreeGram,TreeGramRadial,Gram
read("((A,B)ab,C,(D,E)de)m;")
t = var.trees[0]
t.node(1).br.uName = 'X'
t.node(5).br.uName = 'Y'
tg = TreeGram(t, scale=7.)
print("a", tg.internalNodeLabelSize)
tg.baseName = 'twoTreesII'
t = t.dupe()
tgB = TreeGramRadial(t, scale=8.,
                     slopedBrLabels=True,
                     rotate=90,
                     equalDaylight=True)
print("b", tg.internalNodeLabelSize)
tgB.tree.root.label.yShift = 0.1
tgB.gX = 4.8
tgB.gY = -1.5
gr = Gram()
g = gr.text(r'$\Longleftrightarrow$', 0, 0)  # LaTeX symbol
gr.text('equivalence', 0, 0.5)
gr.gX = 3.5
gr.gY = 1.0
tg.grams.append(tgB)
tg.grams.append(gr)
tg.png()
g.rawText = '⇔'       # unicode symbol
tg.svg()

from gram import TreeGram
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'tinyI'
tg.setScaleBar()
tg.png()
tg.svg()

from gram import TreeGram
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'tinyII'
tg.setScaleBar(length=0.2, xOffset=0.0, yOffset=-0.7)
tg.png()
tg.svg()

from gram import TreeGram
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'tinyIII'

# Grab the leaf style ...
st = tg.styleDict['leaf']
# ... and change it
st.textShape = 'itshape'
tg.png()
tg.svg()

from gram import TreeGram
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGram(t,showNodeNums=True)
tg.baseName = 'tinyIV'
tg.font = 'lms'
# tg.defaultTextFamily = 'sffamily'
if 1:
    # Make a new style, and put it in the
    # styleDict, with a name.
    from gram import GramText
    g = GramText("Xyx")
    g.textShape = 'itshape' # oblique, not italic
    g.textSize = 'normalsize'
    g.color = 'white'
    g.draw = 'black'
    g.lineThickness = 'very thick'
    g.fill = 'blue!60'
    g.name = 'myleaf'
    g.anchor = 'mid west'
    tg.styleDict[g.name] = g

    # Apply the style to some of the leaves.
    for nNum in [1,4,5,7]:  # and one internal, node 5
        n = t.node(nNum)
        n.label.myStyle = 'myleaf'
# tg.pdf()
tg.png()
tg.svg()

from gram import TreeGram
read('((A, B)uvw, (C, D)xyz);')
t = var.trees[0]
tg = TreeGram(t.dupe(),showNodeNums=True)
tg.baseName = 'nodeLabels'
tgB = TreeGram(t.dupe())
tgB.tree.node(1).label.anchor = 'north east'
tgB.tree.node(4).label.anchor = 'west'
tgB.gX = 3.
tg.grams.append(tgB)
tg.png()
tg.svg()

from gram import TreeGram
read("((A,B)Wxy,(C,(D,E, F)Xyz)Vwxy);")
t = var.trees[0]
tg = TreeGram(t.dupe(),showNodeNums=True)
tg.baseName = 'stylesForInternalNodes'
tgB = TreeGram(t.dupe())
tgB.tree.node(1).label.myStyle = 'node lower left'
tgB.tree.node(4).label.myStyle = 'node right'
tgB.tree.node(6).label.myStyle = 'node lower right'
tgB.gX = 4.
tg.grams.append(tgB)
tg.png()
tg.svg()

from gram import TreeGram
read("((A, B))root;")
t = var.trees[0]
t.node('A').br.name = 'label'
tg = TreeGram(t)
tg.scale = 8. # 7.035 otherwise, so a bit wider
tg.baseName = 'brLabels'
n = t.node('B')
tg.setBranchULabel(n, 'uLabel')
tg.png()
tg.svg()

from gram import TreeGram
read("tinyTree.nex")
# read("((A,B)89,C,(D,E)95);")
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'brokenBranches'
tg.setBrokenBranch(1)
tg.setBrokenBranch(7)
# tg.showTextBB = True
tg.png()
tg.svg()

from gram import TreeGram
read("tinyTree.nex")
# read("((A,B)89,C,(D,E)95);")
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'emphasizeBranch'
myThickness = 2.5
tg.emphasizeBranch(1, myThickness, colour="red")
tg.emphasizeBranch(4, thickness="very thick")
tg.emphasizeBranch(6, colour="cyan")
tg.emphasizeBranch(7, thickness=myThickness, color="blue")
tg.png()
tg.svg()

from gram import TreeGram
read("((A, B), (C, D), (E, (F, G)));")
t = var.trees[0]
tg = TreeGram(t, showNodeNums=False)
tg.baseName = 'bracket1'
t.draw()
# tg.grid(0,0,4,4)
tg.setBracket(2, 3, text='these brackets line',
              leftNode=1)
tg.setBracket(6, 10, text='up with each other',
              leftNode=None, rotated=True)
tg.showTextBB = False
# tg.pdf()
tg.png()
tg.svg()

from gram import TreeGram
read("((A, B), (C, D), (E, (F, G)));")
t = var.trees[0]
tg = TreeGram(t, showNodeNums=False)
tg.font = 'palatino'
tg.baseName = 'bracket2'
t.draw()
longText1 = """A long note 
about this grouping of taxa, 
composed of A and B"""
b = tg.setBracket(2, 3, text=longText1,
                  leftNode=None)
b.label.style=None
b.label.textSize='scriptsize'
b.label.anchor = 'west'
b.label.textWrapWidth = 3.0
b.label.innerSep = 0.2
b = tg.setBracket(6, 10, text='Rotated label',
                  leftNode=None, rotated=True)
b.label.textSize='large'
tg.bracketsLineUp = False
#tg.showTextAnchor = True
tg.pdf()
tg.png()
tg.svg()

read("((A,B)89,C,(D,E)95);")
t = var.trees[0]
n = t.node('A')
n.name = r'Ab{\textcolor{blue}{cde}}fgh {\textcolor{blue}{\ding{110}}}'
#n.name = r'Ab<tspan fill="blue">cde</tspan>fgh <tspan fill="blue"> &#x2B1B;</tspan>'
#n.name = r'Ab<tspan fill="blue">cde</tspan>fgh <tspan fill="blue"> &#xFFED;</tspan>'
t.draw()
from gram import TreeGram
tg = TreeGram(t, scale=None, showNodeNums=False, widthToHeight=0.67)
tg.latexUsePackages.append('pifont')   # for \ding
tg.baseName = "multiBrackets"



g = tg.setBracket(t.node('D').nodeNum,7, text="Bracket DE", rotated=True)
g = tg.setBracket(t.node('B').nodeNum,6, text="Bracket BCD", rotated=True)
g.rightExtra = 0.7
g = tg.setBracket(2,4, text="Bracket", rotated=False)
tg.bracketsLineUp = False
# tg.styleDict['bracket label'].textSize = 'tiny'
# tg.showTextBB=True
# tg.showTextAnchor=True
# tg.latexOutputGoesToDevNull=False
# tg.grid(0,0,4,4)

tg.png()
n.label.rawText = r'Ab<tspan fill="blue">cde</tspan>fgh <tspan fill="blue">&#9632;</tspan>'  # or &#9724; 
tg.svg()

from gram import TreeGram
read('(A, (B, (C, (D, (E, F))85)));')
t = var.trees[0]
tg = TreeGram(t, showNodeNums=False, yScale=1.0)
tg.font = 'helvetica'
tg.baseName = 'simplified'
tg.leafLabelSize = 'tiny'
tg.tgDefaultLineThickness = "thick"
# tg.grid(0,0,6,5)
tg.styleDict['bracket label'].textSize = 'Large'
for n in t.iterLeavesNoRoot():
    n.label.rawText = ""
    #n.label.draw = True
t.node(5).label.rawText = 'Euryarchaeota'
t.node(7).label.rawText = 'Crenarchaeota / eocytes'
t.node(6).label.anchor = 'north east'
g = tg.setBracket(1, 3, text='Bacteria', leftNode=0)
g.fill = 'blue!15'
g = tg.setBracket(5, 7, text='Archaea', leftNode=4)
g.fill = 'orange!20'
g = tg.setBracket(9, 10, text='Eukaryotes', leftNode=8)
g.fill = 'green!20'
# tg.showTextAnchor=True
# tg.showTextBB = True
tg.png()
tg.svg()

from gram import TreeGram
read('((A, (B, C)), (D, (E, (F, G))));')
t = var.trees[0]
t.draw()
nB = t.node('B')
nB.name = r"""This is the very long name of the node that used to be named `B'.  It needs to have the text wrapped by setting \texttt{label.textWrapWidth}, and that affects the vertical spacing of the leaf taxa.  """

nE = t.node('E')
thePng = r"../../frownie_tongue2.png"
nE.name = r"\includegraphics[width=2cm]{%s}" % thePng

tg = TreeGram(t, yScale=0.5, showNodeNums=True)
tg.font = 'palatino'
tg.latexUsePackages.append('graphicx')
tg.latexOutputGoesToDevNull = False # default True
tg.baseName = 'fatTaxa'
#tg.grid(0,0,5,6)
tg.showTextBB = True

nB.label.textWrapWidth = 3.5
nB.label.textAlign = "left"

b = tg.setBracket(4, 5, text='A bracket',
                  leftNode=None, rotated=True)

bText = r"""This is a text for the bracket."""
b = tg.setBracket(9, 11, text=bText,
                  leftNode=None, rotated=True)

# b.label.style = None
b.label.textWrapWidth = 2.5
b.label.textSize = 'scriptsize'
b.label.textAlign = 'center'
tg.bracketsLineUp = False
tg.png()
# tg.svg()  # no workee, svg does not do wrapping

from gram import TreeGram
read('((A, B), (C, (D, E)));')
t = var.trees[0]

nC = t.node('C')
nC.name = r"""synonym 1,\\another synonym,\\
and a third synonym."""

nD = t.node('D')
nD.name = r"""here\\the vertical space\\ 
for the node\\expands \\to fit\\the extra \\lines"""

tg = TreeGram(t, scale=5.0)
tg.baseName = 'wrapLeafNames'

# tg.grid(0,-5,5,3)
# tg.showTextBB = True

nC.label.fill = "blue!10"


tg.png()
# tg.svg() # svg does not wrap

from gram import TreeGram
var.nexus_getAllCommandComments = True
var.nexus_readBeastTreeCommandComments = True
read('treeannotatorOut')
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'beastA'
for n in t.iterNodes():
    if not n.isLeaf:
        tg.setNodeConfidenceBox(n)
tg.png()
tg.svg()

from gram import TreeGram
var.nexus_getAllCommandComments = True
var.nexus_readBeastTreeCommandComments=True
read('treeannotatorOut')
t = var.trees[0]

# The two cBoxes on the left are too big, and dominate the figure.
# Make them text, as node labels, instead.
n = t.root
n.name = "(%.1f, %.1f)" % (n.height_95_HPD[1], n.height_95_HPD[0])
n = t.node(1)
n.name = "(%.1f, %.1f)" % (n.height_95_HPD[1], n.height_95_HPD[0])

tg = TreeGram(t)
tg.font = 'palatino'
tg.documentFontSize = 10
tg.baseName = 'beastB'
for nNum in [3,4,6,9]:
    n = t.node(nNum)
    tg.setNodeConfidenceBox(n)

# Define a style
from gram import GramText
tb = GramText('myStyle')
tb.textWrapWidth = 1.
tb.textAlign = "flush left"
tb.textSize = 'scriptsize'
tb.anchor = 'west'
tb.name = 'wrappedNode'
tg.styleDict['wrappedNode'] = tb

for nNum in [0,1]:
    n = t.node(nNum)
    n.label.myStyle = 'wrappedNode'

tg.png()
tg.svg()  # no wrapping in svg

from gram import TreeGramRadial
tA = func.readAndPop('((A, B), (C, D), (E, (F, (G, H))));')
tB = tA.dupe()

if os.path.isfile("intree"):
    os.remove("intree")

tg = TreeGramRadial(tA, maxLinesDim=3.,equalDaylight=True)
tg.baseName = 'equalDaylightAndSimpleRadialA'

tgB = TreeGramRadial(tB, maxLinesDim=3.,equalDaylight=False, rotate=70)
tgB.gX = -3.
tgB.gY = 2.6
tg.grams.append(tgB)

# tg.grid(-5,0,4,4)
gA = tg.text("Equal Daylight", 0.6,0.5)
gB = tg.text("Simple radial", -4.5,0.5)
for g in [gA, gB]:
    g.anchor = 'west'
    g.textSize = 'normalsize'

tg.png()
tg.svg()

# import string
# t = func.randomTree(taxNames=list(string.uppercase), seed=0)
# t.writeNexus('t26.nex')


from gram import TreeGramRadial
tA = func.readAndPop('t26.nex')
tA.reRoot(19)     # re-rooting can often help.
tB = tA.dupe()

if os.path.isfile("intree"):
    os.remove("intree")

tg = TreeGramRadial(tA, maxLinesDim=8.,equalDaylight=True)
tg.baseName = 'equalDaylightAndSimpleRadialB'

tgB = TreeGramRadial(tB, maxLinesDim=8.,equalDaylight=False)
tgB.gX = 5.
tgB.gY = -2.5
tg.grams.append(tgB)

#tg.grid(0,-10,10,10)
gA = tg.text("Equal Daylight", 0,3)
gB = tg.text("Simple radial", 0,-6.5)
for g in [gA, gB]:
    g.anchor = 'west'
    g.textSize = 'normalsize'
# gC = tg.text("(equalDaylight=False)", 0,-7.2)
# gC.textFamily = 'ttfamily'
# gC.anchor = 'west'

tg.png()
tg.svg()

from gram import TreeGramRadial
read('(chimp, gorilla, (human, (gibbon, orang)));')
t = var.trees[0]
# tg = TreeGramRadial(t, maxLinesDim=2.,rotate=50, equalDaylight=False)
tg = TreeGramRadial(t, maxLinesDim=2.,rotate=-50, equalDaylight=True)
tg.baseName = 'radialTinyI'
#tg.showTextBB = True
#tg.showTextAnchor = True
tg.png()
tg.svg()

from gram import TreeGramRadial
read('tinyTree.nex')  # with branch lengths and supports
t = var.trees[0]

# Delete the internal branch supports
for n in t.iterInternalsNoRoot():
    n.name = None

tg = TreeGramRadial(t, maxLinesDim=2.,rotate=-50, equalDaylight=True)
tg.baseName = 'radialTinyII'
tg.png()
tg.svg()

from gram import TreeGramRadial
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGramRadial(t, maxLinesDim=2.,rotate=-50, equalDaylight=True)
tg.baseName = 'radialTinyIII'
tg.pdf()
tg.svg()

from gram import TreeGramRadial
read("((A,B)ab,C,(D,E)de)m;")
t = var.trees[0]
t.node(1).br.uName = 'X'
t.node(5).br.name = 'Y'
tg = TreeGramRadial(t, scale=7.,
                    slopedBrLabels=True,
                    showNodeNums=False,
                    rotate=90,
                    equalDaylight=True)
tg.baseName = 'smallRadialI'
tg.font = 'palatino'

tg.png()
tg.svg()

from gram import TreeGram
read('easyTreeA.nex')
read('easyTreeB.nex')

tA = var.trees[0]
# make a duplicate tree, as tA is used again below
tg = TreeGram(tA.dupe())
tg.baseName = 'combineSplitSupports'
tg.tree.node(8).label.myStyle = 'node upper right'
tg.tree.node(10).label.myStyle = 'node right'

tB = var.trees[1]
tgB = TreeGram(tB)
tgB.gY = -7.5
tg.grams.append(tgB)

tA.makeSplitKeys()
tB.makeSplitKeys()
nodeForSKDict = {}
for n in tB.iterInternalsNoRoot():
    nodeForSKDict[n.br.splitKey] = n
for n in tA.iterInternalsNoRoot():
    theNode = nodeForSKDict.get(n.br.splitKey)
    if theNode:
        n.name += '/%s' % theNode.name

tgX = TreeGram(tA, showNodeNums=False)
tgX.tree.node(8).label.myStyle = 'node upper right'
tgX.tree.node(10).label.myStyle = 'node right'
tgX.gY = -15.
tg.grams.append(tgX)
#tg.font = 'palatino'
#tg.grid(0, -16, 5, 7) 
tg.png()
tg.svgPxForCm = 60.
tg.svg()
#st = tg.styleDict['node upper left']

from gram import Plot
read("data1.py")
gp = Plot()
# gp.svgPxForCm = 100
gp.baseName = 'scatter'
gp.scatter(xx1, yy1)
gp.yAxis.title = 'scratches'
gp.xAxis.title = 'itches'
gp.minXToShow = 0
gp.maxXToShow = 12
gp.minYToShow = 0.
gp.maxYToShow = 34
gp.png()
gp.svg()

from gram import Plot
read("data6.py")
read("data6b.py")
gp = Plot()
gp.baseName = 'regression'
gp.scatter(xx1, yy1, plotMark='square')
g = gp.line(xx2, yy2, smooth=True)
g.lineThickness = 'thick'
gp.maxYToShow=100
gp.minXToShow=-2
gp.xAxis.title = None
gp.yAxis.title = None
gp.png()
gp.svg()

import math
xx1 = [x/100. for x in range(-400, 401)]
yy1a = [math.sqrt(1. + (x * x)) for x in xx1]
yy1b = [-y for y in yy1a]

from gram import Plot
gp = Plot()
g = gp.line(xx1, yy1a)
g.colour = 'green'
g = gp.line(xx1, yy1b)
g.colour = 'green'

g = gp.line(yy1a, xx1)
g.colour = 'blue'
g = gp.line(yy1b, xx1)
g.color = 'blue'

g = gp.line([-4, 4], [-4, 4])
g.color = 'red'
g = gp.line([-4, 4], [4, -4])
g.colour = 'red'

myTextSize = 'tiny'
l1 = r'$y^2 + x^2 = 1$'
g = gp.xYText(-2, 2.5, l1)
g.anchor = 'west'
g.textSize = myTextSize

l1 = r'$x^2 - y^2 = 1$'
g = gp.xYText(1.5, 1., l1)
g.anchor = 'west'
g.textSize = myTextSize

howBig = 3.5
gp.contentSizeX = howBig
gp.contentSizeY = howBig
gp.xAxis.title = None
gp.yAxis.title = None
gp.yAxis.sig = '%.1f'
gp.baseName = 'hyperbolas'
gp.png()
gp.svg() # svg does not work perfectly; it does not typeset latex math

from gram import Plot
read("data3.py")
gp = Plot()
gp.baseName = 'scatterB'
g = gp.scatter(xx1, yy1)
g.color = 'blue'
gp.lineFromSlopeAndIntercept(s1, m1)
g = gp.scatter(xx2, yy2, plotMark='*')
g.color = "black"
g.fill = 'blue!50'
g = gp.lineFromSlopeAndIntercept(s2, m2)
g.lineStyle = 'densely dotted'
g.lineThickness = 'very thick'
gp.xAxis.title = None
gp.yAxis.title = None
gp.minYToShow = 0.0
gp.maxYToShow = 60.
gp.png()
gp.svg()

from gram import Plot

markerShapes = ['+', 'x', '*', '-', '|', 'o', 'asterisk',
                'square', 'square*', 'triangle',
                'triangle*', 'diamond', 'diamond*']

gp = Plot()
gp.baseName = 'plotMarks'
for mShNum in range(len(markerShapes)):
    xx = [5]
    yy = [len(markerShapes) - mShNum]
    myMarker = markerShapes[mShNum]
    gp.scatter(xx, yy, plotMark=myMarker)
    g = gp.xYText(0, yy[0], myMarker)
    g.textFamily = 'ttfamily'
    g.anchor = 'west'

    xx = [6]
    g = gp.scatter(xx, yy, plotMark=myMarker)
    g.color = 'red'

    xx = [7]
    g = gp.scatter(xx, yy, plotMark=myMarker)
    g.fill = 'red'

    xx = [8]
    g = gp.scatter(xx, yy, plotMark=myMarker)
    g.color = 'blue'
    g.fill = 'yellow'

gp.line([4.5,8.5], [14, 14])

colorY = 16
gp.xYText(3, colorY, "color")
gp.xYText(5, colorY, "-")
gp.xYText(6, colorY, "+")
gp.xYText(7, colorY, "-")
gp.xYText(8, colorY, "+")

fillY = 15
gp.xYText(3, fillY, "fill")
gp.xYText(5, fillY, "-")
gp.xYText(6, fillY, "-")
gp.xYText(7, fillY, "+")
gp.xYText(8, fillY, "+")



gp.yAxis.title = None
gp.xAxis.title = None
gp.yAxis.styles.remove('ticks')
gp.xAxis.styles.remove('ticks')
gp.frameT = None
gp.frameB = None
gp.frameL = None
gp.frameR = None
gp.contentSizeX = 4.0
gp.contentSizeY = 7.0
gp.minXToShow = 0
gp.maxYToShow = 16

gp.png()
gp.svg()

from gram import Plot
xx = list(range(1, 100))
yyA = [100 + x + (20 * (random.random() - 0.5)) for x in xx]
yyB = [y - 40 for y in yyA]
yyC = [y - 80 for y in yyA]
gp = Plot()
#gp.svgPxForCm = 100
gp.baseName = 'plotMarkSize'
gp.scatter(xx, yyA, plotMark="*", plotMarkSize=0.3)
gp.scatter(xx, yyB, plotMark="*", plotMarkSize=1.0)
g = gp.scatter(xx, yyC, plotMark="*", plotMarkSize=1.5)
myColour = "black!30"
g.color = myColour
g.fill = myColour
gp.xAxis.title = None
gp.yAxis.title = None
gp.minXToShow = 0
gp.maxXToShow = 100
gp.minYToShow = 0.
# gp.maxYToShow = 

gp.png()
gp.svg()

from gram import Plot
read("data2.py")
gp = Plot()
gp.baseName = 'barB'
gp.font = 'helvetica'
c = gp.bars(xx1, yy1)
# c.barSets[0].fillColor = 'violet!20'
gp.barValAxis.title = 'gnat infestations'
gp.barNameAxis.title = None
#gp.barValAxis.position = 'r'
#gp.barNameAxis.position = 't'
gp.minBarValToShow = 0.
gp.maxBarValToShow = 80.
gp.barNameAxis.textRotate = 44
# gp.png()
gp.png()
gp.svg()

from gram import Plot

myBarNms = [
    "A", "B", "C", "D",
]

myBarVals = [23, 12, 33, 15]

gp = Plot()
gp.baseName = "barsAppearance"
g = gp.bars(myBarNms, myBarVals)

gp.barNameAxis.title = None
gp.barValAxis.title = None
gp.minBarValToShow = 0


gpA = Plot()
g = gpA.bars(myBarNms, myBarVals)
# Here g is a PlotBarSets object, containing a list g.barSets

# Bar color and outline
g.barSets[0].fillColor = "blue!15"
g.barSets[0].drawColor = None  # default 'black'

gpA.barNameAxis.title = None
gpA.barValAxis.title = None
gpA.minBarValToShow = 0

# Adjust the spacing between bars
gpA.halfSpaceBetweenBarGroups = 0.02
gpA.gX = 6.0

gp.grams.append(gpA)

gp.png()
gp.svg()

from gram import Plot
read("data4.py")

# Prepare the numbers, using p4.Numbers.  Make the padMin and padMax
# the same for both data, so that the histo lists are the same size.
n1 = Numbers(nv1)
n1.binSize = 1
n1.histo(verbose=False,padMin=-3, padMax=15.)

n2 = Numbers(nv2)
n2.binSize = 1
n2.histo(verbose=False, padMin=-3, padMax=15.)

# prepare the binNames, and extract the histo values into separate
# lists.
binNames = []
vals1 = []
vals2 = []
for bNum in range(n1.nBins):
    binNames.append('%i' % int(n1.bins[bNum][0]))
    vals1.append(float(n1.bins[bNum][1]))
    vals2.append(float(n2.bins[bNum][1]))
assert len(binNames) == len(vals1)
assert len(vals1) == len(vals2)

gp = Plot()
gp.baseName = 'twoBarsA'
gp.bars(binNames, [vals1, vals2])
gp.barValAxis.title = None
gp.barNameAxis.title = None
gp.png()
gp.svg()

import math

upper = int(round(25. * math.pi * 2.))
rr = [0.04 * r for r in range(upper)]
xxx = []
yyy = []
j = 0
for rev in range(8):
    xx = []
    yy = []
    for i in range(len(rr)):
        r = rr[i]
        h = 0.0005 * j
        h += 0.5
        j += 1
        pt = func.polar2square([r,h])
        xx.append(pt[0])
        yy.append(pt[1])
    xxx.append(xx)
    yyy.append(yy)

from gram import Plot
gp = Plot()
gp.baseName = 'spiral'
for rev in range(8):
    xx = xxx[rev]
    yy = yyy[rev]
    g = gp.line(xx,yy,smooth=True)
    g.lineStyle = gp.goodLineStyles[rev]
    print(g.lineStyle)
gp.contentSizeX = 4.5
gp.contentSizeY = gp.contentSizeX
gp.xAxis.title = None
gp.yAxis.title = None
gp.yAxis.styles.remove('ticks')
gp.xAxis.styles.remove('ticks')
gp.frameT = None
gp.frameB = None
gp.frameL = None
gp.frameR = None
gp.png()
gp.svg()

from gram import Plot
xx1 = [2,4,7,3,9]
yy1 = [4,5,1,7,4]
gp = Plot()
gp.contentSizeX = 2
gp.contentSizeY = 1.5
gp.baseName = 'textInPlot'
gp.scatter(xx1, yy1, plotMark='asterisk')
c = gp.xYText(7, 1.2, r'$\Downarrow$')
c.anchor = 'south'
c = gp.xYText(3.3, 7,
      r'$\leftarrow$\ Ignore this point')
c.textSize = 'tiny'
c.anchor = 'west'
gp.xAxis.title = None
gp.yAxis.title = None
gp.png()
gp.svg()  # looks bad, the latex text is not rendered

from gram import Plot
xx1 = [2,4,7,3,9]
yy1 = [4,5,1,7,4]
gp = Plot()
gp.baseName = 'linesInPlot'
gp.scatter(xx1, yy1, plotMark='diamond')
gp.minXToShow = 0.0
g = gp.lineFromSlopeAndIntercept(1, 2)
g.lineThickness = 'thick'
gp.verticalLine(x=3, y=4)
c = gp.verticalLine(8)
c.colour = 'gray'
c.lineThickness = 'very thick'
gp.xAxis.title = None
gp.yAxis.title = None
gp.font = 'helvetica'
gp.png()
gp.svg()

from gram import Plot

xx1 = [0.2, 2.3, 3.5, 4.5, 7.]
yy1 = [2.2, 3.3, 1.2, 1.8, 5.6]

xx2 = [-19.3, -14.3, -10.5]
yy2 = [-2.6, -15.9, -9.3]

sizeX = 3.0
sizeY = 3.0

gp = Plot()
gp.baseName = 'plotArrayB'
gp.line(xx1, yy1, smooth=True)
gp.scatter(xx1, yy1)
gp.yAxis.title = 'diameter'
gp.xAxis.title = 'time (hours)'
gp.minXToShow = 0.0
gp.minYToShow = 0.0
gp.contentSizeX = sizeX
gp.contentSizeY = sizeY

gp2 = Plot()
# baseName does not matter, and is not needed
gp2.line(xx2, yy2, smooth=False)
gp2.scatter(xx2, yy2)
gp2.yAxis.title = 'spin'
gp2.yAxis.position = 'r'
gp2.xAxis.title = 'impetus'
gp2.contentSizeX = sizeX
gp2.contentSizeY = sizeY

gp2.gX = 3.7
gp2.gY = 0.

gp.grams.append(gp2)
# gp.showTextBB = True
# gp.showTextAnchor = True

gp.png()
gp.svg()  # smooth line plots do not work in svg

import random
from gram import Plot
plotmarks = ['o', 'square',
             'triangle', 'diamond']
gg = []
for i in [0,1]:
    for j in [0,1]:
        xx1 = []
        yy1 = []
        for k in range(23):
            xx1.append(random.random())
            yy1.append(random.random())

        gp = Plot()
        gp.contentSizeX = 2.5
        gp.contentSizeY = 2.
        thePlotMark = plotmarks[(2 * i) +j]
        c = gp.scatter(xx1, yy1,
                       plotMark=thePlotMark)
        gp.minXToShow = 0.0
        gp.minYToShow = 0.0
        gp.maxXToShow = 1.0
        gp.maxYToShow = 1.0
        theText = '[%i.%i]' % (i, j)
        c = gp.xYText(0.5, 0.5, theText)
        c.colour = 'blue'

        if i == 0:
            gp.xAxis.title = None
            gp.xAxis.styles.remove('ticks')
        else:
            gp.xAxis.title = 'xx1'
        if j == 0:
            gp.yAxis.title = 'yy1'
        else:
            gp.yAxis.title = None
            gp.yAxis.styles.remove('ticks')
        gp.gX = j * 3.2
        gp.gY = i * -2.7
        gg.append(gp)

gr = gg[0]
gr.baseName = 'plotArray'
# gr.grid(0,0,6,3)
gr.grams += gg[1:]
# gr.showTextBB = True
# gr.showTextAnchor = True
gr.png()
gr.svg()

from gram import Plot, Gram
from data1 import xx1, yy1
gp = Plot()
gp.baseName = 'hb_lineA'
gp.line(xx1, yy1)
gp.xAxis.title = ''
gp.yAxis.title = None
gp.minXToShow = 0
gp.maxXToShow = 12
# gp.minYToShow = 0.
gp.maxYToShow = 31

# The text on the horizontal bracket has "tickLabel" style, with a south anchor.
g = gp.horizontalBracket(1, 6, 25, "from x=1 to 6")

# Modifications might include ...
# g.text.textAlign = "flush center"
# g.text.textSize = 'tiny'
# g.text.rotate = 0

gp.png()
gp.svg()

from gram import Plot
from data4 import nv1, nv2

# Prepare the numbers, using p4.Numbers.  Make the padMin and padMax
# the same for both data, so that the histo lists are the same size.
n1 = Numbers(nv1)
n1.binSize = 1
n1.histo(verbose=False,padMin=-3, padMax=15.)

n2 = Numbers(nv2)
n2.binSize = 1
n2.histo(verbose=False, padMin=-3, padMax=15.)

# prepare the binNames, and extract the histo values into separate
# lists.
binNames = []
vals1 = []
vals2 = []
for bNum in range(n1.nBins - 1):
    binNames.append('%i' % int(n1.bins[bNum][0]))
    vals1.append(float(n1.bins[bNum][1]))
    vals2.append(float(n2.bins[bNum][1]))
assert len(binNames) == len(vals1)
assert len(vals1) == len(vals2)

gp = Plot()
gp.baseName = 'hb_barsA'
gp.bars(binNames, [vals1, vals2])
gp.barValAxis.title = None
gp.barNameAxis.title = None
gp.maxBarValToShow = 950.
gp.barNameAxis.barLabelsEvery = 2
gp.barNameAxis.barLabelsSkipFirst = 1
gp.barNameAxis.textRotate = 90

# The first two numbers are the bar numbers.
gp.horizontalBracketBars(1, 5, 800, "near")
gp.horizontalBracketBars(7, 16, 800, "far")

gp.png()
gp.svg()

from gram import Plot
import random
import math

mainPlot = None

for doTicks in [False, True]:

    if 0:
        # Make datasets
        random.seed(41)
        yyA = [(-1.2 * x) + 33. + (5. * (random.random() - 0.5)) for x in range(23)]
        yyB = [(-0.1 * x) + 11. + (8. * (random.random() - 0.5)) for x in range(35)]
        yyC = [(1.4 * x) + 3. + (5. * (random.random() - 0.5)) for x in range(14)]
        print([float(f"{x:.1f}") for x in yyA])
        print([float(f"{x:.1f}") for x in yyB])
        print([float(f"{x:.1f}") for x in yyC])
        sys.exit()

    else:
        yyA = [32.4, 30.5, 28.9, 31.5, 28.6, 28.0, 26.1, 24.0, 24.6, 22.6,
               22.4, 20.6, 20.3, 17.1, 14.5, 13.2, 14.9, 10.9, 12.2, 10.8, 6.8, 9.2, 4.3]
        yyB = [13.9, 13.6, 8.5, 12.5, 12.5, 7.5, 11.8, 7.3, 13.5,
               11.6, 13.8, 6.3, 8.3, 10.7, 10.5, 7.0, 12.5, 12.1, 7.6, 6.3,
               10.3, 8.2, 10.1, 8.6, 7.8, 4.7, 5.5, 8.0, 10.0, 7.5, 10.0, 8.2, 10.8, 8.9, 6.2]
        yyC = [1.2, 2.2, 3.5, 9.0, 10.5, 11.3, 9.4, 13.6, 12.3, 17.5,
               17.8, 19.6, 20.3, 20.8]


    yy = yyA + yyB + yyC   # concatenated single list
    yyy = [yyA, yyB, yyC]  # list of lists

    assert min(yy) > 0.0
    myMinY = 0.0
    myMaxY = math.ceil(max(yy))

    if 1:
        print(f"min(yy) is {min(yy)}")
        print(f"max(yy) is {max(yy)}")
        print(f"myMaxY for all plots is {myMaxY}")

    nPlots = 3
    myPltWidth = 1.2   # cm
    spacer = 0.175    # from Plot.frameToContent_llx etc, default 0.175
    between = 3 * spacer  # space between the mini-plots

    mPl = Plot()
    mPl.baseName = "multiNarrowLineA"

    # A hack to get past error checking; make an invisible line
    g = mPl.line([0],[0])
    g.color = 'white'

    # This is needed to make the x-axis label centered
    mPl.contentSizeX = (myPltWidth * nPlots) + ((nPlots - 1) * between)
    # mPl.contentSizeY = 4.0

    # Another hack to get past error checking
    mPl.minXToShow = 0.
    mPl.maxXToShow = 1.

    mPl.minYToShow = 0.
    mPl.maxYToShow = myMaxY



    if doTicks:
        mPl.xAxis.title = "shared x-axis title"
        mPl.yAxis.title = None
        mPl.titleExtraSpaceFromAxisB = 0.4
    else:
        mPl.xAxis.title = None
        mPl.yAxis.title = "shared y-axis title"

    mPl.frameB = None
    mPl.frameT = None
    mPl.frameR = None
    mPl.xAxis.styles.remove('ticks')

    titles = "A B C".split()

    if 1:
        for pNum in range(nPlots):
            yy = yyy[pNum]
            xx = list(range(len(yy)))
            gp = Plot()

            gp.line(xx, yy)
            # gp.minXToShow = 0
            # gp.maxXToShow = 
            gp.minYToShow = 0.
            gp.maxYToShow = myMaxY

            gp.contentSizeX = myPltWidth
            gp.yAxis.title = None
            gp.yAxis.styles.remove('ticks')
            if doTicks:
                # make the x-axis have only two ticks
                gp.xAxis.tickInterval = len(yy) - 1
                gp.xAxis.title = None
            else:
                gp.xAxis.styles.remove('ticks')
                gp.xAxis.title = titles[pNum]

            gp.frameT = None
            # gp.frameB = None 
            gp.frameL = None
            gp.frameR = None


            gp.gX =  spacer + (pNum * (gp.contentSizeX + between))
            mPl.grams.append(gp)

    if mainPlot == None:
        mainPlot = mPl
        mPl = None

mPl.gX = 6.5
mainPlot.grams.append(mPl)
mainPlot.png()

mainPlot.svg()

mainPlot = None

for doTicks in [True, False]:
    nVals = 3
    nPlots = 3

    valsA = [23., 33., 43.]
    valsB = [15., 12., 19.]
    valsC = [28., 22., 41.]

    allVals = valsA + valsB + valsC
    myMaxY = 43

    from gram import Plot

    barNms = "A B C".split()

    myPltWidth = 1.2   # cm
    myPltHt = 3.5
    spacer = 0.175    # from Plot.frameToContent_llx etc, default 0.175
    between = 3 * spacer  # space between the mini-plots


    # A "main" plot, with the shared y-axis
    mPl = Plot()
    mPl.font = 'lms'
    mPl.baseName = "multiNarrowBarA"

    g = mPl.bars(["x"],[0])

    mPl.contentSizeX = spacer + (myPltWidth * nPlots) + ((nPlots - 1) * between)
    mPl.contentSizeY = myPltHt

    mPl.minBarValToShow = 0.
    mPl.maxBarValToShow = myMaxY
    if doTicks:
        mPl.barNameAxis.title = None
        mPl.barValAxis.title = "shared bar val axis title"
    else:
        mPl.barNameAxis.title = "shared bar name axis title"
        mPl.barValAxis.title = None
        mPl.titleExtraSpaceFromAxisB = 0.5

    mPl.frameB = None
    mPl.frameT = None
    mPl.frameR = None
    mPl.barNameAxis.styles.remove('ticks')

    bVal = 0.
    labs = [
        "A",
        "B",
        "C"
    ]

    titles = "AA BB CC".split()

    if 1:
        # Make mini-plots
        for pNum in range(nPlots):
            strt = pNum * nVals
            yy = allVals[strt:strt+nVals]
            gp = Plot()
            # print(xx)
            # print(yy)
            g = gp.bars(labs, yy)
            g.barSets[0].fillColor = "black!30"
            g.barSets[0].drawColor = None
            gp.barNameAxis.title = None
            gp.barValAxis.title = None
            gp.minBarValToShow = 0
            gp.maxBarValToShow = myMaxY

            gp.barValAxis.styles.remove('ticks')
            gp.contentSizeX = myPltWidth
            gp.contentSizeY = myPltHt
            gp.frameToContent_lly = 0

            # gp.frameB = None
            gp.frameT = None
            gp.frameR = None
            gp.frameL = None

            if doTicks:
                pass
            else:
                gp.barNameAxis.styles.remove('ticks')
                gp.barNameAxis.title = titles[pNum]

            gp.gX = spacer + (pNum * (gp.contentSizeX + between))
            gp.gY = 0.175  # to compensate for zeroing the gp.frameToContent_lly above
            mPl.grams.append(gp)

    if mainPlot == None:
        mainPlot = mPl
        mPl = None



mPl.gX = 6.
mainPlot.grams.append(mPl)
mainPlot.svg()

mainPlot.png()

# mPl.svg()