Ticket #12974: trac_12974-fix_graphics_attributes-rebase.patch

File trac_12974-fix_graphics_attributes-rebase.patch, 24.7 KB (added by kcrisman, 9 years ago)
  • sage/functions/piecewise.py

    # HG changeset patch
    # User Punarbasu Purkayastha <ppurka@gmail.com>
    # Date 1337245532 -28800
    # Node ID 529a15e6df54738eff17c07841002796c1c88a7c
    # Parent  a2546990db40e385f8e5df0e233656d892aee347
    change all .__ attributes to ._
    This ensures that the Graphics class can be inherited.
    
    diff --git a/sage/functions/piecewise.py b/sage/functions/piecewise.py
    a b  
    10231023            sage: p = f.plot(legend_label='$f(x)$')
    10241024            sage: lines = [
    10251025            ...     line
    1026             ...     for line in p._Graphics__objects
     1026            ...     for line in p._objects
    10271027            ...     if line.options()['legend_label'] is not None ]
    10281028            sage: len(lines)
    10291029            1
  • sage/geometry/polyhedron/base.py

    diff --git a/sage/geometry/polyhedron/base.py b/sage/geometry/polyhedron/base.py
    a b  
    25702570
    25712571            sage: p = Polyhedron([[1,2,],[1,1],[0,0]])
    25722572            sage: p_wireframe = p.render_wireframe()
    2573             sage: p_wireframe._Graphics__objects
     2573            sage: p_wireframe._objects
    25742574            [Line defined by 2 points, Line defined by 2 points, Line defined by 2 points]
    25752575        """
    25762576        proj = self.projection()
  • sage/geometry/polyhedron/plot.py

    diff --git a/sage/geometry/polyhedron/plot.py b/sage/geometry/polyhedron/plot.py
    a b  
    4747        sage: q1.show() + q2.show() + q3.show() + q4.show()
    4848        sage: from sage.geometry.polyhedron.plot import render_2d
    4949        sage: q = render_2d(p1.projection())
    50         sage: q._Graphics__objects
     50        sage: q._objects
    5151        [Point set defined by 1 point(s),
    5252         Arrow from (1.0,1.0) to (2.0,2.0),
    5353         Polygon defined by 3 points]
     
    850850            sage: hex = polytopes.regular_polygon(6)
    851851            sage: proj = hex.projection()
    852852            sage: hex_points = proj.render_points_2d()
    853             sage: hex_points._Graphics__objects
     853            sage: hex_points._objects
    854854            [Point set defined by 6 point(s)]
    855855        """
    856856        return point2d(self.coordinates_of(self.points), **kwds)
     
    864864
    865865            sage: penta = polytopes.regular_polygon(5)
    866866            sage: outline = penta.projection().render_outline_2d()
    867             sage: outline._Graphics__objects[0]
     867            sage: outline._objects[0]
    868868            Line defined by 2 points
    869869        """
    870870        wireframe = [];
  • sage/graphs/graph_list.py

    diff --git a/sage/graphs/graph_list.py b/sage/graphs/graph_list.py
    a b  
    319319        for j in range (rows*cols):
    320320            glist.append(plist[ i*rows*cols + j ])
    321321        ga = graphics_array(glist, rows, cols)
    322         ga.__set_figsize__([8,10])
     322        ga._set_figsize_([8,10])
    323323        g_arrays.append(ga)
    324324   
    325325    last = len(plist)%20
     
    332332    for i in range (last):
    333333        glist.append(plist[ i + index])
    334334    ga = graphics_array(glist, last_rows, cols)
    335     ga.__set_figsize__([8, 2*last_rows])
     335    ga._set_figsize_([8, 2*last_rows])
    336336    g_arrays.append(ga)
    337337   
    338338    return g_arrays
  • sage/plot/animate.py

    diff --git a/sage/plot/animate.py b/sage/plot/animate.py
    a b  
    7676    TESTS: This illustrates that ticket #2066 is fixed (setting axes
    7777    ranges when an endpoint is 0)::
    7878   
    79         sage: animate([plot(sin, -1,1)], xmin=0, ymin=0)._Animation__kwds['xmin']
     79        sage: animate([plot(sin, -1,1)], xmin=0, ymin=0)._kwds['xmin']
    8080        0
    8181       
    8282    We check that Trac #7981 is fixed::
     
    105105            w.append(x)
    106106        if len(w) == 0:
    107107            w = [sage.plot.graphics.Graphics()]
    108         self.__frames = w
    109         self.__kwds = kwds
     108        self._frames = w
     109        self._kwds = kwds
    110110
    111111    def _combine_kwds(self, *kwds_tuple):
    112112        """
     
    162162            sage: a[3:7].show() # optional -- ImageMagick
    163163        """
    164164        if isinstance(i, slice):
    165             return Animation(self.__frames[i], **self.__kwds)
     165            return Animation(self._frames[i], **self._kwds)
    166166        else:
    167             return self.__frames[i]
     167            return self._frames[i]
    168168
    169169    def _repr_(self):
    170170        """
     
    179179            sage: a._repr_()
    180180            'Animation with 10 frames'
    181181        """
    182         return "Animation with %s frames"%(len(self.__frames))
     182        return "Animation with %s frames"%(len(self._frames))
    183183
    184184    def __add__(self, other):
    185185        """
     
    202202        if not isinstance(other, Animation):
    203203            other = Animation(other)
    204204           
    205         kwds = self._combine_kwds(self.__kwds, other.__kwds)
     205        kwds = self._combine_kwds(self._kwds, other._kwds)
    206206
    207207        #Combine the frames
    208         m = max(len(self.__frames), len(other.__frames))
    209         frames = [a+b for a,b in zip(self.__frames, other.__frames)]
    210         frames += self.__frames[m:] + other.__frames[m:]
     208        m = max(len(self._frames), len(other._frames))
     209        frames = [a+b for a,b in zip(self._frames, other._frames)]
     210        frames += self._frames[m:] + other._frames[m:]
    211211               
    212212        return Animation(frames, **kwds)
    213213
     
    232232        if not isinstance(other, Animation):
    233233            other = Animation(other)
    234234
    235         kwds = self._combine_kwds(self.__kwds, other.__kwds)
     235        kwds = self._combine_kwds(self._kwds, other._kwds)
    236236       
    237         return Animation(self.__frames + other.__frames, **kwds)
     237        return Animation(self._frames + other._frames, **kwds)
    238238
    239239    def png(self, dir=None):
    240240        """
     
    249249            ['00000000.png', '00000001.png', '00000002.png', '00000003.png']
    250250        """
    251251        try:
    252             return self.__png_dir
     252            return self._png_dir
    253253        except AttributeError:
    254254            pass
    255255        d = sage.misc.misc.tmp_dir()
    256         G = self.__frames
    257         for i, frame in enumerate(self.__frames):
     256        G = self._frames
     257        for i, frame in enumerate(self._frames):
    258258            filename = '%s/%s'%(d,sage.misc.misc.pad_zeros(i,8))
    259             frame.save(filename + '.png', **self.__kwds)
    260         self.__png_dir = d
     259            frame.save(filename + '.png', **self._kwds)
     260        self._png_dir = d
    261261        return d
    262262
    263263    def graphics_array(self, ncols=3):
     
    288288            Graphics Array of size 2 x 2
    289289            sage: g.show('sage.png')         # optional
    290290        """
    291         n = len(self.__frames)
     291        n = len(self._frames)
    292292        ncols = int(ncols)
    293         return plot.graphics_array(self.__frames, int(n/ncols),  ncols)
     293        return plot.graphics_array(self._frames, int(n/ncols),  ncols)
    294294
    295295    def gif(self, delay=20, savefile=None, iterations=0, show_path=False,
    296296            use_ffmpeg=False):
  • sage/plot/colors.py

    diff --git a/sage/plot/colors.py b/sage/plot/colors.py
    a b  
    409409            RGB color (0.8235294117647058, 0.4117647058823529, 0.11764705882352941)
    410410        """
    411411        if g is None and b is None:
    412             self.__rgb = rgbcolor(r)
     412            self._rgb = rgbcolor(r)
    413413        else:
    414             self.__rgb = rgbcolor((r, g, b), space=space)
     414            self._rgb = rgbcolor((r, g, b), space=space)
    415415
    416416    def __repr__(self):
    417417        """
     
    428428            sage: Color(1, 0.5, 1/16, space='hsl').__repr__()
    429429            'RGB color (0.09375, 0.03125, 0.03125)'
    430430        """
    431         return "RGB color %s" % (self.__rgb, )
     431        return "RGB color %s" % (self._rgb, )
    432432
    433433    def blend(self, color, fraction=0.5):
    434434        """
     
    472472        """
    473473        fraction = float(fraction)
    474474        if isinstance(color, Color):
    475             color = color.__rgb
     475            color = color._rgb
    476476        if isinstance(color, (list, tuple)) and len(color) == 3:
    477477            color = map(float, color)
    478478            return Color(rgbcolor([(1 - fraction) * a + fraction * b
    479                                    for a, b in zip(self.__rgb, color)]))
     479                                   for a, b in zip(self._rgb, color)]))
    480480        raise TypeError("%s must be a Color or float-convertible 3-tuple/list" % (color, ))
    481481
    482482    def __add__(self, right):
     
    572572            RGB color (0.764705882352942, 0.1529411764705877, 0.1529411764705877)
    573573        """
    574574        right = float(right)
    575         return Color([x * right for x in self.__rgb])
     575        return Color([x * right for x in self._rgb])
    576576
    577577    def __rmul__(self, left):
    578578        """
     
    707707            sage: vector(maroon) == vector(Color(maroon)) == vector(Color('maroon'))
    708708            True
    709709        """
    710         return iter(self.__rgb)
     710        return iter(self._rgb)
    711711
    712712    def __getitem__(self, i):
    713713        """
     
    736736            ...
    737737            IndexError: tuple index out of range
    738738        """
    739         return self.__rgb[i]
     739        return self._rgb[i]
    740740
    741741    def rgb(self):
    742742        """
     
    761761            sage: Color(1, 0.7, 0.9, space='hsv').rgb()
    762762            (0.9, 0.2700000000000001, 0.2700000000000001)
    763763        """
    764         return self.__rgb
     764        return self._rgb
    765765
    766766    def hls(self):
    767767        """
     
    784784            sage: orchid.hls()
    785785            (0.8396226415094339, 0.6470588235294117, 0.5888888888888889)
    786786        """
    787         return tuple(map(float, rgb_to_hls(*self.__rgb)))
     787        return tuple(map(float, rgb_to_hls(*self._rgb)))
    788788
    789789    def hsl(self):
    790790        """
     
    805805            sage: Color('#aabbcc').hsl()
    806806            (0.5833333333333334, 0.25000000000000017, 0.7333333333333334)
    807807        """
    808         h, l, s = tuple(map(float, rgb_to_hls(*self.__rgb)))
     808        h, l, s = tuple(map(float, rgb_to_hls(*self._rgb)))
    809809        return (h, s, l)
    810810
    811811    def hsv(self):
     
    827827            sage: Color('gray').hsv()
    828828            (0.0, 0.0, 0.5019607843137255)
    829829        """
    830         return tuple(map(float, rgb_to_hsv(*self.__rgb)))
     830        return tuple(map(float, rgb_to_hsv(*self._rgb)))
    831831
    832832    def html_color(self):
    833833        """
     
    849849            sage: honeydew.html_color()
    850850            '#f0fff0'
    851851        """
    852         return float_to_html(*self.__rgb)
     852        return float_to_html(*self._rgb)
    853853
    854854    def lighter(self, fraction=1.0/3.0):
    855855        """
  • sage/plot/graphics.py

    diff --git a/sage/plot/graphics.py b/sage/plot/graphics.py
    a b  
    147147       
    148148            sage: G = Graphics()
    149149        """
    150         self.__fontsize = 10
    151         self.__show_axes = True
    152         self.__show_legend = False
    153         self.__legend_opts = {}
    154         self.__axes_color = (0, 0, 0)
    155         self.__axes_label_color = (0, 0, 0)
    156         self.__tick_label_color = (0, 0, 0)
    157         self.__axes_width = 0.8
    158         self.__objects = []
     150        self._axes_color = (0, 0, 0)
     151        self._axes_label_color = (0, 0, 0)
     152        self._axes_width = 0.8
     153        self._bbox_extra_artists = []
    159154        self._extra_kwds = {}
    160         self.__bbox_extra_artists = []
     155        self._fontsize = 10
     156        self._legend_opts = {}
     157        self._objects = []
     158        self._show_axes = True
     159        self._show_legend = False
     160        self._tick_label_color = (0, 0, 0)
    161161
    162162    def set_aspect_ratio(self, ratio):
    163163        """
     
    269269            sage: P # show with the legend
    270270        """
    271271        if show is None:
    272             return self.__show_legend
     272            return self._show_legend
    273273        else:
    274             self.__show_legend = bool(show)
     274            self._show_legend = bool(show)
    275275
    276276    def set_legend_options(self, **kwds):
    277277        r"""
     
    385385            sage: p.set_legend_options(loc=(0.5,0.5)); p # aligns the bottom of the box to the center
    386386        """
    387387        if len(kwds) == 0:
    388             return self.__legend_opts
     388            return self._legend_opts
    389389        else:
    390             self.__legend_opts.update(kwds)
     390            self._legend_opts.update(kwds)
    391391   
    392392
    393393    def get_axes_range(self):
     
    456456            {'xmin': -1.0}
    457457        """
    458458        try:
    459             return self.__axes_range
     459            return self._axes_range
    460460        except AttributeError:
    461             self.__axes_range = {}
    462             return self.__axes_range
     461            self._axes_range = {}
     462            return self._axes_range
    463463
    464464    def fontsize(self, s=None):
    465465        """
     
    488488        """
    489489        if s is None:
    490490            try:
    491                 return self.__fontsize
     491                return self._fontsize
    492492            except AttributeError:
    493                 self.__fontsize = 10
    494                 return self.__fontsize
    495         self.__fontsize = int(s)
     493                self._fontsize = 10
     494                return self._fontsize
     495        self._fontsize = int(s)
    496496
    497497    def axes(self, show=None):
    498498        """
     
    534534        """
    535535        if show is None:
    536536            try:
    537                 return self.__show_axes
     537                return self._show_axes
    538538            except AttributeError:
    539                 self.__show_axes = True
    540                 return self.__show_axes
    541         self.__show_axes = bool(show)
     539                self._show_axes = True
     540                return self._show_axes
     541        self._show_axes = bool(show)
    542542
    543543    def axes_color(self, c=None):
    544544        """
     
    579579        """
    580580        if c is None:
    581581            try:
    582                 return self.__axes_color
     582                return self._axes_color
    583583           
    584584            except AttributeError:
    585                 self.__axes_color = (0.0, 0.0, 0.0)
    586                 return self.__axes_color
    587         self.__axes_color = rgbcolor(c)
     585                self._axes_color = (0.0, 0.0, 0.0)
     586                return self._axes_color
     587        self._axes_color = rgbcolor(c)
    588588
    589589    def axes_labels(self, l=None):
    590590        """
     
    623623        """
    624624        if l is None:
    625625            try:
    626                 return self.__axes_labels
     626                return self._axes_labels
    627627            except AttributeError:
    628                 self.__axes_labels = None
    629                 return self.__axes_labels
     628                self._axes_labels = None
     629                return self._axes_labels
    630630        if not isinstance(l, (list, tuple)):
    631631            raise TypeError, "l must be a list or tuple"
    632632        if len(l) != 2:
    633633            raise ValueError, "l must have length 2"
    634         self.__axes_labels = (str(l[0]), str(l[1]))
     634        self._axes_labels = (str(l[0]), str(l[1]))
    635635
    636636    def axes_label_color(self, c=None):
    637637        r"""
     
    678678        """
    679679        if c is None:
    680680            try:
    681                 return self.__axes_label_color
     681                return self._axes_label_color
    682682            except AttributeError:
    683                 self.__axes_label_color = (0, 0, 0)
    684                 return self.__axes_label_color
    685         self.__axes_label_color = rgbcolor(c)
     683                self._axes_label_color = (0, 0, 0)
     684                return self._axes_label_color
     685        self._axes_label_color = rgbcolor(c)
    686686
    687687
    688688    def axes_width(self, w=None):
     
    719719        """
    720720        if w is None:
    721721            try:
    722                 return self.__axes_width
     722                return self._axes_width
    723723            except AttributeError:
    724                 self.__axes_width = True
    725                 return self.__axes_width
    726         self.__axes_width = float(w)
     724                self._axes_width = True
     725                return self._axes_width
     726        self._axes_width = float(w)
    727727
    728728    def tick_label_color(self, c=None):
    729729        """
     
    750750        """
    751751        if c is None:
    752752            try:
    753                 return self.__tick_label_color
     753                return self._tick_label_color
    754754            except AttributeError:
    755                 self.__tick_label_color = (0, 0, 0)
    756                 return self.__tick_label_color
    757         self.__tick_label_color = rgbcolor(c)
     755                self._tick_label_color = (0, 0, 0)
     756                return self._tick_label_color
     757        self._tick_label_color = rgbcolor(c)
    758758
    759759    def _repr_(self):
    760760        r"""
     
    863863            sage: G[1]
    864864            Circle defined by (2.0,2.0) with r=5.0
    865865        """
    866         return self.__objects[i]
     866        return self._objects[i]
    867867
    868868    def __len__(self):
    869869        """
     
    877877            sage: len(G)
    878878            3
    879879        """
    880         return len(self.__objects)
     880        return len(self._objects)
    881881
    882882    def __delitem__(self, i):
    883883        """
     
    896896            sage: len(G)
    897897            2
    898898        """
    899         del self.__objects[int(i)]
     899        del self._objects[int(i)]
    900900
    901901    def __setitem__(self, i, x):
    902902        """
     
    921921        from sage.plot.primitive import GraphicPrimitive
    922922        if not isinstance(x, GraphicPrimitive):
    923923            raise TypeError, "x must be a GraphicPrimitive"
    924         self.__objects[int(i)] = x
     924        self._objects[int(i)] = x
    925925
    926926    def __radd__(self, other):
    927927        """
     
    10151015                return self.plot3d() + other
    10161016            raise TypeError, "other (=%s) must be a Graphics objects"%other
    10171017        g = Graphics()
    1018         g.__objects = self.__objects + other.__objects
    1019         g.__show_legend = self.__show_legend or other.__show_legend
     1018        g._objects = self._objects + other._objects
     1019        g._show_legend = self._show_legend or other._show_legend
    10201020        g._extra_kwds.update(self._extra_kwds)
    10211021        g._extra_kwds.update(other._extra_kwds)
    10221022        g._Graphics__legend_opts.update(self._Graphics__legend_opts)
     
    10461046            sage: G.add_primitive(A)
    10471047            sage: G
    10481048        """
    1049         self.__objects.append(primitive)
     1049        self._objects.append(primitive)
    10501050
    10511051    def plot(self, *args, **kwds):
    10521052        """
     
    10721072            sage: sum([plot(z*sin(x), 0, 10).plot3d(z) for z in range(6)]) # long time
    10731073        """
    10741074        from sage.plot.plot3d.base import Graphics3dGroup
    1075         g = Graphics3dGroup([g.plot3d(**kwds) for g in self.__objects])
     1075        g = Graphics3dGroup([g.plot3d(**kwds) for g in self._objects])
    10761076        if z:
    10771077            g = g.translate(0,0,z)
    10781078        return g
     
    15971597            sage: list(sorted(g.get_minmax_data().items()))
    15981598            [('xmax', 3.0), ('xmin', -1.0), ('ymax', 2.0), ('ymin', 1.0)]
    15991599        """
    1600         objects = self.__objects
     1600        objects = self._objects
    16011601        if objects:
    16021602            minmax_data = [o.get_minmax_data() for o in objects]
    16031603            xmin = min(d['xmin'] for d in minmax_data)
     
    16991699        do_verify = verify
    17001700
    17011701        if axes is None:
    1702             axes = self.__show_axes
     1702            axes = self._show_axes
    17031703
    17041704        from matplotlib.figure import Figure
    17051705        from matplotlib import rcParams
     
    17241724        else:
    17251725            subplot.set_aspect(aspect_ratio, adjustable='box')
    17261726        #add all the primitives to the subplot
    1727         for g in self.__objects:
     1727        for g in self._objects:
    17281728            g._render_on_subplot(subplot)
    17291729            if hasattr(g, '_bbox_extra_artists'):
    1730                 self.__bbox_extra_artists.extend(g._bbox_extra_artists)
     1730                self._bbox_extra_artists.extend(g._bbox_extra_artists)
    17311731       
    17321732        #add the legend if requested
    17331733        if show_legend is None:
    1734             show_legend = self.__show_legend
     1734            show_legend = self._show_legend
    17351735       
    17361736        if show_legend:
    17371737            from matplotlib.font_manager import FontProperties
    17381738            lopts = dict()
    17391739            lopts.update(legend_options)
    1740             lopts.update(self.__legend_opts)
     1740            lopts.update(self._legend_opts)
    17411741            prop = FontProperties(family=lopts.pop('font_family'), weight=lopts.pop('font_weight'), \
    17421742                    size=lopts.pop('font_size'), style=lopts.pop('font_style'), variant=lopts.pop('font_variant'))
    17431743            color = lopts.pop('back_color')
     
    17571757
    17581758
    17591759        if axes is None:
    1760             axes = self.__show_axes
     1760            axes = self._show_axes
    17611761
    17621762        for spine in subplot.spines.values():
    1763             spine.set_color(self.__axes_color)
    1764             spine.set_linewidth(self.__axes_width)
     1763            spine.set_color(self._axes_color)
     1764            spine.set_linewidth(self._axes_width)
    17651765       
    17661766
    17671767        if frame:
     
    18281828            subplot.set_frame_on(True)
    18291829            if axes:
    18301830                if ymin<=0 and ymax>=0:
    1831                     subplot.axhline(color=self.__axes_color,
    1832                                     linewidth=self.__axes_width)
     1831                    subplot.axhline(color=self._axes_color,
     1832                                    linewidth=self._axes_width)
    18331833                if xmin<=0 and xmax>=0:
    1834                     subplot.axvline(color=self.__axes_color,
    1835                                     linewidth=self.__axes_width)
     1834                    subplot.axvline(color=self._axes_color,
     1835                                    linewidth=self._axes_width)
    18361836           
    18371837        elif axes:
    18381838            ymiddle=False
     
    19881988                subplot.yaxis.get_majorticklabels() + \
    19891989                subplot.yaxis.get_minorticklabels()
    19901990            for ticklabel in ticklabels:
    1991                 ticklabel.set_fontsize(self.__fontsize)
    1992                 ticklabel.set_color(self.__tick_label_color)
     1991                ticklabel.set_fontsize(self._fontsize)
     1992                ticklabel.set_color(self._tick_label_color)
    19931993
    19941994            ticklines=subplot.xaxis.get_majorticklines() + \
    19951995                subplot.xaxis.get_minorticklines() + \
    19961996                subplot.yaxis.get_majorticklines() + \
    19971997                subplot.yaxis.get_minorticklines()
    19981998            for tickline in ticklines:
    1999                 tickline.set_color(self.__axes_color)
     1999                tickline.set_color(self._axes_color)
    20002000               
    20012001           
    20022002        if gridlines is not None:
     
    20572057
    20582058
    20592059
    2060         if self.__axes_labels is not None:
     2060        if self._axes_labels is not None:
    20612061            label_options={}
    2062             label_options['color']=self.__axes_label_color
    2063             label_options['size']=self.__fontsize
    2064             subplot.set_xlabel(self.__axes_labels[0], **label_options)
    2065             subplot.set_ylabel(self.__axes_labels[1], **label_options)
     2062            label_options['color']=self._axes_label_color
     2063            label_options['size']=self._fontsize
     2064            subplot.set_xlabel(self._axes_labels[0], **label_options)
     2065            subplot.set_ylabel(self._axes_labels[1], **label_options)
    20662066               
    20672067
    20682068            if axes is True and frame is False:
     
    22372237
    22382238            if fig_tight is True:
    22392239                figure.savefig(filename, dpi=dpi, bbox_inches='tight',
    2240                     bbox_extra_artists=self.__bbox_extra_artists,
     2240                    bbox_extra_artists=self._bbox_extra_artists,
    22412241                    transparent=transparent)
    22422242            else:
    22432243                figure.savefig(filename, dpi=dpi,
     
    24422442        i = int(i)
    24432443        self._glist[i] = g
    24442444       
    2445     def __set_figsize__(self, ls):
     2445    def _set_figsize_(self, ls):
    24462446        """
    24472447        Set the figsize of all plots in the array.
    24482448
     
    25652565            sage: G = graphics_array(L)
    25662566            sage: G.save(F,500,axes=False)  # long time (6s on sage.math, 2012)
    25672567        """
    2568         if (figsize is not None): self.__set_figsize__(figsize)
     2568        if (figsize is not None): self._set_figsize_(figsize)
    25692569        self._render(filename, dpi=dpi, figsize=self._figsize, axes = axes, **args)
    25702570
    25712571    def show(self, filename=None, dpi=DEFAULT_DPI, figsize=None,
     
    25962596            sage: G = graphics_array([[plot(sin), plot(cos)], [plot(tan), plot(sec)]])
    25972597            sage: G.show(axes=False)
    25982598        """
    2599         if (figsize is not None): self.__set_figsize__(figsize)
     2599        if (figsize is not None): self._set_figsize_(figsize)
    26002600        if sage.plot.plot.DOCTEST_MODE:
    26012601            self.save(DOCTEST_MODE_FILE,
    26022602                      dpi=dpi, figsize=self._figsize, axes = axes, **args)
  • sage/plot/primitive.py

    diff --git a/sage/plot/primitive.py b/sage/plot/primitive.py
    a b  
    4848            sage: GraphicPrimitive({})
    4949            Graphics primitive
    5050        """
    51         self.__options = options
     51        self._options = options
    5252       
    5353    def _allowed_options(self):
    5454        """
     
    133133            sage: q.options()['zorder']
    134134            3
    135135        """
    136         self.__options['zorder'] = zorder
     136        self._options['zorder'] = zorder
    137137       
    138138    def options(self):
    139139        """
     
    150150        """
    151151        from sage.plot.graphics import do_verify
    152152        from sage.plot.colors import hue
    153         O = dict(self.__options)
     153        O = dict(self._options)
    154154        if do_verify:
    155155            A = self._allowed_options()
    156156            t = False