split_rect = wx.Rect(rect.x, rect.y,

rect.width - tab["size"][0] - TAB_BORDER, rect.height)

break

split_tab = tabs.pop(idx)

return {"split": split,

"tab": split_tab,

result = wire.GetConnectedInfos(-1)

else:

result = wire.GetConnectedInfos(0)

refLocalId, formalParameter = result

connections = connection.getconnections()

if connections is None or len(connection.getconnections()) <= idx:

elif isinstance(next, ContinuationClass):

name = next.getname()

computed_value = self.ComputedConnectors.get(name, None)

paths.append(str(computed_value))

else:

connector = None

if transition in self.SFCNetworks["Transitions"].keys():

transition_infos = self.SFCNetworks["Transitions"].pop(transition)

self.Program += [("%sTRANSITION" % self.CurrentIndent, ())]

self.Program += [(" (PRIORITY := ", ()),

("%d" % transition_infos["priority"], (self.TagName, "transition", transition_infos["id"], "priority")),

(")", ())]

if var_name:

program += [(var_name, (self.TagName, variable_type, var_number, "name")),

(" ", ())]

program += [("AT ", ()),

(var_address, (self.TagName, variable_type, var_number, "location")),

(" ", ())]

program += [(": ", ()),

(var_type, (self.TagName, variable_type, var_number, "type"))]

program += [(" := ", ()),

(self.ParentGenerator.ComputeValue(var_initial, var_type), (self.TagName, variable_type, var_number, "initial value"))]

program += [(";\n", ())]

for PDOidx in GetNodePDOIndexes(node, loc_infos["pdotype"]):

values = node.GetEntry(PDOidx)

for subindex, mapping in enumerate(values):

if subindex != 0 and mapping & 0xFFFFFF00 == model:

return PDOidx, subindex

nodeDCF = self.MasterNode.GetEntry(0x1F22, nodeid)

# Extract data and number of params in current DCF

tmpnbparams = [i for i in nodeDCF[:4]]

tmpnbparams.reverse()

nbparams += int(''.join(["%2.2x" % ord(i) for i in tmpnbparams]), 16)

# starting from start_index

while index < PDOTypeBaseIndex[pdotype] + 0x200:

values = self.NodeList.GetSlaveNodeEntry(nodeid, index + 0x200)

# Check that all subindex upper than 0 equal 0 => configurable PDO

if reduce(lambda x, y: x and y, map(lambda x: x == 0, values[1:]), True):

cobid = self.NodeList.GetSlaveNodeEntry(nodeid, index, 1)

# Search if slave has a PDO mapping this locations

result = SearchNodePDOMapping(locationinfos, node)

index, subindex = result

# Get COB ID of the PDO

cobid = self.NodeList.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 1)

# Verify that a not full entry has been found

if mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000:

# Generate subentry name

subindexname = "%(index)d_%(subindex)d_%(bit)d" % variable_infos

else:

subindexname = "%(index)d_%(subindex)d" % variable_infos

# Set value of the PDO mapping

typeinfos = self.Manager.GetEntryInfos(typeidx)

value = (mapvariableidx << 16) + ((nbsubentries) << 8) + typeinfos["size"]

self.MasterNode.SetEntry(current_idx + 0x200, subindex, value)

def open_win_pdf(readerexepath, pdffile, pagenum = None):

os.spawnl(os.P_DETACH, readerexepath, "AcroRd32.exe", "/A", "page=%d=OpenActions" % pagenum, '"%s"' % pdffile)

else:

os.spawnl(os.P_DETACH, readerexepath, "AcroRd32.exe", '"%s"' % pdffile)

def open_lin_pdf(readerexepath, pdffile, pagenum = None):

os.system("%s -remote DS301 %s &" % (readerexepath, pdffile))

else:

print "Open pdf %s at page %d" % (pdffile, pagenum)

mod_type = event.GetModificationType()

if not (mod_type&wx.stc.STC_PERFORMED_UNDO or mod_type&wx.stc.STC_PERFORMED_REDO):

if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

