The gram package

from gram import Gram
gr1 = Gram()
gr1.font = 'helvetica'
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.png()
gr1.svg()

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.colour = 'black!20'
g.colour.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(3.5, 1, 3.5, 2)
g.lineThickness = 10
g.cap = 'rect'  # default butt
g = gr.text('some lines', 3,3)
g.anchor = 'north west'
g.textSize = 'normalsize'
gr.png()
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.color = '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.pdflatexOutputGoesToDevNull = True

gr = Gram()
gr.pdfViewer = 'open'
gr.baseName = 'anchors'
gr.font = 'cm'
# 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.pdf()
# 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.pdflatexOutputGoesToDevNull = False
# gr.showTextBB = True
# gr.pdf()
gr.png()
# gr.cat()

from gram import Gram


gr = Gram()
gr.baseName = "wrap"
gr.font = "cm"
# 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.pdflatexOutputGoesToDevNull = False
# gr.pdf()
gr.png()
# gr.cat()

from gram import Gram

gr = Gram()
gr.baseName = "symbolsT"
gr.font = "cm"
gr.defaultTextFamily = "sffamily"
dY = -0.5

# Don't forget the r"\something" format
gr.text(r"$\alpha \Leftrightarrow \beta \Sigma \Gamma$", 0,0)
# gr.text("£ 100 €", 0,0)  # does not work
gr.text(r"\pounds", 0, 1 * dY)
gr.text(r"\textsterling", 0, 2 * dY)
# gr.text("£", 1,3 * dY)  # does not work
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}{\texttildelow}/myFile", 4.0, 3 * dY)
g.textFamily = "ttFamily"

gr.png()

from gram import Gram

gr = Gram()
gr.baseName = "symbolsS"
gr.font = "helvetica"
gr.defaultTextFamily = "sffamily"
dY = -0.5

# From W3schools
# https://www.w3schools.com/html/html_symbols.asp
# gr.text(r"I will display €", 0, 0)   # does not work
# gr.text(r"I will display €", 0, 0)  # works
# gr.text(r"I will display €", 0, 0) # does not work

g = gr.text("Using the decimal code works: €", 0, 0)
g.anchor = "mid west"
g = gr.text("Unicode characters typed into your text editor works: α ⇔ β ∑Γ£€°→◻︎◼︎", 0, 1 * dY)
g.anchor = "mid west"
g = gr.text(r"The tilde looks good with ttFamily: ~/myFile", 0, 2 * dY)
g.textFamily = "ttFamily"
g.anchor = "mid west"

g = gr.text("a blue square: ◼", 0, 3 * dY)
g.color = "blue"
g.anchor = "mid west"

gr.svg()

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

# 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.pdflatexOutputGoesToDevNull = False
# gr.pdf()
gr.png()
gr.svg()

\tikzset{bunny1/.style={font=\itshape,violet,anchor=base}}
\begin{tikzpicture}[font=\sffamily]
\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,orange] at (1.000,0.200) {Cottontail};
\node [bunny1,font=\bfseries,draw=blue,thin] at (3.000,0.200) {Peter};
\end{tikzpicture}

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

