Exemple #1
0
 def paint(self, canvas, data, axis, axispos):
     if self.breaklinesattrs is not None:
         breaklinesdist_pt = unit.topt(self.breaklinesdist)
         breaklineslength_pt = unit.topt(self.breaklineslength)
         breaklinesextent_pt = (0.5*breaklinesdist_pt*math.fabs(self.cos) +
                                0.5*breaklineslength_pt*math.fabs(self.sin))
         if canvas.extent_pt < breaklinesextent_pt:
             canvas.extent_pt = breaklinesextent_pt
         for v in [data.subaxes[name].vminover for name in data.names[1:]]:
             # use a tangent of the basepath (this is independent of the tickdirection)
             p = axispos.vbasepath(v, None).normpath()
             breakline = p.tangent(0, length=self.breaklineslength)
             widthline = p.tangent(0, length=self.breaklinesdist).transformed(trafomodule.rotate(self.breaklinesangle+90, *breakline.atbegin()))
             # XXX Uiiii
             tocenter = map(lambda x: 0.5*(x[0]-x[1]), zip(breakline.atbegin(), breakline.atend()))
             towidth = map(lambda x: 0.5*(x[0]-x[1]), zip(widthline.atbegin(), widthline.atend()))
             breakline = breakline.transformed(trafomodule.translate(*tocenter).rotated(self.breaklinesangle, *breakline.atbegin()))
             breakline1 = breakline.transformed(trafomodule.translate(*towidth))
             breakline2 = breakline.transformed(trafomodule.translate(-towidth[0], -towidth[1]))
             canvas.layer("baseline").fill(path.path(path.moveto_pt(*breakline1.atbegin_pt()),
                                           path.lineto_pt(*breakline1.atend_pt()),
                                           path.lineto_pt(*breakline2.atend_pt()),
                                           path.lineto_pt(*breakline2.atbegin_pt()),
                                           path.closepath()), [color.gray.white])
             canvas.layer("baseline").stroke(breakline1, self.defaultbreaklinesattrs + self.breaklinesattrs)
             canvas.layer("baseline").stroke(breakline2, self.defaultbreaklinesattrs + self.breaklinesattrs)
     _title.paint(self, canvas, data, axis, axispos)
Exemple #2
0
 def paint(self, canvas, data, axis, axispos):
     if axis.title is not None and self.titleattrs is not None:
         x, y = axispos.vtickpoint_pt(self.titlepos)
         dx, dy = axispos.vtickdirection(self.titlepos)
         titleattrs = self.defaulttitleattrs + self.titleattrs
         if self.titledirection is not None:
             x2, y2 = axispos.vtickpoint_pt(self.titlepos+0.001) # XXX: axisdirection needed
             dx2, dy2 = x2-x, y2-y
             if dx*dy2-dy*dx2 < 0:
                 dy2 *= -1
                 dx2 *= -1
             titleattrs.append(self.titledirection.trafo(dy2, -dx2))
         title = canvas.layer("title").text_pt(x, y, axis.title, titleattrs)
         canvas.extent_pt += unit.topt(self.titledist)
         title.linealign_pt(canvas.extent_pt, -dx, -dy)
         canvas.extent_pt += title.extent_pt(dx, dy)
Exemple #3
0
 def paint(self, canvas, data, axis, axispos):
     if axis.title is not None and self.titleattrs is not None:
         x, y = axispos.vtickpoint_pt(self.titlepos)
         dx, dy = axispos.vtickdirection(self.titlepos)
         titleattrs = self.defaulttitleattrs + self.titleattrs
         if self.titledirection is not None:
             x2, y2 = axispos.vtickpoint_pt(
                 self.titlepos + 0.001)  # XXX: axisdirection needed
             dx2, dy2 = x2 - x, y2 - y
             if dx * dy2 - dy * dx2 < 0:
                 dy2 *= -1
                 dx2 *= -1
             titleattrs.append(self.titledirection.trafo(dy2, -dx2))
         title = canvas.layer("title").text_pt(x, y, axis.title, titleattrs)
         canvas.extent_pt += unit.topt(self.titledist)
         title.linealign_pt(canvas.extent_pt, -dx, -dy)
         canvas.extent_pt += title.extent_pt(dx, dy)
