#windev

The thing that lies at the foundation of positive change is service to a fellow human being. -Lee Iacocca

In the next 30 days, until Windows 10 is available, if you cannot wait, then you can use the Windows 10 Preview edition to develop UWP apps.

This is not for the faint-of-heart. If you are just beginning with Windows app development, then it might be a good idea to just wait until Windows 10 is publicly released. If you have to migrate your existing apps (or, update the projects you are currently working on), then it might be worthwhile to invest a little bit early on to get some "head start". Here's some basic steps you need to take to set up a development environment for UWP apps:

Join the Windows Insider program, if you haven't already done so.

Install a recent flight of Windows 10 Insider Preview edition. I installed the build 10130.

Enable Hyper-V. This is needed in order to be able to run Phone emulators. (Use Win+R, and run "optionalfeatures". Select the "Hyper-V platform" checkbox.)

Install Visual Studio 2015 RC with Windows 10 SDK. You can find the link from the Windows Dev Center. You'll need to use "Custom" (not "Typical") option in order to be able to select Windows 10 platform SDK.

Install VS 2015 RC Update, if it's applicable to you.

Migrate your existing projects, or create new app/library projects, and start developing UWP apps.

The truth will set you free, but first it will make you miserable. -James A. Garfield

As for the currently published demo apps, I might port them to UWP (and, add some more features, etc., and republish them), at some point in the future. (To be frank, maintaining both dev environments (Windows 8.1 and 10) may not be feasible in my case. Note that it's not just apps. We tend to use a lot of shared libraries (in house or third party), etc., and even simple demo apps (at least, many of them) have dependencies on other libraries.)

For now, my priority is to learn this new platform UWP and the best practice for migrating/porting. I haven't really started but, at first glance, it seems that it will require quite a bit of work to (properly) port my apps (and, extensive shared libraries I've been building for the last six months).

(Just to be clear, WinRT apps will run on Windows 10, most likely as is, with no or little modifications. But, obviously, for apps like mine which are currently under active development, there is no point of continuing dev on WinRT. It's best to take advantage of new features of UWP (as well as new features of C# 6, etc.) sooner than later. The only exception for me is the app, Icon Browser, which I already published as Windows 8.1 universal app. I may or may not upgrade this to UWP.)

Our biggest problems arise from the avoidance of smaller ones. -Jeremy Caulfield

Markdown is a simple markup language, which is primarily used for generating an HTML content. It is one of the more popular languages with such purposes. MediaWiki is another such language which is widely used. (And, there are many other varieties.)

These markup languages make it easier to write HTML documents. Markdown is one of the simplest, as the name, Mark down (as opposed to mark up) suggests. Tumblr supports a markdown format, and I'm actually using Markdown to create this post.

Here's the general syntax as originally created: Markdown: Syntax. (Note that there are many variations, or extensions, of Markdown.) The screenshot includes a (modified) copy of this Web page (as written in markdown).

The demo app includes a simple TextBox (for markdown text) and a WebView (for HTML preview). I originally used a FlipView to include both of these controls. But as it turned out, it was unusable. The FlipView handles the arrow keys to "flip" pages, and unfortunately, it interferes with editing in TextBox. I love FlipView (as I used in some of my previous demo apps), but this was such a severe problem that I could not use it for the purpose of this demo app. (I spent days, literally, trying to find a workaround, but I coudln't. There was none as far as I could tell.)

Instead, I just include these two controls in a Grid and use a button to switch between these two controls/views. Not ideal, but it gets the job done.

Doubt must be no more than vigilance, otherwise it can become dangerous. -George C. Lichtenberg

Today's demo app, "Crypt", uses two new API sets which we haven't tried in our previous demo apps.

File system API: Use of IStorageFile and FileOpenPicker, etc.

Cryptography API: "Protect"/"Unprotect" text files.

As I mentioned before, the file system API on Windows Runtime is completely crippled. It is hard for me to understand why Microsoft insists on imposing such a dogmatic rule: Security triumphs everything including usability. I hope Windows 10, the Universal Windows Platform, addresses some of these fundamental limitations on WinRT. (I haven't seen any mention of this on any of the recorded sessions I've watched so far, though.)

Anyways, it seems rather hard to create a generally usable app with the limited WinRT file system APIs. On top of this, there are certain inconsistencies between those available on big Windows and Windows Phone. For example, FileOpenPicker (and, other "pickers") on Windows Phone have rather convoluted APIs. (I understand the rationale behind it, but still....) If you look at my demo app, I added "default folders" to make it just a bit easier for the user to select input and output files.

One other limitation I could not get around was, my file encryption/decryption utility app cannot be used with just any files (even from the "allowed" folders). It seems like you need to declare a file type assoication in the appx manifest file. I'm not sure if I understand the requirement correctly, but this kind of restriction clearly does not make sense for general purpose tools like this demo app. I should be able to encrypt/decrypt any file types on my machine. For my app, I just included ".txt" as a file filter, which means that you can only encrypt/decrypt text files with the .txt extension using this demo app.

Cryptography API on WinRT is no different. A majority of cryto APIs that are available on .Net (and Win32) are not available on Windows Runtime. (Or, at least I could not find APIs that are equivalent.) WinRT provides this limited encryption/decryption APIs to "protect" the user's data (which is not a general purpose encryption API). The demo app uses this API to "encrypt" and "decrypt" the text file content.

If you are interested, here's my demo apps on Windows app stores. The demo apps, both on Windows and Windows Phone, use a single UI to both "protect" and "unprotect" files.

Demo App - Crypt (Windows Store)

In general, pride is at the bottom of all great mistakes. -Steven H. Coogler

We demonstrated the use of a ListView control in building last week's demo app, Color Picker. We use this ListView for displaying the recent 100 bookmarks as stored in the AppData settings.

It was a bit tricky for me to implement event handlers for buttons (the Click event) in each item row (it wasn't immediately obvious to me at first), but after some web search, I realized that you could include the "id" of a bookmark (or, other info like the item PK, for instance) in the "CommandParameter" attribute. (You do not have to use the Command object-based data binding for this.)

I eventually removed the "Open" button which was present in the original version, and instead just used the list item/row click event to launch the Web browser (with the selected URL).

Other than that, I tweaked the UI a little bit so that the app page/user control was no longer limited to a fixed size layout. (Well, the width is still fixed at around 310 pixels, just like all our other demo apps, but the height can grow up to screen height. The Grid control is a very versatile container/panel, which can be used for layouts like this. More on this later.)

Please let me know if you have any questions, or if you need any help.

The updated version of the demo app can be found on Windows app stores:

Bookmark demo app (Windows Store)