Applications for mobile devices are the fastest growing category of apps and the IntraWeb framework offers some unique advantages here, allowing to create applications without deployment headaches, multiplatform support (iOS, Android, RIM) and without the need to pass the gate & tax of Apple, Google or Blackberry. For mobile web application development,we have created TMS IntraWeb iPhone Controls that allow to create web applications with a look & feel that is nearly identical to native applications and that are very response and have low bandwidth usage via asynchronous events and updates. You can find the video on our more informal Facebook information channel and in the process, you can add this group to your favorites.

On the last day of the week in the TMS labs, we present a video on a new component that we're about to release: TMS WebGMaps. This component allows to show Google maps and interact with Google maps in Windows applications. Fine level of control is offered to configure the type of the map, the controls on the map, add markers, show StreetView etc… The TWebGMaps exposes a number of events ranging from simple mouse clicks to moving markers, changing zoom level and many more. You can find the video on our more informal Facebook information channel and in the process, you can add this group to your favorites.

TMS Aurelius has been released and we are very satisfied with feedback from all of you. Most comments are compliments and questions about how to use the existing many features, but some of them are also feature requests.

So the intention of this post is to give you an idea of what's coming next with TMS Aurelius and TMS Data Modeler, based on customers feedback.

Please note that this list is subject to change, especially due to further customer feedback, and is not a commitment of any kind - we have the freedom to refrain from implementing any of these features - this is just the current intention for further development.

Features being considered to be implemented until 2.0 version:
- TObjectDataset component for visual binding objects to data-aware controls
- Support for more databases
- Support for more data-access components - IBObjects will be the next one to be supported
- Custom SQL expressions and projections
- More generator types - GUID should be the next one
- Other minor fixes and of course bug fixes
- More events and/or interceptors

Other features that are being considered (depending on feedback and demand):
- Dynamic properties
- Mapping through external file
- Database schema update (simple and limited)
- Query Language - use of query commands as alternative to query API

TMS Data Modeler will be improved as well, with support for more databases and constant improvements in user interface. And, of course, tighter integration with TMS Aurelius - improved class generation and constant support for new Aurelius features.

The team has been feverishly busy here in the office working on a wide area of Delphi related tools and components to make you more productive and allow you to build applications that will stun your customers. This includes our first two FireMonkey products: TMS Instrumentation Workshop for FireMonkey and TMS TableView for FireMonkey. This includes also our new ORM framework we've just released and that was warmly welcomed: TMS Aurelius. Significant work was also done to continue to enhance, add features and extend the TMS VCL Components, in particular TMS Component Pack that adds the capabilities in a wide range of components to create applications in the Metro design language. We have this year also released our new product TMS WebGMaps to allow you to integrate Google maps in VCL applications. Finally, perhaps not so visually apparent, A LOT of work was done under the covers of our IntraWeb product range. We've added support for IntraWeb 12.1 for the entire TMS IntraWeb Component Studio and TMS IntraWeb Component Pack Pro is now fully adapted to run in Internet Explorer standards mode (full HTML5 compliant mode).

In the coming months, we hope to meet you somewhere on the planet in person to share the technical expertise behind all our latest developments and to listen to your needs, feedback and comments. Following events are already planned:

March 22th: Australia, Melbourne: ADUG symposium
March 23th: Australia, Canberra: ADUG symposium
May 14th: Germany, Frankfurt: Delphi Developer Days
May 22th: Netherlands, Utrecht: Delphi Developer Dag


More dates will be added as these get planned. In addition we also contemplate organizing a TMS day, perhaps one in the Benelux and possibly one in Brazil this year. Let us know if you'd appreciate such TMS day being organized and what content you'd prefer to see presented on such day!

