IDE manifest rsrc

[larrybtoys]

What is the IDE manifest rsrc and is it needed in the compiled versions of programs?

[(X)]

Sjouke addresses this:

gfabasic32.blogspot.com/search?q=manifest

I only have a vague understanding of 'manifest'...

My short answer to your question. It is not required absolutely. 

I found it affects the look of the application and the coder's ability to set custom colors for Frames and such. 

If OFF, i.e: if you include $ManifestOff at the head of the your code, you can specify the color of the Frame caption else it reverts to Windows settings/preferences.

I noticed that while running the .exe version of  a GFA-BASIC 32 for Windows program, if the manifest is left ON, meaning the $ManifestOff is NOT included, then,  I am able to see the icons in a Treeview control, else, the Treeview icons don't appear.

While running the program from the IDE, it does not seem to matter if $ManifestOff is present or not, either way, I can see the Treeview icons.

[larrybtoys]

I am wondering if this checkbox should be checked or not when compiling and how it will affect the compiled program.

Attachments:

[(X)]

If I am not mistaken, with $ManifestOff included in your code, the IDE deselects the 'Add Manifest Resource' automatically, I think you can select it manually if desired.

[(X)]

I admit I've not researched this topic extensively. Bing states that manifest files are XML files and can be edited. I've just not needed to go down that rabbit hole yet.

[larrybtoys]

Rabbit hole indeed. My thoughts without researching it further is that if you include the manifest resource by leaving the box checked the user of the .EXE will see the program how the programmer wanted them to see it. If it is not checked the user of the .EXE may not see everything how the programmer wanted it to be seen if they have some oddball settings in their windows version. Does this sound even remotely correct?

[(X)]