self.StartBuffering()

elif self.CurrentAction[0] != "Add" or self.CurrentAction[1] != event.GetPosition() - 1:

self.Controler.EndBuffering()

self.CurrentAction = ("Add", event.GetPosition())

wx.CallAfter(self.RefreshModel)

elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

self.StartBuffering()

elif self.CurrentAction[0] != "Delete" or self.CurrentAction[1] != event.GetPosition() + 1:

self.Controler.EndBuffering()

self.ParentWindow.RefreshPageTitles()

def ResetBuffer(self):

self.Controler.EndBuffering()

self.CurrentAction = None

self.SetText(new_text)

new_cursor_pos = GetCursorPos(old_text, new_text)

self.LineScroll(column, line)

self.GotoPos(new_cursor_pos)

else:

self.GotoPos(old_cursor_pos)

def DrawLabel(self, dc, width, height, dw=0, dy=0):

bmp = self.bmpLabel

if self.bmpDisabled and not self.IsEnabled():

bmp = self.bmpDisabled

if self.bmpFocus and self.hasFocus:

bw, bh = bmp.GetWidth(), bmp.GetHeight()

if not self.up:

dw = dy = self.labelDelta

else:

bw = bh = 0 # no bitmap -> size is zero

pos_x = (width-bw)/2+dw # adjust for bitmap and text to centre

pos_y = (height-bh-th)/2+dy

dc.DrawBitmap(bmp, pos_x, pos_y, hasMask) # draw bitmap if available

pos_x = (width-tw)/2+dw # adjust for bitmap and text to centre

pos_y += bh + 2

# This method check the IEC 61131-3 compatibility between two SFC blocks

def BlockCompatibility(self, startblock = None, endblock = None, direction = None):

or isinstance(endblock, SFC_Objects)):

# Full "SFC_StandardRules" table would be symmetrical and

# to avoid duplicate records and minimize the table only upper part is defined.

if not self.DisableEvents:

mod_type = event.GetModificationType()

if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

self.StartBuffering()

elif self.CurrentAction[0] != "Add" or self.CurrentAction[1] != event.GetPosition() - 1:

self.Controler.EndBuffering()

self.CurrentAction = ("Add", event.GetPosition())

wx.CallAfter(self.RefreshModel)

elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

self.StartBuffering()

elif self.CurrentAction[0] != "Delete" or self.CurrentAction[1] != event.GetPosition() + 1:

self.Controler.EndBuffering()

self.ParentWindow.RefreshEditMenu()

def ResetBuffer(self):

self.Controler.EndBuffering()

self.CurrentAction = None

self.SetText(new_text)

new_cursor_pos = GetCursorPos(old_text, new_text)

self.Editor.LineScroll(column, line)

self.Editor.GotoPos(new_cursor_pos)

else:

self.Editor.GotoPos(old_cursor_pos)

def ResetCursors():

global CURSORS

