public void SetDescriptionImage(AlternateContent altContent, string fullPath)
{
Tuple <TreeNode, TreeNode> selection = m_UrakawaSession.GetTreeNodeSelection();
TreeNode node = selection.Item2 ?? selection.Item1;
if (node == null)
{
return;
}
var altProp = node.GetAlternateContentProperty();
if (altProp == null)
{
return;
}
if (altProp.AlternateContents.IndexOf(altContent) < 0)
{
return;
}
if (string.IsNullOrEmpty(fullPath))
{
if (altContent.Image != null)
{
AlternateContentRemoveManagedMediaCommand cmd1 =
node.Presentation.CommandFactory.CreateAlternateContentRemoveManagedMediaCommand(node, altContent,
altContent.Image);
node.Presentation.UndoRedoManager.Execute(cmd1);
}
}
else if (File.Exists(fullPath))
{
string extension = Path.GetExtension(fullPath);
if (string.IsNullOrEmpty(extension))
{
return;
}
ManagedImageMedia img1 = node.Presentation.MediaFactory.CreateManagedImageMedia();
ImageMediaData imgData1 = node.Presentation.MediaDataFactory.CreateImageMediaData(extension);
if (imgData1 == null)
{
return;
}
imgData1.InitializeImage(fullPath, Path.GetFileName(fullPath));
img1.ImageMediaData = imgData1;
AlternateContentSetManagedMediaCommand cmd22 =
node.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(node, altContent, img1);
node.Presentation.UndoRedoManager.Execute(cmd22);
}
RaisePropertyChanged(() => Descriptions);
}
protected override void XukInChild(XmlReader source, IProgressHandler handler)
{
bool readItem = false;
if (source.NamespaceURI == XukAble.XUK_NS)
{
readItem = true;
if (source.LocalName == XukStrings.Metadatas)
{
XukInMetadata(source, handler);
}
else if (XukAble.GetXukName(typeof(TextMedia)).Match(source.LocalName))
{
if (m_Text != null)
{
throw new exception.XukException("AlternateContent Text XukIn, already set !");
}
m_Text = Presentation.MediaFactory.CreateTextMedia();
m_Text.XukIn(source, handler);
}
else if (XukAble.GetXukName(typeof(ManagedAudioMedia)).Match(source.LocalName))
{
if (m_Audio != null)
{
throw new exception.XukException("AlternateContent Audio XukIn, already set !");
}
m_Audio = Presentation.MediaFactory.CreateManagedAudioMedia();
m_Audio.XukIn(source, handler);
}
else if (XukAble.GetXukName(typeof(ManagedImageMedia)).Match(source.LocalName))
{
if (m_Image != null)
{
throw new exception.XukException("AlternateContent Image XukIn, already set !");
}
m_Image = Presentation.MediaFactory.CreateManagedImageMedia();
m_Image.XukIn(source, handler);
}
else
{
readItem = false;
}
}
if (!(readItem || source.IsEmptyElement))
{
source.ReadSubtree().Close(); //Read past unknown child
}
}
private void diagramXmlParseBody_(XmlNode diagramElementNode, string xmlFilePath, TreeNode treeNode, int objectIndex)
{
string diagramElementName = diagramElementNode.Name;
AlternateContent altContent = treeNode.Presentation.AlternateContentFactory.CreateAlternateContent();
AlternateContentAddCommand cmd_AltContent =
treeNode.Presentation.CommandFactory.CreateAlternateContentAddCommand(treeNode, altContent);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent);
Metadata diagramElementName_Metadata = treeNode.Presentation.MetadataFactory.CreateMetadata();
diagramElementName_Metadata.NameContentAttribute = new MetadataAttribute();
diagramElementName_Metadata.NameContentAttribute.Name = DiagramContentModelHelper.DiagramElementName;
diagramElementName_Metadata.NameContentAttribute.NamespaceUri = null;
diagramElementName_Metadata.NameContentAttribute.Value = diagramElementName;
AlternateContentMetadataAddCommand cmd_AltContent_diagramElementName_Metadata =
treeNode.Presentation.CommandFactory.CreateAlternateContentMetadataAddCommand(
treeNode,
null,
altContent,
diagramElementName_Metadata,
null
);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_diagramElementName_Metadata);
if (diagramElementNode.Attributes != null)
{
for (int i = 0; i < diagramElementNode.Attributes.Count; i++)
{
XmlAttribute attribute = diagramElementNode.Attributes[i];
if (attribute.Name.StartsWith(XmlReaderWriterHelper.NS_PREFIX_XMLNS + ":"))
{
//
}
else if (attribute.Name == XmlReaderWriterHelper.NS_PREFIX_XMLNS)
{
//
}
else if (attribute.Name == DiagramContentModelHelper.TOBI_Audio)
{
string fullPath = null;
if (FileDataProvider.isHTTPFile(attribute.Value))
{
fullPath = FileDataProvider.EnsureLocalFilePathDownloadTempDirectory(attribute.Value);
}
else
{
fullPath = Path.Combine(Path.GetDirectoryName(xmlFilePath), attribute.Value);
}
if (fullPath != null && File.Exists(fullPath))
{
string extension = Path.GetExtension(fullPath);
bool isWav = extension.Equals(DataProviderFactory.AUDIO_WAV_EXTENSION, StringComparison.OrdinalIgnoreCase);
AudioLibPCMFormat wavFormat = null;
if (isWav)
{
Stream fileStream = File.Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
try
{
uint dataLength;
wavFormat = AudioLibPCMFormat.RiffHeaderParse(fileStream, out dataLength);
}
finally
{
fileStream.Close();
}
}
string originalFilePath = null;
DebugFix.Assert(treeNode.Presentation.MediaDataManager.EnforceSinglePCMFormat);
bool wavNeedsConversion = false;
if (wavFormat != null)
{
wavNeedsConversion = !wavFormat.IsCompatibleWith(treeNode.Presentation.MediaDataManager.DefaultPCMFormat.Data);
}
if (!isWav || wavNeedsConversion)
{
originalFilePath = fullPath;
var audioFormatConvertorSession =
new AudioFormatConvertorSession(
//AudioFormatConvertorSession.TEMP_AUDIO_DIRECTORY,
treeNode.Presentation.DataProviderManager.DataFileDirectoryFullPath,
treeNode.Presentation.MediaDataManager.DefaultPCMFormat,
false,
m_UrakawaSession.IsAcmCodecsDisabled);
//filePath = m_AudioFormatConvertorSession.ConvertAudioFileFormat(filePath);
bool cancelled = false;
var converter = new AudioClipConverter(audioFormatConvertorSession, fullPath);
bool error = ShellView.RunModalCancellableProgressTask(true,
"Converting audio...",
converter,
() =>
{
m_Logger.Log(@"Audio conversion CANCELLED", Category.Debug, Priority.Medium);
cancelled = true;
},
() =>
{
m_Logger.Log(@"Audio conversion DONE", Category.Debug, Priority.Medium);
cancelled = false;
});
if (cancelled)
{
//DebugFix.Assert(!result);
break;
}
fullPath = converter.ConvertedFilePath;
if (string.IsNullOrEmpty(fullPath))
{
break;
}
m_Logger.Log(string.Format("Converted audio {0} to {1}", originalFilePath, fullPath),
Category.Debug, Priority.Medium);
//Stream fileStream = File.Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
//try
//{
// uint dataLength;
// wavFormat = AudioLibPCMFormat.RiffHeaderParse(fileStream, out dataLength);
//}
//finally
//{
// fileStream.Close();
//}
}
ManagedAudioMedia manAudioMedia = treeNode.Presentation.MediaFactory.CreateManagedAudioMedia();
AudioMediaData audioMediaData = treeNode.Presentation.MediaDataFactory.CreateAudioMediaData(DataProviderFactory.AUDIO_WAV_EXTENSION);
manAudioMedia.AudioMediaData = audioMediaData;
FileDataProvider dataProv = (FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
dataProv.InitByCopyingExistingFile(fullPath);
audioMediaData.AppendPcmData(dataProv);
// Stream wavStream = null;
// try
// {
// wavStream = File.Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
// uint dataLength;
// AudioLibPCMFormat pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
// if (!treeNode.Presentation.MediaDataManager.DefaultPCMFormat.Data.IsCompatibleWith(pcmInfo))
// {
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
// wavStream.Close();
// wavStream = null;
// var audioFormatConvertorSession =
// new AudioFormatConvertorSession(
// //AudioFormatConvertorSession.TEMP_AUDIO_DIRECTORY,
// treeNode.Presentation.DataProviderManager.DataFileDirectoryFullPath,
// treeNode.Presentation.MediaDataManager.DefaultPCMFormat, m_UrakawaSession.IsAcmCodecsDisabled);
// string newfullWavPath = audioFormatConvertorSession.ConvertAudioFileFormat(fullPath);
// FileDataProvider dataProv = (FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
// dataProv.InitByMovingExistingFile(newfullWavPath);
// audioMediaData.AppendPcmData(dataProv);
// }
// else // use original wav file by copying it to data directory
// {
// FileDataProvider dataProv = (FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
// dataProv.InitByCopyingExistingFile(fullPath);
// audioMediaData.AppendPcmData(dataProv);
// }
// }
// finally
// {
// if (wavStream != null) wavStream.Close();
// }
AlternateContentSetManagedMediaCommand cmd_AltContent_diagramElement_Audio =
treeNode.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(treeNode, altContent, manAudioMedia);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_diagramElement_Audio);
//SetDescriptionAudio(altContent, audio, treeNode);
}
}
else
{
Metadata diagramElementAttribute_Metadata = treeNode.Presentation.MetadataFactory.CreateMetadata();
diagramElementAttribute_Metadata.NameContentAttribute = new MetadataAttribute();
diagramElementAttribute_Metadata.NameContentAttribute.Name = attribute.Name;
diagramElementAttribute_Metadata.NameContentAttribute.NamespaceUri = attribute.NamespaceURI;
diagramElementAttribute_Metadata.NameContentAttribute.Value = attribute.Value;
AlternateContentMetadataAddCommand cmd_AltContent_diagramElementAttribute_Metadata =
treeNode.Presentation.CommandFactory.CreateAlternateContentMetadataAddCommand(
treeNode,
null,
altContent,
diagramElementAttribute_Metadata,
null
);
treeNode.Presentation.UndoRedoManager.Execute(
cmd_AltContent_diagramElementAttribute_Metadata);
}
}
}
int nObjects = -1;
XmlNode textNode = diagramElementNode;
if (diagramElementName == DiagramContentModelHelper.D_SimplifiedImage ||
diagramElementName == DiagramContentModelHelper.D_Tactile)
{
string localTourName = DiagramContentModelHelper.StripNSPrefix(DiagramContentModelHelper.D_Tour);
XmlNode tour =
XmlDocumentHelper.GetFirstChildElementOrSelfWithName(diagramElementNode, false,
localTourName,
DiagramContentModelHelper.NS_URL_DIAGRAM);
textNode = tour;
IEnumerable <XmlNode> objects = XmlDocumentHelper.GetChildrenElementsOrSelfWithName(diagramElementNode, false,
DiagramContentModelHelper.
Object,
DiagramContentModelHelper.
NS_URL_ZAI, false);
nObjects = 0;
foreach (XmlNode obj in objects)
{
nObjects++;
}
int i = -1;
foreach (XmlNode obj in objects)
{
i++;
if (i != objectIndex)
{
continue;
}
if (obj.Attributes == null || obj.Attributes.Count <= 0)
{
break;
}
for (int j = 0; j < obj.Attributes.Count; j++)
{
XmlAttribute attribute = obj.Attributes[j];
if (attribute.Name.StartsWith(XmlReaderWriterHelper.NS_PREFIX_XMLNS + ":"))
{
//
}
else if (attribute.Name == XmlReaderWriterHelper.NS_PREFIX_XMLNS)
{
//
}
else if (attribute.Name == DiagramContentModelHelper.Src)
{
//
}
else if (attribute.Name == DiagramContentModelHelper.SrcType)
{
//
}
else
{
Metadata diagramElementAttribute_Metadata = treeNode.Presentation.MetadataFactory.CreateMetadata();
diagramElementAttribute_Metadata.NameContentAttribute = new MetadataAttribute();
diagramElementAttribute_Metadata.NameContentAttribute.Name = attribute.Name;
diagramElementAttribute_Metadata.NameContentAttribute.NamespaceUri = attribute.NamespaceURI;
diagramElementAttribute_Metadata.NameContentAttribute.Value = attribute.Value;
AlternateContentMetadataAddCommand cmd_AltContent_diagramElementAttribute_Metadata =
treeNode.Presentation.CommandFactory.CreateAlternateContentMetadataAddCommand(
treeNode,
null,
altContent,
diagramElementAttribute_Metadata,
null
);
treeNode.Presentation.UndoRedoManager.Execute(
cmd_AltContent_diagramElementAttribute_Metadata);
}
}
XmlAttribute srcAttr = (XmlAttribute)obj.Attributes.GetNamedItem(DiagramContentModelHelper.Src);
if (srcAttr != null)
{
XmlAttribute srcType =
(XmlAttribute)obj.Attributes.GetNamedItem(DiagramContentModelHelper.SrcType);
ManagedImageMedia img = treeNode.Presentation.MediaFactory.CreateManagedImageMedia();
string imgFullPath = null;
if (FileDataProvider.isHTTPFile(srcAttr.Value))
{
imgFullPath = FileDataProvider.EnsureLocalFilePathDownloadTempDirectory(srcAttr.Value);
}
else
{
imgFullPath = Path.Combine(Path.GetDirectoryName(xmlFilePath), srcAttr.Value);
}
if (imgFullPath != null && File.Exists(imgFullPath))
{
string extension = Path.GetExtension(imgFullPath);
ImageMediaData imgData = treeNode.Presentation.MediaDataFactory.CreateImageMediaData(extension);
if (imgData != null)
{
imgData.InitializeImage(imgFullPath, Path.GetFileName(imgFullPath));
img.ImageMediaData = imgData;
AlternateContentSetManagedMediaCommand cmd_AltContent_Image =
treeNode.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(
treeNode, altContent, img);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_Image);
}
}
}
}
}
if (textNode != null)
{
string strText = textNode.InnerXml;
if (!string.IsNullOrEmpty(strText))
{
strText = strText.Trim();
strText = Regex.Replace(strText, @"\s+", " ");
strText = strText.Replace("\r\n", "\n");
}
if (!string.IsNullOrEmpty(strText))
{
TextMedia txtMedia = treeNode.Presentation.MediaFactory.CreateTextMedia();
txtMedia.Text = strText;
AlternateContentSetManagedMediaCommand cmd_AltContent_Text =
treeNode.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(treeNode,
altContent,
txtMedia);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_Text);
}
}
if (nObjects > 0 && ++objectIndex <= nObjects - 1)
{
diagramXmlParseBody_(diagramElementNode, xmlFilePath, treeNode, objectIndex);
}
}
protected void GetXmlFragment_(XmlWriter xmlWriter, bool absoluteLinks)
{
if (HasXmlProperty)
{
string name = GetXmlElementPrefixedLocalName();
string NSPrefix;
string localName;
XmlProperty.SplitLocalName(name, out NSPrefix, out localName);
//DebugFix.Assert(string.IsNullOrEmpty(NSPrefix));
string nsUri = GetXmlNamespaceUri(NSPrefix);
XmlProperty xmlProp = GetXmlProperty();
if (String.IsNullOrEmpty(NSPrefix))
{
if (!String.IsNullOrEmpty(nsUri))
{
xmlWriter.WriteStartElement(name, nsUri);
}
else
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
xmlWriter.WriteStartElement(name);
}
}
else
{
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
if (!String.IsNullOrEmpty(nsUri))
{
xmlWriter.WriteStartElement(NSPrefix, localName, nsUri);
}
else
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
xmlWriter.WriteStartElement(name);
}
}
ManagedImageMedia manImageMedia = GetImageMedia() as ManagedImageMedia;
ManagedVideoMedia manVideoMedia = GetVideoMedia() as ManagedVideoMedia;
foreach (XmlAttribute xmlAttr in xmlProp.Attributes.ContentsAs_Enumerable)
{
string value = xmlAttr.Value;
string nsUriAttr = xmlAttr.GetNamespaceUri();
string attrNSPrefix = xmlAttr.Prefix;
string nameWithoutPrefix = xmlAttr.PrefixedLocalName != null ? xmlAttr.PrefixedLocalName : xmlAttr.LocalName;
if (manImageMedia != null &&
(nameWithoutPrefix == "href" || nameWithoutPrefix == "src"))
{
DebugFix.Assert(manImageMedia.ImageMediaData.OriginalRelativePath == value);
if (absoluteLinks)
{
value = ((FileDataProvider)manImageMedia.ImageMediaData.DataProvider).DataFileFullPath;
}
}
if (manVideoMedia != null &&
(nameWithoutPrefix == "href" || nameWithoutPrefix == "src"))
{
DebugFix.Assert(manVideoMedia.VideoMediaData.OriginalRelativePath == value);
if (absoluteLinks)
{
value = ((FileDataProvider)manVideoMedia.VideoMediaData.DataProvider).DataFileFullPath;
}
}
if (String.IsNullOrEmpty(attrNSPrefix))
{
if (nameWithoutPrefix.Equals(XmlReaderWriterHelper.NS_PREFIX_XMLNS))
{
DebugFix.Assert(XmlReaderWriterHelper.NS_URL_XMLNS.Equals(nsUriAttr));
xmlWriter.WriteAttributeString(XmlReaderWriterHelper.NS_PREFIX_XMLNS, XmlReaderWriterHelper.NS_URL_XMLNS, value);
}
else if (!String.IsNullOrEmpty(nsUriAttr) && nsUriAttr != nsUri)
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
xmlWriter.WriteAttributeString(nameWithoutPrefix, nsUriAttr, value);
}
else
{
xmlWriter.WriteAttributeString(nameWithoutPrefix, value);
}
}
else
{
if (attrNSPrefix.Equals(XmlReaderWriterHelper.NS_PREFIX_XMLNS))
{
DebugFix.Assert(nsUriAttr == XmlReaderWriterHelper.NS_URL_XMLNS);
xmlWriter.WriteAttributeString(XmlReaderWriterHelper.NS_PREFIX_XMLNS, nameWithoutPrefix, XmlReaderWriterHelper.NS_URL_XMLNS,
value);
}
else if (attrNSPrefix.Equals(XmlReaderWriterHelper.NS_PREFIX_XML))
{
DebugFix.Assert(nsUriAttr == XmlReaderWriterHelper.NS_URL_XML);
xmlWriter.WriteAttributeString(XmlReaderWriterHelper.NS_PREFIX_XML, nameWithoutPrefix, XmlReaderWriterHelper.NS_URL_XML,
value);
}
else if (!String.IsNullOrEmpty(nsUriAttr))
{
#if DEBUG
//DebugFix.Assert(nsUriAttr != nsUri);
string uriCheck = xmlProp.GetNamespaceUri(attrNSPrefix);
DebugFix.Assert(nsUriAttr == uriCheck);
#endif //DEBUG
xmlWriter.WriteAttributeString(attrNSPrefix, nameWithoutPrefix, nsUriAttr, value);
}
else if (!String.IsNullOrEmpty(nsUri))
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
xmlWriter.WriteAttributeString(attrNSPrefix, nameWithoutPrefix, nsUri, value);
}
else
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
xmlWriter.WriteAttributeString(nameWithoutPrefix, value);
}
}
}
}
if (mChildren.Count > 0)
{
for (int i = 0; i < mChildren.Count; i++)
{
TreeNode child = mChildren.Get(i);
child.GetXmlFragment_(xmlWriter, absoluteLinks);
}
}
else
{
AbstractTextMedia txt = GetTextMedia();
if (txt != null)
{
DebugFix.Assert(!HasXmlProperty || mChildren.Count == 0);
bool needsCData = false;
TreeNode node = null;
if (HasXmlProperty)
{
node = this;
}
else if (Parent != null && Parent.HasXmlProperty)
{
node = Parent;
}
if (node != null)
{
string name = node.GetXmlElementLocalName();
if (name == "script" || name == "style")
{
needsCData = true;
}
}
if (needsCData)
{
xmlWriter.WriteCData(txt.Text);
}
else
{
xmlWriter.WriteString(txt.Text);
}
}
}
if (HasXmlProperty)
{
xmlWriter.WriteEndElement();
}
}
private void OnClick_ButtonExport(object sender, RoutedEventArgs e)
{
m_Logger.Log("DescriptionView.OnClick_ButtonExport", Category.Debug, Priority.Medium);
Tuple <TreeNode, TreeNode> selection = m_Session.GetTreeNodeSelection();
TreeNode node = selection.Item2 ?? selection.Item1;
if (node == null ||
node.GetAlternateContentProperty() == null ||
node.GetImageMedia() == null ||
!(node.GetImageMedia() is ManagedImageMedia))
{
return;
}
SampleRate sampleRate = SampleRate.Hz22050;
sampleRate = Urakawa.Settings.Default.AudioExportSampleRate;
bool encodeToMp3 = true;
encodeToMp3 = Urakawa.Settings.Default.AudioExportEncodeToMp3;
var combo = new ComboBox
{
Margin = new Thickness(0, 0, 0, 12)
};
ComboBoxItem item1 = new ComboBoxItem();
item1.Content = AudioLib.SampleRate.Hz11025.ToString();
combo.Items.Add(item1);
ComboBoxItem item2 = new ComboBoxItem();
item2.Content = AudioLib.SampleRate.Hz22050.ToString();
combo.Items.Add(item2);
ComboBoxItem item3 = new ComboBoxItem();
item3.Content = AudioLib.SampleRate.Hz44100.ToString();
combo.Items.Add(item3);
switch (sampleRate)
{
case AudioLib.SampleRate.Hz11025:
{
combo.SelectedItem = item1;
combo.Text = item1.Content.ToString();
break;
}
case AudioLib.SampleRate.Hz22050:
{
combo.SelectedItem = item2;
combo.Text = item2.Content.ToString();
break;
}
case AudioLib.SampleRate.Hz44100:
{
combo.SelectedItem = item3;
combo.Text = item3.Content.ToString();
break;
}
}
var checkBox = new CheckBox
{
IsThreeState = false,
IsChecked = encodeToMp3,
HorizontalAlignment = System.Windows.HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Center,
};
var label_ = new TextBlock
{
Text = Tobi_Plugin_Urakawa_Lang.ExportEncodeMp3,
Margin = new Thickness(8, 0, 8, 0),
HorizontalAlignment = System.Windows.HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Center,
Focusable = true,
TextWrapping = TextWrapping.Wrap
};
var panel__ = new StackPanel
{
Orientation = System.Windows.Controls.Orientation.Horizontal,
HorizontalAlignment = System.Windows.HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Center,
};
panel__.Children.Add(label_);
panel__.Children.Add(checkBox);
var panel_ = new StackPanel
{
Orientation = System.Windows.Controls.Orientation.Vertical,
HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch,
VerticalAlignment = VerticalAlignment.Center,
};
panel_.Children.Add(combo);
panel_.Children.Add(panel__);
var windowPopup_ = new PopupModalWindow(m_ShellView,
UserInterfaceStrings.EscapeMnemonic(Tobi_Plugin_Urakawa_Lang.ExportSettings),
panel_,
PopupModalWindow.DialogButtonsSet.OkCancel,
PopupModalWindow.DialogButton.Ok,
false, 300, 180, null, 40, m_DescriptionPopupModalWindow);
windowPopup_.EnableEnterKeyDefault = true;
windowPopup_.ShowModal();
if (!PopupModalWindow.IsButtonOkYesApply(windowPopup_.ClickedDialogButton))
{
return;
}
encodeToMp3 = checkBox.IsChecked.Value;
Urakawa.Settings.Default.AudioExportEncodeToMp3 = checkBox.IsChecked.Value;
if (combo.SelectedItem == item1)
{
sampleRate = SampleRate.Hz11025;
Urakawa.Settings.Default.AudioExportSampleRate = sampleRate;
}
else if (combo.SelectedItem == item2)
{
sampleRate = SampleRate.Hz22050;
Urakawa.Settings.Default.AudioExportSampleRate = sampleRate;
}
else if (combo.SelectedItem == item3)
{
sampleRate = SampleRate.Hz44100;
Urakawa.Settings.Default.AudioExportSampleRate = sampleRate;
}
string rootFolder = Path.GetDirectoryName(m_Session.DocumentFilePath);
var dlg = new FolderBrowserDialog
{
RootFolder = Environment.SpecialFolder.MyComputer,
SelectedPath = rootFolder,
ShowNewFolderButton = true,
Description = @"Tobi: " + UserInterfaceStrings.EscapeMnemonic("Export DIAGRAM XML")
};
DialogResult result = DialogResult.Abort;
m_ShellView.DimBackgroundWhile(() => { result = dlg.ShowDialog(); });
if (result != DialogResult.OK && result != DialogResult.Yes)
{
return;
}
if (!Directory.Exists(dlg.SelectedPath))
{
return;
}
ManagedImageMedia managedImage = (ManagedImageMedia)node.GetImageMedia();
string exportImageName =
//Path.GetFileName
FileDataProvider.EliminateForbiddenFileNameCharacters
(managedImage.ImageMediaData.OriginalRelativePath)
;
string imageDescriptionDirectoryPath = Daisy3_Export.GetAndCreateImageDescriptionDirectoryPath(false, exportImageName, dlg.SelectedPath);
if (Directory.Exists(imageDescriptionDirectoryPath))
{
if (!m_Session.askUserConfirmOverwriteFileFolder(imageDescriptionDirectoryPath, true, m_DescriptionPopupModalWindow))
{
return;
}
FileDataProvider.TryDeleteDirectory(imageDescriptionDirectoryPath, true);
}
FileDataProvider.CreateDirectory(imageDescriptionDirectoryPath);
PCMFormatInfo audioFormat = node.Presentation.MediaDataManager.DefaultPCMFormat;
AudioLibPCMFormat pcmFormat = audioFormat.Data;
if ((ushort)sampleRate != pcmFormat.SampleRate)
{
pcmFormat.SampleRate = (ushort)sampleRate;
}
Application.Current.MainWindow.Cursor = Cursors.Wait;
this.Cursor = Cursors.Wait; //m_ShellView
try
{
string descriptionFile = Daisy3_Export.CreateImageDescription(
Urakawa.Settings.Default.AudioCodecDisableACM,
pcmFormat, encodeToMp3, 0,
imageDescriptionDirectoryPath, exportImageName,
node.GetAlternateContentProperty(),
null,
null,
null);
}
finally
{
Application.Current.MainWindow.Cursor = Cursors.Arrow;
this.Cursor = Cursors.Arrow; //m_ShellView
}
m_ShellView.ExecuteShellProcess(imageDescriptionDirectoryPath);
}