From Help Doc... (You've probably already seen.)

The Manifest File and Common Controls
Common Controls
GFABASIC32 comes with many OCX Controls to allow input and output and these controls are underpinned by Windows' Common Controls library.

From Windows XP onwards, Microsoft allowed access to two versions of its Common Controls library: version 5 which retained the appearance and functionality found in Windows 98/ME; and version 6, originally termed as XP Styles, which matches the controls to the themes and styles of whichever version of Windows a program is run on, as well as adding additional functionality.

By default, Windows assumes any program will run using version 5, and GFABASIC32 is no different. If either the IDE or any program compiled by GFABASIC32 is run, all OCX controls will appear as they did in Windows 98/ME.

Manifest Files
To change the styles to those of Common Controls version 6, it is necessary to use a Manifest File. Manifest files can perform numerous tasks, but the file which is supplied with GFABASIC32 (see GfaWin32.exe.manifest) has only one task: to tell Windows to use Coomon Controls version 6 rather than the default version 5.

To effect this, the Manifest file can either be in stand-alone form or embedded in the executable program itself.

To create a stand-alone file, simply make a copy of the GFABASIC32's Manifest file, paste it into the folder which contains the executable file you wish to affect and change the Manifest's name to suit. For example, if you compile a program called 'program.exe', you would copy the GfaWin32.exe.manifest file into the same file as the compiled file and rename it 'program.exe.manifest'.

From IDE version 2.40 onwards, there is an option on the Compile form (Project -> Compile/Build) to 'Add Manifest Resource'; this embeds a Manifest file into the executable, doing away with the need to create a stand-alone file. For those with earlier versions of the IDE, Peter Heinzig created a program here which does exactly the same thing.
Known Issues
There are a number of known issues where using a Manifest file does not make the desired transition from version 5 to version 6 of the Common Controls library. Some of the more common ones are:

[Stand-alone only] If there a spaces in the filename of the executable - and thus in the accompanying stand-alone Manifest file - this can cause a failure; replacing the spaces in both files with underscores ('_') usually fixes this problem.
Occasionally after a change to a compiled file or a Windows Update, controls can return to version 5; simply restarting the computer can, occasionally fix this problem.
There are other issues which can arise with using Manifest files - they are generally Windows-wide rather than just GFABASIC32-specific - and they are dealt with in more detail in Sjouke Hamstra's blog here and here.

{Created by James Gaite; Last updated: 03/03/2018 by James Gaite}

[(X)]

I asked Bing: Can editing the manifest let the coder color the controls the way he wants?

Yes, editing the manifest file can allow a programmer to change the visual style of the controls in a Windows application1. This is done by enabling visual styles in the application1.

To enable your application to use visual styles, you must use ComCtl32.dll version 6 or later1. By default, applications use the user controls defined in User32.dll and the common controls defined in ComCtl32.dll version 51. If you want your application to use visual styles, you must add an application manifest or compiler directive that indicates that ComCtl32.dll version 6 should be used if it is available1.

Here’s how you can create a manifest and enable your application to use visual styles1:

Link to ComCtl32.lib and call InitCommonControls.
Add a file called YourApp.exe.manifest to your source tree that has the XML manifest format1.
However, please note that while enabling visual styles can change the appearance of controls to match the user’s current theme, it does not provide direct control over the colors of individual controls1. For more granular control over the appearance of controls, you may need to use custom drawing or owner-drawn controls1.

[(X)]

Why is there a manifest scheme?

BING...

The main purpose of a manifest schema in Windows programming is to provide a structured format for defining the properties, dependencies, and configurations of an application¹². It serves as a blueprint that describes and identifies the shared and private side-by-side assemblies that an application should bind to at run time¹. These should be the same assembly versions that were used to test the application¹.

The manifest schema can include information such as:
- The names, versions, resources, and assembly dependencies of side-by-side assemblies².
- The names and versions of shared side-by-side assemblies that the application should bind to at run time².
- Metadata for private side-by-side assemblies used by the application².

The manifest schema helps ensure that the application runs correctly with the correct versions of its dependencies, and it can also help improve the customer experience of installing your software⁵. It's an essential part of application deployment and configuration in Windows¹²⁵.

Source: Conversation with Bing, 2023-11-19
(1) Application manifests - Win32 apps | Microsoft Learn. learn.microsoft.com/en-us/windows/win32/sbscs/application-manifests.
(2) Manifest Files Reference - Win32 apps | Microsoft Learn. learn.microsoft.com/en-us/windows/win32/sbscs/manifest-files-reference.
(3) Package manifest schema reference for Windows 10. learn.microsoft.com/en-us/uwp/schemas/appxpackage/uapmanifestschema/schema-root.
(4) MANIFEST File - What is a .manifest file and how do I open it?. fileinfo.com/extension/manifest.
(5) Understanding manifest generation for C/C++ programs. learn.microsoft.com/en-us/cpp/build/understanding-manifest-generation-for-c-cpp-programs?view=msvc-170.
(6) . bing.com/search?q=purpose+of+manifest+schema+in+Windows+programming.
(7) Writing an Instrumentation Manifest - Win32 apps. learn.microsoft.com/en-us/windows/win32/wes/writing-an-instrumentation-manifest.
(8) undefined. learn.microsoft.com/en-us/windows/win32/wes/eventmanifestschema-schema.
(9) undefined. softwareengineering.stackexchange.com/questions/109937/what-is-a-manifest-and-when-is-it-appropriate-to-use-one.
(10) undefined. learn.microsoft.com/en-us/uwp/schemas/appxpackage/appx-package-manifest.

[larrybtoys]

I guess since I do not want to add an additional manifest file to the root directory of my programs nor do I have any desire to modify the look of any windows objects within my programs I will simply leave this box checked when compiling programs to an .EXE

[dragonjim]

Put simply, if you keep the box ticked then the Common Controls in your application will match those of your host OS (Windows XP, Vista, 7, 8, 10 or 11 - all part of the NT family of Windows); if not, then they will revert to Common Controls used in the now defunct 95/98/ME family of OSs.

The IDE uses a manifest by default (you can change this behaviour by renaming the manifest file in the Bin directory).

The 95/98/ME controls are more flexible when it comes to colour - for instance, you can use different colour command buttons. However, the main reason they are still supported is backward-compatibility with software written for the old platforms.

[(X)]

Just to feed the curiosity, I looked up the contents of "GfaWin32.exe.manifest"

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity
processorArchitecture="*" version="0.0.0.0" type="win32" name="GfaWin32"/>
<description>GFABASIC32</description>
<dependency> <dependentAssembly> <assemblyIdentity
type="win32"
name="Microsoft.Windows.Common-Controls"
version="6.0.0.0"
publicKeyToken="6595b64144ccf1df"
language="*"
processorArchitecture="*"/>
</dependentAssembly></dependency>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false" />
</requestedPrivileges>
</security>
</trustInfo>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
</application> </compatibility> </assembly>

This is obviously a place where you can specify many aspects of your program's environment.  A lot of this is over my head!

[larrybtoys]

Most of it is above my pay grade...

[(X)]

I didn't know what side-by-side refered to so, for those interested...

From BING

In Windows programming, "side-by-side" refers to a technology that allows multiple versions of a component (like a DLL) to run simultaneously without interfering with each other¹.

A side-by-side assembly is a collection of resources, which could be a group of DLLs, Windows classes, COM servers, type libraries, or interfaces, that are always provided to applications together¹. These assemblies are described in the assembly manifest and are typically a single DLL¹.

Side-by-side assemblies are used by the operating system as fundamental units of naming, binding, versioning, deployment, and configuration¹. Each side-by-side assembly has a unique identity, one attribute of which is its version¹.

Starting with Windows XP, multiple versions of side-by-side assemblies can be used by applications running at the same time¹. The assembly version number and manifests are used by the loader to determine the correct binding of assembly versions to applications¹.

In summary, side-by-side technology helps to reduce DLL version conflicts and enables multiple versions of COM or Windows assemblies to run at the same time¹.

Source: Conversation with Bing, 2023-11-22
(1) About Side-by-Side Assemblies - Win32 apps | Microsoft Learn. learn.microsoft.com/en-us/windows/win32/sbscs/about-side-by-side-assemblies-.
(2) Isolated Applications and Side-by-side Assemblies - Win32 apps. learn.microsoft.com/en-us/windows/win32/sbscs/isolated-applications-and-side-by-side-assemblies-portal.
(3) Concepts of Isolated Applications and Side-by-side Assemblies. learn.microsoft.com/en-us/cpp/build/concepts-of-isolated-applications-and-side-by-side-assemblies?view=msvc-170.
(4) win32/about-side-by-side-assemblies-.md at docs - GitHub. github.com/MicrosoftDocs/win32/blob/docs/desktop-src/SbsCs/about-side-by-side-assemblies-.md.