public static unsafe void CopyChannel(ImageChannel <TPixel> src, ImageChannel <TPixel> dst, System.Drawing.Point start, System.Drawing.Rectangle region, System.Drawing.Point destAnchor)
{
if (start.X >= src.Width || start.Y >= src.Height)
{
return;
}
int startSrcX = Math.Max(0, start.X);
int startSrcY = Math.Max(0, start.Y);
int endSrcX = Math.Min(start.X + region.Width, src.Width);
int endSrcY = Math.Min(start.Y + region.Height, src.Height);
int offsetX = start.X < 0 ? -start.X : 0;
int offsetY = start.Y < 0 ? -start.Y : 0;
offsetX = destAnchor.X + offsetX;
offsetY = destAnchor.Y + offsetY;
int startDstX = Math.Max(0, offsetX);
int startDstY = Math.Max(0, offsetY);
offsetX = offsetX < 0 ? -offsetX : 0;
offsetY = offsetY < 0 ? -offsetY : 0;
startSrcX += offsetX;
startSrcY += offsetY;
int step = dst.Step;
int endDstX = Math.Min(destAnchor.X + region.Width, dst.Width);
int endDstY = Math.Min(destAnchor.Y + region.Height, dst.Height);
int copyWidth = Math.Min(endSrcX - startSrcX, endDstX - startDstX) * step;
int copyHeight = Math.Min(endSrcY - startSrcY, endDstY - startDstY);
if (copyWidth <= 0 || copyHeight <= 0)
{
return;
}
int srcWidth = src.Width * step;
int dstWidth = dst.Width * step;
TPixel *srcLine = (TPixel *)(src.StartIntPtr) + srcWidth * startSrcY + startSrcX;
TPixel *dstLine = (TPixel *)dst.StartIntPtr + dstWidth * step * startDstY + startDstX;
TPixel *endSrcLine = srcLine + srcWidth * copyHeight;
while (srcLine < endSrcLine)
{
TPixel *pSrc = srcLine;
TPixel *endPSrc = pSrc + copyWidth;
TPixel *pDst = dstLine;
while (pSrc < endPSrc)
{
*pDst = *pSrc;
pSrc += step;
pDst += step;
}
srcLine += srcWidth;
dstLine += dstWidth;
}
}
public static unsafe void FillImage(ImageChannel <TPixel> img, TPixel value)
{
int step = img.Step;
TPixel *start = (TPixel *)img.StartIntPtr;
TPixel *end = start += img.Length * img.Step;
while (start != end)
{
*start = value;
start += step;
}
}
protected virtual void initializeProject(string dataFolderPrefix)
{
m_dataFolderPrefix = dataFolderPrefix;
m_Project = new Project();
m_Project.PrettyFormat = m_XukPrettyFormat;
Presentation presentation = m_Project.AddNewPresentation(new Uri(m_outDirectory),
dataFolderPrefix);
PCMFormatInfo pcmFormat = presentation.MediaDataManager.DefaultPCMFormat; //.Copy();
pcmFormat.Data.SampleRate = (ushort)m_audioProjectSampleRate;
pcmFormat.Data.NumberOfChannels = m_audioStereo ? (ushort)2 : (ushort)1;
presentation.MediaDataManager.DefaultPCMFormat = pcmFormat;
//presentation.MediaDataFactory.DefaultAudioMediaDataType = typeof(WavAudioMediaData);
//presentation.MediaDataManager.EnforceSinglePCMFormat = true;
TextChannel textChannel = presentation.ChannelFactory.CreateTextChannel();
textChannel.Name = "The Text Channel";
DebugFix.Assert(textChannel == presentation.ChannelsManager.GetOrCreateTextChannel());
AudioChannel audioChannel = presentation.ChannelFactory.CreateAudioChannel();
audioChannel.Name = "The Audio Channel";
DebugFix.Assert(audioChannel == presentation.ChannelsManager.GetOrCreateAudioChannel());
ImageChannel imageChannel = presentation.ChannelFactory.CreateImageChannel();
imageChannel.Name = "The Image Channel";
DebugFix.Assert(imageChannel == presentation.ChannelsManager.GetOrCreateImageChannel());
VideoChannel videoChannel = presentation.ChannelFactory.CreateVideoChannel();
videoChannel.Name = "The Video Channel";
DebugFix.Assert(videoChannel == presentation.ChannelsManager.GetOrCreateVideoChannel());
/*string dataPath = presentation.DataProviderManager.DataFileDirectoryFullPath;
* if (Directory.Exists(dataPath))
* {
* Directory.Delete(dataPath, true);
* }*/
}
public static unsafe void CopyToIntChannel(ImageChannel <TPixel> src, ImageChannel <Int32> dst)
{
if (src.Length != dst.Length)
{
throw new InvalidOperationException("The two channels are not the same length.");
}
int length = src.Length;
int srcStep = src.Step;
int dstStep = dst.Step;
TPixel *srcStart = (TPixel *)src.StartIntPtr;
TPixel *srcEnd = srcStart + length * srcStep;
Int32 * dstStart = (Int32 *)dst.StartIntPtr;
while (srcStart != srcEnd)
{
*dstStart = (Int32)(*srcStart);
srcStart += srcStep;
dstStart += dstStep;
}
}
/// <summary>
/// Seperates the specified channel of the image
/// </summary>
/// <param name="image">image to retrieve the channel from</param>
/// <param name="channel">the channel to seperate</param>
/// <returns>channel of an image</returns>
public static Image GetImageChannel(this Image image, ImageChannel channel)
{
Bitmap bmp = new Bitmap(image);
Bitmap img = new Bitmap(image.Width, image.Height);
for (int i = 0; i < image.Width; i++)
{
for (int j = 0; j < image.Height; j++)
{
Color color = bmp.GetPixel(i, j);
int value = 0;
switch (channel)
{
case ImageChannel.Red:
color = Color.FromArgb(color.R, 0, 0);
value = color.R; // - color.G - color.B;
break;
case ImageChannel.Green:
color = Color.FromArgb(0, color.G, 0);
value = color.G; // - color.R - color.B;
break;
case ImageChannel.Blue:
color = Color.FromArgb(0, 0, color.B);
value = color.B; // - color.R - color.G;
break;
}
if (value < 0)
{
value = 0;
}
img.SetPixel(i, j, /*Color.FromArgb(value, value, value)*/ color);
}
}
return(img);
}
public static unsafe void ApplyConvolution(ImageChannel <TPixel> img, ConvolutionKernel k)
{
if (img.Width < 2 || img.Height < 2)
{
return;
}
int widthTypeScaled = img.Width * img.Step;
int kernelHeight = k.Width;
int kernelWidth = k.Height;
int scale = k.Scale;
int[,] kernel = k.Kernel;
int extend = Math.Max(kernelWidth, kernelHeight) / 2;
ImageChannel <TPixel> maskImage = new ImageChannel <TPixel>(img.Width + extend * 2, img.Height + extend * 2);
FillImage(maskImage, (TPixel)0); //这里效率不高。原本只需要填充四周扩大的部分即可
CopyChannel(img, maskImage, new System.Drawing.Point(0, 0), new System.Drawing.Rectangle(0, 0, img.Width, img.Height), new System.Drawing.Point(extend, extend));
int step = img.Step;
int maskStep = maskImage.Step;
int width = img.Width;
int height = img.Height;
TPixel *start = (TPixel *)img.StartIntPtr;
TPixel *maskStart = (TPixel *)maskImage.StartIntPtr;
// 复制边界像素
TPixel *dstStart = maskStart + extend;
int maskWidth = img.Width + extend * 2;
int maskHeight = img.Height + extend * 2;
TPixel *dstContentStart = maskStart + extend + maskWidth * extend;
// 复制上方的像素
for (int y = 0; y < extend; y++)
{
TPixel *lineStart = dstStart + y * maskWidth;
TPixel *lineEnd = lineStart + width;
TPixel *copyStart = dstContentStart;
while (lineStart != lineEnd)
{
*lineStart = *copyStart;
lineStart++;
copyStart++;
}
}
// 复制下方的像素
for (int y = height + extend; y < maskHeight; y++)
{
TPixel *lineStart = dstStart + y * maskWidth;
TPixel *lineEnd = lineStart + width;
TPixel *copyStart = dstContentStart + height * maskWidth - maskWidth;
while (lineStart != lineEnd)
{
*lineStart = *copyStart;
lineStart++;
copyStart++;
}
}
// 复制左右两侧的像素
TPixel *dstLine = maskStart + maskWidth * extend;
TPixel p = default(TPixel);
for (int y = extend; y < height + extend; y++)
{
p = dstLine[extend];
for (int x = 0; x < extend; x++)
{
dstLine[x] = p;
}
p = dstLine[extend + width - 1];
for (int x = width + extend; x < maskWidth; x++)
{
dstLine[x] = p;
}
dstLine += maskWidth;
}
// 复制四个角落的像素
// 左上
p = dstContentStart[0];
for (int y = 0; y < extend; y++)
{
for (int x = 0; x < extend; x++)
{
maskStart[y * maskWidth + x] = p;
}
}
// 右上
p = dstContentStart[width - 1];
for (int y = 0; y < extend; y++)
{
for (int x = width + extend; x < maskWidth; x++)
{
maskStart[y * maskWidth + x] = p;
}
}
// 左下
p = dstContentStart[(height - 1) * maskWidth];
for (int y = height + extend; y < maskHeight; y++)
{
for (int x = 0; x < extend; x++)
{
maskStart[y * maskWidth + x] = p;
}
}
// 右下
p = dstContentStart[(height - 1) * maskWidth + width - 1];
for (int y = height + extend; y < maskHeight; y++)
{
for (int x = width + extend; x < maskWidth; x++)
{
maskStart[y * maskWidth + x] = p;
}
}
if (scale == 1)
{
for (int h = 0; h < height; h++)
{
for (int w = 0; w < width; w++)
{
TValue val = 0;
for (int kw = 0; kw < kernelWidth; kw++)
{
for (int kh = 0; kh < kernelHeight; kh++)
{
val += maskStart[(h + kh) * maskWidth + (w + kw)] * kernel[kh, kw];
}
}
start[h * widthTypeScaled + w] = (TPixel)val;
}
}
}
else
{
double factor = 1.0 / scale;
for (int h = 0; h < height; h++)
{
for (int w = 0; w < width; w++)
{
TValue val = 0;
for (int kw = 0; kw < kernelWidth; kw++)
{
for (int kh = 0; kh < kernelHeight; kh++)
{
val += maskStart[(h + kh) * maskWidth + (w + kw)] * kernel[kh, kw];
}
}
start[h * widthTypeScaled + w] = (TPixel)(val * factor);
}
}
}
maskImage.Dispose();
}
public ChannelFilter(ImageChannel channel)
{
_channel = channel;
}
public ImageConnectionHandler() :
base(".png$", "GET")
{
_statusChannel = new ImageChannel();
}
protected virtual void parseContentDocuments(List <string> spineOfContentDocuments,
Dictionary <string, string> spineAttributes,
List <Dictionary <string, string> > spineItemsAttributes,
string coverImagePath, string navDocPath)
{
if (spineOfContentDocuments == null || spineOfContentDocuments.Count <= 0)
{
return;
}
Presentation spinePresentation = m_Project.Presentations.Get(0);
spinePresentation.RootNode.GetOrCreateXmlProperty().SetQName("spine", "");
if (!string.IsNullOrEmpty(m_OPF_ContainerRelativePath))
{
spinePresentation.RootNode.GetOrCreateXmlProperty().SetAttribute(OPF_ContainerRelativePath, "", m_OPF_ContainerRelativePath);
}
foreach (KeyValuePair <string, string> spineAttribute in spineAttributes)
{
spinePresentation.RootNode.GetOrCreateXmlProperty().SetAttribute(spineAttribute.Key, "", spineAttribute.Value);
}
if (m_PackagePrefixAttr != null)
{
spinePresentation.RootNode.GetOrCreateXmlProperty().SetAttribute("prefix", "", m_PackagePrefixAttr.Value);
}
// Audio files may be shared between chapters of a book!
m_OriginalAudioFile_FileDataProviderMap.Clear();
Presentation spineItemPresentation = null;
int index = -1;
foreach (string docPath in spineOfContentDocuments)
{
index++;
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ReadXMLDoc, docPath));
//DirectoryInfo opfParentDir = Directory.GetParent(m_Book_FilePath);
//string dirPath = opfParentDir.ToString();
string fullDocPath = Path.Combine(Path.GetDirectoryName(m_Book_FilePath), docPath);
fullDocPath = FileDataProvider.NormaliseFullFilePath(fullDocPath).Replace('/', '\\');
if (!File.Exists(fullDocPath))
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
continue;
}
addOPF_GlobalAssetPath(fullDocPath);
TreeNode spineChild = spinePresentation.TreeNodeFactory.Create();
TextMedia txt = spinePresentation.MediaFactory.CreateTextMedia();
txt.Text = docPath; // Path.GetFileName(fullDocPath);
spineChild.GetOrCreateChannelsProperty().SetMedia(spinePresentation.ChannelsManager.GetOrCreateTextChannel(), txt);
spinePresentation.RootNode.AppendChild(spineChild);
spineChild.GetOrCreateXmlProperty().SetQName("metadata", "");
foreach (KeyValuePair <string, string> spineItemAttribute in spineItemsAttributes[index])
{
spineChild.GetOrCreateXmlProperty().SetAttribute(spineItemAttribute.Key, "", spineItemAttribute.Value);
}
string ext = Path.GetExtension(fullDocPath);
if (docPath == coverImagePath)
{
DebugFix.Assert(ext.Equals(DataProviderFactory.IMAGE_SVG_EXTENSION, StringComparison.OrdinalIgnoreCase));
spineChild.GetOrCreateXmlProperty().SetAttribute("cover-image", "", "true");
}
if (docPath == navDocPath)
{
DebugFix.Assert(
ext.Equals(DataProviderFactory.XHTML_EXTENSION, StringComparison.OrdinalIgnoreCase) ||
ext.Equals(DataProviderFactory.HTML_EXTENSION, StringComparison.OrdinalIgnoreCase));
spineChild.GetOrCreateXmlProperty().SetAttribute("nav", "", "true");
}
if (
!ext.Equals(DataProviderFactory.XHTML_EXTENSION, StringComparison.OrdinalIgnoreCase) &&
!ext.Equals(DataProviderFactory.HTML_EXTENSION, StringComparison.OrdinalIgnoreCase) &&
!ext.Equals(DataProviderFactory.DTBOOK_EXTENSION, StringComparison.OrdinalIgnoreCase) &&
!ext.Equals(DataProviderFactory.XML_EXTENSION, StringComparison.OrdinalIgnoreCase)
)
{
DebugFix.Assert(ext.Equals(DataProviderFactory.IMAGE_SVG_EXTENSION, StringComparison.OrdinalIgnoreCase));
bool notExistYet = true;
foreach (ExternalFiles.ExternalFileData externalFileData in m_Project.Presentations.Get(0).ExternalFilesDataManager.ManagedObjects.ContentsAs_Enumerable)
{
if (!string.IsNullOrEmpty(externalFileData.OriginalRelativePath))
{
bool notExist = docPath != externalFileData.OriginalRelativePath;
notExistYet = notExistYet && notExist;
if (!notExist)
{
break;
}
}
}
DebugFix.Assert(notExistYet);
if (notExistYet)
{
ExternalFiles.ExternalFileData externalData = null;
if (docPath == coverImagePath)
{
externalData = m_Project.Presentations.Get(0).ExternalFilesDataFactory.Create
<ExternalFiles.CoverImageExternalFileData>();
}
else
{
externalData = m_Project.Presentations.Get(0).ExternalFilesDataFactory.Create
<ExternalFiles.GenericExternalFileData>();
}
if (externalData != null)
{
externalData.InitializeWithData(fullDocPath, docPath, true, null);
addOPF_GlobalAssetPath(fullDocPath);
}
}
continue;
}
spineChild.GetOrCreateXmlProperty().SetAttribute("xuk", "", "true");
XmlDocument xmlDoc = XmlReaderWriterHelper.ParseXmlDocument(fullDocPath, true, true);
if (RequestCancellation)
{
return;
}
m_PublicationUniqueIdentifier = null;
m_PublicationUniqueIdentifierNode = null;
Project spineItemProject = new Project();
spineItemProject.PrettyFormat = m_XukPrettyFormat;
string dataFolderPrefix = FileDataProvider.EliminateForbiddenFileNameCharacters(docPath);
spineItemPresentation = spineItemProject.AddNewPresentation(new Uri(m_outDirectory),
//Path.GetFileName(fullDocPath)
dataFolderPrefix
);
PCMFormatInfo pcmFormat = spineItemPresentation.MediaDataManager.DefaultPCMFormat; //.Copy();
pcmFormat.Data.SampleRate = (ushort)m_audioProjectSampleRate;
pcmFormat.Data.NumberOfChannels = m_audioStereo ? (ushort)2 : (ushort)1;
spineItemPresentation.MediaDataManager.DefaultPCMFormat = pcmFormat;
//presentation.MediaDataManager.EnforceSinglePCMFormat = true;
//presentation.MediaDataFactory.DefaultAudioMediaDataType = typeof(WavAudioMediaData);
TextChannel textChannel = spineItemPresentation.ChannelFactory.CreateTextChannel();
textChannel.Name = "The Text Channel";
DebugFix.Assert(textChannel == spineItemPresentation.ChannelsManager.GetOrCreateTextChannel());
AudioChannel audioChannel = spineItemPresentation.ChannelFactory.CreateAudioChannel();
audioChannel.Name = "The Audio Channel";
DebugFix.Assert(audioChannel == spineItemPresentation.ChannelsManager.GetOrCreateAudioChannel());
ImageChannel imageChannel = spineItemPresentation.ChannelFactory.CreateImageChannel();
imageChannel.Name = "The Image Channel";
DebugFix.Assert(imageChannel == spineItemPresentation.ChannelsManager.GetOrCreateImageChannel());
VideoChannel videoChannel = spineItemPresentation.ChannelFactory.CreateVideoChannel();
videoChannel.Name = "The Video Channel";
DebugFix.Assert(videoChannel == spineItemPresentation.ChannelsManager.GetOrCreateVideoChannel());
/*string dataPath = presentation.DataProviderManager.DataFileDirectoryFullPath;
* if (Directory.Exists(dataPath))
* {
* Directory.Delete(dataPath, true);
* }*/
//AudioLibPCMFormat previousPcm = null;
if (m_AudioConversionSession != null)
{
//previousPcm = m_AudioConversionSession.FirstDiscoveredPCMFormat;
RemoveSubCancellable(m_AudioConversionSession);
m_AudioConversionSession = null;
}
m_AudioConversionSession = new AudioFormatConvertorSession(
//AudioFormatConvertorSession.TEMP_AUDIO_DIRECTORY,
spineItemPresentation.DataProviderManager.DataFileDirectoryFullPath,
spineItemPresentation.MediaDataManager.DefaultPCMFormat,
m_autoDetectPcmFormat,
m_SkipACM);
//if (previousPcm != null)
//{
// m_AudioConversionSession.FirstDiscoveredPCMFormat = previousPcm;
//}
AddSubCancellable(m_AudioConversionSession);
TreenodesWithoutManagedAudioMediaData = new List <TreeNode>();
//foreach (var key in m_OriginalAudioFile_FileDataProviderMap.Keys)
//{
// FileDataProvider dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
//VERSUS//
// FileDataProvider dataProv = new FileDataProvider();
// dataProv.MimeType = DataProviderFactory.AUDIO_WAV_MIME_TYPE;
//}
//m_Project.Presentations.Get(0).ExternalFilesDataManager.ManagedObjects.ContentsAs_Enumerable
if (RequestCancellation)
{
return;
}
if (parseContentDocParts(fullDocPath, spineItemProject, xmlDoc, docPath, DocumentMarkupType.NA))
{
return; // user cancel
}
//if (RequestCancellation) return;
//reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ParsingMetadata, docPath));
//parseMetadata(fullDocPath, project, xmlDoc);
//if (RequestCancellation) return;
//ParseHeadLinks(fullDocPath, project, xmlDoc);
//reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ParsingContent, docPath));
//parseContentDocument(fullDocPath, project, xmlDoc, null, fullDocPath, null, DocumentMarkupType.NA);
string title = GetTitle(spineItemPresentation);
if (!string.IsNullOrEmpty(title))
{
spineChild.GetOrCreateXmlProperty().SetAttribute("title", "", title);
}
if (false) // do not copy metadata from project to individual chapter
{
foreach (Metadata metadata in m_Project.Presentations.Get(0).Metadatas.ContentsAs_Enumerable)
{
Metadata md = spineItemPresentation.MetadataFactory.CreateMetadata();
md.NameContentAttribute = metadata.NameContentAttribute.Copy();
foreach (MetadataAttribute metadataAttribute in metadata.OtherAttributes.ContentsAs_Enumerable)
{
MetadataAttribute mdAttr = metadataAttribute.Copy();
md.OtherAttributes.Insert(md.OtherAttributes.Count, mdAttr);
}
spineItemPresentation.Metadatas.Insert(spineItemPresentation.Metadatas.Count, md);
}
}
//XmlNodeList listOfBodies = xmlDoc.GetElementsByTagName("body");
//if (listOfBodies.Count == 0)
//{
// listOfBodies = xmlDoc.GetElementsByTagName("book");
//}
//XmlNode bodyElement = XmlDocumentHelper.GetFirstChildElementOrSelfWithName(xmlDoc, true, "body", null);
//if (bodyElement == null)
//{
// bodyElement = XmlDocumentHelper.GetFirstChildElementOrSelfWithName(xmlDoc, true, "book", null);
//}
//if (bodyElement == null)
//{
// continue;
//}
// TODO: return hierarchical outline where each node points to a XUK relative path, + XukAble.Uid (TreeNode are not corrupted during XukAbleManager.RegenerateUids();
foreach (KeyValuePair <string, string> spineItemAttribute in spineItemsAttributes[index])
{
if (spineItemAttribute.Key == "media-overlay")
{
string opfDirPath = Path.GetDirectoryName(m_Book_FilePath);
string overlayPath = spineItemAttribute.Value;
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ParsingMediaOverlay, overlayPath));
string fullOverlayPath = Path.Combine(opfDirPath, overlayPath);
if (!File.Exists(fullOverlayPath))
{
continue;
}
XmlDocument overlayXmlDoc = XmlReaderWriterHelper.ParseXmlDocument(fullOverlayPath, false, false);
IEnumerable <XmlNode> audioElements = XmlDocumentHelper.GetChildrenElementsOrSelfWithName(overlayXmlDoc, true, "audio", null, false);
if (audioElements == null)
{
continue;
}
foreach (XmlNode audioNode in audioElements)
{
XmlAttributeCollection attrs = audioNode.Attributes;
if (attrs == null)
{
continue;
}
XmlNode attrSrc = attrs.GetNamedItem("src");
if (attrSrc == null)
{
continue;
}
//XmlNode attrBegin = attrs.GetNamedItem("clipBegin");
//XmlNode attrEnd = attrs.GetNamedItem("clipEnd");
//string overlayDirPath = Path.GetDirectoryName(fullOverlayPath);
//string fullAudioPath = Path.Combine(overlayDirPath, attrSrc.Value);
//if (!File.Exists(fullAudioPath))
//{
// continue;
//}
//if (RequestCancellation) return;
//reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.DecodingAudio, Path.GetFileName(fullAudioPath)));
TreeNode textTreeNode = null;
XmlNodeList children = audioNode.ParentNode.ChildNodes;
foreach (XmlNode child in children)
{
if (child == audioNode)
{
continue;
}
if (child.LocalName != "text")
{
continue;
}
XmlAttributeCollection textAttrs = child.Attributes;
if (textAttrs == null)
{
continue;
}
XmlNode textSrc = textAttrs.GetNamedItem("src");
if (textSrc == null)
{
continue;
}
string urlDecoded = FileDataProvider.UriDecode(textSrc.Value);
if (urlDecoded.IndexOf('#') > 0)
{
string[] srcParts = urlDecoded.Split('#');
if (srcParts.Length != 2)
{
continue;
}
string fullTextRefPath = Path.Combine(Path.GetDirectoryName(fullOverlayPath),
srcParts[0]);
fullTextRefPath =
FileDataProvider.NormaliseFullFilePath(fullTextRefPath).Replace('/', '\\');
if (!fullTextRefPath.Equals(fullDocPath, StringComparison.OrdinalIgnoreCase))
{
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
continue;
}
string txtId = srcParts[1];
textTreeNode = spineItemPresentation.RootNode.GetFirstDescendantWithXmlID(txtId);
}
else
{
string fullTextRefPath = Path.Combine(Path.GetDirectoryName(fullOverlayPath),
urlDecoded);
fullTextRefPath =
FileDataProvider.NormaliseFullFilePath(fullTextRefPath).Replace('/', '\\');
if (!fullTextRefPath.Equals(fullDocPath, StringComparison.OrdinalIgnoreCase))
{
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
continue;
}
textTreeNode = spineItemPresentation.RootNode;
}
}
if (textTreeNode != null)
{
addAudio(textTreeNode, audioNode, false, fullOverlayPath);
}
}
}
}
spinePresentation.MediaDataManager.DefaultPCMFormat = spineItemPresentation.MediaDataManager.DefaultPCMFormat; //copied!
string xuk_FilePath = GetXukFilePath_SpineItem(m_outDirectory, docPath, title, index);
string xukFileName = Path.GetFileName(xuk_FilePath);
spineChild.GetOrCreateXmlProperty().SetAttribute("xukFileName", "", xukFileName);
//deleteDataDirectoryIfEmpty();
string dataFolderPath = spineItemPresentation.DataProviderManager.DataFileDirectoryFullPath;
spineItemPresentation.DataProviderManager.SetCustomDataFileDirectory(Path.GetFileNameWithoutExtension(xuk_FilePath));
string newDataFolderPath = spineItemPresentation.DataProviderManager.DataFileDirectoryFullPath;
DebugFix.Assert(Directory.Exists(newDataFolderPath));
if (newDataFolderPath != dataFolderPath)
{
try
{
if (Directory.Exists(newDataFolderPath))
{
FileDataProvider.TryDeleteDirectory(newDataFolderPath, false);
}
Directory.Move(dataFolderPath, newDataFolderPath);
}
catch (Exception ex)
{
#if DEBUG
Debugger.Break();
#endif // DEBUG
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
spineItemPresentation.DataProviderManager.SetCustomDataFileDirectory(dataFolderPrefix);
}
}
spineItemProject.PrettyFormat = m_XukPrettyFormat;
SaveXukAction action = new SaveXukAction(spineItemProject, spineItemProject, new Uri(xuk_FilePath), true);
action.ShortDescription = UrakawaSDK_daisy_Lang.SavingXUKFile;
action.LongDescription = UrakawaSDK_daisy_Lang.SerializeDOMIntoXUKFile;
action.Progress += new EventHandler <ProgressEventArgs>(
delegate(object sender, ProgressEventArgs e)
{
double val = e.Current;
double max = e.Total;
int percent = -1;
if (val != max)
{
percent = (int)((val / max) * 100);
}
reportProgress_Throttle(percent, val + "/" + max);
//reportProgress(-1, action.LongDescription);
if (RequestCancellation)
{
e.Cancel();
}
}
);
action.Finished += new EventHandler <FinishedEventArgs>(
delegate(object sender, FinishedEventArgs e)
{
reportProgress(100, UrakawaSDK_daisy_Lang.XUKSaved);
}
);
action.Cancelled += new EventHandler <CancelledEventArgs>(
delegate(object sender, CancelledEventArgs e)
{
reportProgress(0, UrakawaSDK_daisy_Lang.CancelledXUKSaving);
}
);
action.DoWork();
//if (first)
//{
// Presentation presentation = m_Project.Presentations.Get(0);
// XmlProperty xmlProp = presentation.PropertyFactory.CreateXmlProperty();
// xmlProp.LocalName = "book";
// presentation.PropertyFactory.DefaultXmlNamespaceUri = bodyElement.NamespaceURI;
// xmlProp.NamespaceUri = presentation.PropertyFactory.DefaultXmlNamespaceUri;
// TreeNode treeNode = presentation.TreeNodeFactory.Create();
// treeNode.AddProperty(xmlProp);
// presentation.RootNode = treeNode;
// first = false;
//}
//foreach (XmlNode childOfBody in bodyElement.ChildNodes)
//{
// parseContentDocument(childOfBody, m_Project.Presentations.Get(0).RootNode, fullDocPath);
//}
}
}
public ChannelFilter(ImageChannel channel)
{
_channel = channel;
}
