return weak_value

class Element(object):

def __init__(self, parent=None):

block.is_valid = lambda: False

block.get_enabled = lambda: False

for param_n in block_n.get('param', []):

param = block.parent_platform.Param(block=block, n=new_param_n)

def _dummy_block_add_port(block, key, dir):

_Block.__init__(self, flow_graph, n)

self.states.update(_coordinate=(0, 0), _rotation=0)

Element.__init__(self) # needs the states and initial sizes

self._surface_layouts = [

coor: the coordinate tuple (x, y)

"""

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

)

self.states['_coordinate'] = coor

"""

Get the rotation from the position param.

"""

return self.states['_rotation']

"""

Set the rotation into the position param.

self.clear()

if self.is_horizontal():

elif self.is_vertical():

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

if not ports:

continue

for index, port in enumerate(ports):

port.create_shapes()

port.set_coordinate({

}[port.get_connector_direction()])

port.connector_length = Constants.CONNECTOR_EXTENSION_MINIMAL + \

Constants.CONNECTOR_EXTENSION_INCREMENT * index

def get_min_height_for_ports():

min_height = 2 * PORT_BORDER_SEPARATION + len(ports) * PORT_SEPARATION

if ports:

return min_height

height = max(

[ # labels

] +

[ # bus ports only

2 * PORT_BORDER_SEPARATION +

for ports in (self.get_sources_gui(), self.get_sinks_gui())

]

)

self._surface_layout_offsets = [

(width - label_width) / 2.0,

max_width = 0

for port in ports:

port.create_labels()

for port in ports:

def create_comment_layout(self):

markups = []

"""

bg_color = self._bg_color

border_color = (

Colors.MISSING_BLOCK_BORDER_COLOR if self.is_dummy_block else

Colors.BORDER_COLOR

)

# title and params label

if self.is_vertical():

cr.rotate(-math.pi / 2)

cr.translate(*self._surface_layout_offsets)

for layout in self._surface_layouts:

x, y = self.get_coordinate()

if self.is_horizontal():

else:

cr.save()

cr.translate(x, y)

from __future__ import absolute_import

from .Constants import CONNECTOR_ARROW_BASE, CONNECTOR_ARROW_HEIGHT

from .Element import Element

from ..core.Connection import Connection as _Connection

def __init__(self, **kwargs):

Element.__init__(self)

_Connection.__init__(self, **kwargs)

self._sink_rot = self._source_rot = None

self._sink_coor = self._source_coor = None

def get_coordinate(self):

return self.source_port.get_connector_coordinate()

"""

Get the 0 degree rotation.

Rotations are irrelevant in connection.

connector_length = self.source_port.connector_length

except:

return # todo: why?

#get the sink coordinate

connector_length = self.sink_port.connector_length + CONNECTOR_ARROW_HEIGHT

#build the arrow

self.arrow = [(0, 0),

]

source_domain = self.source_port.domain

sink_domain = self.sink_port.domain

points, alt = alt, points

# create 3-line connector

i1, i2 = points

else:

# 2 possible points to create a right-angled connector

point, alt = [(x1, y2), (x2, y1)]

if Utils.get_angle_from_coordinates(point, p1) == source_dir:

point, alt = alt, point

# create right-angled connector

def draw(self, widget, cr):

"""

sink = self.sink_port

source = self.source_port

#check for changes

self.create_shapes()

elif self._sink_coor != sink.parent_block.get_coordinate() or self._source_coor != source.parent_block.get_coordinate():

self._update_after_move()

self._source_coor = source.parent_block.get_coordinate()

# draw

color1, color2 = (

Colors.CONNECTION_DISABLED_COLOR if not self.get_enabled() else

color for color in (self._color, self._color2))

from __future__ import absolute_import

from .Constants import LINE_SELECT_SENSITIVITY

from six.moves import zip

"""

Make a new list of rectangular areas and lines, and set the coordinate and the rotation.

"""

self.set_coordinate((0, 0))

self.highlighted = False

def is_horizontal(self, rotation=None):

"""

Returns:

true if rotation is horizontal

"""

return rotation in (0, 180)

def is_vertical(self, rotation=None):

Returns:

true if rotation is vertical

"""

return rotation in (90, 270)

def create_labels(self):

"""

X, Y = self.get_coordinate()

cr.translate(X, Y)

# aX = X + rX

# aY = Y + rY

cr.set_source_rgb(*bg_color)

cr.stroke()

cr.set_source_rgb(*border_color)

cr.move_to(*line[0])

for point in line[1:]:

cr.line_to(*point)

Args:

rotation: multiple of 90 degrees

"""

def set_coordinate(self, coor):

"""

"""

self.coor = coor

def get_coordinate(self):

"""Get the coordinate.

"""

deltaX, deltaY = delta_coor

X, Y = self.get_coordinate()

def what_is_selected(self, coor, coor_m=None):

"""

if coor_m:

x_m, y_m = [a-b for a,b in zip(coor_m, self.get_coordinate())]

#handle rectangular areas

if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \

in_between(x1+w, x, x_m) and in_between(y1, y, y_m) or \

in_between(x1, x, x_m) and in_between(y1+h, y, y_m) or \

in_between(x1+w, x, x_m) and in_between(y1+h, y, y_m):

return self

#handle horizontal or vertical lines

last_point = line[0]

for x2, y2 in line[1:]:

(x1, y1), last_point = last_point, (x2, y2)

return None

else:

#handle rectangular areas

if in_between(x, x1, x1+w) and in_between(y, y1, y1+h): return self

#handle horizontal or vertical lines

last_point = line[0]

for x2, y2 in line[1:]:

(x1, y1), last_point = last_point, (x2, y2)

if in_between(x, x1, x2) and in_between(y, y1, y2): return self

return None

def mouse_over(self):

pass

#get the new block

block = self.new_block(key)

block.set_coordinate(coor)

block.get_param('id').set_value(id)

Actions.ELEMENT_CREATE()

return id

for selected_block in blocks:

x, y = selected_block.get_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)

ctr_x, ctr_y = (max_x + min_x)/2, (max_y + min_y)/2

for selected_block in blocks:

x, y = selected_block.get_coordinate()

selected_block.set_coordinate(transform(x, y, w, h))

return True

w, h = initial

for block in self.blocks:

x, y = block.get_coordinate()

return w, h

from . import Actions, Colors, Utils, Constants

from .Element import Element

from ..core.Port import Port as _Port

self._bg_color = (0, 0, 0)

self._line_width_factor = 1.0

self.connector_length = 0

self.label_layout = Gtk.DrawingArea().create_pango_layout('')

self.label_layout.set_alignment(Pango.Alignment.CENTER)

@property

self.label_layout.set_width(value * Pango.SCALE)

def _get_color(self):

self.clear()

if self.is_horizontal():

elif self.is_vertical():

self._connector_coordinate = {

}[self.get_connector_direction()]

def create_labels(self):

))

label_width, label_height = self.label_layout.get_pixel_size()

if self.get_type() == 'bus':

def draw(self, widget, cr, border_color, bg_color):

"""

if self.is_vertical():

cr.rotate(-math.pi / 2)

cr.translate(0, Constants.PORT_LABEL_PADDING)

PangoCairo.update_layout(cr, self.label_layout)

the direction in degrees

"""

if self.is_source:

elif self.is_sink:

def rotate(self, direction):

"""

"""

self.parent.rotate(direction)

"""

Args:

"""

def _label_hidden(self):

"""