Exemple #4
0
 def paint(self, canvas, data, axis, axispos):
     if self.breaklinesattrs is not None:
         breaklinesdist_pt = unit.topt(self.breaklinesdist)
         breaklineslength_pt = unit.topt(self.breaklineslength)
         breaklinesextent_pt = (
             0.5 * breaklinesdist_pt * math.fabs(self.cos) +
             0.5 * breaklineslength_pt * math.fabs(self.sin))
         if canvas.extent_pt < breaklinesextent_pt:
             canvas.extent_pt = breaklinesextent_pt
         for v in [data.subaxes[name].vminover for name in data.names[1:]]:
             # use a tangent of the basepath (this is independent of the tickdirection)
             p = axispos.vbasepath(v, None).normpath()
             breakline = p.tangent(0, length=self.breaklineslength)
             widthline = p.tangent(0,
                                   length=self.breaklinesdist).transformed(
                                       trafomodule.rotate(
                                           self.breaklinesangle + 90,
                                           *breakline.atbegin()))
             # XXX Uiiii
             tocenter = [
                 0.5 * (x[0] - x[1])
                 for x in zip(breakline.atbegin(), breakline.atend())
             ]
             towidth = [
                 0.5 * (x[0] - x[1])
                 for x in zip(widthline.atbegin(), widthline.atend())
             ]
             breakline = breakline.transformed(
                 trafomodule.translate(*tocenter).rotated(
                     self.breaklinesangle, *breakline.atbegin()))
             breakline1 = breakline.transformed(
                 trafomodule.translate(*towidth))
             breakline2 = breakline.transformed(
                 trafomodule.translate(-towidth[0], -towidth[1]))
             canvas.layer("baseline").fill(
                 path.path(path.moveto_pt(*breakline1.atbegin_pt()),
                           path.lineto_pt(*breakline1.atend_pt()),
                           path.lineto_pt(*breakline2.atend_pt()),
                           path.lineto_pt(*breakline2.atbegin_pt()),
                           path.closepath()), [color.gray.white])
             canvas.layer("baseline").stroke(
                 breakline1,
                 self.defaultbreaklinesattrs + self.breaklinesattrs)
             canvas.layer("baseline").stroke(
                 breakline2,
                 self.defaultbreaklinesattrs + self.breaklinesattrs)
     _title.paint(self, canvas, data, axis, axispos)
Exemple #5
0
 def paint(self, canvas, data, axis, positioner):
     namepos = []
     for name in data.names:
         subaxis = data.subaxes[name]
         v = subaxis.vmin + self.namepos * (subaxis.vmax - subaxis.vmin)
         x, y = positioner.vtickpoint_pt(v)
         dx, dy = positioner.vtickdirection(v)
         namepos.append((v, x, y, dx, dy))
     nameboxes = []
     if self.nameattrs is not None:
         for (v, x, y, dx, dy), name in zip(namepos, data.names):
             nameattrs = self.defaultnameattrs + self.nameattrs
             if self.namedirection is not None:
                 nameattrs.append(self.namedirection.trafo(dx, dy))
             nameboxes.append(
                 canvas.textengine.text_pt(x, y, str(name), nameattrs))
     labeldist_pt = canvas.extent_pt + unit.topt(self.namedist)
     if len(namepos) > 1:
         equaldirection = 1
         for np in namepos[1:]:
             if np[3] != namepos[0][3] or np[4] != namepos[0][4]:
                 equaldirection = 0
     else:
         equaldirection = 0
     if equaldirection and ((not namepos[0][3] and self.namevequalize) or
                            (not namepos[0][4] and self.namehequalize)):
         box.linealignequal_pt(nameboxes, labeldist_pt, -namepos[0][3],
                               -namepos[0][4])
     else:
         for namebox, np in zip(nameboxes, namepos):
             namebox.linealign_pt(labeldist_pt, -np[3], -np[4])
     if self.basepathattrs is not None:
         p = positioner.vbasepath()
         if p is not None:
             canvas.layer("baseline").stroke(
                 p, self.defaultbasepathattrs + self.basepathattrs)
     if (self.tickattrs is not None
             and (self.innerticklength is not None
                  or self.outerticklength is not None)):
         if self.innerticklength is not None:
             innerticklength_pt = unit.topt(self.innerticklength)
             if canvas.extent_pt < -innerticklength_pt:
                 canvas.extent_pt = -innerticklength_pt
         elif self.outerticklength is not None:
             innerticklength_pt = 0
         if self.outerticklength is not None:
             outerticklength_pt = unit.topt(self.outerticklength)
             if canvas.extent_pt < outerticklength_pt:
                 canvas.extent_pt = outerticklength_pt
         elif innerticklength_pt is not None:
             outerticklength_pt = 0
         for v in [data.subaxes[name].vminover
                   for name in data.names] + [1]:
             x, y = positioner.vtickpoint_pt(v)
             dx, dy = positioner.vtickdirection(v)
             x1 = x + dx * innerticklength_pt
             y1 = y + dy * innerticklength_pt
             x2 = x - dx * outerticklength_pt
             y2 = y - dy * outerticklength_pt
             canvas.layer("ticks").stroke(
                 path.line_pt(x1, y1, x2, y2),
                 self.defaulttickattrs + self.tickattrs)
     for (v, x, y, dx, dy), namebox in zip(namepos, nameboxes):
         newextent_pt = namebox.extent_pt(dx, dy) + labeldist_pt
         if canvas.extent_pt < newextent_pt:
             canvas.extent_pt = newextent_pt
     for namebox in nameboxes:
         canvas.layer("labels").insert(namebox)
     _title.paint(self, canvas, data, axis, positioner)