CURSORS = [wx.NullCursor,

wx.StockCursor(wx.CURSOR_HAND),

wx.StockCursor(wx.CURSOR_SIZENWSE),

if self.DrawingWire:

connector, errorHighlight = self.FindBlockConnectorWithError(pos, self.SelectedElement.GetConnectionDirection(), self.SelectedElement.EndConnected)

self.SelectedElement.ErrHighlight = errorHighlight;

self.SelectedElement.ResetPoints()

movex, movey = self.SelectedElement.OnMotion(event, dc, self.Scaling)

self.SelectedElement.GeneratePoints()

"name": step.GetName(),

"input": len(connectors["inputs"]) > 0,

"output": len(connectors["outputs"]) > 0,

if dialog.ShowModal() == wx.ID_OK:

values = dialog.GetValues()

rect = step.GetRedrawRect(1, 1)

if segment == -1:

segment = len(self.Segments) - 1

# The selected segment is reinitialised

if self.StartConnected:

self.StartConnected.SetSelected(False)

if self.EndConnected:

# Returns the position of the two selected segment points

def GetSelectedSegmentPoints(self):

return self.Points[self.SelectedSegment:self.SelectedSegment + 2]

return []

# Returns if the selected segment is the first and/or the last of the wire

def GetSelectedSegmentConnections(self):

return self.SelectedSegment == 0, self.SelectedSegment == len(self.Segments) - 1

return (True, True)

#else:

# Test if a segment have been handled

result = self.TestSegment(pos)

if result[1] in (NORTH, SOUTH):

wx.CallAfter(self.Parent.SetCurrentCursor, 4)

elif result[1] in (EAST, WEST):

pos = GetScaledEventPosition(event, dc, scaling)

# Test if a segment has been handled

result = self.TestSegment(pos, True)

self.Handle = (HANDLE_SEGMENT, result)

# Popup the menu with special items for a wire

self.Parent.PopupWireMenu(0 < result[0] < len(self.Segments) - 1)

self.OverEnd = False

# Test if a point has been handled

result = self.TestPoint(pos)

if result == 0 and self.StartConnected is not None:

self.OverStart = True

elif result != 0 and self.EndConnected is not None:

# Forbids to select a power rail

def HitTest(self, pt, connectors=True):

if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

return False

# Forbids to select a power rail

Indicate if rubberband is drawn on viewer

@return: True if rubberband is drawn

"""

def GetCurrentExtent(self):

"""

if type == "connection":

self.Condition = Connector(self, "", "BOOL", wx.Point(0, self.Size[1] / 2), WEST)

else:

condition = ""

self.Condition = condition

self.RefreshConditionSize()

elif self.Type != "connection":

condition = ""

self.Condition = condition

self.RefreshConditionSize()

# Returns if the point given is in the bounding box

def HitTest(self, pt, connectors=True):

# Refresh the divergence bounding box

def RefreshBoundingBox(self):

funcdeclname = Function_decl["name"].strip('*_')

fdc = Function_decl["inputs"][:]

for intype in input_ovrloading_types:

Function_decl["inputs"] = []

for decl_tpl in fdc:

if IsOfType(intype, decl_tpl[1]):

funcdeclin = funcdeclname

for outype in output_types:

decl_tpl = Function_decl["outputs"][0]

Function_decl["outputs"] = [ (decl_tpl[0], outype, decl_tpl[2])]

if funcdeclname_orig.endswith('*'):

# keep a copy of requested idx

self._ResetDebugVariables()

for idx, iectype, force in idxs:

c_type, unpack_func, pack_func = \

TypeTranslator.get(iectype,

(None, None, None))

if expr:

#print >> self.output, "} else { throw(%s); } " % errName

print >> self.output, "}"

print >>self.output, " } finally {"

for stmt in node.else_:

self._stmt(stmt, current_klass)

attr_name = v.attrname

if isinstance(v.expr, ast.Name):

obj = self._name(v.expr, current_klass, return_none_for_module=True)

# XXX TODO: distinguish between module import classes

# and variables. right now, this is a hack to get

# the sys module working.

lineNum = "Unknown"

srcLine = ""

if hasattr(node, "lineno"):

lineNum = node.lineno

srcLine = self.src[min(lineNum, len(self.src))-1]

srcLine = srcLine.replace('\\', '\\\\')

if node.flags == "OP_APPLY":

lower = "null"

upper = "null"

lower = self.expr(node.lower, current_klass)

upper = self.expr(node.upper, current_klass)

return "pyjslib.slice(" + self.expr(node.expr, current_klass) + ", " + lower + ", " + upper + ")"

else:

value = 0

# Only update non-existent properties

result[key] = value

self.properties = result

"extract": ExtractTag,

"generate": GenerateTag,

"initial": lambda: None,

}

if instance is None and elements[parts[0]]["minOccurs"] == 0:

instance = elements[parts[0]]["elmt_type"]["initial"]()

setattr(self, parts[0], instance)

if len(parts) > 1:

instance.setElementValue(parts[1], value)

else:

return False

for name, value in schema.items():

ref_value = reference.get(name, None)

return False

result = CompareSchema(value, ref_value)

if not result: