public T Create(string xukLN, string xukNS)
{
//string qname = String.Format("{0}:{1}", xukNS, xukLN);
UglyPrettyName name = new UglyPrettyName(!PrettyFormat ? xukLN : null, PrettyFormat ? xukLN : null);
QualifiedName qname = new QualifiedName(name, xukNS);
Type t = LookupType(qname);
if (t == null)
{
#if DEBUG
Debugger.Break();
#endif
return(null);
}
T obj = Create(t);
TypeAndQNames tt = LookupTypeAndQNames(qname);
DebugFix.Assert(tt != null);
if (tt.Type == null)
{
// not real type of qname => type of first available ancestor in the type inheritance chain.
obj.MissingTypeOriginalXukedName = tt.QName;
}
return(obj);
}
protected void XukOutRegisteredTypes(XmlWriter destination, Uri baseUri, progress.IProgressHandler handler)
{
foreach (TypeAndQNames tp in mRegisteredTypeAndQNames)
{
destination.WriteStartElement(Type_NAME.z(PrettyFormat), XukAble.XUK_NS);
destination.WriteAttributeString(XukLocalName_NAME.z(PrettyFormat), tp.QName.LocalName.z(PrettyFormat));
destination.WriteAttributeString(XukNamespaceUri_NAME.z(PrettyFormat), tp.QName.NamespaceUri);
if (tp.BaseQName != null)
{
DebugFix.Assert(!string.IsNullOrEmpty(tp.BaseQName.LocalName.Pretty) ||
!string.IsNullOrEmpty(tp.BaseQName.LocalName.Ugly));
destination.WriteAttributeString(BaseXukLocalName_NAME.z(PrettyFormat), tp.BaseQName.LocalName.z(PrettyFormat));
destination.WriteAttributeString(BaseXukNamespaceUri_NAME.z(PrettyFormat), tp.BaseQName.NamespaceUri);
}
if (tp.Type != null)
{
tp.AssemblyName = tp.Type.Assembly.GetName();
tp.ClassName = tp.Type.FullName;
}
if (tp.AssemblyName != null)
{
destination.WriteAttributeString(AssemblyName_NAME.z(PrettyFormat), tp.AssemblyName.Name);
destination.WriteAttributeString(AssemblyVersion_NAME.z(PrettyFormat), tp.AssemblyName.Version.ToString());
}
if (tp.ClassName != null)
{
destination.WriteAttributeString(FullName_NAME.z(PrettyFormat), tp.ClassName);
}
destination.WriteEndElement();
}
}
public static string GetXukFilePath(string outputDirectory, string bookFilePath, string title, bool isSpine)
{
string extension = Path.GetExtension(bookFilePath);
string croppedFileName = Path.GetFileNameWithoutExtension(bookFilePath);
if (croppedFileName.Length > 12)
{
croppedFileName = croppedFileName.Substring(0, 12);
}
croppedFileName = croppedFileName + extension;
string xukFileName = (isSpine ? @"_" : "")
+ croppedFileName.Replace('.', '_')
+ (!string.IsNullOrEmpty(title)
? "-" //"["
+ CleanupTitle(title, 12)
//+ "]"
: "")
+ (isSpine ? OpenXukAction.XUK_SPINE_EXTENSION : OpenXukAction.XUK_EXTENSION);
#if DEBUG
DebugFix.Assert(xukFileName.Length <= (1 + 12 + 6 + 1 + 12 + 9));
DebugFix.Assert(outputDirectory.Length + xukFileName.Length <= 250);
#endif
return(Path.Combine(outputDirectory, xukFileName));
}
private void handleMetaData(string rootFilePath, Project project, XmlNode mdNode, string name, string content, string id)
{
if (RequestCancellation)
{
return;
}
if (isUniqueIdName(name))
{
if (m_PackageUniqueIdAttr != null &&
id != null &&
id == m_PackageUniqueIdAttr.Value)
{
DebugFix.Assert(String.IsNullOrEmpty(m_PublicationUniqueIdentifier));
//String.Format("The Publication's Unique Identifier is specified several times !! OLD: [{0}], NEW: [{1}]", m_PublicationUniqueIdentifier, content)
m_PublicationUniqueIdentifier = content;
m_PublicationUniqueIdentifierNode = mdNode;
Presentation presentation = project.Presentations.Get(0);
foreach (Metadata md in presentation.Metadatas.ContentsAs_ListCopy)
{
if (RequestCancellation)
{
return;
}
if (isUniqueIdName(md.NameContentAttribute.Name) &&
md.NameContentAttribute.Value == m_PublicationUniqueIdentifier)
{
presentation.Metadatas.Remove(md);
}
}
}
else if (!metadataUidValueAlreadyExists(project, content) &&
(String.IsNullOrEmpty(m_PublicationUniqueIdentifier) || content != m_PublicationUniqueIdentifier))
{
Metadata meta = addMetadata(rootFilePath, project, name, content, mdNode);
}
}
else
{
MetadataDefinition md = SupportedMetadata_Z39862005.DefinitionSet.GetMetadataDefinition(name);
if (
(md == null && !metadataNameContentAlreadyExists(project, name, content)) ||
(md != null && md.IsRepeatable && !metadataNameContentAlreadyExists(project, name, content)) ||
(md != null && !md.IsRepeatable && !metadataNameAlreadyExists(project, name))
)
{
if (name != "dtb:totalTime" &&
name != "dtb:totalElapsedTime" &&
name != "media:duration" &&
name != "cover"
)
{
Metadata meta = addMetadata(rootFilePath, project, name, content, mdNode);
}
}
}
}
private void OnNoAudioContentFoundByFlowDocumentParserEvent(TreeNode treeNode)
{
DebugFix.Assert(treeNode.NeedsAudio());
DebugFix.Assert(!treeNode.HasOrInheritsAudio());
if (Tobi.Common.Settings.Default.ValidMissingAudioElements_Enable && isTreeNodeValidNoAudio(treeNode))
{
return;
}
foreach (var valItem in ValidationItems)
{
// ensure no duplicates
if (valItem is MissingAudioValidationError && ((MissingAudioValidationError)valItem).Target == treeNode)
{
return;
}
}
var error = new MissingAudioValidationError(m_Session)
{
Target = treeNode,
Validator = this
};
addValidationItem(error);
}
public static string GetXukFilePath_SpineItem(string outputDirectory, string relativeFilePath, string title, int index)
{
relativeFilePath = FileDataProvider.EliminateForbiddenFileNameCharacters(relativeFilePath);
string extension = Path.GetExtension(relativeFilePath);
string croppedFileName = Path.GetFileNameWithoutExtension(relativeFilePath);
if (croppedFileName.Length > 12)
{
croppedFileName = croppedFileName.Substring(0, 12);
}
croppedFileName = croppedFileName + extension;
if (index >= 0)
{
croppedFileName = "_" + index + "_" + croppedFileName;
}
string xukFileName =
croppedFileName.Replace('.', '_')
+ (!string.IsNullOrEmpty(title)
? "-" //"["
+ CleanupTitle(title, 12)
//+ "]"
: "")
+ OpenXukAction.XUK_EXTENSION;
#if DEBUG
DebugFix.Assert(xukFileName.Length <= (1 + 12 + 6 + 1 + 12 + 4));
DebugFix.Assert(outputDirectory.Length + xukFileName.Length <= 250);
#endif
return(Path.Combine(outputDirectory, xukFileName));
}
public static TimeSpan ConvertFromLocalUnitsToTimeSpan(long timeInLocalUnits)
{
if (timeInLocalUnits == long.MaxValue)
{
return(TimeSpan.MaxValue);
}
if (timeInLocalUnits == long.MinValue)
{
return(TimeSpan.MinValue);
}
if (timeInLocalUnits == 0)
{
return(TimeSpan.Zero);
}
double timeMillisecondsDecimal = (double)timeInLocalUnits / TIME_UNIT;
int decimalPlaces = TIME_UNIT == 1 ? 0 : TIME_UNIT == 1000 ? 3 : TIME_UNIT == 1000000 ? 6 : 7;
DebugFix.Assert(decimalPlaces != 7);
timeMillisecondsDecimal = Math.Round(timeMillisecondsDecimal, decimalPlaces, MidpointRounding.AwayFromZero);
double ticksDecimal = timeMillisecondsDecimal * TimeSpan.TicksPerMillisecond;
long ticksIntegral =
(long)
(AudioLibPCMFormat.USE_ROUND_NOT_TRUNCATE ? Math.Round(ticksDecimal) : Math.Truncate(ticksDecimal));
// checking whether we are loosing fractions of milliseconds
/////DebugFix.Assert(ticksDecimal == (double)ticksIntegral);
return(TimeSpan.FromTicks(ticksIntegral));
}
public Time(string stringRepresentation)
{
double timeMillisecondsDecimal = ParseToMilliseconds(stringRepresentation);
int decimalPlaces = TIME_UNIT == 1 ? 0 : TIME_UNIT == 1000 ? 3 : TIME_UNIT == 1000000 ? 6 : 7;
DebugFix.Assert(decimalPlaces != 7);
timeMillisecondsDecimal = Math.Round(timeMillisecondsDecimal, decimalPlaces, MidpointRounding.AwayFromZero);
#if DEBUG
try
{
TimeSpan timeSpan = TimeSpan.Parse(stringRepresentation);
DebugFix.Assert(Math.Abs(timeSpan.TotalMilliseconds - timeMillisecondsDecimal) <= AudioLibPCMFormat.MILLISECONDS_TOLERANCE);
}
catch (FormatException ex)
{
; // we can safely ignore
}
#endif //DEBUG
double timeAsLocalUnitsDecimal = timeMillisecondsDecimal * TIME_UNIT;
long timeAsLocalUnitsIntegral = (long)(AudioLibPCMFormat.USE_ROUND_NOT_TRUNCATE ? Math.Round(timeAsLocalUnitsDecimal) : Math.Truncate(timeAsLocalUnitsDecimal));
#if DEBUG
// checking whether we are loosing fractions (of localunits) greater than 0.1
DebugFix.Assert(((int)Math.Truncate((timeAsLocalUnitsDecimal - timeAsLocalUnitsIntegral) * 10)) <= 1);
#endif //DEBUG
AsLocalUnits = timeAsLocalUnitsIntegral;
}
private bool _validate() //IEnumerable<urakawa.metadata.Metadata> metadatas)
{
bool isValid = true;
string name = m_Session.DocumentProject.Presentations.Get(0).RootNode.GetXmlElementLocalName();
bool isHTML = @"body".EndsWith(name, StringComparison.OrdinalIgnoreCase);
#if DEBUG
bool isXukSpine = @"spine".EndsWith(name, StringComparison.OrdinalIgnoreCase);
DebugFix.Assert(isXukSpine == m_Session.IsXukSpine);
if (isHTML)
{
//DebugFix.Assert(m_Session.HasXukSpine); too early
}
#endif
if (!isHTML && !m_Session.IsXukSpine)
{
//validate each item by itself
foreach (
urakawa.metadata.Metadata metadata in
m_Session.DocumentProject.Presentations.Get(0).Metadatas.ContentsAs_Enumerable)
{
if (!_validateItem(metadata))
{
isValid = false;
}
}
bool val = _validateAsSet();
isValid = isValid && val; //metadatas);
}
return(isValid);
}
private void HandleConfigurationErrorsException(ConfigurationErrorsException ex)
{
#if DEBUG
Debugger.Break();
#endif
string filename = ex.Filename;
if (string.IsNullOrEmpty(filename) &&
ex.InnerException != null &&
ex.InnerException is ConfigurationErrorsException)
{
filename = ((ConfigurationErrorsException)ex.InnerException).Filename;
}
if (filename != null && File.Exists(filename))
{
File.Delete(filename);
}
string directory = Path.GetDirectoryName(filename);
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal);
string settingsPath = Path.GetDirectoryName(config.FilePath);
Shell.ExecuteShellProcess_(settingsPath);
DebugFix.Assert(directory == settingsPath);
Settings.Default.Reset();
//Settings.Default.Reload();
//Settings.Default.Upgrade();
}
private long computeByteOffset(TreeNode targetNode1, TreeNode targetNode2)
{
long byteOffset = 0;
if (State.Audio.PlayStreamMarkers != null && targetNode2 != null)
{
ManagedAudioMedia mediaInPlayMarkers = targetNode2.GetManagedAudioMedia();
if (mediaInPlayMarkers == null)
{
TreeNode prev = targetNode2.GetPreviousSiblingWithManagedAudio();
if (prev != null && prev.IsDescendantOf(targetNode1))
{
ManagedAudioMedia prevAudio = prev.GetManagedAudioMedia();
DebugFix.Assert(prevAudio != null);
byteOffset = getByteOffset(prev, prevAudio);
if (prevAudio != null)
{
byteOffset += prevAudio.AudioMediaData.PCMFormat.Data.ConvertTimeToBytes(prevAudio.AudioMediaData.AudioDuration.AsLocalUnits);
}
}
}
else
{
byteOffset = getByteOffset(targetNode2, mediaInPlayMarkers);
}
}
return(byteOffset);
}
private Stream SetPlayStream_FromTreeNode_OPEN(Stream stream)
{
if (stream != null)
{
stream.Position = 0;
stream.Seek(0, SeekOrigin.Begin);
Tuple <TreeNode, TreeNode> treeNodeSelection = m_viewModel.m_UrakawaSession.GetTreeNodeSelection();
if (treeNodeSelection.Item1 != null)
{
DebugFix.Assert(treeNodeSelection.Item1.Presentation.MediaDataManager.EnforceSinglePCMFormat);
PcmFormat = treeNodeSelection.Item1.Presentation.MediaDataManager.DefaultPCMFormat;
}
else if (m_viewModel.m_UrakawaSession != null && m_viewModel.m_UrakawaSession.DocumentProject != null)
{
DebugFix.Assert(m_viewModel.m_UrakawaSession.DocumentProject.Presentations.Get(0).MediaDataManager.EnforceSinglePCMFormat);
PcmFormat = m_viewModel.m_UrakawaSession.DocumentProject.Presentations.Get(0).MediaDataManager.DefaultPCMFormat;
}
else
{
PcmFormat = null;
Debug.Fail("This should never happen !!");
}
DataLength = stream.Length;
EndOffsetOfPlayStream = DataLength;
}
return(stream);
}
private Stream SetPlayStream_FromFile_OPEN(
FileStream fileStream,
string filePathOptionalInfo)
{
Stream stream = fileStream;
if (stream != null)
{
stream.Position = 0;
stream.Seek(0, SeekOrigin.Begin);
uint dataLength;
AudioLibPCMFormat format = AudioLibPCMFormat.RiffHeaderParse(stream, out dataLength);
PcmFormat = new PCMFormatInfo(format);
dataLength = (uint)(stream.Length - stream.Position);
stream = new SubStream(stream, stream.Position, dataLength, filePathOptionalInfo);
DebugFix.Assert(dataLength == stream.Length);
DataLength = stream.Length;
EndOffsetOfPlayStream = DataLength;
}
return(stream);
}
static FileDataProvider()
{
string str1 = @"C:/dir/file.txt";
string str2 = @"C:/dir/../dir/file.txt";
string str3 = @"C:/dir/./file.txt";
string str4 = @"C:/dir/../dir/./file.txt";
string str5 = @"C:/dir/subdir/../file.txt";
string str6 = @"C:/dir/subdir/./../file.txt";
string str7 = @"C:/dir/subdir/.././file.txt";
string p1 = NormaliseFullFilePath(str1);
string p2 = NormaliseFullFilePath(str2);
string p3 = NormaliseFullFilePath(str3);
string p4 = NormaliseFullFilePath(str4);
string p5 = NormaliseFullFilePath(str5);
string p6 = NormaliseFullFilePath(str6);
string p7 = NormaliseFullFilePath(str7);
DebugFix.Assert(p1 == p2);
DebugFix.Assert(p2 == p3);
DebugFix.Assert(p3 == p4);
DebugFix.Assert(p4 == p5);
DebugFix.Assert(p5 == p6);
DebugFix.Assert(p6 == p7);
str1 = str1.Replace('/', '\\');
str2 = str2.Replace('/', '\\');
str3 = str3.Replace('/', '\\');
str4 = str4.Replace('/', '\\');
str5 = str5.Replace('/', '\\');
str6 = str6.Replace('/', '\\');
str7 = str7.Replace('/', '\\');
p1 = NormaliseFullFilePath(str1);
p2 = NormaliseFullFilePath(str2);
p3 = NormaliseFullFilePath(str3);
p4 = NormaliseFullFilePath(str4);
p5 = NormaliseFullFilePath(str5);
p6 = NormaliseFullFilePath(str6);
p7 = NormaliseFullFilePath(str7);
DebugFix.Assert(p1 == p2);
DebugFix.Assert(p2 == p3);
DebugFix.Assert(p3 == p4);
DebugFix.Assert(p4 == p5);
DebugFix.Assert(p5 == p6);
DebugFix.Assert(p6 == p7);
string pp1 = NormaliseFullFilePath(@"C:/dir/subdir/");
string pp2 = NormaliseFullFilePath(@"C:/dir/subdir");
DebugFix.Assert(pp1 == pp2);
string pp3 = NormaliseFullFilePath(@"\\\\network-share/dir\\subdir/");
string pp4 = NormaliseFullFilePath(@"//network-share\\dir/subdir");
DebugFix.Assert(pp3 == pp4);
}
private static bool IsRunning64()
{
bool is64 = IntPtr.Size == 8;
#if NET40
DebugFix.Assert(is64 == Environment.Is64BitProcess);
#endif
return(is64); //4 in x86 / 32 bits arch
}
private static void NotifyScreenReaderAutomation(AutomationPeer automationPeer, string str)
{
if (automationPeer == null)
{
return;
}
if (!AutomationInteropProvider.ClientsAreListening)
{
return;
}
// if (AutomationPeer.ListenerExists(AutomationEvents.AutomationFocusChanged))
// {
// automationPeer.RaiseAutomationEvent(AutomationEvents.AutomationFocusChanged);
//#if DEBUG
// Console.WriteLine("AUTOMATION EVENT ==> AutomationFocusChanged");
//#endif //DEBUG
// }
// if (AutomationPeer.ListenerExists(AutomationEvents.TextPatternOnTextSelectionChanged))
// {
// automationPeer.RaiseAutomationEvent(AutomationEvents.TextPatternOnTextSelectionChanged);
//#if DEBUG
// Console.WriteLine("AUTOMATION EVENT ==> TextPatternOnTextSelectionChanged");
//#endif //DEBUG
// }
//automationPeer.InvalidatePeer();
//AutomationEventArgs args = new AutomationEventArgs(InvokePatternIdentifiers.InvokedEvent);
//AutomationInteropProvider.RaiseAutomationEvent(InvokePatternIdentifiers.InvokedEvent, this, args);
//AutomationProperties.NameProperty
try
{
#if DEBUG
var autoProp = AutomationProperty.LookupById(AutomationElementIdentifiers.NameProperty.Id);
DebugFix.Assert(AutomationElementIdentifiers.NameProperty == autoProp);
#endif //DEBUG
automationPeer.RaisePropertyChangedEvent(AutomationElementIdentifiers.NameProperty, "", str);
}
catch (Exception e)
{
#if DEBUG
Console.WriteLine("Exception automationPeer.RaisePropertyChangedEvent");
Debugger.Break();
#endif //DEBUG
}
}
private void OnClick_ButtonClearText_Specific(string diagramElementName)
{
AlternateContent altContent = m_ViewModel.GetAltContent(diagramElementName);
DebugFix.Assert(altContent != null);
DescriptionsListView.SelectedItem = altContent;
DebugFix.Assert(DescriptionsListView.SelectedItem == altContent);
OnClick_ButtonClearText(null, null);
}
private void verifyTreeNodeSelection()
{
if (m_TreeNode == null)
{
DebugFix.Assert(m_SubTreeNode == null);
return;
}
TreeNode nodeAncestorAudio = m_TreeNode.GetFirstAncestorWithManagedAudio();
#if ENABLE_SEQ_MEDIA
bool nodeHasDirectAudio = m_TreeNode.GetManagedAudioMediaOrSequenceMedia() != null;
#else
bool nodeHasDirectAudio = m_TreeNode.GetManagedAudioMedia() != null;
#endif
TreeNode nodeDescendantAudio = m_TreeNode.GetFirstDescendantWithManagedAudio();
DebugFix.Assert(nodeAncestorAudio == null);
if (nodeHasDirectAudio)
{
DebugFix.Assert(nodeDescendantAudio == null);
DebugFix.Assert(m_SubTreeNode == null);
}
if (nodeDescendantAudio != null)
{
DebugFix.Assert(!nodeHasDirectAudio);
}
if (m_SubTreeNode == null)
{
DebugFix.Assert(nodeDescendantAudio == null);
}
else
{
DebugFix.Assert(m_TreeNode.IsAncestorOf(m_SubTreeNode)); // nodes cannot be equal
TreeNode subnodeAncestorAudio = m_SubTreeNode.GetFirstAncestorWithManagedAudio();
#if ENABLE_SEQ_MEDIA
bool subnodeHasDirectAudio = m_SubTreeNode.GetManagedAudioMediaOrSequenceMedia() != null;
#else
bool subnodeHasDirectAudio = m_SubTreeNode.GetManagedAudioMedia() != null;
#endif
TreeNode subnodeDescendantAudio = m_SubTreeNode.GetFirstDescendantWithManagedAudio();
DebugFix.Assert(subnodeAncestorAudio == null);
DebugFix.Assert(subnodeDescendantAudio == null);
}
}
private void SetCulture(string str)
{
DebugFix.Assert(CultureInfo.CurrentCulture.Equals(Thread.CurrentThread.CurrentCulture));
DebugFix.Assert(CultureInfo.CurrentUICulture.Equals(Thread.CurrentThread.CurrentUICulture));
//var c1 = CultureInfo.CurrentCulture;
//var c2 = CultureInfo.CurrentUICulture;
//DebugFix.Assert(c1.Equals(c2));
if (str == "en")
{
str = "en-GB";
}
if (str == "fr")
{
str = "fr-FR";
}
var c3 = CultureInfo.GetCultureInfoByIetfLanguageTag(str);
var c4 = CultureInfo.GetCultureInfo(str);
DebugFix.Assert(c3.Equals(c4));
var c5 = new CultureInfo(str);
DebugFix.Assert(c3.Equals(c5));
//if (!c4.IsNeutralCulture)
//{
// Thread.CurrentThread.CurrentCulture = c4;
//}
Thread.CurrentThread.CurrentUICulture = c4;
//DebugFix.Assert(Thread.CurrentThread.CurrentUICulture.Equals(Thread.CurrentThread.CurrentCulture));
str = CultureInfo.CurrentCulture.TwoLetterISOLanguageName;
str = CultureInfo.CurrentCulture.ThreeLetterWindowsLanguageName;
str = CultureInfo.CurrentCulture.ThreeLetterISOLanguageName;
str = CultureInfo.CurrentCulture.NativeName;
str = CultureInfo.CurrentCulture.Name;
str = CultureInfo.CurrentCulture.IetfLanguageTag;
str = CultureInfo.CurrentCulture.EnglishName;
str = CultureInfo.CurrentCulture.DisplayName;
str = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
str = CultureInfo.CurrentUICulture.ThreeLetterWindowsLanguageName;
str = CultureInfo.CurrentUICulture.ThreeLetterISOLanguageName;
str = CultureInfo.CurrentUICulture.NativeName;
str = CultureInfo.CurrentUICulture.Name;
str = CultureInfo.CurrentUICulture.IetfLanguageTag;
str = CultureInfo.CurrentUICulture.EnglishName;
str = CultureInfo.CurrentUICulture.DisplayName;
}
/// <summary>
/// Gets Operating System Architecture. This does not tell you if the program in running in
/// 32- or 64-bit mode or if the CPU is 64-bit capable. It tells you whether the actual Operating
/// System is 32- or 64-bit.
/// </summary>
/// <returns>Int containing 32 or 64 representing the number of bits in the OS Architecture</returns>
private static int getOSArchitectureLegacy()
{
string pa = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
int bits = ((String.IsNullOrEmpty(pa) || String.Compare(pa, 0, "x86", 0, 3, true) == 0) ? 32 : 64);
#if NET40
DebugFix.Assert((bits == 64) == Environment.Is64BitOperatingSystem);
#endif
return(bits);
}
public static string GetXukNamespace(Type type)
{
Attribute attribute = Attribute.GetCustomAttribute(
type,
typeof(XukNamespaceAttribute));
DebugFix.Assert(attribute != null);
return(attribute == null ? string.Empty
: ((XukNamespaceAttribute)attribute).Namespace);
}
protected void XukInRegisteredType(XmlReader source)
{
if (Type_NAME.Match(source.LocalName) &&
source.NamespaceURI == XukAble.XUK_NS)
{
TypeAndQNames tq = new TypeAndQNames();
readTypeAndQNamesFromXmlReader(tq, source, PrettyFormat);
if (tq.Type == null)
{
#if DEBUG
Debugger.Break();
#endif
RegisterType(tq);
}
else
{
TypeAndQNames tq_ = RegisterType(tq.Type);
DebugFix.Assert(tq_.AssemblyName.Name == tq.AssemblyName.Name);
//DebugFix.Assert(tq_.AssemblyName.Version == tq.AssemblyName.Version);
DebugFix.Assert(tq_.ClassName == tq.ClassName);
DebugFix.Assert(tq_.Type == tq.Type);
DebugFix.Assert(tq_.QName.NamespaceUri == tq.QName.NamespaceUri);
DebugFix.Assert(tq_.QName.LocalName.Ugly == tq.QName.LocalName.Ugly);
DebugFix.Assert(tq_.QName.LocalName.Pretty == tq.QName.LocalName.Pretty);
if (tq_.BaseQName != null && tq.BaseQName != null)
{
DebugFix.Assert(tq_.BaseQName.NamespaceUri == tq.BaseQName.NamespaceUri);
if (!String.IsNullOrEmpty(tq.BaseQName.LocalName.Ugly))
{
DebugFix.Assert(tq_.BaseQName.LocalName.Ugly == tq.BaseQName.LocalName.Ugly);
}
if (!String.IsNullOrEmpty(tq.BaseQName.LocalName.Pretty))
{
DebugFix.Assert(tq_.BaseQName.LocalName.Pretty == tq.BaseQName.LocalName.Pretty);
}
}
}
}
if (!source.IsEmptyElement)
{
source.ReadSubtree().Close();
}
}
public bool NeedsAudio()
{
if (HasXmlProperty)
{
string localName = GetXmlElementLocalName();
bool isMath = localName.Equals("math", //DiagramContentModelHelper.Math
StringComparison.OrdinalIgnoreCase);
bool isSVG = localName.Equals("svg", //DiagramContentModelHelper.Svg
StringComparison.OrdinalIgnoreCase);
if (!isMath &&
GetXmlNamespaceUri() == "http://www.w3.org/1998/Math/MathML"
//DiagramContentModelHelper.NS_URL_MATHML
)
{
return(false);
}
if (!isSVG &&
GetXmlNamespaceUri() == "http://www.w3.org/2000/svg"
//DiagramContentModelHelper.NS_URL_SVG
)
{
return(false);
}
if (localName.Equals("img", StringComparison.OrdinalIgnoreCase) ||
localName.Equals("video", StringComparison.OrdinalIgnoreCase) ||
isMath ||
isSVG
)
{
//if (!isMath && !isSVG)
//{
// DebugFix.Assert(Children.Count == 0);
//}
return(true);
}
}
if (GetTextMedia() != null &&
!TextOnlyContainsPunctuation(GetTextFlattened_()))
{
DebugFix.Assert(Children.Count == 0);
return(true);
}
return(false);
}
public void Init(TreeNodeAndStreamSelection selection, TreeNode currentTreeNode)
{
if (selection == null)
{
throw new ArgumentNullException("selection");
}
if (selection.m_TreeNode == null)
{
throw new ArgumentNullException("selection.m_TreeNode");
}
if (currentTreeNode == null)
{
throw new ArgumentNullException("currentTreeNode");
}
//TreeNode = selection.m_TreeNode;
CurrentTreeNode = currentTreeNode;
SelectionData = selection;
//DebugFix.Assert(m_SelectionData.m_TreeNode == TreeNode);
ShortDescription = "Delete audio portion";
LongDescription = "Delete a portion of audio for a given treenode";
ManagedAudioMedia manMedia = m_SelectionData.m_TreeNode.GetManagedAudioMedia();
if (manMedia == null)
{
throw new NullReferenceException("m_SelectionData.m_TreeNode.GetManagedAudioMedia()");
}
OriginalManagedAudioMedia = manMedia.Copy();
m_UsedMediaData.Add(OriginalManagedAudioMedia.AudioMediaData);
#if DEBUG
DebugFix.Assert(manMedia.Duration.IsEqualTo(OriginalManagedAudioMedia.Duration));
#endif //DEBUG
ChannelsProperty chProp = m_SelectionData.m_TreeNode.GetChannelsProperty();
foreach (Channel ch in chProp.UsedChannels)
{
if (manMedia == chProp.GetMedia(ch))
{
ChannelOfOriginalMedia = ch;
break;
}
}
DebugFix.Assert(ChannelOfOriginalMedia != null);
DebugFix.Assert(ChannelOfOriginalMedia is AudioChannel);
}
public ManagedAudioMedia GetManagedAudioMedia()
{
AbstractAudioMedia media = GetAudioMedia();
if (media != null &&
media is ManagedAudioMedia &&
((ManagedAudioMedia)media).IsWavAudioMediaData)
{
DebugFix.Assert(((ManagedAudioMedia)media).HasActualAudioMediaData);
return(media as ManagedAudioMedia);
}
return(null);
}
public void VerifyTree(TreeNode rootNode)
{
if (!rootNode.Presentation.ChannelsManager.HasAudioChannel ||
SourceChannel != rootNode.Presentation.ChannelsManager.GetOrCreateAudioChannel())
{
throw new Exception("The verification routine for the 'publish visitor' only works when the SourceChannel is the default audio channel of the Presentation !");
}
DebugFix.Assert(m_RootNode == null);
DebugFix.Assert(m_TransientWavFileStream == null);
DebugFix.Assert(m_TransientWavFileStreamRiffOffset == 0);
verifyTree(rootNode, false, null);
}
public static string GetNodeXml_Flat(TreeNode node)
{
if (node == null)
{
return("");
}
string nodeName = GetTreeNodeName(node);
string text = GetTreeNodeTextExcerpt(node);
string str1 = @"<";
string str2 = @">";
string str3 = @"/>";
string str4 = @"</";
int capacity = string.IsNullOrEmpty(nodeName) ? text.Length
: (nodeName.Length +
(text.Length == 0 ?
str1.Length + str3.Length
: str1.Length + str2.Length + text.Length + nodeName.Length + str4.Length + str2.Length
)
);
StringBuilder strBuilder = new StringBuilder(capacity);
if (string.IsNullOrEmpty(nodeName))
{
strBuilder.Append(text);
}
else
{
strBuilder.Append(str1);
if (text.Length == 0)
{
strBuilder.Append(nodeName);
strBuilder.Append(str3);
}
else
{
strBuilder.Append(nodeName);
strBuilder.Append(str2);
strBuilder.Append(text);
strBuilder.Append(str4);
strBuilder.Append(nodeName);
strBuilder.Append(str2);
}
}
DebugFix.Assert(strBuilder.Length == capacity);
return(strBuilder.ToString());
}
public static UglyPrettyName GetXukName(Type type)
{
Attribute attribute = Attribute.GetCustomAttribute(
type,
typeof(XukNameUglyPrettyAttribute));
DebugFix.Assert(attribute != null);
if (attribute == null)
{
return(null);
}
return(((XukNameUglyPrettyAttribute)attribute).Name);
}
private void OnUndoRedoManagerChanged_TextNodeStructureEditCommand(UndoRedoManagerEventArgs eventt, bool done, TextNodeStructureEditCommand command, bool isTransactionEndEvent, bool isNoTransactionOrTrailingEdge)
{
DebugFix.Assert(command is TreeNodeInsertCommand || command is TreeNodeRemoveCommand);
//TreeNode node = (command is TreeNodeInsertCommand) ? ((TreeNodeInsertCommand)command).TreeNode : ((TreeNodeRemoveCommand)command).TreeNode;
TreeNode node = command.TreeNode;
bool forceInvalidate = (command is TreeNodeInsertCommand && !done) || (command is TreeNodeRemoveCommand && done);
InvalidatePages(forceInvalidate, node);
bool done_ = (command is TreeNodeInsertCommand) ? !done : done;
checkTreeNodeFragmentRemoval(done_, node);
}
public InputSource ResolveEntity(string name, string publicId, string baseUri, string systemId)
{
string dtdUniqueResourceId;
Stream dtdStream = LocalXmlUrlResolver.mapUri(new Uri(systemId, UriKind.Absolute), out dtdUniqueResourceId);
if (!string.IsNullOrEmpty(dtdUniqueResourceId))
{
DebugFix.Assert(dtdStream != null);
TextReader txtReader = new StreamReader(dtdStream, Encoding.UTF8);
return(new InputSource <TextReader>(txtReader, systemId));
//return new InputSource<Stream>(dtdStream, systemId);
}
return(null);
}