# t2 = r"""\parbox{150pt}{\raggedright This \\ is
# some \\ text in a parbox
# with
# line endings.}
# """

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.50, angle=32]
{../../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',  't3', 't3x', 't4', 't5']
tt = [t1, t3, t3x, t4, t5]

for dNum in range(5):
    gr.graphics = []
    gr.baseName = bNames[dNum]
    gr.text(tt[dNum],0,0)
    print("about to do %s" % tt[dNum])
    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 Gram
gr = Gram()
gr.baseName = 'colour'
gr.grid(0,0,6,4)

g = gr.rect(2.6, 2.6, 3.4, 3.4)
g.fill = "red!30"
g.draw = "blue!50"
g.lineThickness = 5

g = gr.rect(2.6, 1.6, 3.4, 2.4)
g.fill = "red!30"
g.draw = None

g = gr.rect(2.6, 0.6, 3.4, 1.4)
g.fill = None
g.draw = "blue!50"
g.lineThickness = 5

g = gr.text("default, transparent", 3.0, 3.75)
g.textSize = 'tiny'
g.fill = 'white'

g = gr.rect(4.6, 2.6, 5.4, 3.4)
g.fill = "red!30"
g.fill.transparent = False
g.draw = "blue!50"
g.draw.transparent = False
g.lineThickness = 5

g = gr.rect(4.6, 1.6, 5.4, 2.4)
g.fill = "red!30"
g.fill.transparent = False
g.draw = None

g = gr.rect(4.6, 0.6, 5.4, 1.4)
g.fill = None
g.draw = "blue!50"
g.draw.transparent = False
g.lineThickness = 5


g = gr.text("transparent=False", 5.0, 3.75)
g.textSize = 'tiny'
g.fill = 'white'

g = gr.text("with fill, with draw", 0.0, 3.0)
g.textSize = 'tiny'
g.anchor = 'west'
g.fill = 'white'

g = gr.text("with fill, no draw", 0.0, 2.0)
g.textSize = 'tiny'
g.anchor = 'west'
g.fill = 'white'

g = gr.text("no fill, with draw", 0.0, 1.0)
g.textSize = 'tiny'
g.anchor = 'west'
g.fill = 'white'

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.pdf()
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.pdf()
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.pdf()
tg.svg()

from gram import TreeGram
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGram(t)
tg.baseName = 'tinyIII'
# styleDict is empty until you render().
tg.render()
# Grab the leaf style ...
st = tg.styleDict['leaf']
# ... and change it
st.textShape = 'itshape'
#tg.pdf()
tg.svg()

from gram import TreeGram
read('tinyTree.nex')
t = var.trees[0]
tg = TreeGram(t,showNodeNums=True)
tg.baseName = 'tinyIV'
tg.font = 'cm'
# 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.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.pdf()
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.pdf()
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.pdf()
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.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.render()
#tg.styleDict['bracket label'].textSize = 'tiny'
# tg.showTextBB=True
#tg.showTextAnchor=True
# tg.pdflatexOutputGoesToDevNull=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.render()    # needed to get style
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!30'
tg.wrapLeafLabelsAt = 1.3     # svg can't do this
#tg.showTextAnchor=True
# tg.showTextBB = True
tg.pdf()
tg.wrapLeafLabelsAt = None
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 "B".  It needs
to have the text wrapped, but that affects
the spacing of the leaf taxa.  So we need 
to do \texttt{wrapLeafLabelsAt}.  That sets 
the \texttt{label.textWrapWidth}, and 
adjusts the node spacing"""

# nB.name = "B"
nE = t.node('E')
thePng = "../../frownie_tongue2.png"
nE.name = r"\includegraphics[scale=0.2]{%s}" % thePng

tg = TreeGram(t, showNodeNums=False)
tg.font = 'palatino'
tg.latexUsePackages.append('graphicx')
tg.baseName = 'fatTaxa'
#tg.grid(0,0,5,10)

# We want all leaf labels to wrap at 4. cm
tg.wrapLeafLabelsAt = 4.0

b = tg.setBracket(4, 5, text='A bracket',
                  leftNode=1, rotated=True)
b.fill = "black!8"

# Doing the node with PNG is more hands-on.
# The style gets in the way, so it is
# auto-deleted.  With no style, the default
# anchor is center, so change that.
nE.label.anchor = 'west'
tg.extraYSpaceAtNode(nE, extra=1.1)

# Set the bracket
bText = r"""Since the size of the picture is
unknown to Gram, it needed to have its
\texttt{extraYSpaceAtNode} set explicitly.
This bracket also needed to have its
\texttt{topOverRide} and
\texttt{rigthOverRide} set to some
appropriate values in order to
work; use a grid to get those values."""
b = tg.setBracket(9, 11, text=bText,
                  leftNode=None, rotated=True)

# Adjust the bracket position.  Use the grid to get these numbers.
b.topOverRide = 2.8
b.bottomOverRide = 0.6
b.rightOverRide = 4.3

# Adjust the bracket label
b.label.style = None
b.label.textWrapWidth = 2.5
b.label.textAlign="flush center"
b.label.textSize = 'scriptsize'
b.label.anchor = 'north'
b.label.rotate = 90

tg.bracketsLineUp = False
# tg.pdflatexOutputGoesToDevNull = False
# tg.showTextBB = True
tg.png()
# tg.svg()  # does not work; 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 = """synonym 1, another synonym,
and a third synonym."""

nD = t.node('D')
nD.name = """synonym 1, synonym 2, 
yet another synonym, and synonym 4"""

t0 = t.dupe()
tg = TreeGram(t0, scale=5.0)
tg.baseName = 'wrapLeafLabelsAtComma'
# tg.grid(0,-5,5,3)

tgB = TreeGram(t, scale=5.0, showNodeNums=False)
tgB.wrapLeafLabelsAt = 'comma'
tgB.gY = -6.0
tg.grams.append(tgB)

# tg.showTextBB = True
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 a 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
tg.render()
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.pdf()
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.pdf()
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.pdf()
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.pdf()
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.pdf()
tg.svg()

from gram import TreeGramRadial
read('fancyTree.nex')
t = var.trees[0]
for n in t.iterInternalsNoRoot():
    if n.name:
        if n.name in ['0.22']:
            n.br.name = n.name
        else:
            n.br.uName = n.name
        n.name = None

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

tg = TreeGramRadial(t, maxLinesDim=6.,
                    rotate=120,
                    showNodeNums=False,
                    slopedBrLabels=True,
                    equalDaylight=True)
tg.baseName = 'smallRadialII'

if 1:
    # There are two superimposed taxon names, 
    # so it is hard to read.
    # Either of these can be used to fix it.
    if 1:
        tg.fixTextOverlaps()
    else:
        t.node(11).label.yShift = -0.25
        t.node(12).label.yShift = 0.25
tg.setScaleBar(xOffset=-1.5, yOffset=3.0)
# tg.pdflatexOutputGoesToDevNull = False
tg.pdf()
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.pdf()
tg.svgPxForCm = 60.
tg.svg()
st = tg.styleDict['node upper left']

from p4 import *
read("((A, (B, C)), ((D, E), F), ((G, H), I));")
t = var.trees[0]
t.draw()
from gram import TreeGramRadial
# TreeGramRadial(theTree, scale=None, maxLinesDim=5, rotate=0, slopedBrLabels=True, showNodeNums=False, tweakOverlaps=False, equalDaylight=True)
tg = TreeGramRadial(t, scale=None, maxLinesDim=2.5, rotate=40, slopedBrLabels=True, showNodeNums=False, equalDaylight=True)
tg.baseName = "inktweak"
tg.render()
st = tg.styleDict['tgr leaf']
st.textShape = 'itshape'


#tg.grid(0,0,4,4)
gA = tg.text('ABC', -1, 2)
gD = tg.text('DEF', 4, 4)
gG = tg.text('GHI', 4, 0)

tg.svg()

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.pdf()
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.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.pdf()
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.pdf()
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

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()

# This uses two levels of embedding, and, this week, svg cannot handle that.
# 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 = 'cm'
    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()

# This uses two levels of embedding, and, this week, svg cannot handle that.
# mPl.svg()