Exemple #6
0
    def paint(self, canvas, data, axis, axispos):
        for t in data.ticks:
            t.temp_v = axis.convert(data, t)
            t.temp_x_pt, t.temp_y_pt = axispos.vtickpoint_pt(t.temp_v)
            t.temp_dx, t.temp_dy = axispos.vtickdirection(t.temp_v)
        maxticklevel, maxlabellevel = tick.maxlevels(data.ticks)
        labeldist_pt = unit.topt(self.labeldist)

        # create & align t.temp_labelbox
        for t in data.ticks:
            if t.labellevel is not None:
                labelattrs = attr.selectattrs(self.labelattrs, t.labellevel,
                                              maxlabellevel)
                if labelattrs is not None:
                    labelattrs = self.defaultlabelattrs + labelattrs
                    if self.labeldirection is not None:
                        labelattrs.append(
                            self.labeldirection.trafo(t.temp_dx, t.temp_dy))
                    if t.labelattrs is not None:
                        labelattrs.extend(t.labelattrs)
                    t.temp_labelbox = canvas.textengine.text_pt(
                        t.temp_x_pt, t.temp_y_pt, t.label, labelattrs)
        if len(data.ticks) > 1:
            equaldirection = 1
            for t in data.ticks[1:]:
                if t.temp_dx != data.ticks[
                        0].temp_dx or t.temp_dy != data.ticks[0].temp_dy:
                    equaldirection = 0
        else:
            equaldirection = 0
        if equaldirection and (
            (not data.ticks[0].temp_dx and self.labelvequalize) or
            (not data.ticks[0].temp_dy and self.labelhequalize)):
            if self.labelattrs is not None:
                box.linealignequal_pt([
                    t.temp_labelbox
                    for t in data.ticks if t.labellevel is not None
                ], labeldist_pt, -data.ticks[0].temp_dx,
                                      -data.ticks[0].temp_dy)
        else:
            for t in data.ticks:
                if t.labellevel is not None and self.labelattrs is not None:
                    t.temp_labelbox.linealign_pt(labeldist_pt, -t.temp_dx,
                                                 -t.temp_dy)

        for t in data.ticks:
            if t.ticklevel is not None and self.tickattrs is not None:
                tickattrs = attr.selectattrs(
                    self.defaulttickattrs + self.tickattrs, t.ticklevel,
                    maxticklevel)
                if tickattrs is not None:
                    innerticklength = attr.selectattr(self.innerticklength,
                                                      t.ticklevel,
                                                      maxticklevel)
                    outerticklength = attr.selectattr(self.outerticklength,
                                                      t.ticklevel,
                                                      maxticklevel)
                    if innerticklength is not None or outerticklength is not None:
                        if innerticklength is None:
                            innerticklength = 0
                        if outerticklength is None:
                            outerticklength = 0
                        innerticklength_pt = unit.topt(innerticklength)
                        outerticklength_pt = unit.topt(outerticklength)
                        x1 = t.temp_x_pt + t.temp_dx * innerticklength_pt
                        y1 = t.temp_y_pt + t.temp_dy * innerticklength_pt
                        x2 = t.temp_x_pt - t.temp_dx * outerticklength_pt
                        y2 = t.temp_y_pt - t.temp_dy * outerticklength_pt
                        canvas.layer("ticks").stroke(
                            path.line_pt(x1, y1, x2, y2), tickattrs)
                        if outerticklength_pt > canvas.extent_pt:
                            canvas.extent_pt = outerticklength_pt
                        if -innerticklength_pt > canvas.extent_pt:
                            canvas.extent_pt = -innerticklength_pt
            if self.gridattrs is not None:
                gridattrs = attr.selectattrs(
                    self.defaultgridattrs + self.gridattrs, t.ticklevel,
                    maxticklevel)
                if gridattrs is not None:
                    canvas.layer("grid").stroke(axispos.vgridpath(t.temp_v),
                                                gridattrs)
            if t.labellevel is not None and self.labelattrs is not None:
                canvas.layer("labels").insert(t.temp_labelbox)
                canvas.labels.append(t.temp_labelbox)
                extent_pt = t.temp_labelbox.extent_pt(t.temp_dx,
                                                      t.temp_dy) + labeldist_pt
                if extent_pt > canvas.extent_pt:
                    canvas.extent_pt = extent_pt

        if self.labelattrs is None:
            canvas.labels = None

        if self.basepathattrs is not None:
            canvas.layer("baseline").stroke(
                axispos.vbasepath(),
                self.defaultbasepathattrs + self.basepathattrs)

        # for t in data.ticks:
        #     del t.temp_v    # we've inserted those temporary variables ... and do not care any longer about them
        #     del t.temp_x_pt
        #     del t.temp_y_pt
        #     del t.temp_dx
        #     del t.temp_dy
        #     if t.labellevel is not None and self.labelattrs is not None:
        #         del t.temp_labelbox

        _title.paint(self, canvas, data, axis, axispos)
