def initUI(self): for i in range(0, self._size_barette): if i == 0 : self.element_tab.append(Element.Element(master = self.master, canvas = self._canvas, angle = self._angle, x_antecedent = self.antecedent_x, y_antecedent = self.antecedent_y)) else : self.element_tab.append(Element.Element(master = self.master, canvas = self._canvas, angle = self._angle, x_antecedent = self.element_tab[i-1].getXYEndincart()[0], y_antecedent = self.element_tab[i-1].getXYEndincart()[1])) self.isStripInit = True
def init(self): print("initialising basic game") #create enemy1spawner at middle leftmost block elementSpawner1Pos = (0, int(self.board.y / 2)) elementspawner1 = Element.Element(ElementState.element1Spawner, elementSpawner1Pos, Direction.right) # # ##create enemy2spawner at middle rightmost block elementSpawner2Pos = (int(self.board.x - 1), int(self.board.y / 2)) elementspawner2 = Element.Element(ElementState.element2Spawner, elementSpawner2Pos, Direction.left) #print(id(elementspawner1)) self.board[elementSpawner1Pos] += elementspawner1 self.board[elementSpawner2Pos] += elementspawner2
def getElement(self, elename): """Create an element instance from the connectivity information (the Element class holds a list of nodes) |elem| is the name (i.e. the number) of the element (This used to be ElementFactory) """ # test whether the element already exists, shortcut if exists try: return self.elementCache[elename] except: pass conn = self.Conn[elename] nodes = conn[1] try: sh = self.shapeCache[conn[0]] except: sh = ShapeFunctions.shapeFunctions[conn[0]]() self.shapeCache[conn[0]] = sh # collect the nodal coordinates nodcoord = N.array([self.Coord[n] for n in nodes]) # invoke an instance of the element e = Element.Element(nodes, sh, nodcoord, elename) self.elementCache[elename] = e return e
def _parse_opening_tag_match(self, opening_tag_match, text): tag_closed_count = 1 end_pos = opening_tag_match.end() tag_dict = opening_tag_match.groupdict() tag, attributes = tag_dict["tag"], tag_dict["attributes"] opening_tag_p = Regex.OPENING_TAG_P_FORMAT.format(tag=tag) closing_tag_p = Regex.CLOSING_TAG_P_FORMAT.format(tag=tag) while tag_closed_count != 0: opening_tag = re.compile(opening_tag_p).search(text, end_pos) closing_tag = re.compile(closing_tag_p).search(text, end_pos) nearest_match_tag = Regex.nearest_match(opening_tag, closing_tag) if nearest_match_tag is None: raise Exceptions.NoMatchingClosingTagError( tag_dict["opening_tag"]) elif nearest_match_tag == opening_tag: tag_closed_count += 1 elif nearest_match_tag == closing_tag: tag_closed_count -= 1 end_pos = nearest_match_tag.end() content = self._create_content( text[opening_tag_match.end():closing_tag.start()]) element = Element.Element(tag, content, attributes) return element, end_pos
def makeElements(EI, F, w0, l, N): elts = [] for i in range(N): elts.append(Element(EI, F, w0, l, N)) print(elts) #K1 = elt.makeKbCblist() return elts
def writeHeader(identifier, number, text): if number < 1 or number > 6: raise ValueError('Invalid header number: ' + str(number) + '\n') f.write('\t<h' + str(number) + ' id="' + identifier + '">' + text + '</h' + str(number) + '>\n') elements.append(Element(identifier, 'heading' + str(number), text)) return
def writeHyperlink(identifier, link, text): if identifier is None: f.write('\t<a href="' + link + '";>' + text + '</a>\n') else: f.write('\t<a id="' + identifier + '" href="' + link + '";>' + text + '</a>\n') elements.append(Element(identifier, 'hyperlink', text)) return
def __init__(self,Z=42): self.element = Element(Z) self.path0 = '../data/XRayAttenuation/' self.fileName = str(Z)+'XRayAttenuation.txt' self.data = genfromtxt(self.Path0+self.fileName,skiprows=11) self.energy = self.data[:,0]*1e6 self.mu = self.data[:,1] # cm^2/g self.muEnergy = self.data[:,2] # cm^2/g self.label= self.element.Symbol #'Z = '+ str(Z)
def addToHeap(self, key, item): if APQ.length(self) == 0: # if the length of the heap is zero index = 0 # initialise i to be zero else: # otherwise if the length is greater than 0 index = APQ.length(self) # i is initialised to length of heap element = Element(key, item, index) # create the element self._binaryheap.append(element) # add this to the binary heap - append as it is a list if APQ.length(self) > 1: # if the size of the binary heap is greater than 1, run the bubble up heap sort self.bubbleUpHeap(element) return element
def writeImage(identifier, source, height, width, link): if link is None: f.write('\t<img id="' + identifier + '" src="' + source + '" height = "' + height + '" width = "' + width + '"/>\n') elements.append(Element(identifier, 'image', None)) else: writeHyperlink( identifier, link, '<img id="' + identifier + '" src="' + source + '" height = "' + height + '" width = "' + width + '"/>') return
def insertModule(): if len(connectEntry.get()) > 0: connectValue = connectEntry.get() ser = serial.Serial(connectValue, 19200) time.sleep(2) unit = ControlUnit(ser, protocol) s = 1 number = str(len(elementen) + 1) name = '#%s' % number element = Element(rootframe, name, unit, s) elementen.append(element)
def minusExponent(lastResult, dividendElements, divisorElements): # lastResult times divisor elements divisorElementsPosition = 1 while divisorElementsPosition <= len(divisorElements) - 1: # init value for tempResult if lastResult.sign == divisorElements[divisorElementsPosition].sign: tempResultSign = '+' else: tempResultSign = '-' tempResultBase = lastResult.base * divisorElements[ divisorElementsPosition].base if lastResult.unknow != '': tempResultUnknow = lastResult.unknow else: tempResultUnknow = divisorElements[divisorElementsPosition].unknow tempResultExponent = lastResult.exponent + divisorElements[ divisorElementsPosition].exponent # create class for tempResult tempResult = Element.Element() tempResult.inputElement(sign=tempResultSign, base=tempResultBase, unknow=tempResultUnknow, exponent=tempResultExponent) # print(f'Create minus exponent: {output(tempResult)}') # minus to dividend elementExist = False for eachDividendElement in dividendElements: if eachDividendElement.unknow == tempResult.unknow and eachDividendElement.exponent == tempResult.exponent: # print(f'Minus: {output(eachDividendElement)} and {output(tempResult)}') elementExist = True eachDividendElement.base = eachDividendElement.base - tempResult.base if eachDividendElement.base < 0: eachDividendElement.sign = '-' else: eachDividendElement.sign = '+' # if element not exist if not elementExist: tempResult.base *= -1 if tempResult.base < 0: tempResult.sign = '-' else: tempResult.sign = '+' # add tempResult to dividendElements dividendElements.append(tempResult) # print(f'Add minus: {output(tempResult)}') # sort dividendElements dividendElements = Element.sortElement(dividendElements) divisorElementsPosition += 1 return dividendElements
def _find_k_neighbors(input, samples, errors, k): result = [] heapq.heapify(result) for i in range(0, len(samples)): current_element = Element.Element( _calculate_distance(input, samples[i]) * -1, errors[i][0]) if len(result) < k: result.append(current_element) else: max = heapq.heappop(result) if max < current_element: heapq.heappush(result, current_element) else: heapq.heappush(result, max) return result
def addElement(self, infoList): id, a, b, c, d, e, f, g, h = infoList id = int(id.split(",")[0].strip()) a = self.getNodeByID(int(a.split(",")[0].strip())) b = self.getNodeByID(int(b.split(",")[0].strip())) c = self.getNodeByID(int(c.split(",")[0].strip())) d = self.getNodeByID(int(d.split(",")[0].strip())) e = self.getNodeByID(int(e.split(",")[0].strip())) f = self.getNodeByID(int(f.split(",")[0].strip())) g = self.getNodeByID(int(g.split(",")[0].strip())) h = self.getNodeByID(int(h.split(",")[0].strip())) newElement = Element(id, a, b, c, d, e, f, g, h) self.elementMap[id] = newElement self.elements += 1 self.insertSurfaces(newElement)
def createMaze(self, matrix): self.maze = matrix self.mazeRow = matrix.row self.mazeCol = matrix.col for i in range(self.mazeRow): elementLine = [] for j in range(self.mazeCol): if ([i, j]) in matrix.getAvailable(): available = True else: available = False elementLine.append(el.Element(i, j, available)) self.element.append(elementLine) self.mazeStart = self.getElement(*matrix.getStart()) self.mazeEnd = self.getElement(*matrix.getEnd())
def fixml_sell_eod(self, ticker, quantity,limit): """ Generates FIXML for a sell order""" fixml=Element("FIXML") fixml.set("xmlns",FIXML_NAMESPACE) order=SubElement(fixml,"Order") order.set("TmInForce","7") #Market on close order.set("Typ","2") #Limit order.set("Side","2") #Sell order.set("Px","%.2f"%limit) #Limit price order.set("Acct",TRADEKING_ACCOUNT_NUMBER) instrmt=SubElement(order,"Instrmt") instrmt.set("SecTyp","CS") #Common stock instrmt.set("Sym",ticker) ord_qty=SubElement(order,"OrdQty") ord_qty.set("Qty",str(quantity)) return self.xml_tostring(fixml)
def load_elements(self, filename): data = np.loadtxt(filename, delimiter="\t", dtype=np.str) data = np.char.strip(data) property_names = data[0, :] data = data[1:, :] name_col_index = np.where(property_names == "Name")[0][0] self.__e_list = [] for i in range(len(data)): row = data[i] name = row[name_col_index] properties = {} for j in range(0, len(row)): if j != name_col_index: properties[property_names[j]] = row[j] self.__e_list.append(Element.Element(name, properties))
def divideHandling(dividendElements, divisorElements): # result element list resultElements = [] # keep working if the synthesis division is not finish while checkExponent(dividendElements, divisorElements): firstDividendElement = dividendElements[0] firstDivisorElement = divisorElements[0] # create the result when 1st dividend element divide to 1st divisor element result = Element.Element() if firstDividendElement.sign == firstDivisorElement.sign: resultSign = '+' else: resultSign = '-' resultBase = firstDividendElement.base / firstDivisorElement.base resultUnknow = firstDividendElement.unknow resultExponent = firstDividendElement.exponent - firstDivisorElement.exponent if resultExponent == 0: resultUnknow = '' # input variable to class result.inputElement(sign=resultSign, base=resultBase, unknow=resultUnknow, exponent=resultExponent) # add current result to result element list resultElements.append(result) # print(f'Add result: {output(result)}') # erase first element in dividend # print(f'Delete element: {output(dividendElements[0])}') dividendElements.pop(0) dividendElements = minusExponent(result, dividendElements, divisorElements) return resultElements, dividendElements
def dragEnterEvent(self, event): _spatium = self.score().spatium() self.dragElement = 0 data = event.mimeData() if data.hasFormat(mimeSymbolListFormat) or data.hasFormat(mimeStaffListFormat): event.acceptProposedAction() return if data.hasFormat(mimeSymbolFormat): event.acceptProposedAction() a = data.data(mimeSymbolFormat) doc = QDomDocument() line = 0 column = 0 err = QString() (ok, err, line, column) = doc.setContent(a) if not ok: print "error reading drag data at %d/%d: %s\n<%s>\n" %(line, column, err.toLatin1().data(), a.data()) return docName = "--" e = doc.documentElement() dragOffset = QPoint() type = Element().readType(e, dragOffset, self.duration) el = Element(None) if type == ElementType.IMAGE: path = QString() ee = e.firstChildElement() while not ee.isNull(): tag = QString(ee.tagName()) if tag == "path": path = ee.text() break ee = ee.nextSiblingElement() image = Image(None) lp = QString(path.toLower()) if lp.endsWith(".svg"): image = SvgImage(self.score()) elif lp.endsWith(".jpg") or lp.endsWith(".png") or lp.endsWith(".gif") or lp.endsWith(".xpm"): image = RasterImage(self.score()) else: print "unknown image format <%s>\n" %path.toLatin1().data() el = image elif type == ElementType.SLUR or\ type == ElementType.VOLTA or\ type == ElementType.OTTAVA or \ type == ElementType.TRILL or \ type == ElementType.PEDAL or \ type == ElementType.HAIRPIN or \ type == ElementType.TEXTLINE or \ type == ElementType.KEYSIG or \ type == ElementType.CLEF or \ type == ElementType.TIMESIG or \ type == ElementType.BREATH or \ type == ElementType.GLISSANDO or \ type == ElementType.ARTICULATION or \ type == ElementType.ACCIDENTAL or \ type == ElementType.DYNAMIC or \ type == ElementType.TEXT or \ type == ElementType.TEMPO_TEXT or \ type == ElementType.STAFF_TEXT or \ type == ElementType.NOTEHEAD or \ type == ElementType.TREMOLO or \ type == ElementType.LAYOUT_BREAK or \ type == ElementType.MARKER or \ type == ElementType.JUMP or \ type == ElementType.REPEAT_MEASURE or \ type == ElementType.ICON or \ type == ElementType.NOTE or \ type == ElementType.SYMBOL or \ type == ElementType.CHORD or \ type == ElementType.SPACER or \ type == ElementType.ACCIDENTAL_BRACKET: el = Element().create(type, self.score()) elif type == ElementType.BAR_LINE or type == ElementType.ARPEGGIO or type == ElementType.BRACKET: el = Element().create(type, self.score()) el.setHeight(_spatium * 5) else: print "dragEnter %s\n" %Element().name(type) if el: self.dragElement = el self.dragElement.setParent(None) self.dragElement.read(e) self.dragElement.layout() return if data.hasUrls(): ul = data.urls() for u in ul: if u.scheme() == "file": fi = QFileInfo(u.path()) suffix = QString(fi.suffix().toLower()) if suffix == "svg" or suffix == "jpg" or suffix == "png" or suffix == "gif" or suffix == "xpm": event.acceptProposedAction() return s = QString(self.tr("unknown drop format: formats %1:\n").arg(data.hasFormat(mimeSymbolFormat))) for ss in data.formats(): s = s + (QString(" <%1>\n").arg(ss)) QMessageBox.warning(0, "Drop:", s, QString.null, "Quit", QString.null, 0, 1)
def create_file(path, content=["<!DOCTYPE html>", Element.Element("html")]): return HTMLFile(path, content)
def __init__(self, parent): GGrule.__init__(self, 1) # this is the first rule to be executed # create the pattern... self.LHS = ASG_LinkedListMM() # create LHS self.LHSnode1 = Top(parent) # List head self.LHSnode1.graphObject_ = graph_Top( 10, 10, self.LHSnode1) # graphical representation... self.LHSnode1.setGGLabel(1) # Set Graph Grammar Label... self.LHSnode2 = LLink(parent) # Link to 1st. element self.LHSnode2.graphObject_ = graph_LLink( 30, 60, self.LHSnode2) # graphical representation... self.LHSnode2.setGGLabel(2) # Set Graph Grammar Label... self.LHSnode3 = Element(parent) # Any value self.LHSnode3.graphObject_ = graph_Element( 10, 150, self.LHSnode3) # graphical representation... self.LHSnode3.Label.setNone() self.LHSnode3.setGGLabel(3) # Set Graph Grammar Label... self.LHSnode1.out_connections_.append(self.LHSnode2) # n1 -> n2 self.LHSnode2.in_connections_.append(self.LHSnode1) self.LHSnode2.out_connections_.append(self.LHSnode3) # n2 -> n3 self.LHSnode3.in_connections_.append(self.LHSnode2) self.LHS.addNode(self.LHSnode1) self.LHS.addNode(self.LHSnode2) self.LHS.addNode(self.LHSnode3) # create RHS... self.RHS = ASG_LinkedListMM() # Also a Linked List... self.RHSnode1 = Top(parent) # List head self.RHSnode1.graphObject_ = graph_Top( 10, 10, self.RHSnode1) # graphical representation... self.RHSnode1.setGGLabel(1) # Set Graph Grammar Label... self.RHSnode2 = LLink(parent) # Link to inserted element self.RHSnode2.graphObject_ = graph_LLink( 30, 60, self.RHSnode2) # graphical representation... self.RHSnode2.setGGLabel(2) # Set Graph Grammar Label... self.RHSnode3 = Element(parent) # NEW ELEMENT self.RHSnode3.Label.setValue('NEW ELEMENT') self.RHSnode3.graphObject_ = graph_Element( 10, 150, self.RHSnode3) # graphical representation... self.RHSnode3.setGGLabel(4) # Set Graph Grammar Label (NEW LABEL) self.RHSnode4 = LLink(parent) # Link to inserted element self.RHSnode4.graphObject_ = graph_LLink( 30, 220, self.RHSnode4) # graphical representation... self.RHSnode4.setGGLabel(5) # Set Graph Grammar Label... self.RHSnode5 = Element(parent) # Any value self.RHSnode5.Label.setNone() self.RHSnode5.graphObject_ = graph_Element( 10, 280, self.RHSnode5) # graphical representation... self.RHSnode5.setGGLabel(3) # Set Graph Grammar Label... self.RHSnode1.out_connections_.append(self.RHSnode2) # n1 -> n2 self.RHSnode2.in_connections_.append(self.RHSnode1) self.RHSnode2.out_connections_.append(self.RHSnode3) # n2 -> n3 self.RHSnode3.in_connections_.append(self.RHSnode2) self.RHSnode3.out_connections_.append(self.RHSnode4) # n3 -> n4 self.RHSnode4.in_connections_.append(self.RHSnode3) self.RHSnode4.out_connections_.append(self.RHSnode5) # n4 -> n5 self.RHSnode5.in_connections_.append(self.RHSnode4) self.RHS.addNode(self.RHSnode1) self.RHS.addNode(self.RHSnode2) self.RHS.addNode(self.RHSnode3) self.RHS.addNode(self.RHSnode4) self.RHS.addNode(self.RHSnode5)
def __init__(self): self.item = Element()
from Element import * periodicTable = { 'Al': Element('Al', '26.97'), 'Sb': Element('Sb', '121.76'), 'Cu': Element('Cu', '63.57'), 'Ag': Element('Ag', '107.88'), 'Hg': Element('Hg', '200.61'), 'Ba': Element('Ba', '137.36'), 'Be': Element('Be', '9.02'), 'Bi': Element('Bi', '209.00'), 'Br': Element('Br', '79.91'), 'Ca': Element('Ca', '40.08'), 'C': Element('C', '12.01'), 'Cl': Element('Cl', '35.457'), 'Co': Element('Co', '58.94'), 'Cu': Element('Cu', '63.57'), 'Sn': Element('Sn', '118.70'), 'Sr': Element('Sr', '87.63'), 'Fe': Element('Fe', '55.84'), 'F': Element('F', '19.00'), 'P': Element('P', '31.02'), 'H': Element('H', '1.0078'), 'I': Element('I', '126.92'), 'Li': Element('Li', '6.940'), 'Mg': Element('Mg', '24.32'), 'Mn': Element('Mn', '54.18'), 'Hg': Element('Hg', '200.61'), 'Mo': Element('Mo', '96.0'), 'Ni': Element('Ni', '58.69'), 'N': Element('N', '14.008'),
def setUp(self): self.driver = Element()
def addElement(self, e, a, n1, n2): self.Elements.append(Element(e, a, n1, n2)) return self.Elements[-1]
def writeParagraph(identifier, text): f.write('\t<p id="' + identifier + '">' + text + '</p>\n') elements.append(Element(identifier, 'paragraph', text)) return
from Node import * from Element import * eqn = 0 n1 = Node(0, 0, 0) n2 = Node(1, 1, 0) e1 = Element(1, 1, n1, n2) c1 = Constraint(False, True, True) print(c1.constraint_print()) n1.set_constraint(c1) eqn = n1.enumerate_dofs(eqn) eqn = n2.enumerate_dofs(eqn) print(e1.get_e1()) print(e1.compute_stiffness_matrix()) print(eqn) print(n1.get_dof_numbers()) print(n2.get_dof_numbers())
def __init__(self, js): # Load the jason file and construct the virtual structure # Create Node objects and put them in nparray "nodes" # self.n_totalFreeDof = 0 #added by pubudu to extractDOF from deformation increment vector self.fix_Point_array = [] self.n_nodes = js["no_of_nodes"] self.nodes = np.empty(self.n_nodes, dtype=Node) js_nodes = js["nodes"] for node in js_nodes: id = node["id"] p_x = node["x"] p_y = node["y"] p_z = node["z"] new_node = Node(id, p_x, p_y, p_z) self.nodes.put(id, new_node) # Create CrossSection objects and put them in nparray "cross_sections" self.no_of_crosssection_types = js["no_of_crosssection_types"] self.cross_sections = np.empty(self.no_of_crosssection_types, dtype=CrossSection) js_cross_sections = js["cross_sections"] for cross_section in js_cross_sections: id = cross_section["id"] shape = cross_section["shape"] dimensions = cross_section["dimensions"] new_cross_section = None if shape == "rectangle": width = dimensions["z"] height = dimensions["y"] new_cross_section = SquareCrossSection(id, width, height) elif shape == "circle": radius = dimensions["radius"] new_cross_section = CircularCrossSection(id, radius) self.cross_sections.put(id, new_cross_section) # Create Element objects and put them in nparray "elements" self.n_elements = js["no_of_elements"] self.elements = np.empty(self.n_elements, dtype=Element) js_elements = js["elements"] for element in js_elements: id = element["id"] start_node_id = element["start_node_id"] start_node = self.nodes[start_node_id] end_node_id = element["end_node_id"] end_node = self.nodes[end_node_id] cross_section = self.cross_sections[element["element_type"]] material_id = element["material_id"] local_x_dir = element["local_x_dir"] local_dirs = [local_x_dir, 0, 0] new_element = Element(id, start_node, end_node, cross_section, material_id, local_dirs) self.elements.put(id, new_element) # Take loads applied and assign them to Nodes self.no_of_loads = js["no_of_loads"] js_loads = js["loads"] for load in js_loads: # id = load["id"] node_id = load["point_id"] force = load["force"] f_x = force["x"] f_y = force["y"] f_z = force["z"] torque = load["torque"] m_x = torque["x"] m_y = torque["y"] m_z = torque["z"] node = self.nodes[node_id] [node.f_x, node.f_y, node.f_z, node.m_x, node.m_y, node.m_z] = [f_x, f_y, f_z, m_x, m_y, m_z] # Take fixed points and assign nodes as fixed self.no_of_fixed_points = js["no_of_fixed_points"] js_fixed_points = js["fixed_points"] for fixed_point in js_fixed_points: # id = fixed_point["id"] node_id = fixed_point["point_id"] translation = fixed_point["translation"] self.fix_Point_array += [node_id] t_x = translation["x"] t_y = translation["y"] t_z = translation["z"] rotation = fixed_point["rotation"] r_x = rotation["x"] r_y = rotation["y"] r_z = rotation["z"] node = self.nodes[node_id] [node.t_x, node.t_y, node.t_z, node.r_x, node.r_y, node.r_z] = [t_x, t_y, t_z, r_x, r_y, r_z]
def parse(self, strInput): """ Detect les element et les insere dans une liste """ strInput = strInput.replace(' ', '') strInput = strInput.replace('+-', '-') strInput = self.replacePowerI(strInput) i = 0 list = [] error = str() while i < len(strInput): if re.match('-i', strInput[i:]): find = re.search('-i', strInput[i:]).group(0) i += len(find) - 1 list.append(Complex(real=0, img=-1)) elif re.match('\d+?\*?i', strInput[i:]): find = re.search('\d+?\*?i', strInput[i:]).group(0) i += len(find) - 1 list.append(Complex(find)) elif re.match('\d+\.\d+\*?i', strInput[i:]): find = re.search('\d+\.\d+\*?i', strInput[i:]).group(0) i += len(find) - 1 list.append(Complex(find)) elif re.match('i', strInput[i:]): find = re.search('i', strInput[i:]).group(0) i += len(find) - 1 list.append(Complex(find)) elif re.match('\d+\.\d+', strInput[i:]): find = re.search('\d+\.\d+', strInput[i:]).group(0) i += len(find) - 1 list.append(Number(find, 'float')) elif re.match('\d+', strInput[i:]): find = re.search('\d+', strInput[i:]).group(0) i += len(find) - 1 list.append(Number(find, 'int')) elif re.match('[a-zA-Z]+\([a-zA-Z]+\)', strInput[i:]): find = re.search('[a-zA-Z]+\([a-zA-Z]+\)', strInput[i:]).group(0) i += len(find) - 1 if 'i' in find: error = "\033[31mA function cannot contain i\033[0m" list.append(Element(find, 'defFunction')) elif re.match('[a-zA-Z]+\(\-?\d+\)', strInput[i:]): find = re.search('[a-zA-Z]+\(\-?\d+\)', strInput[i:]).group(0) i += len(find) - 1 if 'i' in find: error = "\033[31mA function cannot contain i\033[0m" list.append(Element(find, 'callFunction')) elif re.match('[a-zA-Z]+', strInput[i:]): find = re.search('[a-zA-Z]+', strInput[i:]).group(0) i += len(find) - 1 if 'i' in find: error = "\033[31mA variable cannot contain i\033[0m" list.append(Element(find, 'var')) elif strInput[i] == '[': find = Matrice.getMatrice(strInput[i:]) i += len(find) - 1 matrice = Matrice(find) if not matrice.valid: error = "\033[31mInvalid Matrice:\033[0m " + find list.append(matrice) elif re.match('\*\*', strInput[i:]): find = re.search('\*\*', strInput[i:]).group(0) i += len(find) - 1 list.append(Element(find, 'operator')) elif strInput[i] in '+-*/%^=?()': list.append(Element(strInput[i], 'operator')) else: error = "\033[31mInvalid input:\033[0m " + strInput[i] i += 1 if not error == "": break self.solveError(list) if error == "": error = self.checkError(strInput) return list, error
def dropEvent(self, event): pos = QPointF(self.imatrix.map(QPointF(event.pos()))) if self.dragElement: self._score.startCmd() self.dragElement.setScore(self._score) self._score.addRefresh(self.dragElement.abbox()) if self.dragElement.type() == ElementType.VOLTA or\ self.dragElement.type() == ElementType.OTTAVA or \ self.dragElement.type() == ElementType.TRILL or\ self.dragElement.type() == ElementType.PEDAL or\ self.dragElement.type() == ElementType.DYNAMIC or\ self.dragElement.type() == ElementType.HAIRPIN or\ self.dragElement.type() == ElementType.TEXTLINE: self.dragElement.setScore(self.score()) self.score().cmdAdd1(self.dragElement, pos, self.dragOffset) self.event.acceptProposedAction() elif self.dragElement.type() == ElementType.SYMBOL or\ self.dragElement.type() == ElementType.IMAGE: el = self.elementAt(pos) if el == 0: staffIdx = -1 seg = Segment() tick = 0 el = self._score.pos2measure(pos, tick, staffIdx, 0, seg, 0) if el == 0: print "cannot drop here\n" del self.dragElement self._score.addRefresh(el.abbox()) self._score.addRefresh(self.dragElement.abbox()) dropElement = el.drop(self, pos, self.dragOffset, self.dragElement) self._score.addRefresh(el.abbox()) if dropElement: self._score.select(dropElement, SelectType.SELECT_SINGLE, 0) self._score.addRefresh(dropElement.abbox()) event.acceptProposedAction() elif self.dragElement.type() == ElementType.KEYSIG or\ self.dragElement.type() == ElementType.CLEF or\ self.dragElement.type() == ElementType.TIMESIG or\ self.dragElement.type() == ElementType.BAR_LINE or\ self.dragElement.type() == ElementType.ARPEGGIO or\ self.dragElement.type() == ElementType.BREATH or\ self.dragElement.type() == ElementType.GLISSANDO or\ self.dragElement.type() == ElementType.BRACKET or\ self.dragElement.type() == ElementType.ARTICULATION or\ self.dragElement.type() == ElementType.ACCIDENTAL or\ self.dragElement.type() == ElementType.TEXT or\ self.dragElement.type() == ElementType.TEMPO_TEXT or\ self.dragElement.type() == ElementType.STAFF_TEXT or\ self.dragElement.type() == ElementType.NOTEHEAD or\ self.dragElement.type() == ElementType.TREMOLO or\ self.dragElement.type() == ElementType.LAYOUT_BREAK or\ self.dragElement.type() == ElementType.MARKER or\ self.dragElement.type() == ElementType.JUMP or\ self.dragElement.type() == ElementType.REPEAT_MEASURE or\ self.dragElement.type() == ElementType.ICON or\ self.dragElement.type() == ElementType.NOTE or\ self.dragElement.type() == ElementType.CHORD or\ self.dragElement.type() == ElementType.SPACER or\ self.dragElement.type() == ElementType.SLUR or\ self.dragElement.type() == ElementType.ACCIDENTAL_BRACKET: el = Element() for e in self.elementsAt(pos): if e.acceptDrop(self, pos, self.dragElement.type(), self.dragElement.subtype()): el = e break if not el: print "cannot drop here\n" del self.dragElement self._score.addRefresh(el.abbox()) self._score.addRefresh(self.dragElement.abbox()) dropElement = el.drop(self, pos, self.dragOffset, self.dragElement) self._score.addRefresh(el.abbox()) if dropElement: if not self._score.noteEntryMode(): self._score.select(dropElement, SelectType.SELECT_SINGLE, 0) self._score.addRefresh(dropElement.abbox()) event.acceptProposedAction() else: del self.dragElement self.dragElement = 0 self.setDropTarget(0) self.score().endCmd() return if event.mimeData().hasUrls(): ul = event.mimeData().urls() u = ul.front() if u.scheme() == "file": fi = QFileInfo(u.path()) s = Image() suffix = fi.suffix().toLower() if suffix == "svg": s = SvgImage(self.score()) elif suffix == "jpg" or suffix == "png" or suffix == "gif" or suffix == "xpm": s = RasterImage(self.score()) else: return self._score.startCmd() s.setPath(u.toLocalFile()) el = self.elementAt(pos) if el and (el.type() == ElementType.NOTE or el.type() == ElementType.REST): s.setTrack(el.track()) if el.type() == ElementType.NOTE: note = el s.setTick(note.chord().tick()) s.setParent(note.chord().segment().measure()) else: rest = el s.setTick(rest.tick()) s.setParent(rest.segment().measure()) self.score().undoAddElement(s) else: self.score().cmdAddBSymbol(s, pos, self.dragOffset) event.acceptProposedAction() self.score().endCmd() self.setDropTarget(0) return return md = event.mimeData() data = QFileInfo() if md.hasFormat(mimeSymbolListFormat): etype = ElementType.ELEMENT_LIST data = md.data(mimeSymbolListFormat) elif md.hasFormat(mimeStaffListFormat): etype = ElementType.STAFF_LIST data = md.data(mimeStaffListFormat) else: print "cannot drop this object: unknown mime type\n" sl = md.formats() for s in sl: print " %s\n" %s.toAscii().data() self._score.end() return doc = QDomDocument() (ok, err, line, column) = doc.setContent(data) if not ok: qWarning("error reading drag data at %d/%d: %s\n %s\n" %(line, column, err.toAscii().data(), data.data())) return docName = "--" el = self.elementAt(pos) if el == 0 or el.type() != ElementType.MEASURE: self.setDropTarget(0) return measure = el if etype == ElementType.ELEMENT_LIST: print "drop element list\n" elif etype == ElementType.MEASURE_LIST or etype == ElementType.STAFF_LIST: self._score.startCmd() s = measure.system() idx = s.y2staff(pos.y()) if idx != -1: seg = measure.first() while seg.subtype() != SegmentType.SegChordRest: seg = seg.next() self.score().pasteStaff(doc.documentElement(), seg.element(idx * VOICES)) event.acceptProposedAction() self._score.setLayoutAll(True) self._score.endCmd() self.setDropTarget(0)