"""

coor = Utils.scale(coor, reverse=True)

if Actions.TOGGLE_SNAP_TO_GRID.get_active():

coor = (

Utils.align_to_grid(coor[0] + offset_x) - offset_x,

Utils.align_to_grid(coor[1] + offset_y) - offset_y

for ports, has_busses in zip((self.active_sources, self.active_sinks), bussified):

if not ports:

continue

for port in ports:

port.create_shapes()

port.coordinate = {

270: (offset, +self.width),

}[port.connector_direction]

def create_labels(self, cr=None):

"""Create the labels for the signal block."""

markups = [param.format_block_surface_markup()

for param in self.params.values() if (param.hide not in ('all', 'part') or (param.dtype == 'id' and force_show_id))]

else:

params_layout.set_spacing(Constants.LABEL_SEPARATION * Pango.SCALE)

params_layout.set_markup('\n'.join(markups))

self.create_port_labels()

def get_min_height_for_ports(ports):

# If any of the ports are bus ports - make the min height larger

if any([p.dtype == 'bus' for p in ports]):

min_height = 2 * Constants.PORT_BORDER_SEPARATION + sum(

port.height + Constants.PORT_SPACING for port in ports if port.dtype == 'bus'

else:

if ports:

get_min_height_for_ports(self.active_sinks),

get_min_height_for_ports(self.active_sources))

self._surface_layouts_offsets = [

(0, (height - label_height) / 2.0),

]

title_layout.set_width(width * Pango.SCALE)

complexity = utils.flow_graph_complexity.calculate(self.parent)

markups.append(

'<span foreground="#444" size="medium" font_desc="{font}">'

)

comment = self.comment # Returns None if there are no comments

if comment:

for port in self.active_ports():

port_selected = port.what_is_selected(

coor=[a - b for a, b in zip(coor, self.coordinate)],

)

if port_selected:

return port_selected

true for change

"""

type_templates = ' '.join(p.dtype for p in self.params.values()) + ' '

type_param = None

for key, param in self.params.items():

if not param.is_enum():

"""

changed = False

# Concat the nports string from the private nports settings of all ports

# Modify all params whose keys appear in the nports string

for key, param in self.params.items():

if param.is_enum() or param.key not in nports_str:

# fg colors

#################################################################################

HIGHLIGHT_COLOR = get_color('#00FFFF')

BORDER_COLOR = get_color('#616161')

BORDER_COLOR_DISABLED = get_color('#888888')

# port colors

#################################################################################

#################################################################################

#enum_custom { background-color: #EEEEEE; }

"""

# first two components relative to source connector, rest relative to sink connector

self._rel_points = [

rotate((50, 0), source.rotation), # bezier curve control point 1

rotate((-50, 0), sink.rotation), # bezier curve control point 2

rotate((-15, 0), sink.rotation), # bezier curve end

]

self._current_coordinates = None # triggers _make_path()

# make rel_point all relative to source connector

p0 = 0, 0 # x_start - x_pos, y_start - y_pos

p3 = x_e + dx_e1, y_e + dy_e1

p4 = x_e + dx_e2, y_e + dy_e2

p5 = x_e + dx_e3, y_e + dy_e3

self.create_shapes() # triggers _make_path() call below

self._current_port_rotations = port_rotations

if self._current_coordinates != new_coordinates:

self._make_path(cr)

self._current_coordinates = new_coordinates

cr.set_source_rgba(*color2)

cr.rotate(self._arrow_rotation)

cr.rel_move_to(CONNECTOR_ARROW_HEIGHT, 0)

cr.rel_line_to(0, CONNECTOR_ARROW_BASE)

cr.close_path()

cr.fill()

def has_real_sink(self):

return self.sink_port is not self._dummy_port

DummyConnection = Connection.make_cls_with_base(DummyCoreConnection)

editor.open_editor()

except Exception as e:

# Problem launching the editor. Need to select a new editor.

# Reset the editor to force the user to select a new one.

self.parent_platform.config.editor = ''

# calculate the position coordinate

h_adj = scroll_pane.get_hadjustment()

v_adj = scroll_pane.get_vadjustment()

# get the new block

block = self.new_block(key)

block.coordinate = coor

Returns:

the clipboard