Exemple #7
0
 def paint(self, canvas, data, axis, positioner):
     namepos = []
     for name in data.names:
         subaxis = data.subaxes[name]
         v = subaxis.vmin + self.namepos * (subaxis.vmax - subaxis.vmin)
         x, y = positioner.vtickpoint_pt(v)
         dx, dy = positioner.vtickdirection(v)
         namepos.append((v, x, y, dx, dy))
     nameboxes = []
     if self.nameattrs is not None:
         for (v, x, y, dx, dy), name in zip(namepos, data.names):
             nameattrs = self.defaultnameattrs + self.nameattrs
             if self.namedirection is not None:
                 nameattrs.append(self.namedirection.trafo(dx, dy))
             nameboxes.append(canvas.texrunner.text_pt(x, y, str(name), nameattrs))
     labeldist_pt = canvas.extent_pt + unit.topt(self.namedist)
     if len(namepos) > 1:
         equaldirection = 1
         for np in namepos[1:]:
             if np[3] != namepos[0][3] or np[4] != namepos[0][4]:
                 equaldirection = 0
     else:
         equaldirection = 0
     if equaldirection and ((not namepos[0][3] and self.namevequalize) or
                            (not namepos[0][4] and self.namehequalize)):
         box.linealignequal_pt(nameboxes, labeldist_pt, -namepos[0][3], -namepos[0][4])
     else:
         for namebox, np in zip(nameboxes, namepos):
             namebox.linealign_pt(labeldist_pt, -np[3], -np[4])
     if self.basepathattrs is not None:
         p = positioner.vbasepath()
         if p is not None:
             canvas.layer("baseline").stroke(p, self.defaultbasepathattrs + self.basepathattrs)
     if ( self.tickattrs is not None and
          (self.innerticklength is not None or self.outerticklength is not None) ):
         if self.innerticklength is not None:
             innerticklength_pt = unit.topt(self.innerticklength)
             if canvas.extent_pt < -innerticklength_pt:
                 canvas.extent_pt = -innerticklength_pt
         elif self.outerticklength is not None:
             innerticklength_pt = 0
         if self.outerticklength is not None:
             outerticklength_pt = unit.topt(self.outerticklength)
             if canvas.extent_pt < outerticklength_pt:
                 canvas.extent_pt = outerticklength_pt
         elif innerticklength_pt is not None:
             outerticklength_pt = 0
         for v in [data.subaxes[name].vminover for name in data.names] + [1]:
             x, y = positioner.vtickpoint_pt(v)
             dx, dy = positioner.vtickdirection(v)
             x1 = x + dx * innerticklength_pt
             y1 = y + dy * innerticklength_pt
             x2 = x - dx * outerticklength_pt
             y2 = y - dy * outerticklength_pt
             canvas.layer("ticks").stroke(path.line_pt(x1, y1, x2, y2), self.defaulttickattrs + self.tickattrs)
     for (v, x, y, dx, dy), namebox in zip(namepos, nameboxes):
         newextent_pt = namebox.extent_pt(dx, dy) + labeldist_pt
         if canvas.extent_pt < newextent_pt:
             canvas.extent_pt = newextent_pt
     for namebox in nameboxes:
         canvas.layer("labels").insert(namebox)
     _title.paint(self, canvas, data, axis, positioner)
