def parentNameChanged(oldParentName, newParentName, parentID): ''' * Updates BlockStub hashmaps and the BlockStubs of the parent of its new name * @param oldParentName * @param newParentName * @param parentID ''' oldKey = oldParentName + Block.getBlock(parentID).getGenusName(); newKey = newParentName + Block.getBlock(parentID).getGenusName(); # only update if parents name really did "change" meaning the new parent name is # different from the old parent name if(oldKey !=newKey): BlockStub.parentNameToParentBlock[newKey] = parentID; # update the parent name of each stub stubs = BlockStub.parentNameToBlockStubs[oldKey]; for stub in stubs: blockStub = Block.getBlock(stub); blockStub.parentName = newParentName; # update block label of each blockStub.setBlockLabel(newParentName); blockStub.notifyRenderable(); # check if any stubs already exist for new key existingStubs = parentNameToBlockStubs[newKey] if existingStubs != None: stubs += existingStubs parentNameToBlockStubs[newKey] = stubs # remove old parent name from hash maps parentNameToParentBlock.remove(oldKey); parentNameToBlockStubs.remove(oldKey);
def __init__(self, typeId, size, data): Block.__init__(self, typeId, size, data) self.magic = str(data[0:4]) self.gameId = read32(data, 4) versionData = read16(data, 8) self.versionMajor = versionData >> 12 # First 4 bits self.versionMinor = (versionData >> 5) & 0x7F # Middle 7 bits self.versionIncrement = versionData & 0x1F # Last 5 bits self.turn = read16(data, 10) self.year = 2400 + self.turn playerData = read16(data, 12) self.salt = playerData >> 5 # First 11 bits self.playerIndex = playerData & 0x1F # Last 5 bits flags = data[15] self.turnSubmitted = (flags & (1 << 0)) == 1 self.hostUsing = (flags & (1 << 1)) == 1 self.multipleTurns = (flags & (1 << 2)) == 1 self.gameOver = (flags & (1 << 3)) == 1 self.shareware = (flags & (1 << 4)) == 1 pass
def parentNameChanged(oldParentName, newParentName, parentID): ''' * Updates BlockStub hashmaps and the BlockStubs of the parent of its new name * @param oldParentName * @param newParentName * @param parentID ''' oldKey = oldParentName + Block.getBlock(parentID).getGenusName() newKey = newParentName + Block.getBlock(parentID).getGenusName() # only update if parents name really did "change" meaning the new parent name is # different from the old parent name if (oldKey != newKey): BlockStub.parentNameToParentBlock[newKey] = parentID # update the parent name of each stub stubs = BlockStub.parentNameToBlockStubs[oldKey] for stub in stubs: blockStub = Block.getBlock(stub) blockStub.parentName = newParentName # update block label of each blockStub.setBlockLabel(newParentName) blockStub.notifyRenderable() # check if any stubs already exist for new key existingStubs = parentNameToBlockStubs[newKey] if existingStubs != None: stubs += existingStubs parentNameToBlockStubs[newKey] = stubs # remove old parent name from hash maps parentNameToParentBlock.remove(oldKey) parentNameToBlockStubs.remove(oldKey)
def parentConnectorsChanged( parentID): key = Block.getBlock(parentID).getBlockLabel() + Block.getBlock(parentID).getGenusName(); # update each stub only if stub is a caller (as callers are the only type of stubs that # can change its connectors after being created) stubs = BlockStub.parentNameToBlockStubs[key] for stub in stubs: blockStub = Block.getBlock(stub) if(blockStub.stubGenus.startsWith(CALLER_STUB)): blockStub.updateConnectors(); # System.out.println("updated connectors of: "+blockStub); blockStub.notifyRenderable();
def parentConnectorsChanged(parentID): key = Block.getBlock(parentID).getBlockLabel() + Block.getBlock( parentID).getGenusName() # update each stub only if stub is a caller (as callers are the only type of stubs that # can change its connectors after being created) stubs = BlockStub.parentNameToBlockStubs[key] for stub in stubs: blockStub = Block.getBlock(stub) if (blockStub.stubGenus.startsWith(CALLER_STUB)): blockStub.updateConnectors() # System.out.println("updated connectors of: "+blockStub); blockStub.notifyRenderable()
def textChanged(self, text): from blocks.RenderableBlock import RenderableBlock from blocks.BlockStub import BlockStub if (self.labelType == BlockLabel.Type.NAME_LABEL or self.labelType == BlockLabel.Type.PORT_LABEL) and (Block.getBlock( self.blockID).isLabelEditable()): if (self.labelType == (BlockLabel.Type.NAME_LABEL)): Block.getBlock(self.blockID).setBlockLabel(text) plug = Block.getBlock(self.blockID).getPlug() # Check if we're connected to a block. If we are and the the block we're connected to # has stubs, update them. if (plug != None and plug.blockID != Block.NULL): if (Block.getBlock(plug.blockID) != None): if (Block.getBlock(plug.blockID).isProcedureDeclBlock() and Block.getBlock(plug.blockID).hasStubs()): # Blocks already store their socket names when saved so it is not necessary # nor desired to call the connectors changed event again. if (Block.getRenderableBlock( plug.blockID).isLoading()): BlockStub.parentConnectorsChanged( self.workspace, plug.blockID) rb = RenderableBlock.getRenderableBlock(self.blockID) if (rb != None and not rb.isLoading): rb.reformBlockShape() rb.updateBuffImg() #rb.repaint() pass
def getLink(rblock1, otherBlocks): from blocks.BlockLink import BlockLink block1 = Block.getBlock(rblock1.blockID); closestSocket1 = None; closestSocket2 = None; closestBlock2 = None; closestDistance = BlockLinkChecker.MAX_LINK_DISTANCE; #currentDistance; for rblock2 in otherBlocks: currentPlug = BlockLinkChecker.getPlugEquivalent(block1); block2 = Block.getBlock(rblock2.blockID); if (block1 == block2 or not rblock1.isVisible() or not rblock2.isVisible() or rblock1.isCollapsed() or rblock2.isCollapsed()): continue; currentPlugPoint = None; currentSocketPoint = None; if (currentPlug != None): currentPlugPoint = BlockLinkChecker.getAbsoluteSocketPoint(rblock1, currentPlug); for currentSocket in BlockLinkChecker.getSocketEquivalents(block2): currentSocketPoint = BlockLinkChecker.getAbsoluteSocketPoint(rblock2, currentSocket); currentDistance = BlockLinkChecker.distance(currentPlugPoint,currentSocketPoint); if ((currentDistance < closestDistance) and BlockLinkChecker.checkRules(block1, block2, currentPlug, currentSocket)): closestBlock2 = block2; closestSocket1 = currentPlug; closestSocket2 = currentSocket; closestDistance = currentDistance; currentPlug = BlockLinkChecker.getPlugEquivalent(block2); if (currentPlug != None) : currentPlugPoint = BlockLinkChecker.getAbsoluteSocketPoint(rblock2, currentPlug); for currentSocket in BlockLinkChecker.getSocketEquivalents(block1): currentSocketPoint = BlockLinkChecker.getAbsoluteSocketPoint(rblock1, currentSocket); currentDistance = BlockLinkChecker.distance(currentPlugPoint,currentSocketPoint); if ((currentDistance < closestDistance) and BlockLinkChecker.checkRules(block1, block2, currentSocket, currentPlug)): closestBlock2 = block2; closestSocket1 = currentSocket; closestSocket2 = currentPlug; closestDistance = currentDistance; if (closestSocket1 == None): return None; return BlockLink.getBlockLink(block1, closestBlock2, closestSocket1, closestSocket2);
def textChanged(self, text): from blocks.RenderableBlock import RenderableBlock from blocks.BlockStub import BlockStub if (self.labelType == BlockLabel.Type.NAME_LABEL or self.labelType == BlockLabel.Type.PORT_LABEL) and (Block.getBlock(self.blockID).isLabelEditable()): if (self.labelType == (BlockLabel.Type.NAME_LABEL)): Block.getBlock(self.blockID).setBlockLabel(text); plug = Block.getBlock(self.blockID).getPlug(); # Check if we're connected to a block. If we are and the the block we're connected to # has stubs, update them. if (plug != None and plug.blockID != Block.NULL): if (Block.getBlock(plug.blockID) != None): if(Block.getBlock(plug.blockID).isProcedureDeclBlock() and Block.getBlock(plug.blockID).hasStubs()): # Blocks already store their socket names when saved so it is not necessary # nor desired to call the connectors changed event again. if (Block.getRenderableBlock(plug.blockID).isLoading()): BlockStub.parentConnectorsChanged(self.workspace, plug.blockID); rb = RenderableBlock.getRenderableBlock(self.blockID); if(rb != None and not rb.isLoading): rb.reformBlockShape() rb.updateBuffImg() #rb.repaint() pass
def loadBlockDrawerSets(block_drawersets, manager): import json if (block_drawersets == ''): return f = open(block_drawersets) data = json.load(f) if 'block_drawer_sets' in data: block_drawer_sets = data['block_drawer_sets'] for drawerElement in block_drawer_sets: if 'drawer' in drawerElement and 'genus-list' in drawerElement: drawerName = drawerElement['drawer'] canvas = manager.addStaticDrawerNoPos( drawerName, QtGui.QColor(100, 100, 100, 0)) drawerRBs = [] member = drawerElement['genus-list'] for genusName in member: newBlock = Block.createBlock(canvas, genusName, False) if (newBlock == None): continue rb = FactoryRenderableBlock.from_block( canvas, newBlock, False, QtGui.QColor(225, 225, 225, 100)) drawerRBs.append(rb) FactoryRenderableBlock.factoryRBs[genusName] = rb manager.addStaticBlocks(drawerRBs, drawerName) return
def loadBlockDrawerSets(self, root): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock drawerSetNodes = root.findall("BlockDrawerSets/BlockDrawerSet") for drawerSetNode in drawerSetNodes: drawerNodes = drawerSetNode.getchildren() # retreive drawer information of this bar for drawerNode in drawerNodes: if (drawerNode.tag == "BlockDrawer"): if ("name" in drawerNode.attrib): drawerName = drawerNode.attrib["name"] node = FactoryTreeNode(self.rootNode, drawerName) self.rootNode.children.append(node) #manager.addStaticDrawerNoPos(drawerName, QtGui.QColor(100,100,100,0)); drawerBlocks = drawerNode.getchildren() blockNode = None for blockNode in drawerBlocks: if (blockNode.tag == "BlockGenusMember"): genusName = blockNode.text newBlock = Block.createBlock( None, genusName, False) rb = FactoryRenderableBlock.from_blockID( None, newBlock.blockID, False, QtGui.QColor(225, 225, 225, 100)) sub_node = FactoryTreeNode(node, rb) node.children.append(sub_node) #manager.addStaticBlocks(drawerRBs, drawerName); return self.rootNode
def showBlock(self, genus): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock from PyQt4.QtCore import Qt if(genus == None): return block = Block.createBlockFromID(None, genus.genusName) preview_wnd_layout = self.mainWnd.wndPreview.layout() #for i in reversed(range(preview_wnd_layout.count())): # preview_wnd_layout.itemAt(i).widget().setParent(None) for i in reversed(range(preview_wnd_layout.count())): widget = preview_wnd_layout.itemAt(i).widget() widget.setParent(None) widget.deleteLater() self.factoryRB = FactoryRenderableBlock.from_block(None, block) self.factoryRB.updateBuffImg() #factoryRB.setParent(self.mainWnd.wndPreview) #print('%d:%d'%(factoryRB.getBlockWidth(), factoryRB.getBlockHeight())) self.factoryRB.setFixedSize(self.factoryRB.width(), self.factoryRB.height()) preview_wnd_layout.addWidget(self.factoryRB, Qt.AlignCenter); pass
def loadBlockDrawerSets(self, root): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock drawerSetNodes = root.findall("BlockDrawerSets/BlockDrawerSet") for drawerSetNode in drawerSetNodes: drawerNodes=drawerSetNode.getchildren() # retreive drawer information of this bar for drawerNode in drawerNodes: if(drawerNode.tag == "BlockDrawer"): if("name" in drawerNode.attrib): drawerName = drawerNode.attrib["name"] node = FactoryTreeNode(self.rootNode, drawerName) self.rootNode.children.append(node) #manager.addStaticDrawerNoPos(drawerName, QtGui.QColor(100,100,100,0)); drawerBlocks = drawerNode.getchildren() blockNode = None for blockNode in drawerBlocks: if(blockNode.tag == "BlockGenusMember"): genusName = blockNode.text newBlock = Block.createBlock(None, genusName, False) rb = FactoryRenderableBlock.from_blockID(None, newBlock.blockID,False, QtGui.QColor(225,225,225,100)) sub_node = FactoryTreeNode(node, rb) node.children.append(sub_node) #manager.addStaticBlocks(drawerRBs, drawerName); return self.rootNode
def appendRightSidePath(self, painterPath, connectedBlock, connectedBlockShape): ''' * Appends the right side path of the stack of blocks connected to the specified connectedBlock. If there are * some empty sockets, this method will append empty placeholders. * @param painterPath the GeneralPath to append the new path to * @param connectedBlock the Block instance whose right side of its stack of connected blocks will be appened to the * specified painterPath * @param connectedBlockShape the BlockShape of the specified connectedBlock ''' from blocks.RenderableBlock import RenderableBlock # int lastBottomPathWidth; # append top side of connected block BlockShapeUtil.appendPath(painterPath, connectedBlockShape.getTopSide(), False) startX = painterPath.currentPosition().x() for socket in connectedBlock.getSockets(): # Sets the current x-coordinate to the start x-coordinate # Makes it so path movements created by previous blocks don't affect # the subsequent blocks. painterPath.lineTo(startX, painterPath.currentPosition().y()) if (socket.blockID == Block.NULL): # just draw an empty socket placeholder # if its the first socket, draw a top side painterPath.lineTo( painterPath.currentPosition().x() + BlockShape.BOTTOM_SOCKET_SIDE_SPACER, painterPath.currentPosition().y()) # now draw the empty right socket side # draw first socket - down right side BlockShape.BCS.addDataSocket(painterPath, socket.getKind(), False) # TODO:lastBottomPathWidth = (int)BOTTOM_SOCKET_SIDE_SPACER; else: # a block is connected to this socket, check if that block has sockets # OR if the block is an infix block - if it is infix, then just wrap around the infix block block = Block.getBlock(socket.blockID) shape = RenderableBlock.getRenderableBlock( socket.blockID).getBlockShape() if (block.getNumSockets() == 0 or block.isInfix()): # append this block's top and right side # TODO instead of just appending the right side...draw line to BlockShapeUtil.appendPath(painterPath, shape.getTopSide(), False) BlockShapeUtil.appendPath(painterPath, shape.getRightSide(), False) else: self.appendRightSidePath(painterPath, block, shape) # Updates the maximum X-coordinate and sets the current point to self.maxX if (self.maxX < painterPath.currentPosition().x()): self.maxX = painterPath.currentPosition().x() painterPath.lineTo(self.maxX, painterPath.currentPosition().y())
def labelChanged(self, label): from blocks.RenderableBlock import RenderableBlock if(self.widget.hasMenu): oldBlock = Block.getBlock(self.blockID); oldBlock.changeLabelTo(label); rb = RenderableBlock.getRenderableBlock(self.blockID); rb.repaintBlock();
def from_blockID(cls, workspaceWidget, blockID, isLoading=False, back_color=QtGui.QColor(225, 225, 225, 255)): return FactoryRenderableBlock.from_block(workspaceWidget, Block.getBlock(blockID), False, back_color)
def labelChanged(self, label): from blocks.RenderableBlock import RenderableBlock if (self.widget.hasMenu): oldBlock = Block.getBlock(self.blockID) oldBlock.changeLabelTo(label) rb = RenderableBlock.getRenderableBlock(self.blockID) rb.repaintBlock()
def __init__(self, parent, initLabelText, prefix, suffix, labelType, isEditable, blockID, hasComboPopup, tooltipBackground): from blocks.RenderableBlock import RenderableBlock from blocks.FactoryRenderableBlock import FactoryRenderableBlock self.widget = LabelWidget(parent, blockID, initLabelText, prefix, suffix, Block.getBlock(blockID).getColor().darker(), tooltipBackground) self.parent = parent self.zoom = 1.0 self.initLabelText = initLabelText self.labelType = labelType self.blockID = blockID self.hasComboPopup = hasComboPopup # Only editable if the isEditable parameter was true, the label is either a Block's name or # socket label, the block can edit labels, and the block is not in the factory. self.widget.setEditable( isEditable and (labelType == BlockLabel.Type.NAME_LABEL or labelType == BlockLabel.Type.PORT_LABEL) and Block.getBlock(blockID).isLabelEditable() and not isinstance(RenderableBlock.getRenderableBlock(blockID), FactoryRenderableBlock)) if (labelType == None or labelType == (BlockLabel.Type.NAME_LABEL)): self.widget.setFont(BlockLabel.blockFontLarge_Bold) elif (labelType == (BlockLabel.Type.PAGE_LABEL)): self.widget.setFont(BlockLabel.blockFontMedium_Bold) elif (labelType == (BlockLabel.Type.PORT_LABEL)): self.widget.setFont(BlockLabel.blockFontMedium_Bold) elif (labelType == (BlockLabel.Type.DATA_LABEL)): self.widget.setFont(BlockLabel.blockFontMedium_Bold) # set initial text self.widget.updateLabelText(initLabelText) # add and show the textLabel initially self.widget.setEditingState(False) #famList = {} #if (Block.getBlock(blockID).hasSiblings()) : # famList = Block.getBlock(blockID).getSiblingsList(); #self.widget.setMenu(); self.widget.fireTextChanged = self.textChanged self.widget.fireGenusChanged = self.labelChanged self.widget.fireMenuChanged = self.onRenameVariable
def mouseMoveEvent(self, e): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock from components.PyMimeData import PyMimeData from components.DrawerSetsTreeView import DrawerSetsTreeNode if e.buttons() != Qt.LeftButton: return genusName = self.currentItem().text() newBlock = Block.createBlock(None, genusName, False) rb = FactoryRenderableBlock.from_blockID(None, newBlock.blockID, False, QColor(225, 225, 225, 100)) sub_node = DrawerSetsTreeNode(None, rb) mimeData = PyMimeData(sub_node) # write the relative cursor position to mime data #mimeData = QMimeData() #item = self.currentItem() #mimeData.setText(item.text()) #block = Block.createBlockFromID(None, genusName) #factoryRB = FactoryRenderableBlock.from_block(None, block) #print(self.mainWnd.genusTreeModel.factoryRB) # let's make it fancy. we'll show a "ghost" of the button as we drag # grab the button to a pixmap pixmap = QPixmap.grabWidget(rb) mimeData.setImageData(pixmap) # below makes the pixmap half transparent painter = QPainter(pixmap) painter.setCompositionMode(painter.CompositionMode_DestinationIn) painter.fillRect(pixmap.rect(), QColor(0, 0, 0, 127)) painter.end() # make a QDrag drag = QDrag(self) # put our MimeData drag.setMimeData(mimeData) # set its Pixmap drag.setPixmap(pixmap) # shift the Pixmap so that it coincides with the cursor position drag.setHotSpot(QPoint(0, 0)) # start the drag operation # exec_ will return the accepted action from dropEvent if drag.exec_(Qt.CopyAction | Qt.MoveAction) == Qt.MoveAction: #print ('moved') pass else: #print ('copied') pass
def __init__(self,parent, initLabelText, prefix, suffix, labelType, isEditable, blockID, hasComboPopup, tooltipBackground): from blocks.RenderableBlock import RenderableBlock from blocks.FactoryRenderableBlock import FactoryRenderableBlock self.widget= LabelWidget(parent, blockID, initLabelText, prefix, suffix, Block.getBlock(blockID).getColor().darker(), tooltipBackground) self.parent = parent self.zoom = 1.0 self.initLabelText = initLabelText self.labelType = labelType self.blockID = blockID self.hasComboPopup = hasComboPopup # Only editable if the isEditable parameter was true, the label is either a Block's name or # socket label, the block can edit labels, and the block is not in the factory. self.widget.setEditable( isEditable and (labelType == BlockLabel.Type.NAME_LABEL or labelType == BlockLabel.Type.PORT_LABEL) and Block.getBlock(blockID).isLabelEditable() and not isinstance(RenderableBlock.getRenderableBlock(blockID),FactoryRenderableBlock)); if(labelType == None or labelType == (BlockLabel.Type.NAME_LABEL)): self.widget.setFont(BlockLabel.blockFontLarge_Bold); elif(labelType == (BlockLabel.Type.PAGE_LABEL)): self.widget.setFont(BlockLabel.blockFontMedium_Bold); elif(labelType ==(BlockLabel.Type.PORT_LABEL)): self.widget.setFont(BlockLabel.blockFontMedium_Bold); elif(labelType == (BlockLabel.Type.DATA_LABEL)): self.widget.setFont(BlockLabel.blockFontMedium_Bold); # set initial text self.widget.updateLabelText(initLabelText); # add and show the textLabel initially self.widget.setEditingState(False); #famList = {} #if (Block.getBlock(blockID).hasSiblings()) : # famList = Block.getBlock(blockID).getSiblingsList(); #self.widget.setMenu(); self.widget.fireTextChanged = self.textChanged self.widget.fireGenusChanged = self.labelChanged self.widget.fireMenuChanged = self.onRenameVariable
def mouseMoveEvent(self, e): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock from components.PyMimeData import PyMimeData from components.DrawerSetsTreeView import DrawerSetsTreeNode if e.buttons() != Qt.LeftButton: return genusName = self.currentItem().text() newBlock = Block.createBlock(None, genusName, False) rb = FactoryRenderableBlock.from_blockID(None, newBlock.blockID,False, QColor(225,225,225,100)) sub_node = DrawerSetsTreeNode(None, rb) mimeData = PyMimeData(sub_node) # write the relative cursor position to mime data #mimeData = QMimeData() #item = self.currentItem() #mimeData.setText(item.text()) #block = Block.createBlockFromID(None, genusName) #factoryRB = FactoryRenderableBlock.from_block(None, block) #print(self.mainWnd.genusTreeModel.factoryRB) # let's make it fancy. we'll show a "ghost" of the button as we drag # grab the button to a pixmap pixmap = QPixmap.grabWidget(rb) mimeData.setImageData(pixmap) # below makes the pixmap half transparent painter = QPainter(pixmap) painter.setCompositionMode(painter.CompositionMode_DestinationIn) painter.fillRect(pixmap.rect(), QColor(0, 0, 0, 127)) painter.end() # make a QDrag drag = QDrag(self) # put our MimeData drag.setMimeData(mimeData) # set its Pixmap drag.setPixmap(pixmap) # shift the Pixmap so that it coincides with the cursor position drag.setHotSpot(QPoint (0, 0)) # start the drag operation # exec_ will return the accepted action from dropEvent if drag.exec_(Qt.CopyAction | Qt.MoveAction) == Qt.MoveAction: #print ('moved') pass else: #print ('copied') pass
def __init__(self, rb): if (rb != None): self.rb = rb self.blockID = rb.blockID self.block = Block.getBlock(self.blockID) else: print("Cannot create shape of null RenderableBlock.") #initialize gernal path segements around the block shape #self.painterPath = None self.setupProperties()
def onRenameVariable(self, old_name, new_name): from blocks.RenderableBlock import RenderableBlock from blocks.FactoryRenderableBlock import FactoryRenderableBlock from blocks.BlockGenus import BlockGenus rb = RenderableBlock.getRenderableBlock(self.blockID); block = Block.getBlock(self.blockID) familyMap = block.getCustomerFamily(); findVar = False for key in familyMap: if(familyMap[key] == old_name): familyMap[key] = new_name findVar = True if(not findVar): familyMap[new_name] = new_name #self.labelChanged(new_name) #return #factoryBlock = rb.factoryRB #for rb in factoryBlock.child_list: # blockLabel = rb.blockLabel # #blockLabel.widget.setMenu(); # if(blockLabel.getText() == old_name): # blockLabel.labelChanged(new_name) #factoryBlock.blockLabel.widget.setMenu() #if(factoryBlock.blockLabel.getText() == old_name): # factoryBlock.blockLabel.labelChanged(new_name) #print(block.getGenus().familyName) #print(BlockGenus.familyBlocks) if(block.getGenus().familyName in BlockGenus.familyBlocks): for genus in BlockGenus.familyBlocks[block.getGenus().familyName]: genusName = genus.genusName if genusName not in FactoryRenderableBlock.factoryRBs: continue factoryBlock = FactoryRenderableBlock.factoryRBs[genusName] for rb in factoryBlock.child_list: blockLabel = rb.blockLabel #blockLabel.widget.setMenu(); if(blockLabel.getText() == old_name): blockLabel.labelChanged(new_name) #factoryBlock.blockLabel.widget.setMenu(); if(factoryBlock.blockLabel.getText() == old_name): #print(factoryBlock) factoryBlock.blockLabel.labelChanged(new_name)
def onRenameVariable(self, old_name, new_name): from blocks.RenderableBlock import RenderableBlock from blocks.FactoryRenderableBlock import FactoryRenderableBlock from blocks.BlockGenus import BlockGenus rb = RenderableBlock.getRenderableBlock(self.blockID) block = Block.getBlock(self.blockID) familyMap = block.getCustomerFamily() findVar = False for key in familyMap: if (familyMap[key] == old_name): familyMap[key] = new_name findVar = True if (not findVar): familyMap[new_name] = new_name #self.labelChanged(new_name) #return #factoryBlock = rb.factoryRB #for rb in factoryBlock.child_list: # blockLabel = rb.blockLabel # #blockLabel.widget.setMenu(); # if(blockLabel.getText() == old_name): # blockLabel.labelChanged(new_name) #factoryBlock.blockLabel.widget.setMenu() #if(factoryBlock.blockLabel.getText() == old_name): # factoryBlock.blockLabel.labelChanged(new_name) #print(block.getGenus().familyName) #print(BlockGenus.familyBlocks) if (block.getGenus().familyName in BlockGenus.familyBlocks): for genus in BlockGenus.familyBlocks[block.getGenus().familyName]: genusName = genus.genusName if genusName not in FactoryRenderableBlock.factoryRBs: continue factoryBlock = FactoryRenderableBlock.factoryRBs[genusName] for rb in factoryBlock.child_list: blockLabel = rb.blockLabel #blockLabel.widget.setMenu(); if (blockLabel.getText() == old_name): blockLabel.labelChanged(new_name) #factoryBlock.blockLabel.widget.setMenu(); if (factoryBlock.blockLabel.getText() == old_name): #print(factoryBlock) factoryBlock.blockLabel.labelChanged(new_name)
def __init__(self, typeId, size, data): Block.__init__(self, typeId, size, data) # TODO bytes 0-3 self.universeSize = read16(data, 4) # Uses all 16 bits? self.density = read16(data, 6) # Uses all 16 bits? self.playerCount = read16(data, 8) # Uses all 16 bits? self.planetCount = read16(data, 10) self.startingDistance = read32(data, 12) # 16 bits? self.gameSettings = read16(data, 16) """ Determined bits of game settings: Max Minerals - 0000000000000001 Slow tech advances - 0000000000000010 Accel. BBS play - 0000000000100000 No random events - 0000000010000000 Computer Alliances - 0000000000010000 Public scores - 0000000001000000 Galaxy Clumping - 0000000100000000 Single player (?) - 0000000000000100 What is bit 4? 0000000000001000 """ # TODO bytes 18-31 self.gameName = str(data[32:64]) # This is a list of planets with their nameId, x, and y coordinates self.planets = [] pass
def buildNodes(self, data): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock if 'block_drawer_sets' in data: block_drawer_sets = data['block_drawer_sets'] for drawerElement in block_drawer_sets: if 'drawer' in drawerElement and 'genus-list' in drawerElement: drawerName = drawerElement['drawer'] node = DrawerSetsTreeNode(self.rootNode, drawerName, False) self.rootNode.children.append(node) member = drawerElement['genus-list'] for genusName in member: newBlock = Block.createBlock(None, genusName, False) if(newBlock == None): continue rb = FactoryRenderableBlock.from_blockID(None, newBlock.blockID,False, QtGui.QColor(255,255,255,0)) sub_node = DrawerSetsTreeNode(node, rb) node.children.append(sub_node)
def scrub_(self, block, code): ''' * Common tasks for generating Python from blocks. * Handles comments for the specified block and any connected value blocks. * Calls any statements following this block. * @param {!Blockly.Block} block The current block. * @param {string} code The Python code created for this block. * @return {string} Python code with comments and subsequent blocks added. * @private ''' from blocks.Block import Block commentCode = ''; nextCode = '' #return code ''' # Only collect comments for blocks that aren't inline. if (not block.outputConnection or not block.outputConnection.targetConnection): # Collect comment for this block. comment = block.getCommentText(); if (comment): commentCode += Blockly.Python.prefixLines(comment, '# ') + '\n'; # Collect comments for all value arguments. # Don't collect comments for nested statements. for x in range(0, len(block.inputList)): if (block.inputList[x].type == Blockly.INPUT_VALUE): childBlock = block.inputList[x].connection.targetBlock(); if (childBlock): comment = Blockly.Python.allNestedComments(childBlock); if (comment): commentCode += Blockly.Python.prefixLines(comment, '# '); ''' nextBlockID = block.getAfterBlockID() if(nextBlockID != None and nextBlockID != -1): nextBlock = Block.getBlock(nextBlockID) #nextBlock = block.nextConnection and block.nextConnection.targetBlock(); nextCode = self.blockToCode(nextBlock); #nextCode = nextCode.ljust(len(code) - len(code.lstrip())) #print(code) #nextCode = self.prefixLines(nextCode, self.INDENT); return commentCode + code + nextCode;
def determineBlockWidth(self): ''' * Overrided from BlockShape. * Determines the width of the sum of the bottom sockets and uses it if it is * greater than the width determined by the determineBlockWidth in BlockShape. * Else, it returns the sum of these two values. ''' # System.out.println("determining block width"); width = BlockShape.determineBlockWidth(self) # if the sum of bottom sockets is greater than the calculated width, then use it bottomSocketWidth = 0 for socket in self.block.getSockets(): if (socket.getPositionType() == BlockConnector.PositionType.BOTTOM ): if (socket.blockID == Block.NULL): # 3 socket spacers = left of socket, between connectors, right of socket bottomSocketWidth += BlockShape.BOTTOM_SOCKET_SIDE_SPACER else: # a block is connected to socket # TODO get their assigned width from rb if (self.rb.getSocketSpaceDimension(socket) != None): bottomSocketWidth += self.rb.getSocketSpaceDimension( socket).width() bottomSocketWidth -= BlockConnectorShape.NORMAL_DATA_PLUG_WIDTH # if it's a mirror plug, subtract for the other side, too. if (Block.getBlock( socket.blockID).getPlug().getPositionType() == BlockConnector.PositionType.MIRROR): bottomSocketWidth -= BlockConnectorShape.NORMAL_DATA_PLUG_WIDTH bottomSocketWidth += 2 * BlockShape.BOTTOM_SOCKET_MIDDLE_SPACER # TODO need to decide for a size of the middle spacer and how to place them bottomSocketWidth += 2 * BlockShape.BOTTOM_SOCKET_SIDE_SPACER if (bottomSocketWidth > width): return (bottomSocketWidth + self.rb.accomodateLabelsWidth()) width += bottomSocketWidth # make sure its even if (width % 2 == 1): width += 1 return width
def createBlock(typeId, size, data): ''' This method will create a block from the typeId ''' className = BLOCKS[typeId] path = "blocks." + className + "." + className block = None try: clazz = import_class(path) block = clazz(typeId, size, data) except: print "Block type not implemented. typeId: %s; Class: %s" % ( str(typeId), className) # Return generic block for now block = Block(typeId, size, data) return block
def scrub_(self, block, code): ''' * Common tasks for generating Python from blocks. * Handles comments for the specified block and any connected value blocks. * Calls any statements following this block. * @param {!Blockly.Block} block The current block. * @param {string} code The Python code created for this block. * @return {string} Python code with comments and subsequent blocks added. * @private ''' from blocks.Block import Block commentCode = '' nextCode = '' #return code ''' # Only collect comments for blocks that aren't inline. if (not block.outputConnection or not block.outputConnection.targetConnection): # Collect comment for this block. comment = block.getCommentText(); if (comment): commentCode += Blockly.Python.prefixLines(comment, '# ') + '\n'; # Collect comments for all value arguments. # Don't collect comments for nested statements. for x in range(0, len(block.inputList)): if (block.inputList[x].type == Blockly.INPUT_VALUE): childBlock = block.inputList[x].connection.targetBlock(); if (childBlock): comment = Blockly.Python.allNestedComments(childBlock); if (comment): commentCode += Blockly.Python.prefixLines(comment, '# '); ''' nextBlockID = block.getAfterBlockID() if (nextBlockID != None and nextBlockID != -1): nextBlock = Block.getBlock(nextBlockID) #nextBlock = block.nextConnection and block.nextConnection.targetBlock(); nextCode = self.blockToCode(nextBlock) #nextCode = nextCode.ljust(len(code) - len(code.lstrip())) #print(code) #nextCode = self.prefixLines(nextCode, self.INDENT); return commentCode + code + nextCode
def buildNodes(self, data): from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock if 'block_drawer_sets' in data: block_drawer_sets = data['block_drawer_sets'] for drawerElement in block_drawer_sets: if 'drawer' in drawerElement and 'genus-list' in drawerElement: drawerName = drawerElement['drawer'] node = DrawerSetsTreeNode(self.rootNode, drawerName, False) self.rootNode.children.append(node) member = drawerElement['genus-list'] for genusName in member: newBlock = Block.createBlock(None, genusName, False) if (newBlock == None): continue rb = FactoryRenderableBlock.from_blockID( None, newBlock.blockID, False, QtGui.QColor(255, 255, 255, 0)) sub_node = DrawerSetsTreeNode(node, rb) node.children.append(sub_node)
def showBlock(self, genus): #from blocks.BlockGenus import BlockGenus from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock if(genus == None): return block = Block.createBlockFromID(None, genus.genusName) child_list = self.wndPreview.findChildren(FactoryRenderableBlock) for i in reversed(range(len(child_list))): child_list[i].deleteLater() factoryRB = FactoryRenderableBlock.from_block(None, block) factoryRB.setParent(self.wndPreview) factoryRB.show() factoryRB.move((self.wndPreview.width() - factoryRB.width())/2, (self.wndPreview.height() - factoryRB.height())/2) pass
def showBlock(self, genus): #from blocks.BlockGenus import BlockGenus from blocks.Block import Block from blocks.FactoryRenderableBlock import FactoryRenderableBlock if (genus == None): return block = Block.createBlockFromID(None, genus.genusName) child_list = self.wndPreview.findChildren(FactoryRenderableBlock) for i in reversed(range(len(child_list))): child_list[i].deleteLater() factoryRB = FactoryRenderableBlock.from_block(None, block) factoryRB.setParent(self.wndPreview) factoryRB.show() factoryRB.move((self.wndPreview.width() - factoryRB.width()) / 2, (self.wndPreview.height() - factoryRB.height()) / 2) pass
def loadBlockDrawerSets(block_drawersets, manager): import json if(block_drawersets == ''): return f=open(block_drawersets) data=json.load(f) if 'block_drawer_sets' in data: block_drawer_sets = data['block_drawer_sets'] for drawerElement in block_drawer_sets: if 'drawer' in drawerElement and 'genus-list' in drawerElement: drawerName = drawerElement['drawer'] canvas = manager.addStaticDrawerNoPos(drawerName, QtGui.QColor(100,100,100,0)); drawerRBs = [] member = drawerElement['genus-list'] for genusName in member: newBlock = Block.createBlock(canvas, genusName, False) if(newBlock == None): continue rb = FactoryRenderableBlock.from_block(canvas, newBlock,False, QtGui.QColor(225,225,225,100)) drawerRBs.append(rb); FactoryRenderableBlock.factoryRBs[genusName] = rb manager.addStaticBlocks(drawerRBs, drawerName) return
def menuEnabled(self): return self.hasComboPopup and Block.getBlock( self.blockID).hasSiblings()
def cloneBlock(myblock, canvas): mygenusname = myblock.getGenusName(); label = myblock.getBlockLabel(); # sometimes the factory block will have an assigned label different # from its genus label. if(myblock.getInitialLabel() != (myblock.getBlockLabel())): # acquire prefix and suffix length from myblock label prefixLength = len(myblock.getLabelPrefix()); suffixLength = len(myblock.getLabelSuffix()); # we need to set the block label without the prefix and suffix attached because those # values are automatically concatenated to the string specified in setBlockLabel. I know its # weird, but its the way block labels were designed. if(prefixLength > 0 or suffixLength > 0): # TODO we could do this outside of this method, even in constructor label = myblock.getBlockLabel() # check genus instance counter and if label unique - change label accordingly # also check if label already has a value at the end, if so update counter to have the max value # TODO ria need to make this smarter # some issues to think about: # - what if they throw out an instance, such as setup2? should the next time they take out # a setup block, should it have setup2 on it? but wouldn't that be confusing? # - when we load up a new project with some instances with numbered labels, how do we keep # track of new instances relative to these old ones? # - the old implementation just iterated through all the instances of a particular genus in the # workspace and compared a possible label to the current labels of that genus. if there wasn't # any current label that matched the possible label, it returned that label. do we want to do this? # is there something more efficient? labelWithIndex = label; # labelWithIndex will have the instance value # initialize value that will be appended to the end of the label if(mygenusname in BlockUtilities.instanceCounter): value = BlockUtilities.instanceCounter[mygenusname]; else: value = 0; # begin check for validation of label # iterate until label is valid while(not BlockUtilities.isLabelValid(myblock, labelWithIndex, canvas)): value +=1; labelWithIndex = labelWithIndex + value; # set valid label and save current instance number BlockUtilities.instanceCounter[mygenusname] = value if(labelWithIndex != (label)): # only set it if the label actually changed... label = labelWithIndex; if(isinstance(myblock,BlockStub)): parent = myblock.getParent(); block = BlockStub(parent.blockID, parent.getGenusName(), parent.getBlockLabel(), myblock.getGenusName()); else: block = Block.createBlock(canvas, myblock.getGenusName(), True, label); # TODO - djwendel - create a copy of the RB properties too, using an RB copy constructor. Don't just use the genus. # RenderableBlock renderable = new RenderableBlock(this.getParentWidget(), block.blockID); renderable = RenderableBlock.from_blockID(canvas, block.blockID); #renderable.initFinished = False #renderable.setZoomLevel(BlockUtilities.zoom); #renderable.redrawFromTop(); #renderable.repaint(); return renderable;
def menuEnabled(self): return self.hasComboPopup and Block.getBlock(self.blockID).hasSiblings()
def createNewInstance(self): rb = BlockUtilities.cloneBlock(Block.getBlock(self.blockID), self.workspace.getActiveCanvas() ) self.child_list.append(rb) rb.factoryRB = self return rb
def connect(self): from blocks.RenderableBlock import RenderableBlock from blocks.BlockLinkChecker import BlockLinkChecker from blocks.BlockConnectorShape import BlockConnectorShape # Make sure to disconnect any connections that are going to be overwritten # by this new connection. For example, if inserting a block between two # others, make sure to break that original link.*/ if (self.socket.hasBlock()): # save the ID of the block previously attached to (in) this # socket. This is used by insertion rules to re-link the replaced # block to the newly-inserted block. self.lastPlugBlockID = self.socket.blockID # break the link between the socket block and the block in that socket plugBlock = Block.getBlock(self.lastPlugBlockID) plugBlockPlug = BlockLinkChecker.getPlugEquivalent(plugBlock) if (plugBlockPlug != None and plugBlockPlug.hasBlock()): socketBlock = Block.getBlock(plugBlockPlug.blockID) link = BlockLink.getBlockLink(plugBlock, socketBlock, plugBlockPlug, self.socket) link.disconnect() # don't tell the block about the disconnect like we would normally do, because # we don't actually want it to have a chance to remove any expandable sockets # since the inserted block will be filling whatever socket was vacated by this # broken link. #NOTIFY WORKSPACE LISTENERS OF DISCONNECTION (not sure if this is great because the connection is immediately replaced) #Workspace.getInstance().notifyListeners(new WorkspaceEvent(RenderableBlock.getRenderableBlock(socketBlock.blockID).getParentWidget(), link, WorkspaceEvent.BLOCKS_DISCONNECTED)); if (self.plug.hasBlock()): # in the case of insertion, breaking the link above will mean that # the plug shouldn't be connected by the time we reach here. This # exception will only be thrown if the plug is connected even # after any insertion-esq links were broken above #throw new RuntimeException("trying to link a plug that's already connected somewhere."); return # actually form the connection self.plug.setConnectorBlockID(self.socketBlockID) self.socket.setConnectorBlockID(self.plugBlockID) # notify renderable block of connection so it can redraw with stretching socketRB = RenderableBlock.getRenderableBlock(self.socketBlockID) socketRB.blockConnected(self.socket, self.plugBlockID) if (self.getLastBlockID() != None and self.getLastBlockID() != Block.NULL and BlockConnectorShape.isCommandConnector(self.getPlug()) and BlockConnectorShape.isCommandConnector(self.getSocket())): top = Block.getBlock(self.getPlugBlockID()) while (top.hasAfterConnector() and top.getAfterConnector().hasBlock()): top = Block.getBlock(top.getAfterBlockID()) bottom = Block.getBlock(self.getLastBlockID()) # For safety: if either the top stack is terminated, or # the bottom stack is not a starter, don't try to force a link if (top == None or bottom == None or not top.hasAfterConnector() or not bottom.hasBeforeConnector()): return link = BlockLink.getBlockLink(top, bottom, top.getAfterConnector(), bottom.getBeforeConnector()) link.connect() if (self.clickSound != None): # System.out.println("playing click sound"); pass
def makeBottomSide(self): ''' * Overrided from BlockShape. * Takes into account the need to resize the dimensions of an infix block for various cases. ''' from blocks.RenderableBlock import RenderableBlock from blocks.BlockShapeUtil import BlockShapeUtil # Reset the maximum X-coordinate so the infix block can resize if you remove blocks within it self.maxX = 0 # start bottom-right self.setEndPoint(self.gpBottom, self.botLeftCorner, self.topLeftCorner, True) #curve down and right BlockShapeUtil.cornerTo(self.gpBottom, self.botLeftCorner, self.botRightCorner, self.blockCornerRadius) # BOTTOM SOCKETS # for each socket in the iterator socketCounter = 0 #need to use this to determine which socket we're on for curSocket in self.block.getSockets(): #if bottom socket if (curSocket.getPositionType() == BlockConnector.PositionType.BOTTOM): # move away from bottom left corner if (socketCounter > 0): self.gpBottom.lineTo( self.gpBottom.currentPosition().x() + BlockShape.BOTTOM_SOCKET_MIDDLE_SPACER, self.gpBottom.currentPosition().y()) else: self.gpBottom.lineTo( self.gpBottom.currentPosition().x() + BlockShape.BOTTOM_SOCKET_SIDE_SPACER, self.gpBottom.currentPosition().y()) # move down so bevel doesn't screw up from connecting infinitely sharp corner # as occurs from a curved port BlockShapeUtil.lineToRelative(self.gpBottom, 0, -0.1) #////////////////////// #//begin drawing socket #////////////////////// if (curSocket.blockID == Block.NULL): # draw first socket - up left side leftSocket = BlockShape.BCS.addDataSocketUp( self.gpBottom, curSocket.type, True) self.rb.updateSocketPoint(curSocket, leftSocket) # System.out.println("socket poitn: "+rb.getSocketPoint(curSocket)); # System.out.println("socket poitn leftsocket: "+leftSocket); # draw left standard empty socket space - top side self.gpBottom.lineTo( self.gpBottom.currentPosition().x() + BlockShape.BOTTOM_SOCKET_SIDE_SPACER, self.gpBottom.currentPosition().y()) #draw first socket - down right side BlockShape.BCS.addDataSocket(self.gpBottom, curSocket.type, False) #rb.updateSocketPoint(curSocket, rightSocket); else: # there is a connected block connectedBlock = Block.getBlock(curSocket.blockID) connectedRBlock = RenderableBlock.getRenderableBlock( curSocket.blockID) if (connectedBlock == None or connectedRBlock == None): continue # calculate and update the new socket point # update the socket point of this cursocket which should now adopt the plug socket point of its # connected block since we're also adopting the left side of its shape # Use coordinates when the zoom level is 1.0 to calculate socket point unzoomX = connectedRBlock.getSocketPixelPoint( connectedBlock.getPlug()).x( ) / connectedRBlock.getZoom() unzoomY = connectedRBlock.getSocketPixelPoint( connectedBlock.getPlug()).y( ) / connectedRBlock.getZoom() connectedBlockSocketPoint = QtCore.QPoint( unzoomX, unzoomY) currentPoint = self.gpBottom.currentPosition() newX = connectedBlockSocketPoint.x() + abs( connectedBlockSocketPoint.x() - currentPoint.x()) newY = connectedBlockSocketPoint.y() + abs( connectedRBlock.getBlockHeight() / connectedRBlock.getZoom() - currentPoint.y()) self.rb.updateSocketPoint(curSocket, QtCore.QPoint(newX, newY)) self.gpBottom.currentPosition().x() connectedBlockShape = RenderableBlock.getRenderableBlock( curSocket.blockID).getBlockShape() #append left side of connected block connectedBlockShape.reformArea() BlockShapeUtil.appendPath( self.gpBottom, connectedBlockShape.getLeftSide(), False) connectedBlockShape.getLeftSide().currentPosition() self.gpBottom.currentPosition().x() # append right side of connected block (more complicated) if (connectedBlock.getNumSockets() == 0 or connectedBlock.isInfix()): # append top side of connected block BlockShapeUtil.appendPath( self.gpBottom, connectedBlockShape.getTopSide(), False) BlockShapeUtil.appendPath( self.gpBottom, connectedBlockShape.getRightSide(), False) else: # iterate through the sockets of the connected block, checking if # it has blocks connected to them self.appendRightSidePath(self.gpBottom, connectedBlock, connectedBlockShape) # Updates the maximum X-coordinate and sets the current point to self.maxX if (self.maxX < self.gpBottom.currentPosition().x()): self.maxX = self.gpBottom.currentPosition().x() self.gpBottom.lineTo(self.maxX, self.gpBottom.currentPosition().y()) # bump down so bevel doesn't screw up BlockShapeUtil.lineToRelative(self.gpBottom, 0, 0.1) # System.out.println("gpbottom starting point: "+gpBottom.currentPosition()); # draw RIGHT to create divider //// if (socketCounter < self.block.getNumSockets() - 1): self.gpBottom.lineTo( #need to add the width of the block label. warning: this assumes that there is only one block label self.gpBottom.currentPosition().x() + BlockShape.BOTTOM_SOCKET_MIDDLE_SPACER + self.rb.accomodateLabelsWidth(), self.gpBottom.currentPosition().y()) else: self.gpBottom.lineTo( self.gpBottom.currentPosition().x() + BlockShape.BOTTOM_SOCKET_SIDE_SPACER, self.gpBottom.currentPosition().y()) socketCounter += 1 #curve right and up BlockShapeUtil.cornerTo(self.gpBottom, self.botRightCorner, self.topRightCorner, self.blockCornerRadius) #end bottom self.setEndPoint(self.gpBottom, self.botRightCorner, self.topRightCorner, False)
def getBlock(self): return Block.getBlock(self.blockID)
def createNewInstance(self): rb = BlockUtilities.cloneBlock(Block.getBlock(self.blockID), self.workspace.getActiveCanvas()) self.child_list.append(rb) rb.factoryRB = self return rb
def connect(self): from blocks.RenderableBlock import RenderableBlock from blocks.BlockLinkChecker import BlockLinkChecker from blocks.BlockConnectorShape import BlockConnectorShape # Make sure to disconnect any connections that are going to be overwritten # by this new connection. For example, if inserting a block between two # others, make sure to break that original link.*/ if (self.socket.hasBlock()): # save the ID of the block previously attached to (in) this # socket. This is used by insertion rules to re-link the replaced # block to the newly-inserted block. self.lastPlugBlockID = self.socket.blockID; # break the link between the socket block and the block in that socket plugBlock = Block.getBlock(self.lastPlugBlockID); plugBlockPlug = BlockLinkChecker.getPlugEquivalent(plugBlock); if (plugBlockPlug != None and plugBlockPlug.hasBlock()): socketBlock = Block.getBlock(plugBlockPlug.blockID); link = BlockLink.getBlockLink(plugBlock, socketBlock, plugBlockPlug, self.socket); link.disconnect(); # don't tell the block about the disconnect like we would normally do, because # we don't actually want it to have a chance to remove any expandable sockets # since the inserted block will be filling whatever socket was vacated by this # broken link. #NOTIFY WORKSPACE LISTENERS OF DISCONNECTION (not sure if this is great because the connection is immediately replaced) #Workspace.getInstance().notifyListeners(new WorkspaceEvent(RenderableBlock.getRenderableBlock(socketBlock.blockID).getParentWidget(), link, WorkspaceEvent.BLOCKS_DISCONNECTED)); if (self.plug.hasBlock()): # in the case of insertion, breaking the link above will mean that # the plug shouldn't be connected by the time we reach here. This # exception will only be thrown if the plug is connected even # after any insertion-esq links were broken above #throw new RuntimeException("trying to link a plug that's already connected somewhere."); return # actually form the connection self.plug.setConnectorBlockID(self.socketBlockID); self.socket.setConnectorBlockID(self.plugBlockID); # notify renderable block of connection so it can redraw with stretching socketRB = RenderableBlock.getRenderableBlock(self.socketBlockID); socketRB.blockConnected(self.socket, self.plugBlockID); if (self.getLastBlockID() != None and self.getLastBlockID() != Block.NULL and BlockConnectorShape.isCommandConnector(self.getPlug()) and BlockConnectorShape.isCommandConnector(self.getSocket())): top = Block.getBlock(self.getPlugBlockID()); while (top.hasAfterConnector() and top.getAfterConnector().hasBlock()): top = Block.getBlock(top.getAfterBlockID()); bottom = Block.getBlock(self.getLastBlockID()); # For safety: if either the top stack is terminated, or # the bottom stack is not a starter, don't try to force a link if (top == None or bottom == None or not top.hasAfterConnector() or not bottom.hasBeforeConnector()): return; link = BlockLink.getBlockLink(top, bottom, top.getAfterConnector(), bottom.getBeforeConnector()); link.connect(); if(self.clickSound != None): # System.out.println("playing click sound"); pass
def from_blockID(cls, workspaceWidget, blockID, isLoading=False,back_color=QtGui.QColor(225,225,225,255)): return FactoryRenderableBlock.from_block(workspaceWidget,Block.getBlock(blockID),False, back_color)