i would like to produce a online windows 2003 emulator
so anyone can use windows 2003 through a browser instead of
installing the software - something similar to temulator www.temulator.com/- and zen internet emulator va.zensupport.co.uk - i have basic html & css skills
can it be done using html/css or is it better to use java/flash etc ,i am thinking of just using screenshots and then linking them together , but its very time conusming to do. what is the best programming language and BEST approach??
thank you
Neil
Which aspect of Windows do you want to simulate. Do you want to create an on-line "desktop" that looks like Windows 2003? In that case, check out whether you can customize one of the already existing Web Desktop projects like eyeOS. See the Wikipedia article on Web desktops for a list of projects.
It's going to take way more than basic HTML skills to work on a On-line desktop, so you really want to look at existing solutions unless you want to learn advanced Javascript, CSS and server-side programming from scratch.
To actually run Windows 2003 applications through an on-line interface is possible using the Remote Desktop Protocol and an appropriately configured Windows server (See the Link in Carlos's answer for a way to start a RDP session from a web browser window). However, this can't be done for free and is not unrestricted - you need to purchase the Windows OS, and user licenses for people to log on to the system.
Opening such a Terminal Server to the public is, as far as I know, forbidden my Windows 2003's license terms, extremely dangerous because of the risk of people infecting your system, and overall not worth pursuing IMO. You could do something like this with Linux because there are no license terms, but it's not a trivial matter and it's not going to run most Windows 2003 software.
You could use this:
Embedding the Remote Desktop ActiveX Control in a Web Page
For a Win2003-like GUI online: XP is close enough to Win2003.
Actual OS online: Convert VirtualBox to Java.
Related
I've HTML application build with AngularJS/jQuery/Bootstrap with AJAX REST API.
Is it possible to create executable/installer for Windows operating system?
Without any 3rd-party software, it should look like native application, but HTML.
For example, Slack messenger has web/mac/windows versions and they look same.
Any ideas?
// UPD
I probably need a wrapper (webview), but I need all features for EcmaScript5/CSS3.
Electron is the easiest way:
1. Install electron
2. Create and edit main.js:
const electron = require('electron');
const { app, BrowserWindow } = electron;
let mainWindow;
app.on('ready', () => {
mainWindow = new BrowserWindow({
width: 1000,
height: 700
});
mainWindow.setTitle('title of the desktop app');
mainWindow.loadURL('http://www.yourwebpage.com');
mainWindow.on('closed', () => {
mainWindow = null;
});
});
3. Execute desktop app:
electron main.js
And to build the app, use a builder such as electron-builder.
Hope that helps you!
(Full disclosure, I'm the founder of ToDesktop, I'll try to be objective and unbiased here.)
As usual in Computer Science, the answer is "it depends"!
The first question that you should ask yourself is: Who is the desktop app being used by? Just you? Or, are you distributing the app to customers? Because these two segments have very different needs.
Just you
There are a lot of options here (in no particular order):
Nativefier — The obvious option. Lots of configuration options, lots of contributors, open source and regularly updated. This should probably be the default option if you want to whip up an app just for yourself.
WebDGap — This is a lovely project but it is a little old and "as of April 13th, 2018 WebDGap is no longer an active project.". It should also be noted that this is built on an old version of node-webkit and not Electron.
Web2Desk — Great option if you don't want to mess around with the command-line. It uses Nativefier under-the-hood. It is free with a splash screen or $19 with the splash screen removed.
Do-it-yourself with Electron — The basics were covered quite well in this earlier answer. I like this option because it gives you complete flexibility to take the project wherever you like and you'll learn a bit of Electron too.
Fluid App — This is Mac only but otherwise it's a lovely solution and super easy. It's free for the standard version, there is also a $5 version which includes features like fullscreen.
Flotato — Mac only again but this is a really interesting approach. Simply clone the app and give it a name like docs.google.com, it will then turn into Google Docs. At the time of writing this, it's in pre-release (not released yet) but I'll be watching this closely, it's very cool.
ToDesktop — ToDesktop will work but it's probably a bit overkill if you're creating a personal app. Also, it's probably a bit too expensive for this use-case. ToDesktop is targeted at creating a desktop app for distribution to customers (more about that below).
Distributing to customers
There are a few extra considerations which become more important when creating a desktop app for distribution to your customers:
Installer — Mac users expect a "drag to applications" DMG file. Windows users expect an installer and they also expect to be able to uninstall it from the control panel.
Code Signing — If your app isn't code signed then by default Windows Authenticode and Apple Gatekeeper will prevent your desktop app from being opened.
Auto-update — There is still a web browser running "underneath" your desktop app, it's important to keep this updated for two reasons. 1. Security issues + vulnerabilities should be patched over time. 2. You don't want to be stuck supporting an old web browser in 5 years time because your desktop app's browser hasn't been updated
The tools mentioned above don't offer these features, so they're not really suitable for the use-case of distributing your app to customers. These are the features that we wanted to add when building ToDesktop, so I think it fits this use-case quite nicely. We're adding features all the time, last week we added support for App Protocols and Deeplinks.
I myself was looking for an all around solution for awhile. I tried everything from TideSDK, AppJS, Appcelerator Titanium, native code in VB.NET, XCode, Python, C++, Electron, node-webkit, etc: Basically you name it I've tried it.
Note Electron is nice, but it only runs on 64bit processors. So node-webkit is good if you want to run your app on 32bit processors.
So I decided to build my own open source solution called WebDGap.
Currently WebDGap runs on Windows, Linux, Mac OS X, Google Chrome and as a web application!
Watch the How To Video to learn, well how to use the app obviously.
Here's a screenshot.
Being that you're a Mac user already you can merge your exported app into 1 .app mac file. This can be done with Automator (and a little shell scripting).
There's also a coding playground I made for mobile users that has this feature built in called kodeWeave.
Here's a Tic-Tac-Toe game I'm going to export as a Mac App:
Now the web app is running as a native Mac application!
The most easiest and quickest way i know is to use nodejs/npm’s nativefier library which underlying electronjs . It will just take 5 min to create executable for windows. Even a person who do not have programming experience can create desktop application from web application. Below mentioned post has described the steps to convert web application to desktop application. Must read !
Convert any web application to desktop application in 2 min using npm’s nativefier
There are a ton of frameworks out there that can wrap your web app into a native application that can access things like the file storage API for an operating system. This is the specific guide for Windows.
BEWARE THOUGH - you will need to spend time doing solid testing and QA work for your native app so it doesn't feel like a website inside a native wrapper, as well as integrates well with all versions of the OS you want to be compatible with. Tweetdeck for Mac is an example of what not to do - basically a web browser in a native wrapper).
Use Web2Desk: If you are looking for Free and Simple solution.
wherein all you need to do is enter the URL of the web app (or website) and Desktop app for Mac, Windows, and Linux is generated in no time.
With a bit of wrapper code you could package it as a Chrome App. They do not need to run in a browser window but have all the capabilities of a web app, standalone.
https://developer.chrome.com/apps/about_apps
Best Way to Convert Web to Exe is using nativefier:
nativefier --name "Inventory Management System" "http://localhost/php_stock_zip/php_stock_zip/php_stock/" -i ./icon.png -p windows
Steps:
Press Win+x
Press C
Type
nativefier
Installation Requirements
* macOS 10.9+ / Windows / Linux
* Node.js >=6 (4.x may work but is no longer tested, please upgrade)
See optional dependencies for more
Step 5: npm install nativefier -g
Finally type nativefier "Web Link"
I am embarking on my first windows phone app. I noticed there are two templates one is in Javascript (Blank App (Universal Apps)) and the other in C# (XAML) again Blank App (Universal Apps). Which one should I use, I know it depends a lot on the project context, but basically its just a simple phone app, that reads and displays data, mostly crud operations. Any help is appreciated.
I think there are a lot of resources in the internet regarding this question.
For example:
http://www.itwriting.com/blog/8350-xaml-and-c-or-html-and-winjs-for-windows-store-universal-and-cross-platform-apps.html
http://www.neowin.net/news/microsoft-likes-winjs-for-making-windows-8-apps-but-most-developers-prefer-xaml
https://softwareengineering.stackexchange.com/questions/156361/advantages-and-disadvantages-to-using-xaml-c-or-html5-javascipt-for-metro-apps
If you have a C#/.NET background, choose XAML - if you have a web background, choose WinJS...
I think that XAML is more popular than WinJS (especially for Windows Phone).
Here's my take to add to the list--http://www.kraigbrockschmidt.com/2013/01/17/html-javascript-xaml-directx-language-windows-store-app/ . In my partner-facing role at Microsoft I got this question quite a bit, and it really boils down to personal preference and experience unless you run into a place where the languages don't quite have parity at present. Parity was more of an issue in Windows 8, many areas were resolved for Windows 8.1. (Parity is more a matter between Windows/Windows Phone now rather than between the languages.)
Personally, being the author of Programming Windows Store Apps with HTML, CSS, and JavaScript, Second Edition (free ebook, Microsoft Press, 2014), I like the JS approach very much because you can leverage standards. On the downside, JS code is the least secure of all the options (see this blog post of mine), which might be a make-or-break consideration.
Now that TideSDK is effectively dead, I've been looking into alternative 'wrappers' to run HTML/CSS/JS applications as stand-alone desktop applications. The three viable options I have run across so far, are NW.js (formerly node-webkit), brackets-shell, and Electron (formerly atom-shell).
The problem is that there does not appear to be a sufficiently complete comparison between the three in terms of feature set, compatibility, etc. I'm hoping to turn this into a more-or-less canonical thread on the (objective) differences between the three, in particular regarding:
Platform support; operating systems, dependencies, etc.
Language feature support, as far as HTML5, CSS3 and JavaScript are concerned. Think things like "does HTML5 video work, and if yes, what codecs are available?"
Non-standard extra features, such as tray icons, popup notifications, and OS-rendered menu bars.
Extensibility; eg. ability to 'plug in' native code, talk to Node.js, and so on.
Architecture; in particular the architectural differences that affect daily usage as a developer.
Debugging; included development tools, compatibility with commonly used tools like node-inspector, etc.
... and so on.
What are the objective, technical differences that matter when making a choice between them as an application developer?
I did similar research about two months ago, and in the end I went with node-webkit. The biggest upside on node-webkit is node.js and npm. The package management of npm is really nice, and node has well done filesystem access.
Brackets-shell looked interesting, but other than a nice IDE I didn't really get what made this one as good or better than the rest. They are very clear that "The brackets-shell is only maintained for use by the Brackets project ", that screams run away to me.
https://github.com/adobe/brackets-shell#overview
Atom-shell seems to be recently active, but it seems much like brackets in that they are really writing and editor/IDE that just happens to be attached to a webkit runtime. It also is built on top of node.js. This one has the downside of being difficult to search for stuff online without being reminded of your middle school chemistry.
I really don't want an new editor, and most programmers have their favorite already. For the actual application development, they pretty much work the same, and should, since they all use webkit. You basically write 90-95% of it like a website, and then deal with the native parts, and some config.
These things are true for all three of them
platforms - runs on Windows, Mac, and Linux
language support - HTML5, CSS3 and Javascript : since they run javascript you can download and run nearly any library/framework that you want.
The big caveat on webkit is codec support. Typically you will have problems with non-free video codecs, unless you rebuild the dll/so to support them. For example the shipped node-webkit won't play mp4 video.
I've been playing with Atom-Shell over the last few days, and I am loving it so far.
The best part about it is that it's backed by GitHub.. which should allow you to settle into the platform for the long term, especially if it gains a large following. It's also made possible by direct Node.js improvements courtesy of a contract with StrongLoop, who is a major Node.js contributor (they claim to employ more Node.js core developers than any other company, even Joyent).
I've also found it rather comfortable to get started. It took me about a day to learn the structure and get my first proof of concept running. Very cool.
Bullet Points:
Platform support: Windows, Linux, Mac OSX (More Info Here)
Language feature support: HTML5, CSS3, JS via Chromium - so far, zero issues, but I have not tested video specifically.
Native Features: Native App Menus, Task Tray Support, Global Hotkeys, Protocol Handler Support (that I've seen so far)
Extensibility: Excellent Node.js integration, both the client and server can "require" Node.js modules and natives. I've also successfully tested Bower libraries (incl jQuery) without issue.
Architecture: Covered in the other points, but in general its very smooth.
Update (11/25/14): I've not yet found use case for Atom-Shell in any official capacity, but I have used it to build a few small apps for my own use, the most complex being an app that pulls my time logs from my PM software and creates Paypal invoices.
My opinion of the platform remains positive. It's pretty awesome.
On my time invoicing app I successfully brought in Bootstrap 3's Dashboard Example Template and a few node modules (bluebird, Paypal SDK, Teamwork PM Client) to create a mildly complex app. It took me a few days and does its job well.
I really cannot think of anything negative to say about Atom-Shell, its solid, stable, fast, and easy to code for. I hope this helps someone.
Besides fully support Web standards, NW.js supports a list of non-standard features for native app development including:
Protect JS source code by compiling them into machine code: https://github.com/nwjs/nw.js/wiki/Protect-JavaScript-source-code-with-v8-snapshot
Jailed devtools: https://github.com/nwjs/nw.js/wiki/Devtools-jail-feature
Additional security model with which you can do more in DOM: https://github.com/nwjs/nw.js/wiki/Security https://github.com/nwjs/nw.js/wiki/Changes-to-DOM
enhanced file dialog: https://github.com/nwjs/nw.js/wiki/File-dialogs
kiosk mode: https://github.com/nwjs/nw.js/wiki/The-Kiosk-mode
supports for a growing list of chrome.* API, include chrome.webRequest so you can intercept HTTP requests from DOM: https://github.com/nwjs/nw.js/issues/518
support for rich notifications, print preview, many more chrome.* APIs, Chrome Apps and other Chromium features starting from 0.13.0-alpha0
There is much more to see in the wiki including Menu, Tray, etc.
I've been working with brackets-shell for some time now, here are some of my findings:
brackets-shell is primarily developed as a shell under the brackets IDE project, but the project can run any web application. You just need to point it to your own html page. Clint Berry wrote an excellent tutorial about doing just this: http://clintberry.com/2013/html5-desktop-apps-with-brackets-shell/
The project is backed by Adobe and has a lot of activity
Documentation could be better
platform support They support Windows, Mac and Linux. An installer package can also be created. I only tested it on Win and Mac, it works great.
feature support html5, css3, js. Html5 video does not work out of the box, but is very easy to enable (by default the ffmpegsumo.dll is not copied into the installer, if you change the script to copy it it will work).
native features menu bar, 'open file with', file system access. I am not using any of these, as all I need is the communication with the node process.
extensibility a nodejs is built in, and you can communicate with node from your web application. In this way, you can use node to access the filesystem etc.
architecture The project is well set up, keeping a nice separation between the shell project and your own web app running inside it. In your own application, a global appshell object is available which gives you access to the brackets functionality (filesystem access, communication with node process, ...).
One thing to note (if you care), is that the Electron officially does not support Windows Vista. Vista's market share is about halfway between OSX 10.9 and 10.10 (both of which are fully supported by Electron). Vista is also still supported by Microsoft until 2017.
NW.js works fine in Vista, as well as OSX 10.9+. NW.js works on Ubuntu, Debian, Zorin, Manjaro, Arch, and most other Debian based Linux OS's. Electron has refused PR's to fix Ubuntu specific bugs on their platform which is concerning.
NW.js works in XP too. Currently 18% of the market is still on XP. So if you're desktop application is more general purpose or wants to have access to the late adopters still on XP, you're probably better off with NW.js (0.14.7) as Electron only supports Win 7 and up.
If you use NW.js 0.12.3 you can also support OSX 10.6+ and very old versions of Debian based Linux OS's like Ubuntu, and Win XP+. It is recommended that you do special builds just for those legacy systems though and use the newer versions of NW.js for newer OS's.
Do Windows Phone 8 Application developed for Windows Phone 8 device will run on Windows Surface Tablets (RT & 8.1)? Kindly clarify me.
Could you please suggest me on, what are the changes required for migrating the application.
Take a look on the Portable class library.
It allow you to share your code between different platform.
http://msdn.microsoft.com/en-us/library/gg597392(v=vs.110).aspx
This blog clearly explains how to use it :
http://blogs.msdn.com/b/stephe/archive/2012/05/07/partager-du-code-entre-plate-formes-gr-226-ce-224-la-portable-class-library-1-4.aspx
Anyway you got specific dev to do.
You will need to rewrite many portions of the application. It's difficult to be more precise as you did not describe anything about your application.
The UI, assuming you select C# and XAML for the Windows 8 modern application will need a significant amount of changes. While there will be a significant amount of knowledge overlap and technology similarity, the UI will not be portable. The components are similar, but for example, you've probably used the Windows Phone toolkit which is not available for a Windows 8 store application. Another consideration is that on the larger screen sizes, you'll ideally want to use a different layout of your application.
For the business logic, you may be able to use much of it as is. However, anything that deals with the file system or network (and more) will not necessarily be portable. You could use a portable class library for some features, but you may still need platform specific code.
While this all may sound like a tremendous amount of work, I'd actually like to suggest that it's not. The platforms are very similar, the development environment will be identical, and some amount of UI work would have been necessary anyway. Assuming you create two applications, the structure might look like this:
PhoneApplication
Windows8Application
DataModel
PortableClassLibraryStuff
PhoneSpecific
Windows8Specific
A lot of differences beetween WinRT and WP8 API makes porting much more difficult. But if you are still interested in this topic I can suggest you
Waiting for WP8.1 and W8.1 Update 1 API combination or
Writing your own little framework in a portable class library for navigation, setting, notification, ... support. I already did that work and there are a lot of possibilities for code sharing (resources can be completely shared with the binding notation of WP8). For more information please visit the opensource github project: Github MultiPlatform Framework sample. You will still need to rewrite a lot of xaml code but the leaked footage of the WP8.1 API already showed that we will be able to use much more shared UI code :-)
We are looking at building a GUI application having the following attributes -
* approx 100 screens
* approx 200 users
* interfaces with 8 different legacy applications (protocols tbd but we are assuming web services will be exposed)
* has a separate data store for storing authentication and authorisation info along with few other information.
We are trying to avoid spending any money on procurement of physical servers, application servers etc.So we thought instead of building a web application , we could develop a standalone GUI based application that could be deployed on users' desktops considering that the users are less and the access to this application is confined to our organisation.
We were thinking of Java Swing as one of the options to consider. Is it a good choice? Please advice on the other options that we need to think about. We thought MS products would involving licensing costs to buy the product hence we are looking at developing the application using some free software tools.
Thanks a lot!
Regards,
V
I really like Swing and have written many applications with it, but I'm not sure the argument that you will get a cheaper solution because you have to procure less physical servers is a good reason for it.
There are other ways to use computational capacity on the client side. For example you could use SmartGWT. With a browser based solution you get easy deployment and have no problems with client-server communications (i.e. no proxy hell). It's possible to get all of this solved with a standalone GUI, but it requires experience and time (== money).
I think a standalone GUI is a good idea if you need a "rich" user experience and tight integration with the native environment. Web apps are generally less snappy and not so well integrated. If it's just about editing data on a server, the standalone GUI does not really have any advantages.
I won't rehash what we talked about in the comments. It seems you are focused on java gui solutions. With that said there are alternatives for developing gui applications with free tools. Just to name a couple, you could develop your client with Adobe Flex or Adobe Air, use python, php or ruby and GTK, or develop a windows GUI app using c# if your target os is windows. Similar to Air, Microsoft Silverlight is an option. Java is not the only solution.
Many Java gui apps are written using swing. The major competitor to Swing has long been SWT which is used for eclipse and by IBM. Javafx is a newer/alternative platform Sun/Oracle is behind, you should also look at. To be complete, you should also take a look at qt jambi that lets you develop in java against the Qt framework.