Is there a way to disable the visual theme of windows, when running some executables? (not manually, but with some ini or manifest file, or any other option)
Depends on the executable. Is it a managed exe? i.e uses the .NET Framework? Is it a Java Executable (*.JAR)? Does it use some toolkit that does not depend on the Windows Visual theme, but only emulates it? e.g Java Swing or GTK?
I think in GTK you can change the Visual Theme quite easily using the Gtk resource file. In Java Swing you can send the theme as a command-line argument. In .NET, I think you may be able to change it with a manifest file, but I don't know for sure.
Related
How can I deploy my Win32 application as an EXE application so that others (who don't have VC++ installed) can use it?
I am using VC++ 2010 on Windows 7.
If you switch to "Release" mode when you compile your finished program (rather than "Debug", which you use for debugging it during development), you should get an executable that will run on a computer without Visual Studio installed.
However, that executable will still require the appropriate version of the C runtime library to be installed. For example, if you developed it in Visual C++ 2010, you will need version 10 of the CRT installed. This is a freely redistributable library, downloadable here.
So, you have several options for deployment:
Manual Deployment
Give people the bare executable file, and include the installer for the redistributable in another folder on the installation media. If they copy the executable to disk and cannot run it because they get an error message, they should install the CRT libraries from the included redistributable installer. Then the executable will run just fine.
This works great if you have relatively a computer-savvy audience, or you're deploying to a fixed range of machines (like across a school or corporation). But it doesn't work so well for general deployment to customers.
In fact, you don't even need the installer. You can just place the CRT DLLs in the same folder as your executable and it will run just fine. This is how I test apps I'm developing on clean VMs. It works like a charm. There's no need to run the CRT installer at all. You'll find these required libraries as part of your Visual Studio installation:
<Program Files folder>\Microsoft Visual Studio 10.0\VC\redist\x86
Automated Deployment
Create a setup program that automatically installs your application along with any dependencies it requires, including the CRT redistributable. This is what you see most commercial applications doing. I recommend it for anything but the most trivial of apps.
Full versions of Visual Studio 2010 (i.e., not Express versions) can create a Setup Project that you can customize as needed to work as an installer for your application. But this is no longer the recommended way to create an installer, and this functionality has been removed from the latest version of Visual Studio, 2012.
So I recommend using something else, even if you have an older version of VS where the Setup Project is available. No point in wasting time creating something you'll just have to update later. My personal favorite choices for creating setup programs are WiX and Inno Setup. Both are free, and extensive documentation is available online.
Creating simple setups that don't have to do very much is really quite straightforward—this is likely the case for you, as all you need to do is install the CRT redistributable if it is not already there. I'd be willing to bet money you can find a walkthrough or example online for how to do this in either WiX or Inno Setup.
If you need to do more complicated stuff, both of these setup packages support it. They are extensively customizable and very powerful, it just takes more work to get it all going.
Static Linking
If you absolutely need to be able to distribute a bare executable that is guaranteed to simply work when double-clicked, you will need to switch your project to statically link in the required runtime libraries. This means that all of the CRT code is actually embedded by the linker directly into your executable, and means that you don't have to redistribute the CRT libraries separately.
The disadvantage of this approach is that the only way to benefit from improvements, bug fixes, and security patches released for the CRT is to recompile and redistribute your application. If you dynamically link (the default), your app will automatically benefit from enhancements to the installed version of the CRT libraries. Microsoft strongly recommends against static linking.
To switch between these modes in Visual Studio, follow these steps:
Right-click on your project in the Solution Explorer and select "Properties".
Ensure that the "Release" configuration is selected in the drop-down box at the top of the dialog.
Expand the "C/C++" item in the TreeView, and select "Code Generation".
Change the setting of the "Runtime Library" option to "Multi-threaded (/MT)".
A further description on what these cryptic compiler switches mean and which ones you should use when is given in my answer here.
Final Note: The "Debug" versions of the CRT libraries are not redistributable, but that doesn't matter because you should always distribute the "Release" build of your app anyway, never the "Debug" build.
In general, the odds are pretty good your EXE file will run on any version of Windows you built it on or higher.
All bets off, for example, if you built using Visual Studio 2012 Professional on Windows 7, and you try to run it on Windows 95. But otherwise, you're probably safe :)
The best way to test if you have any dependencies is to install and run on a "clean machine".
The best way to get (and reuse) a "clean machine" is with a VM.
I recommend VMWare. But Virtual Box and Windows Virtual PC are also viable choices.
As far as an installer, I'd strongly encourage you to look at InnoSetup
I hope that helps!
Make sure you build in release mode. As Floris Velleman said, you're using unneeded libraries for standalone executable.
For more information, you can check Compiler Options (MSDN).
For my UI system, which is similar to WPF but written cross plattform with OpenGL, i need to embed the xml files into the DLL which are used to layout the user controls. The problem is: By default MonoTouch does not support embedding any file into a dll and afaik there is only one solution which solves this: Embed the xml into a *.cs file and compile it.
Now, this is a task which doesn't make any fun if you do it per hand each time, so the question is how is the best way to achieve this for both, Visual Studio and MonoDevelop?
MonoTouch does not compile C# code, it uses the smcs compiler. That's the same compiler being used for Mono for Android and, originally, for Moonlight.
That smcs compiler is able to embed files into assemblies, it's doing so the BCL (e.g. globalization files for mscorlib.dll) and that was an important requirement for XAML (in Moonlight).
Previously i was using the WDK drivers separately to set the environment.
But just i came to know that VS2010 contain inbuilt wdk package in it. If it contains, how to use it. how we can start building through VS2010 ? I am currently wanted to use free build for x64 platform.
can anyone help me out in this context. I need some screen short, since m new to VS. :)
No, to my knowledge WDK is still a self-contained kit and you can't use VS2010 to build your drivers -- this is still done by running "make" and using an appropriate makefile from WDK that is distributed separately.
You can, however, use VS2010 as a code editor with syntax highlight and autocompletion to edit the source code of your driver. Any other free editor, like Notepad++ or JEdit would also do here.
I would recommend you to read the following very nice document for the start with WDK:
http://msdn.microsoft.com/en-us/windows/hardware/gg463002
I need to create a basic app to check the availability of components and if necessary download them to any computer running Windows XP or above. Which language (preferably free or VS 2010) should I use to create such an application which can run without requiring any frameworks installed beforehand?
could you please elaborate? By static library, do you mean a dll that should reside alongside the exe? or do you refer to available dlls in windows/system32? Also, will programs compiled using this method require the 'Visual C++ Redistributable'?
When C++ executable links to a static library, then the linker includes the library's object code in the same file as the EXE. The result is a single *.exe file, and the library does not need to be shipped as a separate *.dll.
The DLLs in windows/system32 are typically O/S files. They're O/S-specific. You may/must/do not ship/redistribute these files (Microsoft does). Your EXE (or e.g. the C run-time library to which you have statically linked) depends on (requires) some of the functions which are exported from these DLLs. These O/S DLLs tend to be backward-comptible, so that if you target the O/S API which exists on XP, your code will also run on Vista.
I'm guessing that by 'Visual C++ Redistributable' you mean "the Visual C run-time library", whose DLL filename is something like msvcrt80.dll. This is what I talked about in my first paragraph: if you choose the build option (available under project/properties) to statically link to the C run-time library, then the code you require is statically linked into your EXE and you don't require (don't run-time link to) this DLL.
Visual C++ 6 with MFC. If you use a later version of Visual C++ then your Windows XP targets will need libraries for them.
Edit: Comments pointed out that the CRT and MFC library can be linked staticly even in later versions. That is right and I forgot.
While not specifically designed for this, I recommend InnoSetup for setup bootstrappers. It doesn't require any libraries, provides functionality for common setup requirements and has PascalScript to extend it. There are a lot of plugins available, and you can do anything left with a custom script (basically like Delphi). PascalScript can import API functions, so you can really do anything. With InnoCallback, you can even get callbacks from the API - I used this to bootstrap a lot of MSI setups into a single package using the MSI API.
If you download it, get the QuickStart Pack, which includes a good editor and the InnoSetup preprocessor.
Recently, I installed the JDK and a java library called LeJOS NXJ, for controlling a LEGO Mindstorms robot. I'd like to be able to set up the language to run through visual studio, which offers J# color coding. The command line to compile the program is:
nxjc "Myfile.java"
and the command line to deploy or download the program to the controller is:
nxj -r "Myfile"
How can I set up a way to make Visual Studio use these options?
When you use Visual Studio for Java work, the editor is more or less as comfortable and helpful as Notepad, so I'd strongly suggest to use an IDE with full Java support for this kind of work. There are plugins for LeJOS support for both Eclipse and Netbeans, two complete, open source, free and easy-to-use IDE's.
Try them (I'd start with Netbeans but that's entirely a personal choice) and you'll see right away what you're missing when trying to shoehorn Java into VS :-)
You should really be using Eclipse, as the Eclipse plug-in has been greatly enhanced.
Netbeans support has been dropped, as the (very simple) Netbeans plug-in that leJOS provided in the past never really was very convenient. It never properly overrided the bootclasspath of projects for NXT-side programs.
Example projects with a sample build.xml for use with Ant (or anything that supports Ant) is still available. However, the programming experience will not be as smooth as with Eclipse.