Got an old module which is generates reports with data from sparx ea project.
There is a part where you need to insert diagrams as pictures in the document.
Now it looks like that
public static void copyDiagram(
EA.Diagram diagram,
EA.Repository eaRepository)
{
eaRepository.App.Project.PutDiagramImageOnClipboard(diagram.DiagramGUID, 0);
eaRepository.CloseDiagram(diagram.DiagramID);
}
copying it to clipboard, and after that there goes something like
currentDocumentRange.Paste()
Looks strange for me.
I think it's not really good to use clipboard like that, so I want to rewrite it in future.
So, only other function I found there looks like that PutDiagramImageToFile(diagrammGUID, path, type)
If there are no better option is it okay to create new file, after that get it by it's path insert into word document, and then delete it?
Or, maybe there are some other SparxEA function, which get image from diagram in byte[] format or like Image format?
What way is better?
I'm using this code (on a diagram wrapper class) to get the image of a diagram without having to use the clipboard.
This code is used primarily in a custom written document generator and is surprisingly fast.
/// <summary>
/// returns diagram image
/// </summary>
public Image image
{
get
{
EA.Project projectInterface = this.model.getWrappedModel().GetProjectInterface();
string diagramGUID = projectInterface.GUIDtoXML(this.wrappedDiagram.DiagramGUID);
string filename = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".png";
//save diagram image to file (format ".png")
projectInterface.PutDiagramImageToFile(diagramGUID, filename, 1);
//load the contents of the file into a memorystream
MemoryStream imageStream = new MemoryStream(File.ReadAllBytes(filename));
//then create the image from the memorystream.
//this allows us to delete the temporary file right after loading it.
//When using Image.FromFile the file would have been locked for the lifetime of the Image
Image diagramImage = Image.FromStream(imageStream);
//delete the temorary file
System.IO.File.Delete(filename);
return diagramImage;
}
}
Related
I am trying to build a PowerPoint add-in that will allow me to do a one-click optimization of the current presentation by removing unused master slides and converting huge 24-bit PNG files to slightly-compressed JPGs.
I have the first part handled already, and now I'm working on the images. Although I can easily find the Shape object containing the image, I cannot find a way to access the source image through the managed API. At best, I can copy the shape to the clipboard, which does give me the image but in a different format (MemoryBmp).
using PPTX = Microsoft.Office.Interop.PowerPoint;
...
foreach (PPTX.Slide slide in Globals.ThisAddIn.Application.ActivePresentation.Slides)
{
foreach (PPTX.Shape shape in slide.Shapes)
{
if (shape.Type == MsoShapeType.msoPicture)
{
// Now, how can I access the source image contained within this shape?
// I -can- copy it via the clipboard, like this:
shape.Copy();
System.Drawing.Image image = Clipboard.GetImage();
// ...but image's format reflects a MemoryBmp ImageFormat, as noted here:
// https://referencesource.microsoft.com/#System.Drawing/commonui/System/Drawing/Advanced/ImageFormat.cs
// ...which doesn't help me determine if the source image is something that should be optimized.
}
}
}
Obviously, I can get to the images directly via other methods (e.g. accessing the contents of the file as a ZIP, or using OpenXML SDK), but I'm trying to perform all the steps from within the already-opened presentation (which means I can't update the open file). Any thoughts on how I can do this?
You could use a Microsoft.Office.Interop.PowerPoint.Shape Export function.
void Export(string PathName, PpShapeFormat Filter, int ScaleWidth = 0, int ScaleHeight = 0, PpExportMode ExportMode = PpExportMode.ppRelativeToSlide)
There is a very little documentation of this function.
I've found it in the Shape interface definition.
So your code would look something like:
shape.Export(<some_file>, PpShapeFormat.ppShapeFormatPNG);
More info on MSDN
I am using dropzone.js to upload multiple images to a .NET MVC website. When the images come into the server, I resize them, save information to the database, and then save the actual image on the server in a folder. When I upload them one at a time this works, but if I do multiple uploads at once, I get this error every few uploads:
A generic error occurred in GDI+
Googling this seems that this is a generic error when you are unable to save a file as some other process is using the location. I assume that the multiple uploads are trying to save in the same folder at the same time and one dies. They are not the same filename.
How can I avoid this? Is there a way to have the threads wait for one to finish before it tries saving in the same folder? I'm wondering if there is a method that is like the await call where it waits until it can save.
Edit More Code
I can't copy my whole function as it's very long etc but the part that saves is the following:
//Now we will try saving the actual file. Generate the file name.
String savedFileName = PhotoTools.GenerateImageFileName(photo.image_base_file_name);
String thumbnailSavedFileName = PhotoTools.GenerateImageFileName(photo.image_base_file_name, true);
//Store the file path (directory) that we are going to save the image to.
String directoryToSave = Server.MapPath(Constants.ImageDirectory + $"/{house_id}");
//Create the directory. This function will not do anything if it already exists.
Directory.CreateDirectory(directoryToSave);
//Save the images to the filesystem.
mainImage.Save(Path.Combine(directoryToSave, savedFileName), ImageFormat.Jpeg);
thumbnailImage.Save(Path.Combine(directoryToSave, thumbnailSavedFileName), ImageFormat.Jpeg);
They should not be the same filename as the file name is created as such:
/// <summary>
/// Generates the base property image filename based on the passed in information.
/// </summary>
/// <param name="propName">The house name that we will use for the file name.</param>
/// <returns>The generated file name.</returns>
public static String GenerateBaseImageFileName(String propName)
{
//Save the current datetime to create the filename with.
DateTime now = DateTime.Now;
//Generate the name.
return $"{CommonTools.RemoveSpecialCharacters(propName).Replace(" ","-")}-{now.Hour}{now.Second}{now.Millisecond}";
}
Usually this error A generic error occurred in GDI+ mean that the file or the path doesn't exist:
so try for example to check if the directory exist or create it if not .. and then double check if you have already a file with same name or if the full path exist:
try:
var guid = Guid.New().ToString(); //<-- generate new random guid
//Store the file path (directory) that we are going to save the image to.
String directoryToSave = Server.MapPath(Constants.ImageDirectory + $"/{house_id}");
//Create the directory. This function will not do anything if it already exists.
if(!Directory.Exist(directoryToSave)
Directory.CreateDirectory(directoryToSave);
//Save the images to the filesystem.
mainImage.Save(Path.Combine(directoryToSave, savedFileName + "_" + guid), ImageFormat.Jpeg);
Hope it helps you
I'm trying to create an add-in in C# for MS Word 2010 that will add a new ribbon and a click event-handler. This click event-handler should save the active file in c:\temp, for example. And then I need to load the file content into a byte array.
Probably something like this:
public void ClickEventHandler(Office.IRibbonControl control)
{
string fileLocation = "c:\temp\test.docx";
Word.Document document = this.Document;
document.SaveAs(fileLocation);
byte[] byteArray = File.ReadAllBytes(fileLocation);
}
The point is, this is pseudo-code and I don't know how to load an active document into a byte array. If there is a way without saving the document it would be even better.
And a query if the active file is a docx (and not a doc file) would be nice as well.
Word.Document document = Globals.ThisAddIn.Application.ActiveDocument;
document.SaveAs2(goldenpath + "\\" + name + "." + id + ".docx");
document.Close();
I use this generic function in my program to serialize arbitrary objects to a byte array:
private byte[] MakeByteSize<U>(U obj)
{
if (obj == null) return null;
var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
var ms = new System.IO.MemoryStream();
bf.Serialize(ms, obj);
return ms.ToArray();
}
Edit:
After reading your additional content, I'm confident that serializing the Word.Document object won't get you what you need, since the byte array representing that object in the program (which is probably a wrapper around some COM interop) won't be the same as the byte array representing the information stored in the file about the document.
Looking at the MSDN article you referenced, it looks like what we really need is a WordprocessingDoc instance representing the document that we can pass to the HtmlConverter class. So I think the question you really want to ask is "How can I create a DocumentFormat.OpenXml.Packaging.WordprocessingDocument from an open document without saving the file first?"
Unforunately, I'm not sure that's possible since I'm not really spotting any methods on that class that would do that.
On the .doc vs .docx issue, the Open XML SDK for Microsoft Office says that it works with documentat that adhere to the "Office Open XML File Formats Specification" which I believe means it will only work with the .docx file format. You might have to try a different route on this, like exporting to PDF perhaps. Good luck!
I am basically creating a xlsx file but I am getting an error while using that file like below.
System.IO.FileFormatException: Archive file cannot be size 0.
The way I tried.
string file = "c:\\DoneDone61.xlsx";
using(File.Create(file))
{
}
Also I cannot open excel file manually because it says the file is corrupted.
Thanks for answers in advance.
An Excel file which you consider to be "blank" is not just a file with no data in it (which is what you are creating). You can see this yourself by creating a document manually in Excel and then opening it in notepad. You'll notice that it actually has data inside of it. That data is used to store information regarding the three empty sheets named "Sheet1", "Sheet2" and "Sheet3". Also, there is some header information so that any program looking at the file knows that it is actually a compressed file (as per the Excel file format). So, as you can see, even a pretty empty excel file still contains SOME data.
If you want to create a blank excel document using C#, you have two good options:
Use a library that allows you to actually work with creating Excel documents that takes care of creating the file correctly. Check out something like the Microsoft OpenXML SDK or ExcelPackage.
Create an empty Excel document, store it somewhere, and when you want to "create" a new empty Excel document, just make a copy of this file.
This one ...
using(File.Create(filePath))
{
}
... creates an empty file. Read: really empty (=> 0 bytes) not an empty XLSX with an XLSX skeleton: ZIP container, file header, style definitions, ....
What exactly did you expect?
EDIT:
If you want to create an empty XLSX file (like "Right Click on Mouse > New > New Microsoft Excel"), you have to use such an template, ... and write it onto the disk.
To achieve that, you have to deploy this template file with your application, and then do a File.Copy(source, dest), or integrate it as a resource and write the resource content to the disk.
What you need to use is Interop.Excel namespace. Here's a guide from msdn
please use this...Its a bit hacky but couldn't get a better way to do this using InterOp
public static void CreateEmptyXLSXFile(string FilePath)
{
FileStream MyStream = new FileStream(FilePath, FileMode.CreateNew, FileAccess.ReadWrite);
MyStream.Write(ExcelDocumentsInterOps.GetEmptyXSLXFileBytes(), 0, ExcelDocumentsInterOps.GetEmptyXSLXFileBytes().Length);
MyStream.Flush();
MyStream.Close();
MyStream.Dispose();
MyStream = null;
}
/// <summary>
/// Returns the bytes for an empty xslx file
/// </summary>
/// <returns></returns>
public static byte[] GetEmptyXSLXFileBytes()
{
string TheSting = "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";
return Convert.FromBase64String(TheSting);
}
When dealing with spreadsheet related tasks in .NET, you can use this open source library called SpreadsheetLight to write an excel file (especially, if you want to write content at some point).
If you prefer adding it as package via Nuget, you can say:
Install-Package SpreadsheetLight
After that, going by GenerateReport() exmaple:
// this one creates an empty workbook
using (SLDocument sl = new SLDocument())
{
// sl.SetCellValue("B3", "I love ASP.NET MVC");
sl.SaveAs("c:\\DoneDone61.xlsx");
}
Also see their tutorial for more interesting stuff.
I have code which works in all sorts of different situations, including when copying images into the body of the document.
The code works when copying (adding) headers and footers from one document to the other, as long as the headers/footers being copied do not contain images.
When I copy a header which has an image in it, then the resulting file is corrupt, and when I try to open it with the OpenXML SDK it throws an exception saying "Compressed part has inconsistent data length".
I do know that the image has to be created in the HeaderPart (as against the MainDocumentPart when copying into the body).
The code which does the merging of the image looks something like:
private void AddSourceImagesToDestination(XElement sourceXml, OpenXmlPart sourcePart, OpenXmlPart destPart) {
foreach(XElement drawingElement in sourceXml.Descendants(_mswDrawingElementName)) {
XAttribute aBlipEmbedAttribute = drawingElement.Descendants(_ablipElementName).First().Attribute(_embedAttributeName);
string relationshipId = aBlipEmbedAttribute.Value;
ImagePart sourceImagePart = (ImagePart)sourcePart.GetPartById(relationshipId);
ImagePart destinationImagePart = ((HeaderPart)destPart).AddImagePart(sourceImagePart.ContentType);
string newRelationshipId = destPart.GetIdOfPart(destinationImagePart);
aBlipEmbedAttribute.SetValue(newRelationshipId);
destinationImagePart.FeedData(sourceImagePart.GetStream(FileMode.Open, FileAccess.Read));
}
}
The above is called passing the source and destination HeaderParts, and the XML of the source header which will after this be copied into the destination document. After calling the above procedure, destinationHeaderPart.Header.Save() is called.
As I said above, if there are no images in the source header, then the resulting document is fine (i.e. when the foreach doesn't find any drawing elements in the source XML).
I wonder, though, whether this symptom of the images in the header is perhaps a red herring and the real problem is somewhere else.
As I said in the comment on the question, the code to include the images into the header and footer was fine - it did the trick.
How I solved the problem of the corrupt file that my code (elsewhere) was creating was by a bit of trial and error. As other contributors have said, the documentation around OpenXML is, to put it mildly, not very good. So there might be another resolution to this problem, and maybe my "solution" just works because of some other side effects.
Anyway, I have some code which looks like this:
private MemoryStream _memoryStream;
private WordprocessingDocument _wordDocument;
...
_wordDocument = WordprocessingDocument.Open(_memoryStream, true);
...
private void ReopenDocument() {
_wordDocument.Package.Flush();
_wordDocument.Close();
MemoryStream newStream = new MemoryStream();
_memoryStream.WriteTo(newStream);
_memoryStream.Close();
_memoryStream = newStream;
_memoryStream.Position = 0L;
_wordDocument = WordprocessingDocument.Open(_memoryStream, true);
}
If I call the ReopenDocument method immediately prior to writing the _memoryStream to a FileStream, then the corruption is avoided.