Are there any libraries available that can help to change the look-and-feel of Desktop Applications made using VB.net 2008? Here is a snapshot of an application that runs on Windows 7:
I think its made using the .net framework, but how can it be styled like this?
PS - Even if its not built using .net framework, then please let me know which language supports the UI customization on windows platform.
NOTE - As everyone is suggesting me to go with WPF or SWING using JAVA, I still want to know if its possible in VB.net WinForms or not.
Theme handlers (Use standard controls and the handler takes care of the visual UI):
Open source
http://www.codeproject.com/KB/miscctrl/FancyNetForms.aspx
Closed source
http://www.appface.com/ ($ 149 USD) (Skin your app with 2 lines of code)
Special controls that has built in theaming:
ComponentOne:
http://www.componentone.com/SuperProducts/StudioWinForms/
Infragistics:
http://www.infragistics.com/
I don't know how this specific window was styled, but there are many posibilities:
Maybe was made in WPF. Microsoft WPF are available since VS2008 and Framework 3.0 and it allow to make a complete look and feel customization for every control that you use.
Maybe It was made in winforms using a custom control set. For example, DevExpress has a set of 60 free controls that comes with some predefined look and allow creating your own skin. (60 Free Controls)
Maybe It just was made in Java with Swing (look this Question)
Related
I'm new in WinRT or COM application but now looking for good sample program using C++ SwapChainPanel in XAML for DirectX and operate it in C# as desktop applications using WindowsAppSDK.
I know there are some or few examples showing:
Make Windows Runtime Component using C++/WinRT and consume it in C# (but no XAML) The reflection is used.
Make custom control in C++/WinRT and consume it in C++ on the same project.
Make custom control in C#/WinRT and consume it in C# on the same project.
Use DirectX via DirectN or old sharpDX or such C# wrapper. (but no C++)
Make C++ user control as UWP control and consume it in UWP project.
There many comments UWP and WinUI3 is almost equivalent but I cannot find out exact example doing this. If you know some, please point them out.
Or, should I give it up and go another choice? Once I've made a .Net program using OpenTK but not so good at get performance, then this time I'm trying DirectX.
Thanks for any advise.
What are the differences between these two programming choices
I know that the following features are supported by only HTML/Javascript
1. Flyout control
2. Header Menu
3. Rating Control
Do they have any other difference in terms of controls, integrations, connections, deployment?
html/javascript
html5 and js are open web standards. That's why they work (and act) in nearly every browser the same way. That is the reason why you can develop html5 applications for Mac OS and port it without many extra coding to Windows.
Microsoft however wants to have as many Apps inside the market as possible, that's why they made confession to the web developer and implemented a native looking support to html and Javascript. But there are a lot of Javascript functions, that are only supported by IE10 (in fact, nearly every function you can find in the WinJS-File). If you want to port Win 8 Application to any other Operation System, you have to review your code.
A good example for this is the click-eventhandler in WinJS, which has a event.pointerId to identify multitouch. This is a good easy way but not standard.
XAML/C# or VB
XAML is .NET and so it is fixed to this Framework. You cannot easily port a XAML Application to a mac os. Therefor XAML and C# is very good implemented into Visual Studio (Intellisense,Blend and Design-Views) and has some nice features like LINQ and DataBinding. Also the MVVM pattern allows to split up designers and programmers. In my opinion the documentation on msdn is better for XAML and C# than for Html5 and JS. For games there is also a DirectX implementation which is a better choice because of higher performance.
What to choose?
The decision which way to program is really hard. The following Questions should help:
Which programming language are you more familiar with?
IF OOP -> C# and XAML
IF web and prototype based languages -> HTML and JS
Which type of application will you code?
If it's fixed to Win 8 -> XAML and C#
If it should run on more than one platform -> HTML and JS
Do you like Visual Studio?
If yes -> use XAML and C#
If no -> use HTML and JS, you can than
first develop the app with your common IDE and later import it into
visual studio to create the application.
We can’t just leave our customers that are not able to upgrade to windows 8 for a long time in the larch. However there is demand for a “tablet”/”touch” version of our app.
So how can we support both touch with Metro on Windows 8 and our current customers from a single code base?
When WPF come out, after a lot of “Pushing” Microsoft saw since and make it work on Windows XP – has anything like this been talked about for WinRT.
(I am not expecting any solution to work on XP, as XP support is being wound down.)
See Also: Can the ARM version of Windows 8 only run Metro (WinRt) style apps?
The best answer is that you do not want the same application to run on Windows 7 and Windows 8 Metro style. The UI that works best for mouse and keyboards (windows 7) will not work well for a touch-first presentation and visa versa. It is important to re-imagine the UI for the two different worlds.
That said, you have 2 options if you want to share a lot of the code:
1) Write it largely in JavaScript/HTML5. This will let you re-use many of the assets (especially the business logic parts).
2) Write it in (desktop) Silverlight. The Silverlight XAML is closest to Windows XAML. WPF is further away and will require more re-work later.
In either case, you should look at and follow the principles used when writing cross-platform code. Understand the platform dependencies and isolate them behind indirection boundaries. You want to localize all of the code that will have to change. For instance, you don't want calls to the .Net System.IO.File APIs which you know will have to change to Windows.System.Storage calls being scattered throughout your code. Instead, you want it localized in one function that can be modified later.
The only way I can think of is to implement your application in HTML5/CSS3/JS, and avoid using WinRT APIs inasmuch as possible - this may be feasible depending on what, exactly, your app needs to do (e.g. portable 2D graphics is easy with HTML5 canvas).
Then, for Win8, you'll package this as Metro web app. For Win7 and below, you write a simple app that embeds your browser of choice (not IE9, since it doesn't work on XP - so Firefox or Chrome) with all chrome hidden, and loads your HTML5 app inside that embedded browser.
As others have noted, you would not want to have exactly the same application working in Win8 Metro and Win7 / Vista Desktop. If you structure your application properly, using a suitabel design pattern, it is possible to share quite a bit of code between the various version that you would require. For the Win8 version, you will be using WinRT, for Win7 / Vista you have a choice of Silverlight or WPF.
I have published a couple of articles that demonsrate how this can be done, they include quite a bit of code as well:
XAMLFinance – A Cross-platform WPF, Silverlight & WP7 Application - while this article does not cover Win8, it does share code from WPF to Windows Phone 7, which is a very similar problem.
TweetSearch – A Cross platform Metro UI WinRT and Silverlight Application - this article shows how to use the same techniques to share code between WinRT and Silverlight
It is unlikely that we'll see Microsoft push the Metro-style
application framework back to past releases due to the level of
re-architecting that went into Windows 8.
I agree with Zac on this point. It appears Microsoft is definitely pushing both the technology and usability forward with the introduction of Windows 8 (and Windows Runtime).
The Metro UI is a different UI paradigm. If your using the current
Win32 controls (which includes WPF controls), your application will
look really dated in Metro. The only way to fix that is to
re-implement the UI (your View classes in an MVVM design) using Metro
controls. However, C# and majority of the .NET APIs are first class
citizens in this new environment. The rest of your application should
be fine.
As you already have what I assume a rather large application your best solution would be separate your view from your model-viewmodel. Then you can continue to develop both Windows 8 Metro full-screen touch-friendly awesome interfaces and the "classic" window interface (what we have done for the last x number of years). With good separation, design, and an excellent source control solution (i.e. Perforce) you will able to share a lot of the code base.
In addition to the answers given to your recent question on Windows Runtime Bill Wagner (one of the many C# bloggers that I follow) has posted summary on WinRT and managed languages conference sessions; it is an good read and recommended if you have a few minutes. One of the things that his summary clarified (in the FAQ at the end) was that the future of .NET as the branding for the framework we use is going to be replaced with Windows Runtime.
Another piece from Bill's blog post:
Some of the .NET APIs are changing for WinRT. I don’t have an
exhaustive list, and I’m not sure there is one yet. Other APIs are not
exposed via WinRT. (They are still available as .net APIs, just not as
Metro / WinRT APIs.)
It is unlikely that we'll see Microsoft push the Metro-style application framework back to past releases due to the level of re-architecting that went into Windows 8.
Like Pavel said, if you kept your application from using as much of the WinRT libraries as possible, it is possible but then again, you're now building a regular web app.
I am trying to convert some old VB6 code to VB.NET. The VB6 uses a Canvas control, simply
Dim cv as Canvas
I cannot for the life of me figure out how to use the Canvas control in VB.NET (using VS2005). MSDN says it is in the System.Windows.Controls namespace, which doesn't seem to exist? All I see is System.Windows.Forms, which doesn't include the Canvas control. Any tips?
Thanks
You need to find out what the Canvas was in VB6, then you will be able to see what the nearest equivalent is in VB.Net.
I think it must have been an obscure third-party control or possibly some custom code. I've not come across Canvas before in VB6
In recent history things have changed a bit here. There are now two sets of windows frameworks.
Forms are the old one. The new ones are controls, and they come in the WPF and Silverlight variety. WPF is to replace windows forms, silverlight is meant for the web, etc etc.
Since you are using the older VS2005, I believe you will need to install the WPF extensions to get access to them.
Unfortunately the WPF Extensions for VS2005 are no longer supported by Microsoft:
http://blogs.msdn.com/b/acangialosi/archive/2008/06/27/vs-2005-extensions-for-net-framework-3-0-wpf-wcf-ctp-is-coming-off-the-ms-download-center.aspx
You can still get them from various places, but for your own ease you should probably consider upgrading to at least VS2008 if you want to use WPF/Silverlight.
We are in the process of creating active-x controls used within our application.
Since Microsoft stopped supporting classic Visual Basic, is it wise to use Visual Basic to develop the Active X control or the latest VC++/ATL/MFC libraries provide more feature where we can create controls faster by leaving Visual Basic flexibility?
We will not be able to use .NET/VB.NET/C# since the application is supposed to work inside containers and containers may not support latest .NET runtime.
Any other language is best fit for Active X control development other than VB and VC++?
I, personally, would recommend using Delphi for this. It is still actively developed, and has the control you get with C++, but a rapid development environment more like VB.NET.
#nobugz: If you are really interested what is ActiveX in Delphi, look at docwiki. Normally it is 100% source code (yours + VCL, VCL is also available as sources) with autogenerated COM wrappers. So all potential security problems are also in source code. If you find a security problem in VCL, please send a bug report to Quality Central.
Here is a good example on how to create ActiveX Controls with C# .NET
http://www.codeproject.com/KB/cs/CreateActiveXDotNet.aspx
By all means VB6 is the best language. After reading your question I feel that you are a VB6 developer. If you know VB6 and use it then why hesitate using it for producing ActiveX controls.
I program in Delphi as well as VB6 along with VB.NET and C# but creating ActiveX controls is the easiest in VB6 compares to all other development tools.
If you are hell bent on not using VB and if you are looking for an alternative then try out PowerBasic (commercial - very costly) or PureBasic (commercial but affordable) Get it from here or better still MinGW (a GNU C++ compiler).
I have to say that VB6 with a good book like Developing COM/ActiveX Components with VB6: A Guide to the Perplexed you will be up and running faster.