def extract_kicad_text_note(edif_annotate): """ Parse EDIF general text from schematic to KiCad schematic """ text_notes = [] height = 60 # fudged string_display = edif_annotate.get_object("stringDisplay") if string_display != None: text = string_display.get_param(0) edif_pt = string_display.get_object("display.origin.pt") if edif_pt != None: xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt)) textnote = KicadTextNote(xpos, ypos) textnote.set_text(text) figure_group_override = \ string_display.get_object("display.figureGroupOverride") if figure_group_override != None: text_height = figure_group_override.get_object("TextHeight") if text_height != None: height = int(text_height.get_param(0)) if height >= 12: textnote.set_bold() textnote.set_size((float(height) / 11 * 60)) #print " new text note: " + text text_notes.append(textnote) if len(text_notes) == 0: return None else: return text_notes
def extract_offset_drawing(library_component, figure_list, offset_x, offset_y): """ Extract EDIF drawing with offset x, y to KiCad drawing """ for figure in figure_list: figure_type = extract_edif_str_param(figure, 0) if figure_type != None: path_list = search_edif_objects(figure, "path") extract_offset_path(library_component, path_list, offset_x, offset_y) point_list = figure.get_object("polygon.pointList") if point_list != None: extract_offset_point_list(library_component, [point_list], offset_x, offset_y) arc_point_list = figure.get_object("openShape.curve.arc") if arc_point_list != None: extract_offset_arc_point_list(library_component, [arc_point_list], offset_x, offset_y) rectangle = figure.get_object("rectangle") if rectangle != None: xstart, ystart = \ convert_kicad_coor(extract_edif_pt(rectangle.get_param(0))) xend, yend = \ convert_kicad_coor(extract_edif_pt(rectangle.get_param(1))) rectangle = KicadRectangle(xstart, ystart, xend, yend) rectangle.set_offset(offset_x, offset_y) library_component.add_draw(rectangle) circle = figure.get_object("circle") if circle != None: xstart, ystart = \ convert_kicad_coor(extract_edif_pt(circle.get_param(0))) xend, yend = \ convert_kicad_coor(extract_edif_pt(circle.get_param(1))) circle = KicadCircle(xstart, ystart, xend, yend) circle.set_offset(offset_x, offset_y) library_component.add_draw(circle) return
def extract_offset_arc_point_list(library_component, point_list, offset_x, offset_y): """ Extract EDIF arc points with offset x, y to KiCad arc """ for ptl in point_list: arc = KicadArc() arc.set_offset(offset_x, offset_y) points = search_edif_objects(ptl, "pt") for pointxy in points: xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy)) arc.add_point(xpos, ypos) library_component.add_draw(arc) return
def extract_offset_point_list(library_component, point_list, offset_x, offset_y): """ Extract EDIF point list (segments) with offset x, y """ for ptl in point_list: poly = KicadPoly() poly.set_offset(offset_x, offset_y) points = search_edif_objects(ptl, "pt") for pointxy in points: xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy)) poly.add_segment(xpos, ypos) library_component.add_draw(poly) return
def extract_offset_connections(library_component, port_impl_list, port_list, offset_x, offset_y): """ Extract EDIF pin connections from EDIF with offset x, y """ for port_impl in port_impl_list: i_name = port_impl.get_object("name") if i_name != None: port_impl_p_name = i_name.get_param(0) if port_impl_p_name != None: #print "port_impl_p_name =", port_impl_p_name pin_name, pin_type, pin_number = \ extract_pin_parameters(port_impl_p_name, port_list) #print pin_name, pin_type, pin_number if pin_number != None: connection = KicadConnection(pin_number, pin_name) connection.set_offset(offset_x, offset_y) dot_pt = \ port_impl.get_object("connectLocation.figure.dot.pt") if dot_pt != None: dot_x, dot_y = \ convert_kicad_coor(extract_edif_pt(dot_pt)) ptl_pin = port_impl.get_object("figure.path.pointList") if ptl_pin != None: xstart, ystart = \ convert_kicad_coor( extract_edif_pt(ptl_pin.get_param(0))) xend, yend = \ convert_kicad_coor( extract_edif_pt(ptl_pin.get_param(1))) # xstart = dot_x # ystart = dot_y connection.set_pin(xstart, ystart, xend, yend) library_component.add_connection(connection) return
def extract_kicad_junctions(edif_net): """ Extracts a junction from EDIF and creates a KiCad junction """ junctions = [] instances = search_edif_objects(edif_net, "instance") for instance in instances: if instance != None: #ident = instance.get_param(0) edif_pt = instance.get_object("transform.origin.pt") if edif_pt != None: xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt)) junction = KicadJunction(xpos, ypos) junctions.append(junction) if len(junctions) == 0: return None else: return junctions
def get_edif_string_anchor(prop): """ Helper function: get x, y anchor for string """ xpos, ypos = [0, 0] string = prop.get_object("string") if string != None: string_display = string.get_object("stringDisplay") else: string_display = prop.get_object("stringDisplay") if string_display != None: value = string_display.get_param(0) pointxy = string_display.get_object("display.origin.pt") if pointxy != None: xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy)) else: print "WARN: string with no point in EDIF as " \ + str(extract_edif_str_param(string, 0)[0]) return [xpos, ypos]
def find_edif_points_maxmin(point_list, maxmin_xy): """ Finds the max and min x, y in an EDIF point list """ max_x = maxmin_xy[0][0] max_y = maxmin_xy[0][1] min_x = maxmin_xy[1][0] min_y = maxmin_xy[1][1] #print "maxmin: max_xy " + str([max_x, max_y]) \ # + ", min_xy " + str([min_x, min_y]) for point in point_list: points = search_edif_objects(point, "pt") for pointxy in points: xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy)) if xpos > max_x: max_x = xpos if ypos > max_y: max_y = ypos if xpos < min_x: min_x = xpos if ypos < min_y: min_y = ypos return [max_x, max_y], [min_x, min_y]
def extract_kicad_net_aliases(edif_net): """ Extracts a net alias text from EDIF and creates a KiCad net alias """ net_aliases = [] net_name = extract_edif_str_param(edif_net, 0) if net_name != None: if type(net_name[0]) != unicode: display_list = search_edif_objects(net_name[0], "display") for display in display_list: edif_pt = display.get_object("origin.pt") if edif_pt != None: xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt)) #print net_name[1], xpos, y net_alias = \ KicadNetAlias(xpos, ypos, normalize_edif_string(net_name[1])) net_aliases.append(net_alias) if len(net_aliases) == 0: return None else: return net_aliases
def extract_kicad_wires(edif_net): """ Extracts a wire from EDIF and creates a KiCad wire """ wires = [] xnext, ynext = [0, 0] figures = search_edif_objects(edif_net, "figure") for figure in figures: if figure != None: if figure.get_param(0) == "WIRE": pts = figure.get_object("path.pointList") for i in range(0, pts.get_nb_param()): edif_pt = pts.get_param(i) xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt)) if i > 0: wire = KicadWire(xnext, ynext, xpos, ypos) wires.append(wire) xnext, ynext = [xpos, ypos] if len(wires) == 0: return None else: return wires
def extract_kicad_wire_notes_lines(edif_figure): """ Parse EDIF figure DASHED_LINE polygon from schematic to KiCad schematic """ wire_notes_lines = [] xpos, ypos = [0, 0] startx, starty = [0, 0] fromx, fromy = [0, 0] figure_group_override = edif_figure.get_object("figureGroupOverride") if figure_group_override != None: figure_style = figure_group_override.get_param(0) #print "figure style = " + str(figure_style) if figure_style == "DASHED_LINE": point_list = edif_figure.get_object("polygon.pointList") edif_pts = search_edif_objects(point_list, "pt") points = 1 for edif_pt in edif_pts: xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt)) if points == 1: fromx, fromy = [xpos, ypos] startx, starty = [xpos, ypos] else: line = KicadWireNotesLine(fromx, fromy, xpos, ypos) wire_notes_lines.append(line) fromx, fromy = [xpos, ypos] points += 1 if points >= 2: line = KicadWireNotesLine(fromx, fromy, startx, starty) wire_notes_lines.append(line) if len(wire_notes_lines) == 0: return None else: return wire_notes_lines
def _extract_component_view(view, library_component): """ Extracts an EDIF component or drawing entity to KiCad """ view_name = extract_edif_str_param(view, 0) ref = "?" xpos = int(0) ypos = int(0) value_x = int(0) value_y = int(0) visible = "V" orientation = "H" hvjustify = text_justify("CENTERCENTER", "R0", "R0") interface = view.get_object("interface") if interface != None: symbol = interface.get_object("symbol") if symbol != None: prop_list = search_edif_objects(symbol, "property") if prop_list != None: for prop in prop_list: prop_type = extract_edif_str_param(prop, 0)[0] if prop_type == "VALUE": value_x, value_y = get_edif_string_anchor(prop) elif prop_type == "PIN_NAMES_VISIBLE": string = prop.get_object("string") if string != None: pin_names_visible = \ remove_quote(extract_edif_str_param(string, 0)[1]) if pin_names_visible == "False": library_component.set_pin_names_visible(False) elif prop_type == "PIN_NUMBERS_VISIBLE": string = prop.get_object("string") if string != None: pin_numbers_visible = \ remove_quote(extract_edif_str_param(string, 0)[1]) if pin_numbers_visible == "False": library_component.set_pin_numbers_visible( False) figure_list = search_edif_objects(symbol, "figure") extract_drawing(library_component, figure_list) port_impl_list = search_edif_objects(symbol, "portImplementation") port_list = search_edif_objects(interface, "port") extract_connections(library_component, port_impl_list, port_list) designator = interface.get_object("designator") if designator != None: #print "designator = "+extract_str_param(designator, 0)[1] ref = extract_edif_str_param(designator, 0)[1] ref = remove_quote(ref) if ref.endswith('?'): ref = ref[:-1] #pointxy = get_edif_string_anchor(designator) #print "pointxy = " + str(pointxy) string_display = designator.get_object("stringDisplay") if string_display != None: print "Info: found extra information in reference designator:" pointxy = string_display.get_object("display.origin.pt") if pointxy != None: print " " + str(extract_edif_pt(pointxy)) # xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy)) # display_justify = string_display.get_object("display.justify") # if display_justify != None: # hvjustify = text_justify(display_justify.get_param(0), # "R0") # print "JUSTIFY with " + str(hvjustify) else: pointxy = \ interface.get_object("symbol.keywordDisplay.\ display.origin.pt" ) if pointxy != None: xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy)) display_justify = \ interface.get_object("symbol.keywordDisplay.\ display.justify" ) if display_justify != None: hvjustify = text_justify(display_justify.get_param(0), "R0", "R0") #print "JUSTIFY with " + str(hvjustify) contents = view.get_object("contents") if contents != None: figure_list = search_edif_objects(contents, "figure") figure = figure_list[0] figure_group_override = figure.get_object("figureGroupOverride") if figure_group_override != None: figure_name = figure_group_override.get_param(0) else: figure_name = figure.get_param(0) if figure_name == "POWEROBJECT": power_symbol = extract_powerobject_symbol(library_component, view_name[0], figure_list) if power_symbol['is_valid'] == True: if power_symbol['is_ground'] == True: #print "**** GND" xpos = 0 ypos = power_symbol['min_y'] value_x = 0 value_y = power_symbol['min_y'] - 100 else: #print "**** POWER" xpos = 0 ypos = power_symbol['min_y'] value_x = 0 value_y = power_symbol['max_y'] + 100 visible = "V" orientation = "V" ref = "#PWR" library_component.set_pin_names_visible(False) library_component.set_pin_numbers_visible(False) # pylint: disable=W0105 """ # # GND # DEF GND #PWR 0 0 Y Y 1 F P F0 "#PWR" 0 -250 50 H I C CNN F1 "GND" 0 -150 50 H V C CNN F2 "" 0 0 50 H I C CNN F3 "" 0 0 50 H I C CNN DRAW P 6 0 1 0 0 0 0 -50 50 -50 0 -100 -50 -50 0 -50 N X GND 1 0 0 0 D 50 50 1 1 W N ENDDRAW ENDDEF # # +3V3 # DEF +3V3 #PWR 0 0 Y Y 1 F P F0 "#PWR" 0 -150 50 H I C CNN F1 "+3V3" 0 140 50 H V C CNN F2 "" 0 0 50 H I C CNN F3 "" 0 0 50 H I C CNN ALIAS +3.3V DRAW P 2 0 1 0 -30 50 0 100 N P 2 0 1 0 0 0 0 100 N P 2 0 1 0 0 100 30 50 N X +3V3 1 0 0 0 U 50 50 1 1 W N ENDDRAW ENDDEF """ library_component.set_designator(ref) #print "x = " + str(xpos) + ", ypos = " + str(ypos) + "; vx = " \ # + str(value_x) + ", vy = " + str(value_y) + ";" library_component.add_field({ 'id': 0, 'ref': add_quote(ref), 'posx': xpos, 'posy': ypos, 'visible': 'I', 'text_align': hvjustify[0], 'props': hvjustify[1] + "NN" }) library_component.add_field({ 'id': 1, 'ref': add_quote(view_name[0]), 'visible': visible, 'posx': value_x, 'posy': value_y }) library_component.add_field({'id': 2, 'ref': '""', 'posx': 0, 'posy': 0}) library_component.add_field({'id': 3, 'ref': '""', 'posx': 0, 'posy': 0}) return library_component
def extract_kicad_port(edif_port): """ Extracts a port from EDIF and creates a KiCad port """ # portImplementation, pI port_is_labeled = False hvjustify = text_justify("CENTERCENTER", "R0", "R0") refdes_orientation = "H" port_orientation = "H" porttext_x, porttext_y = [0, 0] # p2 instance = edif_port.get_object("instance") p2_name = normalize_edif_string(extract_edif_str_param(instance, 0)[1]) #print "p2_name = " + str(p2_name) view_ref = instance.get_object("viewRef") name = view_ref.get_param(0) # pylint: disable=W0105 """ edif_pt = instance.get_object("transform.origin.pt") if edif_pt != None: component_x, component_y = extract_pt(edif_pt) """ port_orientation = instance.get_object("transform.orientation") if port_orientation != None: port_orientation = remove_quote(port_orientation.get_param(0)) else: port_orientation = "R0" edif_pt = edif_port.get_object("connectLocation.figure.dot.pt") if edif_pt != None: component_x, component_y = convert_kicad_coor(extract_edif_pt(edif_pt)) else: return #print "x, ypos = " + str([component_x, component_y]) port_instance = edif_port.get_param(0) if type(port_instance) == unicode: p_inst_type = None p_inst_name = port_instance #print "UNICODE: " + str(port_instance) else: instance = edif_port.get_object("instance") if instance != None: view_ref = instance.get_object("viewRef") p_inst_type = port_instance.get_context() if p_inst_type == "name": # text module p_inst_name = normalize_edif_string(port_instance.get_param(0)) #print "pI_name = " + str(p_inst_name) display = port_instance.get_object("display") if display != None: p_inst_type = display.get_param(0) designator_pt = display.get_object("origin.pt") display_orientation = display.get_object("orientation") if display_orientation != None: text_orientation = \ remove_quote(display_orientation.get_param(0)) else: text_orientation = "R0" display_justify = display.get_object("justify") if display_justify != None: hvjustify = text_justify(display_justify.get_param(0), text_orientation, port_orientation) display_orientation = display.get_object("orientation") if display_orientation != None: refdes_orientation = \ remove_quote(display_orientation.get_param(0)) else: refdes_orientation = "R0" refdes_orientation = \ convert_edif_orientation_to_hv(refdes_orientation, port_orientation) if designator_pt != None: porttext_x, porttext_y = \ convert_kicad_local_coor(extract_edif_pt(designator_pt), [component_x, component_y], port_orientation) port_is_labeled = True #print "port " + str(p_inst_name) + " of " \ # + str(p_inst_type) + " at : " + str(porttext_x) \ # + ", " + str(porttext_y) # TODO: test EDIF MODULETEXT and KicadTextPort class if p_inst_type == "MODULETEXT": text_port = KicadTextPort(p_inst_name, component_x, component_y) name, rot = name.split("_") name = name.replace("PORT", "") if name == "BOTH": port_type = "BiDi" elif name == "LEFT": port_type = "Output" elif name == "RIGHT": port_type = "Input" else: port_type = "UnSpc" if rot == "L": angle = 1 else: angle = 0 def_rot = { "R0": [0, 2], "R90": [3, 1], "R180": [2, 0], "R270": [1, 3], "MY": [2, 0], "MYR90": [1, 3], #"MYR180":[0, 2], #"MYR270":[1, 3], "MX": [0, 2], "MXR90": [3, 1], #"MXR180":[0, 2], #"MXR270":[1, 3] } comb_angle = def_rot[port_orientation][angle] #print name, rot, orientation, comb_angle text_port.set_text(p2_name[1]) text_port.set_type(port_type) text_port.set_rotation(comb_angle) return text_port if p_inst_type == "POWERTEXT" or \ (p_inst_type == None and p_inst_name in {'GND', 'GNDA', 'GNDD', 'GNDS', 'EARTH', 'GND_POWER'}): ref = "\"#PWR?\"" else: ref = "\"" + name + "\"" value = "\"" + p_inst_name + "\"" #x = component_x #y = component_y xpos, ypos = [porttext_x, porttext_y] f0_data = {'ref': ref, 'posx': xpos, 'posy': ypos, 'attributs': '0001'} if port_is_labeled == True: f1_data = { 'ref': value, 'posx': porttext_x, 'posy': porttext_y, 'attributs': '0000', 'orient': refdes_orientation, 'hjust': hvjustify[0], 'props': hvjustify[1] + "NN" } else: f1_data = { 'ref': value, 'posx': xpos, 'posy': ypos, 'attributs': '0001' } f2_data = { 'ref': '""', 'posx': component_x, 'posy': component_y, 'attributs': '0001' } f3_data = { 'ref': '""', 'posx': component_x, 'posy': component_y, 'attributs': '0001' } kicad_component = KicadSchematicComponent(name, ref) kicad_component.set_position(component_x, component_y) kicad_component.set_orientation(port_orientation) kicad_component.add_field(f0_data) kicad_component.add_field(f1_data) kicad_component.add_field(f2_data) kicad_component.add_field(f3_data) return kicad_component
def extract_kicad_component(instance): """ Extracts a component from EDIF and creates a KiCad component """ f_data = [] view_ref = instance.get_object("viewRef") #cell_ref = view_ref.get_object("cellRef") libname = "" + view_ref.get_param(0) #libname = "IMPORT_"+cellRef.get_param(0) hvjustify = text_justify("CENTERCENTER", "R0", "R0") refdes_orientation = "H" comp_orientation = "H" xpos = 0 ypos = 0 # F 0 string_display = instance.get_object("designator.stringDisplay") if string_display == None: return None ref_design = string_display.get_param(0) kicad_component = KicadSchematicComponent(libname, ref_design) # component orientation instance_orientation = instance.get_object("transform.orientation") if instance_orientation != None: comp_orientation = remove_quote(instance_orientation.get_param(0)) else: comp_orientation = "R0" kicad_component.set_orientation(comp_orientation) display_orientation = string_display.get_object("display.orientation") if display_orientation != None: refdes_orientation = remove_quote(display_orientation.get_param(0)) else: refdes_orientation = "R0" refdes_orientation = convert_edif_orientation_to_hv( refdes_orientation, comp_orientation) # component position - the reference point edif_pt = instance.get_object("transform.origin.pt") if edif_pt != None: component_x, component_y = convert_kicad_coor(extract_edif_pt(edif_pt)) kicad_component.set_position(component_x, component_y) component_xy = [component_x, component_y] # Position designator for Kicad coordinates # - designator X is relative to component X for rotation and mirroring # - designator ypos is flipped relative to # component x-axis line of symmetry # - visible properties text is offset from component # relative to designator [xpos, ypos] #prop_xy = component_xy edif_pt = string_display.get_object("display.origin.pt") if edif_pt != None: xpos, ypos = convert_kicad_local_coor(extract_edif_pt(edif_pt), component_xy, comp_orientation) #prop_xy = convert_kicad_local_coor(extract_edif_pt(edif_pt), # component_xy, # comp_orientation) display_orientation = string_display.get_object("display.orientation") if display_orientation != None: text_orientation = remove_quote(display_orientation.get_param(0)) else: text_orientation = "R0" display_justify = string_display.get_object("display.justify") if display_justify != None: hvjustify = text_justify(display_justify.get_param(0), text_orientation, comp_orientation) f_data.append({ 'ref': ref_design, 'posx': xpos, 'posy': ypos, 'orient': refdes_orientation, 'hjust': hvjustify[0], 'props': hvjustify[1] + "NN" }) # F 1 "Value" properties = search_edif_objects(instance, "property") for prop in properties: if extract_edif_str_param(prop, 0)[0] == "VALUE": f_prop = build_kicad_field(prop, component_xy, comp_orientation) if f_prop != None: f_data.append(f_prop) # F 2 "Footprint" for prop in properties: if extract_edif_str_param(prop, 0)[0] == "PCB_FOOTPRINT": f_prop = build_kicad_field(prop, component_xy, comp_orientation) #print str(f_prop) if f_prop != None: f_data.append(f_prop) # F 3 "Data Link" f_data.append({ 'ref': '""', 'posx': component_x, 'posy': component_y, 'attributs': '0001' }) # F 4 and up for prop in properties: if extract_edif_str_param(prop, 0)[0] != "VALUE": # f_prop = build_kicad_field(prop, prop_xy, comp_orientation) f_prop = build_kicad_field(prop, component_xy, comp_orientation) if f_prop != None: f_data.append(f_prop) #print value + " " + f1_data['attributs'] #******* for field in f_data: kicad_component.add_field(field) return kicad_component
def build_kicad_field(prop, ref_xy, symbol_orientation): """ Builds a single KiCad schematic "F n" property field: F field_number 'text' orientation posX posY size Flags hjustify vjustify/italic/bold 'name' These properties typically start at F 4, or the 5th property of a component and onwards Example: F 4 "Infineon" H 2300 4500 50 0000 L TNN "Manufacturer" F 5 "ESD108-B1-CSP0201" H 2300 4400 50 0000 L TNN "Manufacturer Part Number" F 6 "D DIODE BIDIRECTIONAL TVS" H 0 0 50 0001 C CNN "Source Package" ... Returns: A dictionary of "F" elements """ prop_attributs = int('0', 2) orientation = "H" hvjustify = text_justify("CENTERCENTER", "R0", symbol_orientation) xpos = 0 ypos = 0 property_name = extract_edif_str_param(prop, 0) #property_tag = str(property_name[0]) #print "name = " + str(property_name[1]) + "(" + property_tag + ")" name = str(property_name[1]) string = prop.get_object("string") if string != None: #value = extract_edif_str_param(string, 0) value = str(string.get_param(0)) #print "value = " + value string_display = string.get_object("stringDisplay") if string_display != None: value = string_display.get_param(0) #print "SCH: prop value = " + str(value) display_orientation = \ string_display.get_object("display.orientation") if display_orientation != None: prop_orientation = \ remove_quote(display_orientation.get_param(0)) else: prop_orientation = "R0" orientation = convert_edif_orientation_to_hv( prop_orientation, symbol_orientation) edif_pt = string_display.get_object("display.origin.pt") if edif_pt != None: xpos, ypos = convert_kicad_local_coor(extract_edif_pt(edif_pt), ref_xy, symbol_orientation) #print " field xy = " + str([xpos, ypos]) \ # + "orientation = " \ # + symbol_orientation if value == '"N/A"': prop_attributs = bin(prop_attributs | TEXT_NO_VISIBLE) else: prop_attributs = int('0', 2) display_orientation = \ string_display.get_object("display.orientation") if display_orientation != None: text_orientation = \ remove_quote(display_orientation.get_param(0)) else: text_orientation = "R0" display_justify = string_display.get_object("display.justify") if display_justify != None: hvjustify = text_justify(display_justify.get_param(0), text_orientation, symbol_orientation) figure_group_override = \ string_display.get_object("display.figureGroupOverride") if figure_group_override != None: visible_false = \ figure_group_override.get_object("visible.false") if visible_false != None: prop_attributs = bin(prop_attributs | TEXT_NO_VISIBLE) #prop_attributs = int('1', 2) else: prop_attributs = bin(prop_attributs & ~TEXT_NO_VISIBLE) #prop_attributs = int('0', 2) else: prop_attributs = bin(prop_attributs | TEXT_NO_VISIBLE) #print "ref des coordinates assigned to prop value " \ # + str(value) + " of " + str(property_name[0]) #value = "" f_data = { 'ref': value, 'posx': xpos, 'posy': ypos, 'attributs': eda_attribut_string(prop_attributs), 'orient': orientation, 'hjust': hvjustify[0], 'props': hvjustify[1] + "NN", 'name': name } return f_data return None