Good news guys! I like to share experience after using latest Aspose.Slides 19.4 which has been enriched with improved chart data support features. The good thing about Aspose.Slides is that it has a monthly release where .NET, Java, Android via Java and C++ based APIs are published together. So, whats available in .NET based API is also available for Java, Android via Java and C++ based APIs. This way the users feels comfortable with API they are using and with same features available across the board.
In following sections, I am going to give you a walk through of what new features have been included and what improvements have been carried in API.
Working with chart data external workbook
As all of you may be aware of the fact MSO (Microsoft Office) charts support is available in PowerPoint that display the chart in slides but maintain its data in chart data workbook. Usually, the chart data workbook is embedded inside PowerPoint presentation and linked with its respective chart. The other option is to maintain external workbook to hold chart data by linking chart with that external workbook.
Good news is that Aspose.Slides has also introduced the support for managing external chart data workbook in this new release. You can create an external chart data workbook for existing chart in presentation by accessing it chart data workbook stream and saving that as file. Here’s how you can use this feature.
The similar Java based example for this is:
The similar C++ based example for this is:
You can also set the path to external workbook for existing chart. However, while doing so, you need to ensure that chart data is in accordance with chart categories and series. Otherwise, you need to point the chart categories and series data to respective cells in new external chart workbook. Here’s how you can use this feature:
The similar Java based example for this is:
The similar C++ based example for this is:
Moreover, you can also modify the chart data in workbook as well. Here’s how you can use this feature:
The similar Java based example for this is:
The similar C++ based example for this is:
Wait, there’s many other features, enhancement, and bug fixes included in this release. Here you can get the detail!
When time allows you can check out API examples at Github, talk about this release and other API related issues in our forum.
Aspose.Words for C++ now provides support to save Word document to PCL (Printer Command Language). Aspose.Words can save documents to PCL 6 (PCL 6 Enhanced or PCL XL) format. PclSaveOptions class can be used to specify additional options when saving a document into the PCL format. The following code example shows how to save the document to PCL using save options.
Additional Text Positioning
We have added a AdditionalTextPositioning member in PdfSaveOptions class which can be used to specify whether to write additional text positioning operators or not. If you set it to true, then additional text positioning operators are written to the output PDF. This may help to overcome issues with inaccurate text positioning with some printers. The downside is the increased PDF document size.
Predefined Font FallBack Settings for Google Noto Fonts
We have added a new LoadNotoFallbackSettings member to FontFallbackSettings class that loads predefined fallback settings which uses Google Noto fonts. Google Noto are free fonts licensed under SIL OFL and can be downloaded from here (https://www.google.com/get/noto/). Sample usage code is as follows:
Specify Unit of Measure to OpenDocument
We now provide a MeasureUnit option in OdtSaveOptions class to specify units of measure that can be applied to document content. Open Office uses centimeters when specifying lengths, widths and other measurable formatting and content properties in documents whereas MS Office uses inches. You can use OdtSaveOptions.MeasureUnit property to specify the unit of measure to apply to document content. The following code example shows how to use this property.
Prevent Embedding Fonts while saving Document into HtmlFixed
By default, Aspose.Words embeds the fonts into HtmlFixed file format. You can set the value of HtmlFixedSaveOptions.UseTargetMachineFonts property as true to prevent fonts from embedding into HtmlFixed document. When the value of this property is true, the fonts from the target machine will be used to display the document.
Write all CSS Declarations of HtmlFixed Document into Single File
By default, Aspose.Words saves “@font-face” rules of HtmlFixed documents into a separate file “fontFaces.css” while other CSS declarations are written to “styles.css”. You can change this behavior by setting the value of HtmlFixedSaveOptions.SaveFontFaceCssSeparately property to false. This saves all CSS rules and declarations into the same file “styles.css”. Below code example shows how to save all CSS rules and declarations into one file.
How to Align Chart Label
If you want to set a text alignment for multi-line labels, you can simply achieve this by setting the value of ChartAxis.TickLabelAlignment property. The following code example shows how to tick label alignment.
See Also Useful Links
The resources, you may need to accomplish your tasks:
Download Examples at GitHub Repository – we have published our code examples on the social coding website GitHub.com. Anyone could explore the code examples for learning purposes.
Keeping the Aspose tradition, you are welcome to shape the upcoming releases of Aspose.Words for C++ API by posting your suggestions and concerns in the Aspose.Words for C++ support forum.
Wait is over guys! Aspose.OMR or .NET has been released and now is available over NuGet Gallery to be used in .NET Application. As shared in pre-release announcement of the API, Aspose.OMR has been provided as simple and lightweight solution that makes performing OMR operation on images a breeze. In this blog post, we will try to go through maximum features API is offering to its users. Without waiting so much, let’s dive into information which will be helpful to use API first time and perform OMR operations over images.
Perform OMR using Aspose.OMR
API provides simple to use features for performing OMR operation. For a simple OMR operation, you only need two things; the prepared template (special markers will be drawn over user’s form) and the images to perform OMR operation on. Aspose.OMR provides TemplateProcessor.RecognizeImage() method that takes an image path and returns a string output. The following code snippet demonstrates the usage of OmrEngine and TemplateProcessor to perform OMR on two images.
Well, we are not finished yet. The things would get more exciting because this API also provides a threshold setting to fine-tune the result of OMR according to your needs. You can set the value of threshold from 0 to 100 depending upon your needs. A detailed example and demonstration can be seen over following link in API documentation:
The most worth-mentioning feature API has been offered with is Graphic Control that can be added into your application and lets you manually correct the threshold and markup to see changes in real-time. A complete guide to use Graphic Control in your application has been given in API documentation and can be visited on following link:
First version of the API also offers some following limitations which should be kept in view while working with it:
Recognition process works only with prepared templates (special markers will be drawn over the user’s form)
Performing OCR operation is also not supported for now
OMR operation will show results only in text format
We really hope that above guide will help you setting up the API for first time usage. In case we missed something here, you are always welcome to post your inquiries in our support forum. Do not forget to go through release notes page of the API. We further intend to introduce more enhancements and attractive features in future releases of the API. Stay with us in order to get latest updates about releases of the API.
It will please all of you to know that new updated version of Aspose.Note for .NET 19.3 is available now. This release contains enhancements and improvements which will provide you a quality product and performance rich version. A common programming paradigm i.e. parallel processing is targetted this time and improvements are made to get error free functionality in this environment. Please visit the release notes section of API documentation for details about this new release.
Process multiple files in parallel
You may require to use this library in a multi-document processing environment like opening multiple documents in separate threads and say searching hyperlinks along with making replacements in parallel for all the documents. Sometimes you may get an exception like “Object is currently in use elsewhere” while saving a document and getting the process terminated. This was causing hindrance in some cases and there was a desire to investigate this issue thoroughly. It was identified that as System.Drawing.Graphics class is used by Aspose.Note, this was causing the problem because it was was not threadsafe somehow and was verified by disabling it for successful operations. Be calm! This issue is resolved now and you can use Aspose.Note without any error while processing multiple documents in parallel.
Other improvements
Exception “Aspose.Note.UnsupportedFileFormatException-Unknown binary data compression in OneNote Online file format” was raised while loading some OneNote files. This issue is resolved now.
Another exception “System.ArgumentOutOfRangeException-Index was out of range. Must be non-negative and less than the size of the collection occurred in mscorlib.dll” is also resolved in this release.
So, you want to know what is new there in the latest Aspose.BarCode release. Pleasure is mine to share the details about the latest release Aspose.BarCode 19.4.0. You will find enhancements providing a rich experience while using this product with a variety of barcodes used nowadays. A summary of details about all the upgrades in this release can be reviewed here. Let us start exploring this new release. Are you ready?
As you know barcode reading is quite a complex task as a lot of issues can be there in the barcodes (especially received via Fax), like slim white modules, invasion of the quiet zone, small modules (1-2px), broken time pattern, incorrect bits location and a ragged border of the l-time pattern. Remember that there is a limit for any barcode reader to read an image and may have difficulties to read images with a lot of blurs or too poor image quality. Don’t you think so? Also, it was possible to read such barcodes by adding clear whitespace around the barcode but this workaround was not practical in all the cases due to extra effort and process involvement. We have worked hard on these issues and have improved our library a lot to handle all the above-mentioned issues and can read most of such barcodes. Following is a list of few improvements which are made in this release:
Detect region on an image with the heterogeneous brightness
Support recognition of invasion in the quiet zone for data matrix
Recognize data matrix with a lot of errors because of low scanner resolution
Recognize a datamtrix with black dots around
Correct the bits in datamatrix recognition
Identify cells of poor quality
Following sample code can be used to test results after these up gradations:
Other Improvements
IMB barcode was failing to be recognized. This issue is resolved and it works fine now like following sample IMB barcode can be read.
Following sample code can be used to test results after these up gradations:
Sample IMB barcode
There were some issues while detecting 1D and 2D barcode images in .NET Core environment due to some error while using Skia Graphics Library. Those issues are resolved now and you can read barcode images without any error.
Guys, I’m going to walk you through all the exciting features, improvements and other fixes of Aspose.Cells for Android via Java v19.3. This release includes new features, enhancements and other bug fixes that further improve the overall stability and usability of the Android API. For an easy access and utilization, Aspose.Cells for Android via Java APIs can be directly installed from Maven repository, see the document for your reference. Please check the release notes in order to get an idea about what is new and what has been fixed with this revision of Aspose.Cells for Android via Java. Let us start reviewing what is there in this release.
Insert rows with formatting
Microsoft Excel supports a feature to insert a row using one of the three different options. The objective of these options is to adopt settings from other rows. These three options include the following:
Format Same as Above (copy formatting from the above row)
Format Same as Below (copy formatting from the row below)
Clear Formatting (add new row but without any formatting)
You can also see these three options in the following screenshot:
The good news is, using Aspose.Cells for Android via Java API, you can use this feature in your code as well. You can programmatically create new rows with specified formatting option. Here is a code sample for you to do just that along the documentation to insert row with formatting:
Replace special chars while opening a CSV file
There was a demand, from you guys, that just like Excel, Aspose.Cells supports replacing special characters while opening a CSV file. So, we're very excited to break the news that this feature is now supported in the API. Just have a look at the below example to see how easy it is to achieve this with Aspose.Cells for Android via Java.
Detect type of encrypted OOXML files
As you must already have some idea that Office Open XML, which is also known as OOXML or Microsoft Open XML (MOX), is a very common format used for files. It is an XML-based format developed by Microsoft for representing office documents like spreadsheets, charts, presentations, and word processing documents. Aspose.Cells already allowed to open and detect type of this format. But now, our team has gone a step forward, and supported to detect type of encrypted OOXML files. Check out the sample code below:
Import data from JSON
As you know that JavaScript Object Notation is a common data interchange format which is quite lightweight and can be read by human and machines easily. Now, for example, you get data from some Web API in JSON format and need it to be imported into some Excel file, then Aspose.Cells is there to provide this facility.
JSONUtility class is introduced by Aspose.Cells for this purpose having ImportData method that not only imports data but also performs different conversions and formatting using the JsonLayoutOptions object during the import process. You may try this exciting feature by following article Importing Data from JSON. Here is a sample code to use this feature:
You can see that result is cool as fully formatted Excel file is created without using any extra code to parse the JSON string from any source like Web API. Isn't it? For example, if you get the following string from Web API, then output Excel file is shown in the image below:
[{"color": "red","value": "#f00"},{"color": "green","value": "#0f0"},{"color": "blue","value": "#00f"},{"color": "cyan","value": "#0ff"},{"color": "magenta","value": "#f0f"},{"color": "yellow","value":"#ff0"},{"color": "black","value": "#000"}]
Convert table to range with Options
Conversion of the table to a range was available earlier. However what if you want to control the formatting of destination range like formatting only the partial output. The good news is that this feature is available now and you don't need to write extra code to format the output range. We have introduced a new class TableToRangeOptions where LastRow property is available to set the last row to which formatting is copied from the source table. Here is the view of a sample table and converted range which is formatted up to row 5.
Here is a sample code which is used to create the above range.
For detailed information on conversions follow this link.
Get Range with External Links
Microsoft Excel supports external links for fetching data from different sources. We have provided the option to retrieve these links from the Excel file using Name.GetRefferedAreas method. This method returns ReferredArea which has many useful properties as follows:
In the following example, an external file having named range "Names" is linked with the Excel file. We can access this named range in the linked file and display its properties mentioned above.
Keep separators for blank rows during spreadsheet to CSV
Many times you convert the Excel sheets to CSV for using it in some other environment or applications. You may need to decide yourself about the separators for blank rows in the spreadsheet while exporting it to CSV. For example, there is a blank row in the source spreadsheet and you want either a blank row in the CSV or have a row with predefined separators. We have provided this feature now and you can get details about this feature here.
For better understanding, have a look at the following image which shows the result of this feature.
Following is a sample code which demonstrates this new feature.
Autofit Rows for Merged Cells
Autofitting rows is a very common operation which you perform while working with the Excel files. This feature was already there in Aspose.Cells API however many people asked for more control over this operation. To fulfill this requirement we have provided AutoFitMergedCellsType enumerator which contains the following options:
Here is a snapshot of this feature where the effect of one of the options EACH_LINE is shown.
You can test this feature using following sample code.
For more details on this topic please visit here.
Useful Links
The resources, you might need to accomplish your tasks:
Aspose.Cells Product Family Forum – post your technical questions and queries, or any other problem you are facing while working with Aspose.Cells APIs.
Enable Blog Subscription – do not limit yourself, you can keep yourself updated with the latest news on Aspose.Cells APIs, new features, fixes and other API related topics by subscribing to Aspose.Cells blog.
Aspose.Cells for Android via Java Examples – we have published our code examples on the social coding website GitHub.com. Anyone could explore the code examples for learning purposes.
Today we’re announcing two further changes that our customers can take advantage of from the 1st of May 2019:
GroupDocs Pricing Update
We’ve updated GroupDocs pricing to deliver the best value Document Manipulation API suite on the market. Use GroupDocs APIs to build awesome experiences for your users.
From the 1st of May 2019, All individual GroupDocs APIs will be priced from only $999 and GroupDocs.Total will start from just $2999.
Get started today – download a trial from GroupDocs.com
Introducing Conholdate.Total
Introducing Conholdate.Total – Every Aspose & GroupDocs API in one ultimate API bundle.
We’re also extending this pricing update to our Conholdate.Total bundle.
Get ALL Aspose & GroupDocs APIs in our Conholdate.Total suite for a single, incredible price.
Conholdate.Total starts at only $3999, so, for only $1000 over the price of an Aspose.Total or GroupDocs.Total Developer Small Business license you can get EVERY Aspose and GroupDocs API AND free upgrades for a year.
Hi guys! Whenever you want to do document processing tasks, the name of Aspose comes to everyone’s mind. As you know we add new features and enhancement in every release of Aspose.Words. You will be happy to know that we released new version of Aspose.Words for .NET 19.4. Let me walk you through the new features and API changes in this release.
Added More Flexible Control Over Document Import
We added ImportFormatOptions class with public property SmartStyleBehavior in Aspose.Words 19.4. This property is used to specify how styles will be imported when they have equal names in source and destination documents. You can enable or disable this feature while importing one document into another.
What will happen when this option is enabled or disabled?
If KeepSourceFormatting importing mode is used and this option is enabled, the source style will be expanded into direct attributes inside a destination document. When this option is disabled, a source style will be expanded only if it is numbered. Existing destination attributes will not be overridden, including lists.
The usage of this property is very simple. Here it is:
Resolve Fonts While Loading HTML or SVG
In old versions of Aspose.Words, font families were resolved against fonts installed in the local system while loading HTML or SVG. So, if a font family could not be resolved to an installed font, it was stored in the Aspose.Words’ model as is. In the result, FontSettings specified by users were not affected the resolved font names depended on the local system.
Let me make it easy for your understanding with an example.
Please check the following HTML. If ‘UnknownFont1’ is not installed on the system, the following font family declaration resolved to “Arial” (“Arial” is the font name we use for “san-serif” generic font name.)
<p style='font-family:UnknownFont1, sans-serif;'>This is a paragraph.</p>
Starting from Aspose.Words 19.4, FontSettings are taken into account while importing HTML and SVG documents and you can set up FontSettings before loading a document (add substitution rule, specify fonts folder, etc.) in order to change fonts available for font resolution.
Here is sample code example that shows how to add a font substitution rule while loading a document.
Set Vertically Aligned Text Within Text Box
If you want to set the text alignment of textbox vertically, the solution is simple. You can use TextBox.VerticalAnchor property. We added this property in Aspose.Words 19.4.
Following code example shows how to use this property.
Please note that saving warnings will be thrown for unsupported formats
(WordML) and for incompatible Word versions above 2007 (DOC, DOT).
Write Additional Text Positioning Operators
We have added PdfSaveOptions.AdditionalTextPositioning property in this version of Aspose.Words to overcome the issue with text position with some printers. Please read the following artice for more detail. Additional Text Positioning
Improved Importing Behavior for List Numbers
When you import one document into another, there can be a situation where source and destination documents have the same list identifiers. In such cases, MS Word uses formatting from the destination lists. We have added new property ImportFormatOptions.KeepSourceNumbering in Aspose.Words for .NET 19.4 to control this behavior. Please read following article for more detail. Set Keep Source Numbering
Moreover, we added new public method that accepts the new KeepSourceNumbering option.
/// <summary>
/// Initializes a new instance of the <see cref="NodeImporter"/> class.
/// </summary>
/// <param name="srcDoc">The source document.</param>
/// <param name="dstDoc">The destination document that will be the owner of imported nodes.</param>
/// <param name="importFormatMode">Specifies how to merge style formatting that clashes.</param>
/// <param name="importFormatOptions">Specifies various options to format imported node.</param>
public NodeImporter(DocumentBase srcDoc, DocumentBase dstDoc, ImportFormatMode importFormatMode, ImportFormatOptions importFormatOptions)
Improved Importing Behavior for TextBox
When you import a text box between different documents, the formatting of the destination document is applied to it. This corresponds to the behavior of MS Word. To allow users to choose an appropriate behavior, we have added ImportFormatOptions.IgnoreTextBoxes property in this release. For more detail, please read following article. Ignore Text Boxes while Importing Document
There are many other features, enhancement, and bug fixes included in this release. Please check the release notes of Aspose.Words for .NET 19.4.
When time allows you can check Aspose.Words’ API examples at Github, talk about this release and other API related issues in our forum.
Process of signing PDF documents has been commonly known and being practiced in many systems. Signatures are meant to secure documents and authenticate them. We can simple take example of a piece of paper where some information is written on. Now, if you do not find any reference of that information or any attestation mark over that paper, it would be hard to believe if information is correct. But, if any stamp or signature is present on the paper then you will definitely find that information as approved or from some authentic source. Similarly, signing a PDF document digitally approves that it is from a reliable source and content present in it is authenticated.
Signing PDF documents is one of the mostly used features offered by Aspose.PDF and because of many requests from its users, this features has been being enhanced and improved with each new revision of the API. In earlier versions of the API, signature text over the signature could not be changed and used to remain constant. Following image is showing how signature text displays in PDF viewer once document is signed.
Aspose.PDF for .NET 19.4 enables you to change text and information of the signature which is visible over the document. The signature text contains following information:
Date Signed
Date Digitally Signed
Reason Label
Location Label
Along with changing or specifying the information mentioned above, you will also be able to specify the format of Date as per your needs. Following code snippet shows complete implementation of the functionality introduced in latest version of the API.
Furthermore, API has been revised with other new features and enhancements along with major fixes and improvements. Following list contains areas where latest version of the API has been improved for performance and usability:
Support of Latex Script for mathematical expressions is added
You can now tag existing images in PDF for Accessibility feature
Structure element into text element can now be added
Concatenation scenarios have been improved
Rendering of HTML content inside PDF document has been further enhanced
Table manipulation and rendering have been further improved
PDF to PDF/A conversion engine has been improvised
Text replacement scenarios have been taken care of for better performance
Working with Annotation area is now better
PDF to XPS conversion engine has further been improved
Detail information about all fixes and enhancements has been given in release notes page of the API. In order to stay updated with every news about releases of the API, subscribe us. Do not forget to post your inquiry in our forums in case you have some. We will be back soon with updates of future version(s) of the API.
We are here to share an exciting news about upcoming API for .NET platforms. Aspose APIs are about to add a new member in their community with the name of Aspose.OMR for .NET. Yeah, you may be thinking right after getting name of upcoming API. The API will be offering quite demanding functionality to perform OMR operations over images. Speaking of OMR, you may have idea that it is Optical Mark Reading/Recognition – the process of gathering information from human beings by recognizing/reading marks on a document. It will be quite exciting and a complete new experience to read questionnaires, bubble sheets, multiple-choice answer sheets or any survey programmatically through your application. Without making any delay, let’s have insights into when this API will be available for download and with which features it will be serving its users.
First Version Availability and Features
After great hard work to get API Ready, Aspose.OMR for .NET is now at its final stage to get released publicly. You will soon be able to notice a new API in downloads section of Aspose website. As far as features of first version of the API are concerned, following is the list:
Recognition of scanned images and photos
Ability to process rotated and perspective (side
viewed) images
Recognize data from tests, exams,
questionnaires, surveys, etc.
High accuracy rate
GUI for correcting complex cases
Export the results to CSV file format
It will be really exciting to announce first public release of the API and we hope to see you soon with that update. In order to get in touch with us in the regard, do not forget to subscribe our blogs and always feel free to reach us over forums.
Good news guys! I like to share experience after using latest Aspose.Slides 19.4 which has been enriched with improved chart data support features. The good thing about Aspose.Slides is that it has a monthly release where .NET, Java, Android via Java and C++ based APIs are published together. So, whats available in .NET based API is also available for Java, Android via Java and C++ based APIs. This way the users feels comfortable with API they are using and with same features available across the board.
Process of signing PDF documents has been commonly known and being practiced in many systems. Signatures are meant to secure documents and authenticate them. We can simple take example of a piece of paper where some information is written on. Now, if you do not find any reference of that information or any attestation mark over that paper, it would be hard to believe if information is correct. But, if any stamp or signature is present on the paper then you will definitely find that information as approved or from some authentic source. Similarly, signing a PDF document digitally approves that it is from a reliable source and content present in it is authenticated.
