def OnMethodGen(obj, meth):

def OnMethod(evt):

if obj.CTR is not None:

wx.CallAfter(self.RefreshStatusToolBar)

return OnMethod

newid = wx.NewId()

return "Project"

def CTNTestModified(self):

def CTNFullName(self):

return ""

# Do generate

code = generator()

if code is None:

code_path = os.path.join(buildpath, filename)

open(code_path, "w").write(code)

# Insert this file as first file to be compiled at root confnode

# will be set in reverse order

buttons = self.ContextualButtons[:]

if direction in [wx.TOP, wx.LEFT]:

# Set contextual menu buttons position aside rect depending on

# direction given

(SIMULTANEOUS_CONVERGENCE, _('Simultaneous Convergence'))]

poss_div_btns = []

if poss_div_types is not None:

else:

poss_div_btns = divergence_buttons

self.TypeRadioButtons = {}

comment.Draw(dc)

for wire in self.Wires.iterkeys():

if wire != self.SelectedElement and (wire.IsVisible() or printing):

wire.Draw(dc)

if self.Debug:

for wire in self.Wires.iterkeys():

def SetType(self, type, condition=None):

if self.Type != type:

if self.Type == "connection":

self.Type = type

if type == "connection":

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

def fileBaseOf(filename, withPath=0):

def mkdir(directory):

def unixpath(thePath):

# -----------------------------------------------------------------------------

pyjs.path.append(abspath(d))

if options.platforms:

# this is mostly for getting boilerplate stuff

data_dir = os.path.abspath(options.data_dir)

if importName == '__pyjamas__': # special module to help make pyjamas modules loadable in the python interpreter

pass

elif importName.endswith('.js'):

else:

elif isinstance(child, ast.From):

if child.modname == '__pyjamas__': # special module to help make pyjamas modules loadable in the python interpreter

pass

elif isinstance(child, ast.Global):

self._global(child, None)

elif isinstance(child, ast.Printnl):

elif isinstance(child, ast.Print):

elif isinstance(child, ast.TryExcept):

self._tryExcept(child, None)

elif isinstance(child, ast.Raise):

elif isinstance(node, ast.Function):

self._function(node, True)

elif isinstance(node, ast.Printnl):

elif isinstance(node, ast.Print):

elif isinstance(node, ast.TryExcept):

self._tryExcept(node, current_klass)

elif isinstance(node, ast.Raise):

tnode = ast.Assign([ast.AssName(tempvar, "OP_ASSIGN", node.lineno)], node.expr, node.lineno)

self._assign(tnode, current_klass, top_level)

for v in node.nodes:

return

local_var_names = None

debugStmt = self.debug and not self._isNativeFunc(node)

if debugStmt and isinstance(node.expr.node, ast.Name) and \

node.expr.node.name == 'import_wait':

if debugStmt:

st = self.get_line_trace(node)

print >>self.output, "sys.addstack('%s');\n" % st

def _mod(self, node, current_klass):

if isinstance(node.left, ast.Const) and isinstance(node.left.value, StringType):

return self.expr(node.left, current_klass) + " % " + self.expr(node.right, current_klass)

def _invert(self, node, current_klass):

print >> app_code, self._translate(

module_name, is_app, debug=debug, imported_js=imported_js)

for js in imported_js:

return lib_code.getvalue(), app_code.getvalue()

# Get all xsd toolchains

for toolchainname, xsdfilename in toolchains.iteritems():

# Get all xsd targets

for targetname, nfo in targets.iteritems():

def endlog(self):

if self.endlock.acquire(False):

if not self.outt.finished and self.kill_it:

self.finishsem.release()

def spin(self):

raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

elif facettype == "whiteSpace":

if basevalue == "collapse" and value in ["preserve", "replace"] or basevalue == "replace" and value == "preserve":

elif facettype == "totalDigits":

if facets.has_key("fractionDigits") and value <= facets["fractionDigits"][0]:

raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")