By Synergex, Posted on January 14, 2019 at 3:26 pm
As we head into 2019, we reflect back on one of our favorite events of the year: the 2018 Synergy DevPartner Conference in New Orleans.
Packed with sessions on topics ranging from modern and agile development practices to RESTful web services to QA and learning culture, not to mention an engaging and illuminating keynote presentation from Microsoft’s Donovan Brown, the conference offered a plethora of info, ideas, tips, tricks, and plans for the future. Case studies and customer demos provided insight into practical implementations of technical concepts, and we were jazzed to introduce our new open source RESTful web services project, Harmony Core. Bourbon Street wasn’t too bad either! The legendary food, music, and culture of one of America’s most historic cities provided a great backdrop to a fun and productive week.
Here are some key takeaways from the conference:
Improve your productivity and practices by adopting more efficient development methodologies.
Enhance years of Synergy data and code with new technologies, including enabling connectivity through RESTful web services.
Security and disaster recovery are important for compliance—stay up to date with Synergy SSL and operating system security patches.
Use traditional Synergy in Visual Studio (it’s not as hard as it seems!) to significantly boost productivity, lower the barrier to continuous code integration, and improve your processes and software quality.
Move to the cloud. Developing and running your Synergy application in the cloud is relatively easy and provides a convenient path to expand your infrastructure to meet demands.
Education in the workplace is important—create an onboarding program that includes presentations, videos, and discussion.
The Synergex team came back to the office energized and ready to implement big plans for Synergy in the new year. We look forward to seeing you at the 2020 conference!
By Steve Ives, Posted on September 23, 2018 at 4:43 pm
Just a quick note to announce that CodeGen 5.3.6 has been released and is available for immediate use. This latest version represents the culmination of a series of recent releases which together have added significant new features across the entire product, including the ability to generate code based on metadata found in the xfServerPlus Synergy Method Catalog.
Many of the new features were added specifically to support code generation for the new Harmony Core RESTful web services framework that we are excited to be introducing at the upcoming DevPartner Conference in New Orleans next month.
If you are joining us for the post-conference Harmony Core workshop then you will need to have this new version of CodeGen installed on your development system; you can download it here. And even if you’re not intending to use the new Harmony Core framework, there are many new features that may be useful to all CodeGen users; we recommend this release for general use.
We’re looking forward to seeing you all in New Orleans between October 8th and 12th. If you haven’t signed up yet, it’s not too late! You can still sign up here.
Development of your traditional Synergy code in Microsoft’s Visual Studio was introduced at the DevPartner conference back in 2016. Using an integrated development environment (IDE) like Visual Studio not only promotes better code development practices and team development but shows prospective new hires that your tooling is the latest and greatest.
The next release of Synergy—10.3.3d—includes all the capabilities now required to fully develop and build your traditional Synergy–based applications in Visual Studio. During a recent engagement I worked with a team of developers to migrate their existing Synergy Workbench development to Visual Studio with great results. Although there are a few steps to complete, the results of developing in Visual Studio more than outweigh the effort taken to get there. And if you think developing in Synergy Workbench is great and productive, just wait until you are using Visual Studio—there will be no turning back! Here are the high-level steps you can take to get your traditional Synergy development to Visual Studio.
First place to start is the Synergy Repository. We all have (or should have) one. Synergy now provides a Repository project that will allow you to build your repository files from one or multiple schema files. If you have multiple schema files you can use the new pre-build capability to run your existing command scripts to create the single, ordered schema file or load the repository your way—simple. So why have the Repository project? Because you can load all your individual schema files into it, and if any change, your repository will be rebuilt automatically.
Next create your library projects. These are either executable (recommended) or object libraries. Ensure you reference the Repository project using “Add Reference…”. You no longer define the Repository environment variables “RPSMFIL” and “RPSTFIL”. This step ensures that if your Repository project is rebuilt, any projects referencing it will be as well. Next add the source files for the routines that make up your library, and build. You may have a few build issues to resolve—the 10.3.3d compiler is a little stricter, and unresolved references will need to be resolved. Any environment variables required to build your software should be set in the project common properties page or if they are library specific in the project environment page.
Finally, your main line programs. Create the required project with single or multiple main line programs. The multiple main line project allows you to have all the programs in one place, and you can easily specify the program to run.
Now you can build and run your traditional Synergy code from Visual studio—and even better, you can debug through the code using the powerful Visual Studio debugger.
Using UI Toolkit? Keep a look out for a future blog post showing how to easily incorporate window script file builds into your development process.
Building for UNIX? Not a problem. A future post will show the simple steps to target the UNIX platform from within Visual Studio.
We are here to help! Synergex can help with every aspect of getting your traditional Synergy development environment inside Visual Studio. Just ask your account manager or contact me directly.
Most Synergy developers would love to use the very latest and greatest development tools to develop and maintain their Synergy applications, but how do you get started? At the recent DevPartner conference in Atlanta product manager Marty Lewis not only discussed the concepts of how to get started, but actually demonstrated the entire process with a real Synergy application. Check out his presentation entitled Developing Synergy Code in Visual Studio:
The post conference workshop developed from the ground up a vinyl record collection catalogue system that allowed the management of your favourite records. The workshop stepped through the various aspects of the system including a desktop WPF maintenance program and remote management of your cloud based catalogue using the Synergy DBMS manager.
Having all your vinyl discs catalogued is great – but when I’m in the record shop browsing through all the latest available titles I often wonder – have I got this one? I’ve got a lot of vinyl’s and many more CD’s so remembering all the one’s I have can be difficult, and there is nothing worse than buying a duplicate.
So our OnVinyl app we built at the conference allows us to scan the barcode of the album in the store and check it against our catalogue – if we have it then the details are displayed and we don’t go and buy it again.
Getting all the album information into our catalogue would have been a long and rather boring job – especially having to trawl the web looking for the artwork to associate with each album we have. We need an easier solution – and so to Google we turn.
We all know how good Google is at searching for basically anything you can think of really, but did you know you can use this powerful searching capability from within your Synergy programs? Google provide a search API that allows you to simply and very easily perform any search you require. This is the facility we added into our OnVinyl Album Maintenance program – enter (or scan if you have a barcode scanner to hand) the barcode on the album and pass this through to the Google search API. Our implementation retrieved the album name, artist, cost and artwork so we are able to populate all the fields in the maintenance form – without any typing!
The Google search API provides a REST API that you can call directly from within your Synergy program. For full details visit https://developers.google.com/custom-search/json-api/v1/using_rest. To use the API you need a Google account. The first step is to create an “API key” which allows you access to various Google API’s and identifies you to those API’s. Visit the Google API Manager console to create an API Key. Once you have an API key then you can set up a custom “search engine” that allow you to customize how your searching is performed. You can limit the results to certain web sites for example. This is all configured using the Google control panel (https://cse.google.com/all). To begin you create a new “search engine” and name it. Once created it will be assigned a unique search engine ID – you’ll need this!
In your Synergy code define some constants;
The API is a REST implementation that has a defined URI;
And then make the required REST call to retrieve the search results;
And that’s the call to your custom search engine complete. The response from Google will be in the form of a JSON string which you need to parse and out and extract the individual elements you require. The code for that is available in the OnVinyl project.
And the results in your application;
Easy really is easy with Synergy and Google searching!
On a side note – I’ve been wondering where Jodah had got to, and then this appeared in my inbox;
I’m sure I recognise those eyes…. Have you seen or got a picture of Jodah’s identifying name tag?
This year’s DevPartner conference was held in Atlanta, Georgia and was a blast. I guess I say “the best ever”” each year, so I won’t this time – but it was. The whole conference ran flawlessly, although throughout the week I did see a few strange things in the corner of my eye – but you know how it is. You think you are seeing things… But maybe not.
We had lots of new faces in the audience seeing what Synergy has to offer which is always great, and they got to see a few new faces presenting at the DevPartner conference for the first time.
Although Phil could be considered a veteran now – his third conference – he was joined on stage by first-timer Tate, a fellow support engineer. They presented a cool session on BOTS – not those things you sit on, the automated robots that answer whatever questions you have. There are loads of bots around and the duo showed us what it’s all about and how to build you own!
Another new face was Jacklin who presented all the ways to get fully up to speed with Synergy today including all the various media feeds and the cool YouTube channel we have that’s being loaded with great training videos – and of course you can always re-watch all the conference sessions.
At the beginning of March I blogged about “Physio My Way” which is an app to monitor a patients compliance to perform their prescribed upper limb exercises. Ashley presented the full Physio My Way story and received great feedback – if you get the time check out the Synergex YouTube channel in the coming days to see the full video! It’s a complete mobile solution written end to end in Synergy.
And so to my post-conference workshop. The goal was to write, from scratch, a complete application called “On Vinyl”. “On Vinyl” is a vinyl collection management and inquiry system. The system is written entirely in Synergy .Net and uses the Symphony Framework.
We started off by code generating the base data objects – the classes that expose the Synergy Repository structures as classes with full get/set properties for the fields. We also code generated classes to provide complete data management using Symphony Harmony.
Next we built a simple maintenance program to allow us to manage our collection of vinyl albums. To save typing we also implemented the ability to perform a Google search passing in the album barcode and returning/displaying all the album information, including the cover artwork. I’ll blog about just how easy it was to implement Google searching soon.
Next we hosted all the server logic on a remote cloud server behind Symphony Bridge and showed how to manage the data remotely using the Synergy DBMS Manager (available on the download page at www.symphonyframework.net).
Next we moved to the client portion of the project – to build and deploy an app on the Android and iOS platforms to enable us to check if we have a particular vinyl in our collection. We built up the technology stack. First layer was the client data layer – code generated data objects built into a portable class library. Next we created the connection library which used commands to search for vinyl details using the barcode:
If we didn’t have the album in our collection we could call our stored procedure to perform the required Google search:
And if we chose to buy the album we could insert it into our collection directly from the device:
Our final portable library was the common UI code – using Xamarin Forms. This provides the ability to write the UI once and deploy to different target devices such as Android and iOS.
Up to this point, although there were a couple of “what was that…” moment’s things all built and ran just fine.
The final piece of the puzzle was to write the device specific code – and our first target was Android. We created the project, added the required resource (images, etc.) and after a couple of minor typo’s the project built. But something was not quite right and we could not get the program to successful deploy and run.
We’d hit the end of the day so aborted the attempt and regrouped to try to find out what had gone wrong. Once we have the solution I’ll post the entire project to GitHub and blog about it!
Now I don’t really believe in code gremlins, ghosts or phantoms, but throughout the week there were some strange goings-on, and to be honest I was having flash-backs to conference time 2009! Surely he was not back to try to mess up my workshop again?
Working with the many customers we have is a great opportunity to advance the software we write. Some time ago I blogged about Symphony Bridge – a server based utility that allows you to expose Synergy data and logic through Symphony Harmony using an SQL-like syntax. In essence you can write queries on the client like “select * from part” and the bridge server will return a collection of part objects that are based on a structure you have created in your repository. You can then bind these to grids or input controls on you windows or mobile applications or display them in web pages. In fact you can use the data in any Synergy .Net or non-Synergy application.
Another aspect of Symphony Harmony/Symphony Bridge is the ability to call a remote procedure using the syntax “exec @MyNameSpace.MyClass.MyMethod”. You can pass in arguments and again a data object or a collection of data objects are returned.
During a recent visit with one of our customers who is currently utilizing symphony Harmony and Symphony Bridge to provide third-party access to their systems to allow enquiries on orders, etc. I was asked about “providing the ability to return a standard object that contains the call status AND the response data”. Simple, no problem: Create an RPS structure that defines your response details – call status, error codes, and error message for example. Code generate the required data object and then customize it by exposing a collection of <DataObjectBase> (the base class of all data objects!) As I said – simple.
But the customer was not overly impressed – and they had an idea! Oh dear me thinks – these are seasoned C# developers and I’m not convinced I’ll be able to implement their ideas in Synergy .Net! But how wrong I was…. and without any changes to the Symphony Framework. The basic requirement is to have a “response” class that they can extend with any serializable “type” – be that a single instance or a collection of “type” – without any restrictions.
The starting point was the same – create the required response structure in the repository and code-generate the “response” class. This is the resulting class definition;
public partial class Server_response_Data extends Symphony.Conductor.Model.DataObjectBase
The code generation process creates all the required properties and the logic to serialize the data into JSON or BSON.
The next step was to create a second class with the same name as the response class but this time it will accept a generic – generics are quite cool and allow you to defer the specification of a type until that type is instantiated. So our generic response class definition looks like this;
public class Server_response_Data<T(new)> extends Server_response_Data
By extending the base code-generated class we get all the required Symphony capabilities. The “T” denotes the generic “type”. The (new) ensures that any type you provide must have a parameter-less constructor which ensures that this class can creates an instance of it. We can expose the property so it’s serializable;
public property Result, T
And in the constructor we can ensure there is an instance (to prevent null object exceptions);
public method Server_response_Data
Result = new T()
And that is about it. You can then write your server methods to create an instance of your response class, populate the generic “response.Result” with the required “type” and set the response properties accordingly. For example;
data response = new Server_response_Data<Part_Data>()
Will create a response class with the “Result” as a type of Part_Data data object. If you need to return a collection of Part_Data objects;
data response = new Server_response_Data<List<Part_Data>>()
It’s really as easy as that. On the client you simply make the remote EXEC call through Symphony Harmony;
result = DataExecute.RunDataExecute(connector,
& "exec @MyNameSpace.MyClass.MyMethod",
& new Server_response_Data<List<Part_Data>>()).Result
You can also await the call on a separate thread.
Big shout-out to Gareth for the idea and his persistence to make me get it working!
I’ll be using these techniques in my DevPartner 2017 post conference workshop as we build a mobile app from start to finish using Symphony Harmony/Symphony Bridge to access remote data and logic.
The DevPartner 2017 conference is rapidly approaching and so I thought I’d follow on from Steve’s recent blog about the conference and what a content packed agenda we have this year. As usual we have the hugely successful customer demonstrations – always great to see how developer are making the most from Synergy today. There are guest speakers taking about testing your software – and I thought if it compiled it was tested, so I’ll be glued to that one. We also have a student Physiotherapist guest speaker – not your usual topic for a Synergy software conference I must agree!
Way back in 1981 a certain blond bombshell by the name of Olivia Newton-John hit our screens in tight pink leggings telling us all to “get physical”. For many around my age she was the pin-up of our times. I’m sure I can recite all the lyrics today! Although we won’t be seeing Miss Newton-John at the conference (sorry) we will be “getting physical”!
As part of an undergraduate degree I’ve developed an interactive mobile app:
“Exercise compliance is one of the most important parts in patient rehabilitation, and yet it is given minimal consideration. The Chartered Society of Physiotherapists (CSP) detail that the first step in rehabilitating a patient back to their pre-injury function lies with their Physiotherapist’s ability to educate and motivate their patient through a clear and concise home exercise program. Patients can regularly expect to receive a printed sheet of generic exercises laden with hand-written amendments which look to tailor the exercises to the patient’s needs. Given that more than 70% of adults in the U.K. own a smartphone, there has never been a better time to take the technological leap and focus of connecting with and engaging patients much more remotely. That’s where Physio My Way comes in.”
And so Physio My Way was born. Written entirely in Synergy .Net it’s a true mobile application that is designed to educate patients to perform the correct exercises and monitor their compliance with the exercise schedules defines by their therapist. In-app options include the ability to review the various assigned exercises and stream videos that show just how they should be performed. Guidance is provided through spoken instructions and monitoring patient compliance is recorded using the devices accelerometer.
“Movement patterns and screen activity can provide a clear and detailed account of every single repetition that a patient completes. Their Physiotherapist will have secure access to all of their patients’ data through their own personal log in. Specifically, this means that all exercise progressions or regressions will now be based on objective outcome markers, rather than a patient’s subjective recollection of their exercise completion. This gives superior reliability of patient feedback and is based on key Physiotherapy findings such as severity, intensity and frequency of pain and rate of perceived exertion at every interval.”
Our guest student Physiotherapist , Ashley, will be presenting an interesting session on his design and the theory behind the Physio My Way app and the results from his studies – did it improve people’s compliance with their prescribed exercise plan? And I’ll be dissecting the technologies used to develop and deploy data in the cloud and the app to Google Play Store and the Apple App Store:
At the post conference workshop on 12th May I’ll be building, from the ground up, a cross-device mobile application through lecture and demonstration. The session will target both Android and iPhone devices. Using the latest Synergy tools, Xamarin forms and Visual Studio. We will initially build and deploy a simple cloud based server. From here we will build a client connection module to communicate to our server and also implement the required code to manage Synergy device licensing. Next we will layer on the UI – XAML based cross device compliant forms. We’ll include some cool Xamarin components and finally build and deploy to both iPhone and Android. It’s a not-to-be-missed day if you are interested in expanding your Synergy applications capabilities onto the mobile device platforms.
Make sure to sign up and bring your exercise gear as we “get physical” at DevPartner 2017!
By Steve Ives, Posted on February 23, 2017 at 10:23 pm
Today we published the agenda for the 2017 DevPartner Conference which will take place in Atlanta, GA the week of Monday May 8th; we hope you can join us. The main conference will be a three-day event from Tuesday May 9th through Thursday May 11th. And similar to other recent conferences we will be offering both pre- and post-conference workshops on Monday 8th and Friday 12th respectively. I will be hosting the pre-conference workshop entitled “Building RESTful Web Services with Synergy .NET and ASP.NET Web API”. My colleague Richard Morris will be presenting the post-conference seminar entitled “Building Platform-Independent Mobile Apps with Xamarin Forms”. Of course we hope you can join us for both workshops, but for the remainder of this article I will be focusing on providing information about the pre-conference RESTful web services workshop.
Building and implementing web service APIs isn’t exactly new, but there are definitely some new and exciting technologies in play that can make building, deploying and interacting with web services faster, easier and more powerful than ever. With the relentless increase in demand for mobile applications and solutions the requirement to expose web service APIs is greater than ever. Not that web service API’s are only used to support mobile applications, that is certainly is not the case. In fact almost any new application developed today is likely to either require the use of a web service API, or it will just make sense to architect the application that way for increased flexibility and future-proofing.
I’m developing the content for my workshop right now and I wanted to give you some information about the audience that I am targeting, which is very broad. To be honest, unless you are already implementing RESTful web service APIs then this workshop is for you! And even if you ARE already implementing RESTful web services APIs, but with some technology other than ASP.NET Web API, then this workshop is also for you! In my opinion it is really important that every developer have at least a good understanding of what a RESTful web service APIs are and how they can be used, and it sure doesn’t hurt to know how to build them either! This workshop will teach you all of those things, and more.
We will start with the basics and will not assume any previous knowledge of web services. After an introductory presentation there will be lots of code, so you will need to be comfortable with that. I don’t want to just show you how to build a RESTful web service API, I want you to really understand what it is and how it works. So as well as covering ASP.NET Web API we will also be talking about the basic principles of REST, as well as various underlying technologies like HTTP, JSON and XML. If it all works out as planned it should be an action packed and interesting day.
This year both of the full-day workshops will be lecture and demonstration based; there won’t be any hands-on component. Unfortunately the hardware and software requirements of the underlying technologies that we will be using, particularly in the post-conference workshop, make it virtually impossible for us to offer a hands-on experience this time around. But rest assured that you will have access to all of the code that is developed and demonstrated, and we’ll make sure that you know exactly what hardware and software you will need if you want to work with that code, or perform your own similar development projects.
Time is ticking away and DevPartner 2017 is only about 10 weeks away. We’re all looking forward to seeing you again, or meeting you for the first time, and if you haven’t done so already then it’s time to register. See you there!
One cool aspect of a Synergy UI Toolkit program has been list processing. When we introduced the concept of a list load method to populate the list as items were required was a huge step towards decoupling the program logic from the user interface. Because of this separation of concerns it’s actually very easy using the Symphony Framework to load a modern WPF data grid using an existing UI Toolkit list load method.
Our starting point has to be the UI, and that’s being rewritten in XAML. XAML allows data binding between class properties and the column elements of a data grid. We exposes our Synergy data by use of a Symphony Data Object. These data object classes represent your repository based data structures. The fields within your structures are exposed as the properties that the data grid will data-bind to.
Once we have the data grid defined we need to define the hooks between the collection of data we are going to expose to the data grid and the host programs list load method. First we call a generic method that will allow us to signal the required list loading requirements back to the host program. This snippet is going to call a generic method that will then raise the event back to the host:
We are passing the load method name and then various parameters that define the actual data we are going to load and any additional list load method data. Now we can raise the load method request to the host DBL program:
In the host DBL program we need to handle the event so we register an event handler:
The following code snippet dispatches the load request to the existing UI Toolkit load method. There are two formats to the request depending if the list has associated list method data:
So now we need to change the load method. If you have coded your list load method according to the standards laid out in the UI Toolkit manual there should only be a single line of code to change:
The DoingTK test is a flag we have set to indicate if the program is running with the traditional UI Toolkit or our new WPF UI.
We shall be drilling down into the ability to handle list loading during the DevPartner 2016 pre-conference workshop as we all migrate an existing UI Toolkit program to a modern WPF user interface.
It’s the tried and trusted way to get the users attention. At the slighting hint of an issue with their data entry you put up a big dialog box complete with warning icons and meaningful information.
We’ve all done it, and many programs we write today may still do it. Writing code using the Synergy UI Toolkit its common practice to write a change method to perform field level validation. When the user has changed the data and left the field – either by tabbing to the next or clicking the “save my soul” button – the change method executes and validates the entry. It is here were we stop the user in their tracks. How dare they give us invalid data – don’t they know what they should have entered? It’s an ever so regimented approach. The user must acknowledge their mistake by politely pressing the “OK” button before we allow them to continue. Users are usually not OK with this interruption to their daily schedule so there must be a nicer way to say “hey there, this data is not quite as I need it, fancy taking a look before we try to commit it to the database and get firm with you and tell you how bad you are doing at data entry?”
When migrating to a new Windows Presentation Foundation UI we can do things a little different and guide the user through the process of entering the correct data we need to complete a form or window. We will still use the same change method validation logic however as there is no reason to change what we know works.
When using the Symphony Framework you create Symphony Data Objects – these classes represent your repository based data structures. The fields within your structures are exposed as properties that the UI will data-bind to. These data objects are a little bit cleverer that just a collection of properties. Based on the attributes in the repository it knows what fields have change methods associated with them. Because of this the data object can raise an event that we can listen for – an event that says “this field needs validation by means of this named change method”. Here is a snippet of code registering the event handler:
The event handler simply raises the required “change method” event back to the host DBL program;
Back in the DBL program we can now listen for the change method events. Here is the event handler being registered:
Remember, we are now back in the host DBL code so we can now dispatch to the actual change methods registered against the field. This is a code snippet and not the complete event handler code:
We are calling into the original change method and passing through the required structure data and method data. Inside the change method we will have code that validate the entry and then, as this snippet shows, we can perform the error reporting:
If the code is running as a UI Toolkit program the normal message box dialog is used to display the message. However, when running with the new WPF UI the code provides the required error information against the field. No message boxes are displayed. To the user they will see:
The edit control background is coloured to indicate an issue with the data and the tooltip gives full details of the problem. When the user has entered valid data, the field reverts back to the standard renditions:
We shall be exploring the ability to handle field change method processing during the DevPartner 2016 pre-conference workshop as we all migrate an existing UI Toolkit program to a modern WPF user interface.
Menu processing is a fundamental requirement in any UI Toolkit program. Without menu columns and entries your program would not function. You also signal menu events from toolbars, and buttons placed on windows and lists. Once a menu entry of any sort is fired, even if it’s signalled from within the DBL code, there is usually a using statement that dispatches to the required segment of logic. When configuring a new Windows Presentation Foundation UI this technique is still valid.
The Symphony Framework UI Toolkit assists the developer to bridge the connection between the DBL host program and the commands associated with menu bars, toolbar, and buttons – basically any WPF control that can bind to a command, and that includes selecting an item within a data grid!
Before we head into how the Symphony Framework UI Toolkit helps let’s first look at some simple UI Toolkit script and code snippets. Firstly we can create menu entries in scripts:
Here we have a menu column called “mfile” with an entry called “f_new”. The important element is the entry name “f_new” as this is the menu signal name that is used within the DBL code. You can create toolbars in code that will signal a menu event, for example:
Here we have the same menu event name of “f_new” being signalled when the toolbar button is selected. We can also add buttons to tab containers;
Windows and lists can also have buttons added to them both in scrip and in code;
If we need to enable or disable the “f_new” capability within the UI Toolkit application we need to do this for all instances, for example;
The Symphony Framework UI Toolkit removes the verbosity of this structure of programming while retaining the same logical concept. Using the Symphony.UIToolkit.Menu.MenuController class allows you to create a command;
Now we have the command we can bind it to any WPF control that accepts a command binding. So for a menu;
We can utilise the same command on, for example, an Infragistics ribbon control;
Using a regular tool bar;
And of course as a regular button on an input form or data grid view;
In the host DBL code we can now simplify the control of the commands. By enabling the single command it changes the executable status of the all UI controls that it is bound to;
When the command is executed the toolkit menu entry is signalled to the host program. We need to define an event handler;
This is a code snippet and not the complete event handler code:
This code is setting up the required menu entry name and then calling into the host DBL code to process the menu select. In the host program we need to ensure that we dispatch to the menu processing code segment. In this example the original toolkit code was processing an input form. We continue to process the input window using the i_input() routine if the toolkit is still the active environment. If we are running using the new WPF UI then we simple process the menu event;
We shall be covering menu, toolbar and command processing during the DevPartner 2016 pre-conference workshop as we all migrate an existing UI Toolkit program to a modern WPF user interface.
It was very exciting to learn at Build this week that Microsoft will now be offering Visual Studio (VS) as a development tool to build anything to deploy anywhere—from Linux to Apple to Android, you name it! As Steve Ives referenced in his recent blog post, all of the Xamarin tools that we’ve been leveraging are now included with VS.
The really cool thing about all of this is that Microsoft’s direction is in perfect alignment with ours. At our Summit meeting at the end of last year—a gathering of Synergex customers who provide input on Synergex’s technology roadmap—we received overwhelmingly positive feedback on our proposal to include the ability to use traditional Synergy within Visual Studio.
More and more of our customers are adopting Synergy .NET while still maintaining and developing in traditional Synergy, leading them to work with two separate development IDEs: Workbench for traditional Synergy and VS for Synergy .NET. We are happy to say that this will all change with the release of Synergy/DE 10.3.3, pegged for OUR conference in May. The 10.3.3 release will allow developers to use VS for both traditional and Synergy .NET—the post-conference workshop is even dedicated to this topic! I’m even thinking that this new functionality might inspire even more developers to play/experiment with Synergy .NET once they are using VS as their single IDE.
Synergex has always been committed to helping companies leverage their existing investments to stay competitive and current. This latest announcement from Microsoft really echoes that sentiment. After this week, reaching for the stars is now easier than ever!
By Steve Ives, Posted on March 28, 2016 at 1:38 pm
Last year I announced that we had created a new PDF API and made it available via the CodeExchange in the Synergy/DE Resource Center. Now I am pleased to announce that we have made some enhancements to the original API, namely by adding the ability to:
View existing PDF documents (Windows only).
Print existing PDF documents (Windows only).
Draw pie charts.
Draw bar charts (with a single or multiple data series).
Here’s an example of a pie chart that was drawn with the new API:
Here’s an example of a bar chart:
And here’s an example of a multi-series bar chart:
It’s early days for the support of charts, and I plan to make several additional enhancements as time permits, but I wanted to make the work that has been done so far out into the wild, and hopefully get some feedback to help me decide what else needs to be done.
If you’re interested in learning how to use the PDF API then I’ll be presenting a session that will teach you all about it at our up-coming DevPartner conference in May. So if you haven’t already done so, head on over to http://conference.synergex.com to reserve your spot at the conference now.
It’s been a while since I posted a blog, but the SPC always seems to propel me back into the blogosphere! SPC 2010 is unbelievably just around the corner, and we are once again gearing up for a conference that is not-to-be-missed.
A few years ago, a customer asked me to help him justify the conference to his team and upper management. I quickly jotted down the top reasons to attend the SPC and ended up sending the list to all of our customers. As the reasons haven’t changed much since then, I won’t bore you by repeating them all but think the main ones deserve a recap.
Continuing education. Imagine going to your heart doctor for a check up and learning that he or she has not been to an industry-related conference for several years. How has he/she kept up with all of the advances in the technology? Reading journals and surfing the net? Wouldn’t you prefer he/she had a more well-rounded education including hands-on instruction, networking with peers, and one-on-ones with industry experts? Likewise with your software—make sure your “application doctors” are getting the best education possible.
Break away from your day-to-day routine. One of our customers said about the SPC, “The SPC gives me a chance to escape the hustle and bustle of business and think strategically—I use it like a software development retreat.” I have to agree. More often than not I solve problems or come up with new ideas when I’m away from the office on a business trip or seminar. And, your employees who attend will come back motivated and inspired by your confidence in sending them. I know this first-hand from the responses I get from my employees when I send them to conferences.
Learn about the future of Synergy/DE. Version 9.5 will offer native support for Microsoft’s .NET Framework, enabling you to interoperate with applications written in other .NET languages, such as C# or VB .NET; to take advantage of all .NET Framework classes; and to develop Synergy code in Visual Studio. At the SPC, you will learn the ins and outs of the new technology, and get the opportunity to try it out for yourself with hands-on exercises. (Note: The focus isn’t on getting to .NET. The focus is on modernizing your application – and .NET just happens to be the best way to do it. I’ll be blogging more about this shortly!)
Experience the latest functionality hands-on. It’s one thing to hear about all the new features we’ve added to our products over the years—it’s another to actually try them out with the knowledgeable PSG consultants standing by for questions. The popular Code Phantom is back, offering even bigger, better, and more enjoyable challenges to help you experience the latest functionality first-hand.
You want to make sure you are fully taking advantage of Synergy/DE 9.3. Synergy/DE 9.3 delivers a number of important features that enable you to improve security, performance, and productivity. The SPC will cover these features in detail so you can be sure you are making the most of them in your own applications.
Networking. SPC attendees often describe the networking opportunities as the most valuable aspect of the conference. Where else will you be among so many other Synergy/DE developers, who may be working on or may have completed projects just like those you are considering or may be struggling with? One of our customers who traveled from Europe told me he justified the entire conference just by one conversation he had with another customer at the welcome reception. The rest of the conference was just icing on the cake. And because this year’s conference is in Sacramento, the Synergex staff members who are developing and supporting your Synergy/DE products will be there to answer your questions.
Your business depends on it. I could go through several analogies ranging from maintaining your health, home, investment portfolios, etc., but the bottom line is that your business depends on your Synergy/DE solutions. With that in mind, how could you not take advantage of this once-a-year opportunity to make sure you are taking advantage of all that is available to you—that you are working most efficiently, and that your products are as functional and powerful as the technology allows them to be?