Changeset 11202:dba4e6f2678e in orange


Ignore:
Timestamp:
11/26/12 13:32:28 (17 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Added annotation font and color serialization.

Location:
Orange/OrangeCanvas
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/canvas/scene.py

    r11200 r11202  
    442442            item.resize(w, h) 
    443443            item.setTextInteractionFlags(Qt.TextEditorInteraction) 
    444             font = QFont() 
    445             font.fromString(scheme_annot.font) 
     444 
     445            font = font_from_dict(scheme_annot.font, item.font()) 
    446446            item.setFont(font) 
    447447            scheme_annot.text_changed.connect(item.setPlainText) 
     
    727727 
    728728 
     729def font_from_dict(font_dict, font=None): 
     730    if font is None: 
     731        font = QFont() 
     732    else: 
     733        font = QFont(font) 
     734 
     735    if "family" in font_dict: 
     736        font.setFamily(font_dict["family"]) 
     737 
     738    if "size" in font_dict: 
     739        font.setPointSize(font_dict["size"]) 
     740 
     741    return font 
     742 
     743 
    729744def grab_svg(scene): 
    730745    """Return a SVG rendering of the scene contents. 
  • Orange/OrangeCanvas/document/interactions.py

    r11201 r11202  
    749749        """ 
    750750        annot = scheme.SchemeTextAnnotation(rect_to_tuple(rect)) 
    751         annot.set_font(self.font.toString()) 
     751        font = {"family": unicode(self.font.family()), 
     752                "size": self.font.pointSize()} 
     753        annot.set_font(font) 
    752754 
    753755        item = self.scene.add_annotation(annot) 
  • Orange/OrangeCanvas/scheme/annotations.py

    r11200 r11202  
    44""" 
    55 
    6 from PyQt4.QtCore import QObject 
     6from PyQt4.QtCore import QObject, QString 
    77from PyQt4.QtCore import pyqtSignal as Signal 
    88from PyQt4.QtCore import pyqtProperty as Property 
     9 
     10from .utils import check_type 
    911 
    1012 
     
    3032 
    3133    def set_line(self, start_pos, end_pos): 
     34        """Set arrow lines start and end position ((x, y) tuples). 
     35        """ 
    3236        if self.__start_pos != start_pos or self.__end_pos != end_pos: 
    3337            self.__start_pos = start_pos 
     
    3640 
    3741    def start_pos(self): 
     42        """Start position. 
     43        """ 
    3844        return self.__start_pos 
    3945 
     
    4147 
    4248    def end_pos(self): 
     49        """Arrows end position (arrow head points toward the end).""" 
    4350        return self.__end_pos 
    4451 
     
    4653 
    4754    def set_geometry(self, (start_pos, end_pos)): 
     55        """Set the geometry of the arrow as a start and end position tuples 
     56        (e.g. `set_geometry(((0, 0), (100, 0))). 
     57 
     58        """ 
    4859        self.set_line(start_pos, end_pos) 
    4960 
    5061    def geometry(self): 
     62        """Return the start and end positions of the arrow. 
     63 
     64        """ 
    5165        return (self.start_pos, self.end_pos) 
    5266 
     
    5468 
    5569    def set_color(self, color): 
     70        """Set the fill color for the arrow as a string (#RGB, #RRGGBB, 
     71        #RRRGGGBBB, #RRRRGGGGBBBB format or one of SVG color keyword 
     72        names). 
     73 
     74        """ 
     75        check_type(color, (basestring, QString)) 
     76        color = unicode(color) 
    5677        if self.__color != color: 
    5778            self.__color = color 
     
    5980 
    6081    def color(self): 
     82        """Return the arrow's fill color. 
     83        """ 
    6184        return self.__color 
    6285 
     
    6891    """ 
    6992    text_changed = Signal(unicode) 
    70     font_changed = Signal(unicode) 
     93    font_changed = Signal(dict) 
    7194 
    72     def __init__(self, rect, text="", font="", anchor=None, parent=None): 
     95    def __init__(self, rect, text="", font=None, anchor=None, parent=None): 
    7396        BaseSchemeAnnotation.__init__(self, parent) 
    7497        self.__rect = rect 
    7598        self.__text = text 
    76         self.__font = font 
     99        self.__font = {} if font is None else font 
    77100        self.__anchor = anchor 
    78101 
    79102    def set_rect(self, (x, y, w, h)): 
     103        """Set the text geometry bounding rectangle 
     104        ((x, y, width, height) tuple). 
     105 
     106        """ 
    80107        rect = (x, y, w, h) 
    81108        if self.__rect != rect: 
     
    84111 
    85112    def rect(self): 
     113        """Text bounding rectangle 
     114        """ 
    86115        return self.__rect 
    87116 
     
    89118 
    90119    def set_geometry(self, rect): 
     120        """Set the text geometry (same as `set_rect`) 
     121        """ 
    91122        self.set_rect(rect) 
    92123 
     
    97128 
    98129    def set_text(self, text): 
     130        """Set the annotation text. 
     131        """ 
     132        check_type(text, (basestring, QString)) 
     133        text = unicode(text) 
    99134        if self.__text != text: 
    100135            self.__text = text 
     
    102137 
    103138    def text(self): 
     139        """Annotation text. 
     140        """ 
    104141        return self.__text 
    105142 
     
    107144 
    108145    def set_font(self, font): 
     146        """Set the annotation's font as a dictionary of font properties 
     147        (at the moment only family and size are used). 
     148 
     149            annotation.set_font({"family": "Helvetica", "size": 16}) 
     150 
     151        """ 
     152        check_type(font, dict) 
     153        font = dict(font) 
    109154        if self.__font != font: 
    110155            self.__font = font 
     
    112157 
    113158    def font(self): 
    114         return self.__font 
     159        """Return the annotation's font property dictionary. 
     160        """ 
     161        return dict(self.__font) 
    115162 
    116163    font = Property(unicode, fget=font, fset=set_font) 
  • Orange/OrangeCanvas/scheme/readwrite.py

    r11139 r11202  
    99import cPickle 
    1010 
    11 try: 
    12     from ast import literal_eval 
    13 except ImportError: 
    14     literal_eval = eval 
     11from ast import literal_eval 
    1512 
    1613import logging 
     
    2623 
    2724def parse_scheme(scheme, stream): 
    28     """Parse saved scheme string 
     25    """Parse a saved scheme from `stream` and populate a `scheme` 
     26    instance (:class:`Scheme`). 
     27 
    2928    """ 
    3029    from xml.etree.ElementTree import parse 
     
    3332    version = scheme_el.attrib.get("version", None) 
    3433    if version is None: 
     34        # Fallback: check for "widgets" tag. 
    3535        if scheme_el.find("widgets") is not None: 
    3636            version = "1.0" 
     
    115115            rect = annot_el.attrib.get("rect", "(0, 0, 20, 20)") 
    116116            rect = literal_eval(rect) 
    117             annot = SchemeTextAnnotation(rect, annot_el.text or "") 
     117 
     118            font_family = annot_el.attrib.get("font-family", "").strip() 
     119            font_size = annot_el.attrib.get("font-size", "").strip() 
     120 
     121            font = {} 
     122            if font_family: 
     123                font["family"] = font_family 
     124            if font_size: 
     125                font["size"] = literal_eval(font_size) 
     126 
     127            annot = SchemeTextAnnotation(rect, annot_el.text or "", font=font) 
    118128        elif annot_el.tag == "arrow": 
    119129            start = annot_el.attrib.get("start", "(0, 0)") 
    120130            end = annot_el.attrib.get("end", "(0, 0)") 
    121131            start, end = map(literal_eval, (start, end)) 
    122             annot = SchemeArrowAnnotation(start, end) 
     132 
     133            color = annot_el.attrib.get("fill", "red") 
     134            annot = SchemeArrowAnnotation(start, end, color=color) 
    123135        annotations.append(annot) 
    124136 
     
    206218 
    207219def scheme_to_ows_stream(scheme, stream): 
    208     """Write scheme to a a stream in Orange Scheme .ows format 
     220    """Write scheme to a a stream in Orange Scheme .ows (v 2.0) format. 
    209221    """ 
    210222    builder = TreeBuilder(element_factory=Element) 
     
    266278            tag = "text" 
    267279            attrs.update({"rect": repr(annotation.rect)}) 
     280 
     281            # Save the font attributes 
     282            font = annotation.font 
     283            attrs.update({"font-family": font.get("family", None), 
     284                          "font-size": font.get("size", None)}) 
     285            attrs = [(key, value) for key, value in attrs.items() \ 
     286                     if value is not None] 
     287            attrs = dict((key, unicode(value)) for key, value in attrs) 
     288 
    268289            data = annotation.text 
    269290 
     
    272293            attrs.update({"start": repr(annotation.start_pos), 
    273294                          "end": repr(annotation.end_pos)}) 
     295 
     296            # Save the arrow color 
     297            try: 
     298                color = annotation.color 
     299                attrs.update({"fill": color}) 
     300            except AttributeError: 
     301                pass 
     302 
    274303            data = None 
    275304        else: 
Note: See TracChangeset for help on using the changeset viewer.