We would like to announce that TMS software is a Platinum Sponsor of Delphi Developer Days 2012. (http://www.delphideveloperdays.com/)
Delphi Developer Days is a synonym for 2 days of intense training on a wide range of subjects related to Delphi programming. Delphi veterans and the world's most well-known Delphi speakers Cary Jensen and Marco Cantù share their deep knowledge about Delphi, and in 2012, you can expect a lot of coverage on Delphi XE2. One of the two tracks is focusing on the new technologies.

TMS software has been a sponsor of Delphi Developers Days for many years and I attended my first event last May 2011 when I was asked to be the guest speaker in Frankfurt, Germany. You can find the presentation description of the event last year here.

Also this year, you can expect top-notch Delphi knowledge from speakers Marco Cantù & Cary Jensen. From all conferences I have attended in the past years, I strongly believe that Marco Cantù & Cary Jensen bring with Delphi Developer Days the most technically deep & serious Delphi conference of all. And while there is a choice to be made of two tracks to follow, there is a hefty book you receive as attendee with the contents of each session, so you won't have to miss anything when two simultaneous sessions interest you both. Hurry to signup as on this type of conference, the number of places is very limited!

Also this year, I'm pleased and honored to be invited to speak at the Delphi Developer Days in Frankfurt on May 14th. This year, my session will be all about custom FireMonkey component development. In 10 steps with 10 custom sample custom components, various techniques are shown that form the basis of creating full-fledged FireMonkey components. Finally, Bruno Fierens shows where and how the techniques learned are applied in several TMS components designed for FireMonkey."

If you cannot make it to Frankfurt, Germany this year, don't worry as Delphi Developer Days is coming in more places than ever this year:

• March 26-27, 2012: London, UK
• March 29-30, 2012: Amsterdam, The Netherlands
• April 16-17, 2012: Washington DC/Baltimore, USA
• April 19-20, 2012: Chicago, USA
• May 14-15, 2012: Frankfurt, Germany
• May 17-18, 2012: Rome, Italy

I am really happy to say we have finally released our first version of FlexCel 5 for VCL/Firemonkey. It has been a huge lot of hard work, and even when there is still a lot of work to do, the biggest part is done. This version doesn't include the rendering and reporting engines, but that is no more than 20% of the total lines of code; the other 80% has already been delivered.

I still need to write a post about the technical stuff on how it was created (which I think is quite interesting), but today I want to speak about the release itself, how you can use it, what is changed and what is still missing.

What's included?

Launch schedule:

• Full recalculation support: We found some showstopper bugs and had to disable recalculation in v5.0, but it will be coming as soon as we can possibly fix the problem.


• APIMate: APIMate is a tool that tells you how to code an Excel sheet. You open an xls/xlsx file created with Excel in APIMate, and it will tell you the exact Delphi code you need to create that file. As with recalculation, APIMate is internally working and I hoped it would make the initial release, but it had some bugs (related to RTTI in initialized enums) that made us delay it.


• If possible, C++ Builder support: I am not 100% sure if this one is even possible, the truth is that Delphi produces completely bonked hpp headers for FlexCel that won't even compile. After some investigation headers could manually be fixed, but there are also bugs in the way Rad Studio returns records (C structs) to C++ builder, causing AVs when some records are returned. As said, we still need to investigate this in depth so I can't say much more until we do.


• Encrypted files xls and xlsx files: Support for encrypted files is already in the shipped 5.0 code, but not enabled since we need to code our own encryption algorithms like SHA1 and AES for it to work. At the moment the code just calls some abstract interfaces for SHA1 and AES and will not open encrypted files.


• Documentation and demos: We should be improving a lot in the documentation, providing F1 help, and adding many new demos. APIMate should help a lot with the learning curve too.


• Stability fixes: As with any first release, we expect to find many small issues that we will be fixing in this 5.1 release.

• Reporting Engine: A completely rewritten report engine that will allow a lot of new stuff in Reports. A converter from v3 reports to v5 reports will be included.

• Rendering Engine: Exporting xls/x files to pdf, html or images. Printing and previewing Excel files.

Structural changes

var
  xls: TXlsFile;
begin
  xls := TXlsFile.Create(true);
  try
     DoSomething(xls);
  finally
     xls.Free;
  end;
end;

TExcelAdapter was an abstract class that provided an interface between an actual Excel file and the components doing the work. We originally provided two different implementations of TExcelAdapter: TXlsAdapter (native interface) and TOleAdapter (interface using OLE Automation). Then you could plug TFlexCelReport into a TXlsAdapter and have a report generated natively, or plug it to an OLE Adapter and have the report generated by OLE Automation.

This was a nice abstraction and it worked fine at the beginning (when we only had a FlexCelReport component), but with the introduction of FlexCelImport (a component that was originally designed to only read xls files as its name implies, but later was expanded to also write files) things got a little too complex.

As you can see in the diagram, you have an "Adapter" and a "FlexCelImport" class that do mostly the same. So most of the methods (but not all) in FlexCelImport, just call the same method in the ExcelAdapter engine. This meant not only a lot of redundant code (and redundancy is one of the main things that we want to avoid), but also a lot of confusion in users who didn't know what to use, if ExcelAdapter or FlexCelImport. We explained in the documentation that you should use FlexCelImport and not ExcelAdapter, but people kept using ExcelAdapter. And when people keeps doing the "wrong" thing despite what the docs say, this normally means not a problem in the docs or the users, but a deeper problem in the conceptual design of the code. This wasn't as intuitive as it could be.

The last problem with this architecture was that FlexCelImport was at the same level as FlexCelReport, so they couldn't "see" each other. The design was top-down, and the components at the top can only know about the components at the bottom. So in the places where FlexCelReport allowed hand-optimization of the code, it had to expose an Adapter component (the only thing it knew about) and not a FlexCelImport component. But you were supposed to use FlexCelImport to do manual modifications in the file, not the Adapters.

If we sit back and take a look from the distance, all the problems came from the fact that FlexCelImport was added as a separate layer over the Adapter components, and it didn't had to be that way. So, in v5 we only have one class to read and write Excel files, and it is at the bottom where everybody else can use them, as it should be. There is no more FlexCelImport in v5, and the scheme looks something like this:

Where now the abstract class to read and write is TExcelFile, and the native implementation of that class is TXlsFile. All the code you used to use with FlexCelImport, should use TXlsFile now instead.

Migration from v3 to v5

Thanks

We're proud to announce our first Windows Phone app! Stay in touch with the latest developments and releases at TMS software anywhere, anytime with one single Windows Phone application. View the latest blogs, tweets, product releases and Youtube training videos.

• View latest product updates, release history, component descriptions
• Stay in touch with the latest blog articles as they are written
• Instantly view latest TMS tweets
• Detailed product information with the latest updates
• Read our blog, check our tweets
• See what's new, what's improved, what's fixed in our components
• View latest Youtube training videos from the tmssoftwareTV's channel

After many months of research, developing, testing, polishing and documenting, the team at TMS software is proud to announce the availability of our first TMS FireMonkey cross-platform grid!

• import and export: CSV, TXT, ASC, HTML, XML, RTF (native),XLS (native), streams
• clipboard support
• printing support: print to printer, print to image file, print preview component
• find & replace including find & replace dialogs
• various built-in inplace editors: edit, combobox, datepicker, dial, spin, ... and customizable
• various built-in cell types: text, bitmap, button, checkbox, radiobutton, progressbar, ... and customizable
• cell merging
• fixed header rows, fixed footer rows, fixed left columns, fixed right columns
• column freezing, row freezing
• cell scrolling & pixel scrolling modes
• various selection modes: single cell, range, column, row, disjunct column, row, cell
• sorting: single column & multi column in normal & in grouped mode
• filtering: programmatic row filtering and filter dropdowns in a column header cells
• grouping: built grouping with group headers, group summary rows
• calculations: column calculation results in fixed footer row
• HTML formatted text in cells, URLs in cells
• Fine grained control over keyboard & mouse interaction
• Lots and lots of smaller features

Listening to the needs of our customers was always a top priority during the last 17 years at TMS software. The daily communication with our customers has proven to be very fruitful for steering not only what capabilities and features are being added to existing components but also creation of entirely new components and products. As our customer base has grown through the years, the communication has grown too. It is not always easy to determine if some particular feature requests are highly anticipated by a large enough amount of customers or not. In many cases, it is obvious that some feature request makes a lot of sense and will help a lot of customers and then we don't hesitate to add it. In other cases, it's not so clear whether a particular feature would be welcomed by many users. Therefore, we thought it was time add another dimension to the process of deciding what to do.

We have released this week an extension to our website, a feature request voting system. On each component/product page the item "Feature requests" was added from where customers can add new feature requests or vote for existing feature requests. These feature requests will then be taken in account with our own internal development planning and roadmap.

We hope this will:

• drive more customers to communicate about their needs
• streamline the process to capture and list these feature requests
• help us to further fine-tune setting the right priorities and doing resource allocation

On Saturday September 1 near Utrecht, Blaise Pascal Magazine is organizing the free PasCon: Pascal Conference day. I am very honoured that I was invited to do a session about one of our most exciting recent developments, the TMS Grid for FireMonkey.
In the session on the Pascal Conference, I will highlight the architectural decisions, the challenges in developing large and high performance style-able components for the FireMonkey framework, the feature set of the grid and I will present an exclusive first look at the LiveBindings capabilities that will be built-in in the next update of the grid that we will release shortly.
If you're around, feel free to register for free for the great Pascal Conference and come by as there are interesting sessions about Smart Mobile Studio and FastReport too.
Of course, it is also a great opportunity to meet and discuss about other TMS components and developments, ask questions, provide feedback in the time between the sessions. Looking forward to meet you there.

Be-Delphi organises on November 22 the second yearly Delphi event Be-Delphi 2.0 in Antwerp, Belgium. National and internationally acclaimed speakers such as Marco Cantu, Bruno Fierens, Pawel Glowacki, Bob Swart, Brian Long, Jason Vokes … bring a varied mix of technical sessions.

Top speaker Marco Cantu will reveal as much advanced information about the upcoming Mobile Studio and preparing your code for it as he's allowed to and will also give a second session about getting the most out of development for Windows 8 with XE3, including the new Windows 8 Live tiles for which he was involved in the development. Brian Long will present another hot product: Nougat for native iOS and OS-X development with Object Pascal. Pawel Glowacki will cover the new FireMonkey 2.0 features in depth.

TMS software is platinum sponsor for this event, the team will be present the entire day with a booth and Bruno Fierens will give a presentation on the TMS Grid for FireMonkey. So you're welcome to come & discuss everything ongoing at TMS software as well.

The best speakers, simultaneous sessions, very interesting talks in a fantastic surrounding make Be-Delphi 2.0 the event not to miss for the Delphi developer. Don't miss out on the early bird discount and register now via www.be-delphi.com. See you on Be-Delphi 2.0!

Speakers / Sessions

	Jason Vokes - Embarcadero What's new in RAD Studio XE3 and what's cooking at Embarcadero			Bob Swart - eBob42 Building multi-tier applications with DataSnap
	Brian Long - blong.com Project 'Nougat' - native iOS and OSX with Object Pascal			Filip Lagrou - C-Quel Multi-Tier with RemObjects DataAbstract for Delphi
	Bruno Fierens - TMS Software TMS Grid for FireMonkey discovered			Stefaan Lesage - Devia User Interface & User Experience (UI vs UX)
	Pawel Glowacki - Embarcadero What's new in FireMonkey v2.0			Marco Cantu - Wintech Italia Windows 8 support in Delphi XE3 Getting your Delphi code ready for the upcoming Mobile Studio

Embarcadero Delphi Conference Brasil will happen in Sao Paulo, Brazil, this Tuesday, October, 23rd. This is the fourth edition of the event organized by Embarcadero, which had nothing less than 700 attendees last year. There will be up to five simultaneous sessions in two auditoriums and three rooms covering the latest Firemonkey technology, Multi-tier development, databases and also TMS Aurelius.

Among the speakers, there will be Michael Swindell, Senior Vice President of Marketing and Product Management, and David Intersimone, Vice President of Developer Relations and Chief Evangelist. Both will be presenting the new HTML5 Builder tool and the new features in Rad Studio XE3.

From TMS Software, Wagner Landgraf will talk about TMS Aurelius showing how to build an ORM-based application from scratch using techniques that allow to easily port from a single local-based database application to a complete multi-tier application based on REST servers, even using JavaScript clients.

For more information, visit the official Embarcadero Delphi Conference web site.

The Be-Delphi conference is getting closer. As platinum sponsor of this conference, we are delighted that this will be a very special conference! For the first time, attendees will have the opportunity to meet Marco Cantu in his new role as Delphi product manager. I have been sitting together with the Be-Delphi organisation and there will be some flexibility for extra Q&A time with Marco Cantu. That's good news. Of course, you'll also be able to chat during the breaks with the new Delphi product manager.
In addition, we just got special permission from Embarcadero to show live some first-time and highly exclusive previews of what's coming in the near future from Embarcadero and TMS software. At this time, we can't say more.
We are counting down the days and look forward to be there. If you want to attend Be-Delphi as well, I heard the limited number of places are running out quickly, so hurry to register at http://www.be-delphi.com

Delphi sessions of Code Rage 7 conference happened on beginning of November. One of the sessions, presented by Olaf Monien, was about building a DataSnap Rest Client using TMS Aurelius and TMS Data Modeler.

It's an great video for those interested in learning more about DataSnap, REST and course, Aurelius and Data Modeler.

Watch on youtube:

Download link: http://cc.embarcadero.com/item/29184

TMS Aurelius version 1.7, released a couple of weeks ago, introduced a new feature that was often requested by users: JSON support. You may ask yourself, why is that so important? Can't I "use JSON" already with Delphi itself using JSONMarshal class, or even by a 3rd party library like Super Object?

Well, yes and no. Actually there are already many people using Aurelius in distributed applications, using it with DataSnap, REST servers. etc.. My previous blog post is an example of that. If you have in your application simple entity classes like this:

  
  [Entity, Automapping]
  TCustomer = class
  private
    FId: Integer;
    FName: string;
    FCity: string;
  public
    property Id: Integer read FId write FId;
    property Name: string read FName write FName;
    property City: string read FCity write FCity;
  end;

function TBugTrackerMethods.LoadIssue(Id: integer): TJsonValue;
begin
  Result := FSerializer.ToJson(FManager.Find<TIssue>(Id));
end;

procedure TBugTrackerMethods.SaveIssue(Issue: TJsonValue);
begin
  FManager.SaveOrUpdate(FDeserializer.FromJson<TIssue>(Issue));
  FManager.Flush;
end;

function TBugTrackerMethods.ListIssuesByProject(ProjectId: integer): TJsonValue;
var
  IssueList: TList<TIssue>;
begin
  IssueList := FManager.Find<TIssue>
    .SubCriteria('Project')
    .Where(TLinq.IdEq(ProjectId))
    .List<TIssue>;
  try
    Result := FSerializer.ToJson(IssueList);
  finally
    IssueList.Free;
  end;
end;

var issue = null;
$(document).ready(function() {

  $('#issuediv').hide();

  $('#searchButton').click(function(event) {
    issue = serverMethods().LoadIssue(issueIdField.value).result;
    $('#issuediv').show();
    $('#idField').val(issue.Id);
    $('#subjectField').val(issue.Subject);
    $('#priorityField').val(issue.Priority);
    $('#statusField').val(issue.Status);
    $('#assignedToField').val(issue.AssignedTo.Name);
    $('#projectField').val(issue.Project.Name);
    $('#descriptionField').val(issue.Description);
  });

  $('#closeButton').click(function(event) {
    issue.Status = 'Closed';
    serverMethods().SaveIssue(issue);
    $('#issuediv').hide();
  });

  $('#cancelButton').click(function(event) {
    issue.Status = 'Canceled';
    serverMethods().SaveIssue(issue);
    $('#issuediv').hide();
  });
});

At the end of the year, it is always good to reflect on what the year has brought, to learn from it and to plan for the next year.

Product releases in 2012

In January, we released a new product, TMS WebGMaps, a set of components to add Google mapping capabilities in your Delphi applications.
That was not all, in January, we also released our new ORM for Delphi, TMS Aurelius. It was quickly a widely acclaimed, appreciated and quality ORM framework that we continued to give extensions and improvements throughout the year. And if you thought that was all for January, we also released TMS Metro Controls Pack. This is a set of controls that offer this flat new Microsoft Windows 8 look and feel to your Delphi applications. With respect to this Metro style, we also added Metro style support in the TMS Smooth Controls Pack.

In February, we released a new component for FireMonkey: TTMSFMXTableView, an iOS tableview inspired cross platform list control. Shortly after this, we also released TTMSFMXPopup, the iOS inspired popup window control. But there was more in February: we added Metro style support in the TMS ribbon and we released TMS Aurelius with a major new component TAureliusDataSet to make it easy to connect the ORM to existing DB-aware VCL controls. But without a doubt, the biggest release in February was TMS Flexcel v5. This long awaited and extremely comprehensive library now can natively handle XLS,XLSX,XLSM files on Win32,Win64 and Mac OSX.

In March, we were busy with more FireMonkey components, in particular TTMSFMXTileList. We also created TMS Grid Filters, the interface between TMS Flexcel and the TMS VCL grid components to offer seamless support for importing & exporting grid data from and to XLS and XLSX files. We were also happy to see TMS Aurelius seen choosen by Andreano Lanusse as project of the month.

In April, we launched a new product, TMS Pack for FireMonkey to give customers access to all our FireMonkey components with one bundle. We also released an update for our syntax highlighting VCL TAdvMemo with a list of new features that were added.

In May, TMS Flexcel for VCL/FireMonkey was released with the new APIMate tool that automatically shows the Delphi or C++ code needed to use to create the wanted effects in the XLS/XLSX file. We released TMS Aurelius 1.4 with the new capability to allow mapping of dynamic properties to database columns at runtime. A major update for our award-winning VCL Grid TAdvStringGrid was released with many new capabilities added. Meanwhile, our team continued development off several new FireMonkey components, with two new releases: TTMSFMXHotSpotImage and TTMSFMXSpeedButton.

In June, TMS DataModeler got an update with SQLite support added but also extended capabilities to integrate with TMS Aurelius. We launched in June also the TMS BI Pack, the bundle of TMS Aurelius, TMS Data Modeler, TMS Scripter, TMS Diagram Studio and TMS Query Studio, a bundle of tools to streamline and automate DB applications and DB application development. We also released a new product: TMS IntraWeb Cloud Pack: a set of components to allow seamless integration of cloud servvices such as Paypal, Twitter, Facebook, Windows Live with IntraWeb applications. There was more, TMS HTML5 Controls Pack got an update with XY scatter chart support added and TMS Aurelius was released with new support for Absolute databases and new capabilities for control over and customizing SQL expressions.

In July, after many months of hard work, we released a first version of our grid component for FireMonkey. All TMS Pack for FireMonkey users got now also this powerful and feature rich cross platform grid. We also worked on our website and added a feature voting system. All the time, we of course also continued to update our TMS Component Pack, getting all improvements and new components for VCL Win32 and Win64 development.

In August, we released TMS Cloud Pack v1.0. In this first version, we offered access to cloud storage services DropBox, SkyDrive and Google Drive from VCL applications. The TMS VCL Subscription was also extended with this new TMS Cloud Pack.

As Delphi & C++Builder XE3 was released in the beginning of September, we updated all our components with support for this new IDE and also released a new version of the TMS Pack for FireMonkey with support for the new Visual Livebindings in XE3. Another major release in September was TMS Scripter with new support to use the scripting engine from FireMonkey cross platform applications. Finally, a new VCL TAdvListEditor component was also released in September.

In October, a series of updates was released. TMS Component Pack with the new TAdvListEditor component, TMS Pack for FireMonkey with the new TTMSFMXCalendar and TTMSFMXCalendarPicker, TMS Smooth Controls with the new TAdvSmoothCalendarGroup. A major release was the update for TMS Flexcel and TMS Grid Filters with the new PDF export capability. This allows to generate high quality PDF files from Excel files or from data in TMS grid components. We also showed a very exclusive preview of Flexcel .NET code running on WinRT.

In November, there was yet another update for TMS Pack for FireMonkey, this time with native PDF export capabilities added for our FireMonkey cross platform grid. Also TMS Cloud Pack got a major update with new components for seamless access to cloud services Twitter, Facebook, Windows Live Calendars, Windows Live Contacts, Google Calendar, Wunderground weather service access and more. We showed a preview of the cloud components working on iOS as well.

And finally, in December, we released a major update for TMS WebGMaps with new support for showing directions, adding polygons, adding marker labels on the map, showing a directions list,... To conclude the year, TMS Component Pack 6.7 was released with 5 new VCL components and TMS T(DB)Planner got a free add-on TPlannerGCalendarExchange, TPlannerLiveCalendarExchange to import/export data from a Planner to cloud calendar services with the TMS Cloud Pack.

Events in 2012:

TMS software was also present on many events throughout 2012.

In March, Bruno Fierens gave presentations on TMS Components in Melbourne and Canberra at the ADUG Conference. In May, we were present at the Delphi Developer Day organised by Barnsten in the Netherlands and also in Frankfurt for the Delphi Developer Days organised by Marco Cantu & Cary Jensen. In June, Bruno Fierens gave a presentation on cross platform FireMonkey development on the cross platform conference in Moscow and also a session in Brussels on a Barnsten organised event. In September, TMS software was present at the CodeWay tour in Paris, France showing the latest developments for XE3. In October, Bruno Fierens received the Embarcadero MVP status and in November, TMS software was present at the Be-Delphi conference in Antwerp and Bruno Fierens gave a presentation about the FireMonkey grid.


I think we can conclude 2012 was a very busy year. We're already brainstorming on several things for 2013. We look forward to be at your service in 2013 and we look forward to hear about all your wishes, comments, feedback.

Last summer we have released our powerful, feature-rich cross platform grid for FireMonkey. Shortly after we have also released a major update for TMS Flexcel. With TMS Flexcel v5.5 there is full native support for manipulating, creating, reading .XLS, .XLSX files as well as for generating .PDF files from cross platform FireMonkey applications.

Today we have released free bridge components between our grid for FireMonkey and TMS Flexcel to offer seamless export and import of .XLS, .XLSX files in our grid for FireMonkey and to generate .PDF files on Windows and Mac OS-X and soon also iOS from data in our grid. With these components, just dropping a few components on the form, interconnecting and 1 line of code allows you to load or create Excel files from our grid for FireMonkey or generate a PDF from the grid data.

Some of the features:

• Fully native solution to import/export to .XLS, .XLSX without the need for Excel to be installed on Windows & Mac OS-X!
• Fully native solution to export grids to .PDF, no extra tools or libraries required
• Import/export wide range of cell properties: background color, alignment, font, wordwrap, ..
• Import/export of cell images, multi cell images, checkboxes, hyperlinks
• Import/export merged cells
• Export of HTML formatted text in grid cells
• Support for virtually unlimited nr. of columns & rows for import/export with new .XLSX file format

It's a fact, in cooperation with Be-Delphi, organizer of the Be-Delphi Delphi developer events, we will be organizing the first TMS Day on April 25, 2013 in Antwerp, Belgium.

The TMS Day will bring all TMS experts together: Bruno Fierens (Embarcadero MVP / CTO TMS software), Adrian Gallero (Product Manager TMS Flexcel), Wagner Landgraf (Product Manager TMS Aurelius, TMS Scripter, TMS Diagram, TMS Workflow) , Pieter Scheldeman (Tech lead FireMonkey products) for in-depth and personalized training on TMS Delphi & C++Builder products.

In order to ensure technical focus, participation during sessions and personalized information, the number of places will be very limited. We aim at 20 attendees with an absolute maximum of 25. Attendees will also be able to submit questions in advance so speakers can devote time to prepare topics for the TMS Day and sufficient time will be allocated for Q&A the day itself. In short, we want to make it a highly valuable event for TMS customers.

Some of the topics that will be covered are: TMS VCL grid, TMS FireMonkey components, TMS Aurelius, TMS Flexcel. Detailed program is being worked on.

Registration for the event will open soon. Prices will be kept at an absolute minimum just to cover organisational costs in the range of 200EUR/seat. Facilities for hotel rooms at the event will be available for international attendees. If you have any questions, don't hesitate to contact us.

On February 14, Delphi turns 18 years. To celebrate 18 years of Delphi, we've searched through our archives and brought together quite some items that bring back memories and recall moments of these exciting 18 years.

Every day during February we'll publish a new picture of some item that defined something special in the history of Delphi on our Facebook page: http://www.facebook.com/tmssoftware.
We look forward to your comments and to hear how these items were relevant and affected your passion for Delphi.

We kick off on this first day of February with a series of TShirts from the big Borland conference held in various cities in the USA. Enjoy!

Even though TMS Aurelius provides extensive documentation, I sometimes receive requests to provide more examples, sample codes and explanations about how to accomplish some daily tasks. Thus, I will start a series of posts about how to use TMS Aurelius. Everything is already covered in the documentation, but here I will try not to provide complete, technical, “official” coverage of a feature, but plainly explain what it is for instead by giving real-world examples etc. - in summary, a different, hands-on way of showing things.

I will start right from the beginning. I want to show a small application using TMS Aurelius. Having an entity/a model class TCustomer, mapped as follows:

unit Customer;
interface
uses
  Aurelius.Mapping.Attributes;

type
  [Entity, Automapping]
  TCustomer = class
  private
    FId: integer;
    FName: string;
  public
    property Id: integer read FId write FId;
    property Name: string read FName write FName;
  end;

implementation
end.

program GettingStarted;

{$APPTYPE CONSOLE}

uses
  Aurelius.Drivers.Interfaces,
  Aurelius.Drivers.SQLite,
  Aurelius.Engine.DatabaseManager,
  Aurelius.Engine.ObjectManager,
  Aurelius.SQL.SQLite,
  Customer;

var
  Connection: IDBConnection;
  Manager: TObjectManager;
  Customer: TCustomer;
begin
  Connection := TSQLiteNativeConnectionAdapter.Create('test.db');
  Manager := TObjectManager.Create(Connection);
  Customer := TCustomer.Create;
  Customer.Name := 'First customer';
  Manager.Save(Customer);
  Manager.Free;
  WriteLn('Customer saved.');
  ReadLn;
end.

procedure CreateDatabase(Connection: IDBConnection);
var
  DBManager: TDatabaseManager;
begin
  DBManager := TDatabaseManager.Create(Connection);
  DBManager.BuildDatabase;
  DBManager.Free;
end;