def deserialize(self,
source,
prefixes=None,
strict=False,
as_attribute=None,
as_list=None,
as_attribute_of_element=None):
if isinstance(source, basestring):
try:
if os.path.exists(source):
xtr = XmlTextReader(StreamReader(source))
except ValueError:
xtr = XmlTextReader(StringReader(source))
else:
xtr = XmlTextReader(StringReader(source))
elif hasattr(source, 'read'):
xtr = XmlTextReader(StringReader(source.read()))
settings = XmlReaderSettings()
settings.ProhibitDtd = True
reader = XmlReader.Create(xtr, settings)
document = Document()
document.as_attribute = as_attribute or {}
document.as_list = as_list or {}
document.as_attribute_of_element = as_attribute_of_element or {}
self._deserialize(reader, document)
xtr.Close()
reader.Close()
return document
def makeAnimation(top):
xamlStr = """
<Storyboard xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<DoubleAnimationUsingKeyFrames>
<EasingDoubleKeyFrame KeyTime="0:0:0.2" Value="{0}">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseOut"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
<EasingDoubleKeyFrame KeyTime="0:0:0.4" Value="{1}">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseIn"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
<EasingDoubleKeyFrame KeyTime="0:0:0.6" Value="{2}">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseOut"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
<EasingDoubleKeyFrame KeyTime="0:0:0.8" Value="{3}">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseIn"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
</DoubleAnimationUsingKeyFrames>
</Storyboard>
""".format(top - 30, top, top - 30, top)
sr = StringReader(xamlStr)
sb = XamlServices.Load(sr)
sr.Dispose()
Storyboard.SetTarget(sb.Children[0], harriet.Window.Window)
Storyboard.SetTargetProperty(sb.Children[0], PropertyPath("Top"))
return sb
def GetLinesFromText(text):
reader = StringReader(text)
lines = []
try:
line = reader.ReadLine()
while line is not None:
lines.append(line)
line = reader.ReadLine()
finally:
reader.Dispose()
return lines
def _handle_empty_fragment(self, fragment):
xtr = XmlTextReader(StringReader(str(fragment) + '/>'))
reader = XmlReader.Create(xtr, self.settings)
while reader.Read():
node_type = reader.NodeType
if node_type == XmlNodeType.Element:
return self.handle_start_element(reader)
def __init__(self, xaml):
self._xaml = xaml
xr = XmlReader.Create(StringReader(xaml))
self.winLoad = XamlReader.Load(xr)
self._button = self.winLoad.FindName('button')
self._stakpanel = self.winLoad.FindName('stackPanel')
self._button.Click += self.onClick
def Parse(self, data, isfinal=False):
self._data.append(data)
if isfinal:
data = "".join(self._data)
self._data = None
reader = StringReader(data)
self._parse(reader)
def __deserialize_from_xml(file_full_name):
iaddin_custom_frame_instance = None
try:
filereader = None
try:
filereader = File.OpenText(file_full_name)
if filereader:
content = filereader.ReadToEnd()
stringreader = StringReader(content)
xmlreader = None
try:
xmlreader = XmlReader.Create(stringreader)
if xmlreader:
iaddin_custom_frame_instance = XamlReader.Load(
xmlreader)
finally:
if xmlreader:
xmlreader.Dispose()
xmlreader = None
finally:
if filereader:
filereader.Dispose()
filereader = None
except Exception as e:
CommonUtil.sprint("Failed to desrialize: {}".format(e))
iaddin_custom_frame_instance = None
return iaddin_custom_frame_instance
def __init__(self, xaml):
self._xaml = xaml
xr = XmlReader.Create(StringReader(self._xaml))
self.winLoad = wpf.LoadComponent(self, xr)
#self._comboBox = self.winLoad.FindName('_comboBox') # not necessary with wpf IronPython Module Wpf
for x in range(1, 10):
self._comboBox.Items.Add("Item " + str(x))
def __init__(self, overlay: OverlayWindow):
self.overlay = overlay
self.window = XamlReader.Load(
XmlReader.Create(StringReader(SettingsXaml)))
self.InitializeComponent()
self.LoadConfig()
def ExecuteExpr(self, expr_str, moduleEO):
f = StringReader(expr_str)
ASTs = parser.ParseExpr(f)
self.dbgASTs = ASTs
scope = etgen.AnalysisScope(
None, #parent
"__snippet__",
self,
Exprs.Expression.Parameter(Sympl, "symplRuntime"),
Exprs.Expression.Parameter(ExpandoObject, "fileModule"))
self.dbgascope = scope
body = [
Exprs.Expression.Convert(etgen.AnalyzeExpr(ASTs, scope), object)
]
#body = [etgen.AnalyzeExpr(ASTs, scope)]
self.dbgbody = body
ftype = Exprs.Expression.GetFuncType(
System.Array[System.Type]([Sympl, ExpandoObject, object]))
## Due to .NET 4.0 co/contra-variance, IPy's binding isn't picking
## the overload with just IEnumerable<Expr>, so pick it explicitly.
body = Exprs.Expression.Block.Overloads[IEnumerable[Exprs.Expression]](
body)
fun = Exprs.Expression.Lambda(ftype, body, scope.RuntimeExpr,
scope.ModuleExpr)
dbgmodfun = fun
return fun.Compile()(self, moduleEO)
def makeEndAnimation():
xamlStr = """
<Storyboard xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<DoubleAnimationUsingKeyFrames>
<DiscreteDoubleKeyFrame KeyTime="0" Value="1"/>
<EasingDoubleKeyFrame KeyTime="0:0:0.15" Value="1.2">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseOut"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
<EasingDoubleKeyFrame KeyTime="0:0:0.3" Value="1.0">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseIn"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
</DoubleAnimationUsingKeyFrames>
<DoubleAnimationUsingKeyFrames>
<DiscreteDoubleKeyFrame KeyTime="0" Value="1"/>
<EasingDoubleKeyFrame KeyTime="0:0:0.15" Value="0.84">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseOut"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
<EasingDoubleKeyFrame KeyTime="0:0:0.3" Value="1.0">
<EasingDoubleKeyFrame.EasingFunction>
<QuadraticEase EasingMode="EaseIn"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
</DoubleAnimationUsingKeyFrames>
</Storyboard>
"""
sr = StringReader(xamlStr)
sb = XamlServices.Load(sr)
sr.Dispose()
#FIXME: 入れる先が用意されてないのでダメ
Storyboard.SetTarget(sb.Children[0], harriet.Character)
Storyboard.SetTarget(sb.Children[1], harriet.Character)
Storyboard.SetTargetProperty(
sb.Children[0], PropertyPath("RenderTransform.Children[2].ScaleX"))
Storyboard.SetTargetProperty(
sb.Children[1], PropertyPath("RenderTransform.Children[2].ScaleY"))
return sb
def ReadLinesFromText(text):
lines = []
with StringReader(text) as reader:
line = reader.ReadLine()
while line is not None:
lines.append(line)
line = reader.ReadLine()
return lines
def _getStoryboardAppliedToWindowProperty(xamlStr, propertyPath):
with StringReader(xamlStr) as sr:
sb = XamlServices.Load(sr)
Storyboard.SetTarget(sb.Children[0], harriet.Window.Window)
Storyboard.SetTargetProperty(sb.Children[0], PropertyPath(propertyPath))
return sb
def __init__(self):
self.ui = wpf.LoadComponent(self, StringReader(MyForm.LAYOUT))
collElems = FilteredElementCollector(
doc, doc.ActiveView.Id).OfClass(FamilyInstance).ToElements()
collElems = sorted(collElems, key=lambda x: x.Name)
for e in collElems:
item = System.Windows.Controls.ListBoxItem()
item.Content = e.Name
item.Tag = e.Id
self.ui.listBox1.Items.Add(item)
def test_external_assemblies(self):
import clr
clr.AddReferenceByPartialName('System.Xml')
from System.IO import StringReader
from System.Xml import XmlReader
buffer = StringReader("<foo>test</foo>")
xml = XmlReader.Create(buffer)
xml.ReadStartElement("foo")
assert xml.ReadString() == 'test'
xml.ReadEndElement()
def _parse(self, data):
settings = XmlReaderSettings(ProhibitDtd=False)
reader = XmlReader.Create(StringReader(data), settings)
self._reader = reader
while reader.Read():
nodetype = reader.NodeType
typename = Enum.GetName(XmlNodeType, nodetype)
handler = getattr(self, '_handle_' + typename, None)
if handler is not None:
handler()
def __init__(self, xaml_file, literal_string=False):
self.Parent = self
if not literal_string:
if not op.exists(xaml_file):
# noinspection PyUnresolvedReferences
wpf.LoadComponent(self, os.path.join(__commandpath__, xaml_file))
else:
wpf.LoadComponent(self, xaml_file)
else:
wpf.LoadComponent(self, StringReader(xaml_file))
def __init__(self, title, default=None, description=None):
self.selected = None
self.ui = wpf.LoadComponent(self, StringReader(TextInput.LAYOUT))
# self.ui = wpf.LoadComponent(self, os.path.join(cwd, 'form_text_input.xaml'))
self.ui.Title = title
if default is not None:
self.ui.text_box.Text = default
if description is not None:
self.ui.selection_label.Content = description
self.ui.button_select.Click += self.select_click
def __init__(self):
self.window = XamlReader.Load(
XmlReader.Create(StringReader(OverlayXaml)))
self.console = Console()
self.InitializeComponent()
self.LoadConfig()
self.settings = SettingsWindow(self)
self.Run()
def __init__(self, title, options, description=None): self.selected = None self.ui = wpf.LoadComponent(self, StringReader(DropdownInput.LAYOUT)) self.ui.Title = title if description is not None: self.ui.selection_label.Content = description self.ui.button_select.Click += self.select_click self.ui.combo_data.Items.Clear() self.ui.combo_data.ItemsSource = options self.ui.combo_data.SelectedItem = options[0]
def __init__(self, title, options, description=None):
# TODO: Validate options type, and handle dictionary input
# So user can feed a list or a dictionary
self.selected = None
self.ui = wpf.LoadComponent(self, StringReader(SelectFromList.LAYOUT))
# self.ui = wpf.LoadComponent(self, os.path.join(cwd, 'form_select_list.xaml'))
self.ui.Title = title
if description is not None:
self.ui.selection_label.Content = description
self.ui.button_select.Click += self.select_click
self.ui.combo_data.Items.Clear()
self.ui.combo_data.ItemsSource = options
self.ui.combo_data.SelectedItem = options[0]
def _makeFadeStoryboard(start, end, duration):
xamlStr = """
<Storyboard xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<DoubleAnimation From="{0:.2f}" To="{1:.2f}" Duration="0:0:{2:.2f}" />
</Storyboard>
""".format(start, end, duration)
with StringReader(xamlStr) as sr:
sb = XamlServices.Load(sr)
Storyboard.SetTarget(sb.Children[0], harriet.Window.Window)
Storyboard.SetTargetProperty(sb.Children[0],
PropertyPath("(UIElement.Opacity)"))
return sb
def ImportEnv():
#read each line from the file
file = open(EnvironmentData, "r")
contents = file.read()
reader = CsvReader(StringReader(contents), False)
reader.SkipEmptyLines = False
rows = []
while reader.ReadNextRecord():
row = []
colCount = reader.FieldCount
for i in range(colCount):
row.append(reader[i])
rows.append(row)
file.close()
global envAsList
envAsList = rows[0]
return envAsList
def close(self):
"""Parse the XML from the internal buffer to build an
element tree.
:return:
the root element of the XML document
:rtype:
:class:`xml.etree.ElementTree.ElementTree`
"""
xml_string = "".join(self._buffer)
self._buffer = None
reader = XmlReader.Create(StringReader(xml_string), self.settings)
# figure out which encoding to use
next = reader.Read()
document_encoding = (
reader.GetAttribute("encoding") if next
and reader.NodeType == XmlNodeType.XmlDeclaration else None)
if document_encoding:
self.__log.info(
"parsed document encoding %r from XML declaration",
document_encoding)
else:
document_encoding = "UTF-8"
self.__log.warn(
"document encoding is missing! assuming default %r",
document_encoding)
while next:
if reader.IsStartElement():
self._start_element(reader)
elif reader.NodeType in [XmlNodeType.Text, XmlNodeType.CDATA]:
# decode the value first to work around IronPython quirk
self._target.data(reader.Value.decode(document_encoding))
elif reader.NodeType == XmlNodeType.EndElement:
self._target.end(reader.LocalName)
next = reader.Read()
return self._target.close()
def __init__(self, xml):
self._xml = xml
self.Sources = List[String]()
self.Video = True
self.Loop = True
self.Autoplay = True
self.Volume = .5
self.Width = 300
self.Height = 150
self.Poster = ""
self.Controls = True
self.Autobuffer = True
self.Muted = False
reader = XmlReader.Create(StringReader(self._xml))
while (reader.Read()):
if reader.Name == "video":
self.Video = reader.ReadElementContentAsBoolean()
elif reader.Name == "width":
self.Width = reader.ReadElementContentAsDouble()
elif reader.Name == "height":
self.Height = reader.ReadElementContentAsDouble()
elif reader.Name == "autoplay":
self.Autoplay = reader.ReadElementContentAsString()
elif reader.Name == "volume":
self.Volume = reader.ReadElementContentAsDouble()
elif reader.Name == "poster":
self.Poster = reader.ReadElementContentAsString()
elif reader.Name == "loop":
self.Loop = reader.ReadElementContentAsBoolean()
elif reader.Name == "controls":
self.Controls = reader.ReadElementContentAsBoolean()
elif reader.Name == "autobuffer":
self.Autobuffer = reader.ReadElementContentAsBoolean()
elif reader.Name == "muted":
self.Muted = reader.ReadElementContentAsBoolean()
elif reader.Name == "sources":
item = None
while (reader.Read()):
if reader.Name == "source":
item = reader.ReadElementContentAsString()
self.Sources.Add(item)
def getOpacityMaskAndStoryboard(duration):
xamlStr = """
<Rectangle xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="10" Height="10">
<Rectangle.Resources>
<Storyboard x:Key="Appear">
<DoubleAnimationUsingKeyFrames Storyboard.TargetProperty="(GradientBrush.GradientStops)[0].(GradientStop.Offset)"
Storyboard.TargetName="OpacityBrush">
<EasingDoubleKeyFrame KeyTime="0:0:0" Value="-0.1"/>
<EasingDoubleKeyFrame KeyTime="0:0:{0}" Value="1">
<EasingDoubleKeyFrame.EasingFunction>
<CubicEase EasingMode="EaseInOut"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
</DoubleAnimationUsingKeyFrames>
<DoubleAnimationUsingKeyFrames Storyboard.TargetProperty="(GradientBrush.GradientStops)[1].(GradientStop.Offset)"
Storyboard.TargetName="OpacityBrush">
<EasingDoubleKeyFrame KeyTime="0:0:0" Value="0"/>
<EasingDoubleKeyFrame KeyTime="0:0:{0}" Value="1.1">
<EasingDoubleKeyFrame.EasingFunction>
<CubicEase EasingMode="EaseInOut"/>
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
</DoubleAnimationUsingKeyFrames>
</Storyboard>
</Rectangle.Resources>
<Rectangle.OpacityMask>
<LinearGradientBrush x:Name="OpacityBrush" EndPoint="0.5,1" StartPoint="0.5,0">
<GradientStop Offset="0" Color="Black" />
<GradientStop Offset="0" Color="Transparent" />
</LinearGradientBrush>
</Rectangle.OpacityMask>
</Rectangle>
""".format(duration)
with StringReader(xamlStr) as sr:
rect = XamlServices.Load(sr)
sb = rect.TryFindResource("Appear")
opMask = rect.OpacityMask
return opMask, sb
def close(self):
"""Parse the XML from the internal buffer to build an
element tree.
Returns
-------
:class:`xml.etree.ElementTree.ElementTree`
The root element of the XML document
"""
xml_string = "".join(self._buffer)
self._buffer = None
reader = XmlReader.Create(StringReader(xml_string), self.settings)
while reader.Read():
if reader.IsStartElement():
self._start_element(reader)
elif reader.NodeType in [XmlNodeType.Text, XmlNodeType.CDATA]:
self._target.data(reader.Value.decode(self._document_encoding))
elif reader.NodeType == XmlNodeType.EndElement:
self._target.end(reader.Name)
elif reader.NodeType == XmlNodeType.XmlDeclaration:
self._parse_xml_declaration(reader.Value)
return self._target.close()
def GetReader(self):
return SourceCodeReader(StringReader(self.text), Encoding.GetEncoding(0))
def _deserialize(cls, type, xml):
if NilClasses.CanDeserialize(xml):
raise DeserializeFailedError
else:
return type.Serializer.Deserialize(StringReader(xml))
print "\n" * 3
print "Enter expressions. Enter blank line to abort input."
print "Enter 'exit (the symbol) to exit."
print "\n"
while True:
print prompt,
input = Console.ReadLine()
if (input == ""):
exprstr = ""
prompt = ">>> "
continue
else:
exprstr = exprstr + " " + input
## See if we have complete input.
try:
sympl.parser.ParseExpr(StringReader(exprstr))
except Exception, e:
prompt = "... "
continue
## We do, so execute.
try:
res = s.ExecuteExpr(exprstr, feo)
exprstr = ""
prompt = ">>> "
if res is s.MakeSymbol("exit"): break
print res
except Exception, e:
exprstr = ""
prompt = ">>> "
Console.Write("ERROR: ")
Console.WriteLine(e)
def _ironparse(source):
# internal event generator. takes a TextReader subclass, a file-
# like object, or a filename, and generates an event stream. use
# the parse() and iterparse() adapters to access this from user-
# code.
if isinstance(source, TextReader):
pass # use as is
elif hasattr(source, "read"):
# FIXME: implement TextReader wrapper for Python I/O objects
source = StringReader(source.read())
# FIXME: handle settings here? (disable comments, etc)
reader = XmlReader.Create(source)
# tag cache
tags = {}
namespaces = []
def gettag():
key = reader.NamespaceURI, reader.LocalName
try:
tag = tags[key]
except KeyError:
if key[0]:
tag = "{%s}%s" % key
else:
tag = key[1]
tags[key] = tag
return tag
while reader.Read():
node = reader.NodeType
if node == START:
tag = gettag()
attrib = {}
ns = 0 # count namespace declarations
while reader.MoveToNextAttribute():
if reader.LocalName == "xmlns":
ns += 1 # default namespace
yield "start-ns", ("", reader.Value)
elif reader.Prefix == "xmlns":
ns += 1 # prefixed namespace
yield "start-ns", (reader.LocalName, reader.Value)
else:
attrib[gettag()] = reader.Value
namespaces.append(ns)
reader.MoveToElement()
yield "start", tag, attrib
if reader.IsEmptyElement:
yield "end", tag
for i in xrange(namespaces.pop()):
yield "end-ns", None
elif node == END:
yield "end", tags[reader.NamespaceURI, reader.LocalName]
for i in xrange(namespaces.pop()):
yield "end-ns", None
elif node == DATA_TEXT or node == DATA_SPACE or node == DATA_CDATA:
yield "data", reader.Value
else:
pass # yield "unknown", node
reader.Close()