Exemple #8
0
    def paint(self, canvas, data, axis, axispos):
        for t in data.ticks:
            t.temp_v = axis.convert(data, t)
            t.temp_x_pt, t.temp_y_pt = axispos.vtickpoint_pt(t.temp_v)
            t.temp_dx, t.temp_dy = axispos.vtickdirection(t.temp_v)
        maxticklevel, maxlabellevel = tick.maxlevels(data.ticks)
        labeldist_pt = unit.topt(self.labeldist)

        # create & align t.temp_labelbox
        for t in data.ticks:
            if t.labellevel is not None:
                labelattrs = attr.selectattrs(self.labelattrs, t.labellevel, maxlabellevel)
                if labelattrs is not None:
                    labelattrs = self.defaultlabelattrs + labelattrs
                    if self.labeldirection is not None:
                        labelattrs.append(self.labeldirection.trafo(t.temp_dx, t.temp_dy))
                    if t.labelattrs is not None:
                        labelattrs.extend(t.labelattrs)
                    t.temp_labelbox = canvas.texrunner.text_pt(t.temp_x_pt, t.temp_y_pt, t.label, labelattrs)
        if len(data.ticks) > 1:
            equaldirection = 1
            for t in data.ticks[1:]:
                if t.temp_dx != data.ticks[0].temp_dx or t.temp_dy != data.ticks[0].temp_dy:
                    equaldirection = 0
        else:
            equaldirection = 0
        if equaldirection and ((not data.ticks[0].temp_dx and self.labelvequalize) or
                               (not data.ticks[0].temp_dy and self.labelhequalize)):
            if self.labelattrs is not None:
                box.linealignequal_pt([t.temp_labelbox for t in data.ticks if t.labellevel is not None],
                                      labeldist_pt, -data.ticks[0].temp_dx, -data.ticks[0].temp_dy)
        else:
            for t in data.ticks:
                if t.labellevel is not None and self.labelattrs is not None:
                    t.temp_labelbox.linealign_pt(labeldist_pt, -t.temp_dx, -t.temp_dy)

        for t in data.ticks:
            if t.ticklevel is not None and self.tickattrs is not None:
                tickattrs = attr.selectattrs(self.defaulttickattrs + self.tickattrs, t.ticklevel, maxticklevel)
                if tickattrs is not None:
                    innerticklength = attr.selectattr(self.innerticklength, t.ticklevel, maxticklevel)
                    outerticklength = attr.selectattr(self.outerticklength, t.ticklevel, maxticklevel)
                    if innerticklength is not None or outerticklength is not None:
                        if innerticklength is None:
                            innerticklength = 0
                        if outerticklength is None:
                            outerticklength = 0
                        innerticklength_pt = unit.topt(innerticklength)
                        outerticklength_pt = unit.topt(outerticklength)
                        x1 = t.temp_x_pt + t.temp_dx * innerticklength_pt
                        y1 = t.temp_y_pt + t.temp_dy * innerticklength_pt
                        x2 = t.temp_x_pt - t.temp_dx * outerticklength_pt
                        y2 = t.temp_y_pt - t.temp_dy * outerticklength_pt
                        canvas.layer("ticks").stroke(path.line_pt(x1, y1, x2, y2), tickattrs)
                        if outerticklength_pt > canvas.extent_pt:
                            canvas.extent_pt = outerticklength_pt
                        if -innerticklength_pt > canvas.extent_pt:
                            canvas.extent_pt = -innerticklength_pt
            if self.gridattrs is not None:
                gridattrs = attr.selectattrs(self.defaultgridattrs + self.gridattrs, t.ticklevel, maxticklevel)
                if gridattrs is not None:
                    canvas.layer("grid").stroke(axispos.vgridpath(t.temp_v), gridattrs)
            if t.labellevel is not None and self.labelattrs is not None:
                canvas.layer("labels").insert(t.temp_labelbox)
                canvas.labels.append(t.temp_labelbox)
                extent_pt = t.temp_labelbox.extent_pt(t.temp_dx, t.temp_dy) + labeldist_pt
                if extent_pt > canvas.extent_pt:
                    canvas.extent_pt = extent_pt

        if self.labelattrs is None:
            canvas.labels = None

        if self.basepathattrs is not None:
            canvas.layer("baseline").stroke(axispos.vbasepath(), self.defaultbasepathattrs + self.basepathattrs)

        # for t in data.ticks:
        #     del t.temp_v    # we've inserted those temporary variables ... and do not care any longer about them
        #     del t.temp_x_pt
        #     del t.temp_y_pt
        #     del t.temp_dx
        #     del t.temp_dy
        #     if t.labellevel is not None and self.labelattrs is not None:
        #         del t.temp_labelbox

        _title.paint(self, canvas, data, axis, axispos)