"""

blocks = list(self.selected_blocks())

if not blocks:

return None

x_min, y_min = blocks[0].coordinate

for block in blocks:

x, y = block.coordinate

x_min = min(x, x_min)

y_min = min(y, y_min)

connections = list(filter(

lambda c: c.source_block in blocks and c.sink_block in blocks,

self.connections,

block.move((x_off, y_off))

while any(Utils.align_to_grid(block.coordinate) == Utils.align_to_grid(other.coordinate)

for other in self.blocks if other is not block):

# shift all following blocks

x_off += Constants.CANVAS_GRID_SIZE

y_off += Constants.CANVAS_GRID_SIZE

if not blocks:

return

for selected_block in blocks:

x, y = selected_block.coordinate

min_x, min_y = min(min_x, x), min(min_y, y)

# Sanitize delta_coordinate so that blocks don't move to negative coordinate

for selected_block in blocks:

selected_block.move(delta_coordinate)

self.element_moved = True

x += selected_block.width

y += selected_block.height

max_x, max_y = max(max_x, x), max(max_y, y)

# align the blocks as requested

transform = {

Actions.BLOCK_VALIGN_TOP: lambda x, y, w, h: (x, min_y),

Actions.BLOCK_VALIGN_BOTTOM: lambda x, y, w, h: (x, max_y - h),

Actions.BLOCK_HALIGN_LEFT: lambda x, y, w, h: (min_x, y),

Actions.BLOCK_HALIGN_RIGHT: lambda x, y, w, h: (max_x - w, y),

}.get(calling_action, lambda *args: args)

"""

if not any(self.selected_blocks()):

return False

min_x, min_y = max_x, max_y = self.selected_block.coordinate

# rotate each selected block, and find min/max coordinate

for selected_block in self.selected_blocks():

selected_block.rotate(rotation)

x, y = selected_block.coordinate

min_x, min_y = min(min_x, x), min(min_y, y)

max_x, max_y = max(max_x, x), max(max_y, y)

for selected_block in self.selected_blocks():

x, y = selected_block.coordinate

selected_block.coordinate = (x + ctr_x, y + ctr_y)

return True

element.create_labels(cr)

def create_shapes(self):

# until the shape is drawn. The workaround is to draw blocks before connections

for element in filter(lambda x: x.is_block, self._elements_to_draw):

else: # called from a mouse release

if not self.element_moved and (not self.selected_elements or self.drawing_area.ctrl_mask) and not self._new_connection:

# this selection and the last were ports, try to connect them

if self.make_connection():

if selected_port and selected_port.is_source:

selected.remove(selected_port.parent_block)

self.drawing_area.queue_draw()

# update selected ports

if selected_port is not self._new_selected_port:

dX, dY = x - X, y - Y

if Actions.TOGGLE_SNAP_TO_GRID.get_active() or self.drawing_area.mod1_mask:

dX, dY = dX * Constants.CANVAS_GRID_SIZE, dY * Constants.CANVAS_GRID_SIZE

else:

dX, dY = int(round(dX)), int(round(dY))

if dX != 0 or dY != 0:

self.move_selected((dX, dY))

redraw = True

return redraw

def get_extents(self):

show_comments = Actions.TOGGLE_SHOW_BLOCK_COMMENTS.get_active()

def sub_extents():

for element in self._elements_to_draw:

yield element.get_extents()

extent = 10000000, 10000000, 0, 0

cmps = (min, min, max, max)

for sub_extent in sub_extents():

return tuple(extent)

tooltip_lines.extend(' * ' + msg for msg in errors)

return '\n'.join(tooltip_lines)

##################################################

# Truncate helper method

##################################################

def truncate(self, string, style=0):

max_len = max(27 - len(self.name), 3)

if len(string) > max_len:

if style < 0: # Front truncate

elif style == 0: # Center truncate

elif style > 0: # Rear truncate

return string

def pretty_print(self):

display_value = expr_string

return '<span {foreground} font_desc="{font}"><b>{label}:</b> {value}</span>'.format(

label=Utils.encode(self.name), value=display_value)

color = colors.PORT_TYPE_TO_COLOR.get('message')

else:

self._font_color[-1] = 1.0

if self.vlen > 1:

color = tuple(max(c - dark, 0) for c in color)

self._bg_color = color

self._border_color = tuple(max(c - 0.3, 0) for c in color)

self.bounds_from_area(self._area)

self._connector_coordinate = {

180: (0, self.height / 2),

270: (self.height / 2, self.width)

}[self.connector_direction]

label_width, label_height = self.label_layout.get_size()

self.width = 2 * Constants.PORT_LABEL_PADDING + label_width / Pango.SCALE

self._label_layout_offsets = [0, Constants.PORT_LABEL_PADDING]

self.height += self.height % 2 # uneven height