Messenger Plus! Live - Skinning Documentation

Messenger Plus! Live

Introduction to Skinning

Welcome to the documentation of the Messenger Plus! Live skinning system. This technical documentation is intended to be read by skin developers. Whether it is to make your first skin or to get more information on a given skinning subject, you've come to the right place!

A technology you should be familiar with before you can create full featured Messenger Plus! skins is XML. XML stands for eXtensible Markup Language and looks like HTML. It is basically a way to define data in text form. If you've never worked with XML before, you'll quickly see how straightforward it can be. A lot of tutorials can be found on the internet and despite the fact that XML can be typed in any text editor, it is highly recommended that you get a good XML editor that will be able to validate your syntax. The Messenger Plus! Live skinning system makes extensive use of XML in the SkinInfo configuration file (the main file used to define the properties of a skin) and Messenger's own Windows Definition files use a very similar syntax.

The structure of SkinInfo is defined in what's called an XML Schema file. Even if this file is also text based, schema files are meant to be read in graphic form; do not try to read its XML data as this would make your task more difficult than it should be. A very good XML editor capable of perfectly rendering XML Schema files is XMLSpy from Altova (the Standard Edition is available as a free trial).

Aside from the technology, what you mostly need is the will to learn how to work with the system. Skinning is something that anybody with ideas and average computer knowledge can do but you'll need to be patient and willing to put time into your project if you want something good to come out of it. This documentation includes explanation pages, references, examples, ... use them! If you don't feel easy about skinning, just take it one step at a time, spend time in the various topics/examples available, and stick to reproducing what you see while bringing your own small modifications to existing skin code. Your first lesson awaits you in what's a skin in Messenger Plus!.

If you need help about anything related to skinning, feel free to visit the official Messenger Plus! forum. Please remember to search if somebody posted a similar question before you and if the answer was already given: you'll get your answer faster and it will save us some time to help other members. Also, if you become a more advanced skin developer with time, we would appreciate if you could help on the forum and answer people's questions when you know the answer :).

Have fun!
Patchou

Last update: January 31th, 2011
Documented version: Messenger Plus! 5.00
Latest update available at msgplus.net.


Messenger Plus! Live

Getting Started

The following topics should be read in the order specified here if you want to learn how to create skins in Messenger Plus!.

What's a Skin in Messenger Plus! ?

How Does it Work?

Integration with Messenger

Your First Skin


Getting Started

What's a Skin in Messenger Plus! ?

In the world of software, "skins" generally refer to custom graphical interfaces created for an application. Skins in Messenger Plus! are exactly that: a way to customize the look of Messenger. Since the days MSN Messenger became popular, people have spent their time and talent creating skins for Messenger. The concept is not new but Messenger Plus! brings it back with a couple of new twists.

With time, creating skins for Messenger proved to be a rather complicated task. Nowadays, anybody who wants to customize the windows of Messenger from scratch needs to have good knowledge of how resource files are organized, find where the files needed to be modified are, get past encrypted pictures, spend hours getting information from style files full of de-referenced data... and when all of that is done, a special installer program needs to be created to modify the binaries of Messenger appropriately and unfortunately, all the changes applied by the skin will go away as soon as the user applies any other update (or even another patch) to Messenger.

For all these reasons, skins created for Messenger have become quite rare and this is why a brand new skinning system was developed for Messenger Plus! Live. If you are reading this documentation wondering why you would choose to create a skin for Messenger Plus! rather than a skin for Messenger itself, here is a list of some of the reasons you may find appealing.

Developer's point of view (you) :

  • No knowledge of resource files structures is required. You won't need to repack Messenger resources with your modifications either (no need for a resource unpacker/repacker tool).
  • You won't ever need to check if a new version of Messenger uses new file names, new directories or new internal methods to display its interfaces. Messenger Plus! skins are created as separate entities and Messenger Plus! itself is in charge of ensuring file compatibility with all (present and future) versions of Messenger.
  • Your skin won't disappear every time an update is released for Messenger or a user decides to apply a patch that modifies the resources. This is particularly interesting for small updates that do not modify the interface but only fix some known problems. This kind of update is expected to become more frequent now that Windows Live Messenger is using the Windows Update system.
  • Redistributing modified Messenger binary files is not really legal and creating a proper installer for that can be tricky as a skin created this way generally only works on one specific version of Messenger. In addition, redistributing entire binary files requires much bigger setup files. Messenger Plus! skins are packed only with the resources modified by the skin.
  • Finding the right resource to modify can take hours, even with a a specialized resource unpacker program. Messenger Plus! extracts all the pertinent resources of Messenger with a single click, organizes the files in categories, decrypts the UIB windows files, decrypts the RLE encrypted pictures, creates maps of which picture is used by which window and rebuilds windows definitions and styles files to include most of the de-referenced data directly inside the file (like color codes, texts, ...). In less than a minute, you'll get everything you'll ever need to customize anything you want in Messenger.
  • No need to create an installer, Messenger Plus! skins can be packed for redistribution in seconds.
  • Many good skins disappear over time because of the amount of work required to ensure compatibility with new versions of Messenger. Updating an existing Messenger Plus! skin for a major update of Messenger is an easy task that can be executed quickly. Backward compatibility is also possible so a single skin file can work the same way on multiple versions of Messenger.
  • Messenger Plus! brings its own additions to the world of Messenger skins: you'll now be able to do things like add user modifiable options for your skin, add multi-language support or change the shape of Messenger's windows.
  • Trace file automatically generated when a parsing error is detected in a window definition or style sheet files. This trace will help you to quickly find typos inserted by mistake in the Messenger files you edit.
  • Messenger Plus! has a user base of more than 60 million active users (as of December 2008). By creating a skin for Messenger Plus! and sending it to the official database for public distribution, your work will instantly connect with millions of people.
  • Messenger Plus! has a built-in auto-update mechanism that sends new versions of your skin to users (displayed as an update option). This ensures your continuous work keeps on being used and that major new versions of Messenger keep on being supported.

Users' point of view:

  • No potentially dangerous executable file to run to install the skin (and in Vista, no need to request elevation because the skin needs to modify files in Program Files). Messenger Plus! Skin Packs bring a uniformed way to install skins efficiently into Messenger.
  • More than one skin can be installed at a time allowing users to vary their experience.
  • Messenger Plus! skins can offer a variety of options to their users. Many elements can be changed on the fly without the need for reinstallation, allowing even more customization per skin. This means that as a skin developer, you also won't have to make all the choices for the users (like what buttons to keep in the toolbar).
  • Messenger Plus! skins resist to Messenger updates (any small update distributed for security or bug fixes reasons). When a bigger update is applied and the skin gets disabled, the user will have the opportunity, from the Plus! menu, to access the official database or the developer's web page to get a new version.
  • Less risk associated with installing a new skin: Messenger binary files won't be touched and a skin can be disabled as quickly as it can be enabled. Also, in case of a major issue with a skin, the user can quickly restore his Messenger with the Maintenance Wizard of Messenger Plus!. That's less responsibilities for you and more peace of mind for your users.

Although Messenger Plus! skins have even more to offer than what's listed here, this page looks enough as an infomercial as it is already. We simply hope that we've picked your curiosity and that this will be enough to convince you to take a closer look into the Messenger Plus! skinning system. After that, you're free to choose whether you want to use it or not. Keep in mind that if you consider it important to offer a skin to your users that does not require any additional add-on such as Messenger Plus! to be installed, you can still offer two versions of the same skin, there's no need to be exclusive if you have time to develop both ways.

Some of the advantages offered by the Messenger Plus! skinning system come from the fact that, like everything else in Messenger Plus!, all the changes are done in memory. Messenger files are never touched which solves many problems (and creates others but you can leave that to the guy in charge of Plus! ;). The active skin is analyzed when Messenger starts-up, all the resources are loaded in memory and Messenger Plus! then takes care of sending the skinned material to Messenger when appropriate. You'll never have to worry about the technical details, all you need to do is concentrate on your own files.

Now that you know what these skins are about, it is time you learn how the system works.

See Also

Introduction to Skinning, How Does it Work?.


Getting Started

How Does it Work?

Physically, Messenger Plus! skins are organized into folders and files, located in the "Skins" subdirectory of Messenger Plus! Live's main directory (C:\Program Files\Messenger Plus! Live\Skins by default). Each skin has its own directory, generally named the same way as the skin. The actual data defining what the skin does to Messenger is located in a single file called SkinInfo.xml. If you have already worked on Messenger Plus! scripts, this should all sound familiar to you.

The SkinInfo.xml file is what you really want to concentrate on. Adding lines to this file means adding features to your skin. The file itself uses XML syntax and it is recommended (but not required) to save it in Unicode (UTF-16) for internationalization and loading speed reasons. XML files are basically organized text files and if you're not familiar with them, it is very important that you learn a little bit more on the subject before continuing with this documentation. A simple search on the internet will give you all the information you need on that subject.

To ensure your file is properly written for Messenger Plus!, you will also need to validate your data with the associated schema file. The schema file is distributed with this documentation along with its own associated documentation. Everything you can do in your skin is written in this file. Once you'll know more about the basics, you'll be able to use the schema as a reference while writing your XML code.

XML files are used to write data. Three kinds of data can be added in skininfo:

  • Information data. Examples: name of the skin, compatible versions of Messenger, etc...
  • Embedded skin data. Example: new lines of text to replace Messenger's original strings.
  • References to external data. Example: file name of a new picture to replace an existing one in Messenger.

Skin data is anything that is being fed to Messenger, in other words, skin data is the resources you'll modify for your skin. This includes pictures, bitmaps, icons, lines of text, windows definition files, dialog boxes, menus, etc... depending on the type of resource, data can be specified in 3 different ways:

  • Text embedded directly in the skininfo file.
    Allows quick and easy replacement of resources such as strings.
  • A file placed in the directory or a subdirectory of the skin.
    Ideal for images and windows definition files.
  • A resource compiled in a DLL file distributed with your skin.
    Required for dialog boxes and menus. Most other types of resources can also be distributed in DLL files if you don't want your files to be too easily accessible to your users.

So, to sum things up, a skin needs some information concerning itself and its surroundings, and it needs new data to replace existing stuff in the Messenger resources. Let's see how these elements all come together.

The Basics of SkinInfo

As explained previously, skininfo is the place where you'll specify all the information and data concerning your skin. Only two elements are required at the root of the file: Information and MessengerSkin. Information is explained in details in Packaging your Skin, all you need to know for now is that any skin requires a name. MessengerSkin is where things start to get interesting as all the data you'll use in your skin is defined there:

Skin data is organized in what's called resource groups. Although simple skins may not need more than one group, this additional entity allows your skin to be more flexible thanks to the use of restrictions. All the data defined in a resource group is subject to a certain set of restrictions defined by the skin developer. Many kinds of restrictions exist but only one is required for each group and that's the MsgVersions restriction.

When adding data to a new resource group, you must specify the Messenger versions that the data applies to. For new skins, all you need to do is specify your own version of Messenger for the restriction. Then, once you're satisfied with the results, you may want to test your skin in a previous version of Messenger so that more people can enjoy the skin. If everything works just the same in the other version, all you need to do is add the version number to the restrictions of your resource group. If not, you either keep things this way to prevent people from messing up an older version of Messenger with your work (and future unknown versions as well) or you have the possibility to create a new resource group and add specific data for different versions of Messenger. This way, a single skin can be used in a broad range of environments without problems or need for duplication.

Despite the flexibility offered by the restrictions system, the implementation was kept very simple. Here is an example of what an empty resource group applying to Windows Live Messenger 8.5 looks like in XML:

<MessengerSkin>
    <ResGroup>
       <Restrictions>
            <MsgVersions><Version Major="8" Minor="5"/></MsgVersions>
        </Restrictions>

        ...
    </ResGroup>
</MessengerSkin>

Remember that internal version numbers can sometimes be different from the public name given to Messenger. You'll find exact version numbers of any given version of Messenger by going in the "Help\About" menu. For example, Messenger 2009 is version 14.0.

Replacing Messenger Resources

Once a resource group is created in the skininfo file, all you need to do is add actual resource data to the group. The Resources element offers two different categories: New and Replace. The first one allows you to add new resources to Messenger using new resource ids (you'll learn the use of this in the Windows Definitions and Styles section). The second one is what most skinners will be first interested in as it allows you to replace existing resources in Messenger.

For clarity reasons, replaced resources are organized into categories and sub-categories. Here is the full listing of what Messenger Plus! skins allow you to change in Messenger:

Most skinners will concentrate on Definitions, Styles and Pictures and for your first attempts, you should concentrate on the later with maybe the addition of Strings as they are simple and safe to test. By default, Messenger Plus! automatically detects the original source of each resource category as most resources can only be defined in one place. Resources can either be replaced in the main Messenger executable, in the Messenger resources DLL or in the Messenger language DLL.

Here are some examples of sources: all the Pictures used in Messenger (not including older Bitmaps and special Vista pictures) are coming from msgsres.dll so there's no point in specifying the source every time you want to replace one of them. In that case, the Source attribute of the Picture element you're replacing will always be "msgres" and does not need to be specified. However, resources like Icons can come from both the executable and the resources DLL of Messenger so the Source attribute can either be "msgexe" or "msgres" and will need to be specified to avoid confusion. The sources allowed for each category of resource along with their respective defaults are documented in the schema file of skininfo.

To replace a resource, all you need to know is its id. How to get it is explained in the Integration with Messenger section. A resource id is unique in a given file, for a given resource category. This means that a bitmap and an icon could have the same id, two pictures from two different resource files could have the same id, but two bitmaps from the same file cannot. In order to facilitate your work, special resources such as icons (that are generally represented in groups) and strings (represented in tables) are appropriately separated. Each different format of an icon file has a different id and each string also has a different id (the id of the icon groups and the string tables are irrelevant in a skininfo file).

Here is an example showing how to replace a string and a window's definition file:

<Resources>
    <Replace>

        <Strings>
            <String Id="11">Messenger is signing in</String>
        </Strings>

        <Windows>
            <Definitions>
                <Definition Id="923"><File>mainwnd_def.txt</File></Definition>
            </Definitions>
        </Windows>

    </Replace>
</Resources>

Now that you know how to replace resources in your skininfo file, it's time to see how Messenger Plus! will help you find those precious resource ids. The next section will tell you all about the integration of skin features into Messenger.

See Also

Introduction to Skinning, Integration with Messenger section, SkinInfo Information.


Getting Started

Integration with Messenger

Being able to replace the resources of Messenger is not enough to make a complete skinning system. You have to know what to replace exactly and the effects it will have on other windows of the program. Remember that a single image can be used in many places so you can't arbitrarily change one picture for one window without considering the global impact of the modification.

For that reason, Messenger Plus! offers a special feature integrated in Messenger called the Resource Extractor. As its name implies, this feature extracts all the resources from your version of Messenger, however, it does not stop there. The resources are also categorized, decrypted, analyzed and reformatted to be more understandable. All of this is done automatically and the whole process takes about a minute to complete.

The Resource Extractor can be found in the Preferences panel of Messenger Plus! (Customize!\Skins section). By default, all the resources will be extracted in a new directory in your documents, named with the version string of your Messenger. The only option not enabled by default concerns Messenger Plus!'s own resources. Leave this option unchecked until you read the Skinning Messenger Plus! Itself (keep that one for a later date). Also, note that if a hard-patch skin (a skin not made for Messenger Plus!) is installed on your Messenger, its resources will be extracted the same way but some of the more advanced analyses may not be achieved properly.

Resource Extraction

Once the resources are extracted, the log file of the operation called Extraction Log is automatically opened. You can quickly verify if everything went well by checking the last line of the log. This file sums-up some primary information regarding the extraction: version of Messenger Plus!, version and language of Messenger, number of resources extracted grouped by categories, result of each consolidation operation along with the name of the associated window if available, and finally, the number of pictures that were cross-referenced to generate the Picture Map file.

Directories and sub-directories are created for clarity reasons. Overall, you'll find four different kinds of files in these directories:

  • Raw resources. These are the resources as extracted from Messenger, untouched by Messenger Plus! (with the exception of decrypted resources, see below). Raw resources can be found in the Graphics and Windows directories and are generally named using this convention: file_type_id.ext. So for example, a bitmap with id 11103 extracted from Messenger's executable file will be named msgexe_bitmap_11103.bmp and a window's style sheet with id 920 extracted from Messenger's resources DLL will be named msgres_4005_920.txt or msgres_style_920.txt (style sheet's resource type were 4005 in previous versions of Messenger but you don't have to care about that).

  • Reorganized Raw Resources. Text files can be found in the Strings or Strings & Colors directory. The msglang_strings.txt file contains all the text displayed by Messenger anywhere in the program (with the exception of some dialog boxes and menus). The strings are kept unchanged but are organized in an ini-like file for more readability. The original table ids are specified in the file although this information should not be of much importance for your skin. Each line is formatted like this: id=string and special characters such as carriage returns and tabulations are replaced with their corresponding escape codes (\r, \n and \t). The same escape codes are recognized in the skininfo file for strings replacement.
  • Reformatted Resources. You'll find these in the Consolidated Windows directory. The text files recorded there are the results of several analyses performed by Messenger Plus! on Messenger's windows and style sheet files. Because of the way these files are generated internally at Microsoft, their raw form is not very practical or user-friendly. Definition files' lines are packed together and style sheets are full of references to sub-resources ids for strings, integers, colors, rectangles, backgrounds, etc... whenever possible, Messenger Plus! rearranges the lines and replaces cryptic resource references with actual data (see below for more details). Messenger Plus! also analyzes the files for pictures references and places a copy of each picture file in the Pictures sub directory of each window. This way, you instantly get to see all the pictures used by a given window (keep in mind though that in some instances, Messenger can also use other pictures not hard-coded in the windows files).
  • Generated Data Files. Although the string file could be considered part of this category, the term specifically refers to files that are generated without data taken directly from Messenger. This includes Extraction Log.txt that you'll find in the root directory and Picture Map.txt that's located in the Graphics directory. This particular file will give you the list of every window using each picture files. Use it to quickly assess the impact of modifying one specific picture. As noted above, remember that some pictures are also used by Messenger in some places without direct linking in the windows files: the map file is here to help but nothing beats live testing.

RLE Encrypted Files

One thing that discouraged many skinners in the recent releases of Messenger is the use of a proprietary RLE encryption system for pictures. Fortunately, Messenger Plus! deals with this and can successfully decrypt most of the encrypted files. In most cases, Messenger accepts both encrypted and un-encrypted picture files in its windows which means that you don't need to worry about the need to re-encrypt your pictures when replacing encrypted content. Most of the pictures decrypted by Messenger Plus! are not named in a particular way so you won't even know if the file was previously encrypted or not. Here are the known limitations of the current decryption system:

  • Some RLE files do not translate properly into picture files. These files are left untouched with a .msrle extension attached to them. If Messenger Plus! encounters a problem while trying to decrypt a file, the result will also be a raw RLE file. These files are provided as-is and can only have some use if you find another tool to decrypt them.
  • The RLE system used by Microsoft is complex and supports many different kinds of properties. Although Messenger Plus! does its best to produce an accurate representation of the picture, some properties cannot be emulated 100% in a decrypted format.
    • Some RLE files contain more than one picture. When such a file is detected, Messenger Plus! outputs every picture next to one another and appends "_multi" to the name of the file. This kind of file cannot be replaced directly although some of them can be entirely replaced with new pictures using new ids.
    • Other RLE files may have a variable size to better be adapted in Messenger windows that can be resized. These pictures will be marked with "_var" and can generally be replaced with any static image. It is recommended to use bigger pictures than usual for these files. Doing so will prevent bad looking effects from being displayed when the picture is stretched too much.

Consolidation of Windows Files

If you're among the more experienced skinners (or are working toward this goal), the consolidated windows files are exactly what you'll need to study to create skins that are truly different from the original Messenger layout. This subject is discussed in details in the Windows Definitions and Styles section. Here, you'll find a list of what exactly Messenger Plus! does to the files to make them more understandable. In the Consolidated Windows directory, you'll find a sub-directory for each window. If the name of the window is available in the style file, it is added to the name of the directory. For each window, a modified version of the definition file and the style sheet file is copied along with the associated pictures.

  • Changes made to Definition Files

    • Tabulation. All the lines in the definition files are tabulated based on their child level. This helps get a better understanding of the various groups of elements specified in each file.

    • The rest of the file is analyzed for various purposes (like the Picture Map file) but is not touched. Although skinners can add actual data into this file, Messenger concentrates most of its data into the associated style file of each window.

    • In Messenger 2009, Definition Files are also parsed like Style Files to detect resource references.

  • Changes made to Style Files

    • Tabulation. The lines of the style sheet files are also tabulated, using a much simpler pattern. One level of tabulation is added for all the lines included between brackets. This helps identify the styles more quickly.

    • Strings and Integers. References to the string tables (using rcstr and rcint) are replaced with the associated data. If a string includes escape codes or double quotes, it is included in commentaries only.

      accdefaction:rcstr(20068)  ®    accdefaction:"Press"
      fontsize:rcint(20074)pt    ®    fontsize:10pt

    • Rectangles. Many coordinates are de-referenced in style files (using rcrect). Messenger Plus! creates the appropriate readable code for each of them. Coordinates in the generated rect code are in this order: left, top, right, bottom.

      padding:rcrect(20189)      ®    padding:rect(0,1,0,1)

    • Colors. Messenger uses many different kinds of internal methods to reference color (using rcclr and rcbkg). Messenger Plus! decrypts all of them and replaces the color with the appropriate RGB code when possible. The alpha channel is also specified when used by a color. Remember that some colors are variations of the user's chosen color (blue by default) and thus, cannot be expressed in RGB code. In that case, a comment is added to show the intensity of the colorized color.

      bordercolor:rcclr(46604)   ®    bordercolor:rgb(152,151,139)
      background:rcbkd(1458)     ®    background:argb(128,255,255,255)
foreground:rcclr(20090)    ®    foreground:rcclr(20090) /* Colorized. I=128 */

    • Pictures. Images are referenced in many places (using rcimg and rcbkd). The problem with image tags is that they can also refer to something else than a picture, like colors (as seen above) or predefined Messenger brushes. Messenger Plus! does its best to detect which is which and adds a comment (text between /* */) when appropriate.

      background:rcbkd(706)      ®    background:rcbkd(20203) /* not a picture */

    • And much more... everything is done to simplify the reading of the file as much as possible.

Note that because Messenger uses ANSI encoding for its style and definition files, string replacements applied in Messenger versions using extended character sets (such as Japanese) will produce files that are not readable by Messenger (the files will possibly be accepted on some systems and not others). In that case, Messenger won't be able to read the modified files if specified in a skin, the strings will need to be kept separated from those files.

Except for some minor limitations (like explained above), it is interesting to note that the consolidated versions of definition and style files are created to stay compatible with Messenger. This means that if needed, you can do your changes in the consolidated version of the file and use it in your skin without any problem. That being said, it is recommended to use this practice for testing purposes only, especially for style sheet files. Public versions of your skin should use the original raw version of the files with the appropriate modifications included into them. This ensures that compatibility with localized versions of Messenger (as well as with future updates) is kept at its maximum.

Final Word

Although this section of the documentation may seem quite technical, you'll quickly get used to it while working on your skins. Don't give it too much thoughts in the beginning and just use this page as a reference when needed. All you need to remember is that you can count on Messenger Plus! to extract the resources of Messenger and present them to you in the best possible way. The main reason you'll generally want to look at the extracted files is to get the id of a resource you want to modify, whether it's a string, a picture, a window definition or anything else belonging to Messenger.

With that in mind, you're now ready to create your very first skin!

See Also

Introduction to Skinning, Your First Skin.


Getting Started

Your First Skin

If you've already read all the other sections of Getting Started, you're ready to create your very first skin. Nothing beats a concrete example, especially after all this technical talk about resources, file formats, resource data types, etc... in order to keep things simple, this sample will only work in Messenger 8.5 as it is. However, the very same XML code will require very little modification to work properly in other versions of Messenger so feel free to modify the version restriction (see below) if you're using a different version of Windows Live Messenger.

Note to Messenger 2009 users: this part of the documentation has yet to be updated for Messenger 2009. We suggest you install Messenger 8.5 to practice with the samples found in this documentation, you'll then be able to use what you learnt in any other version of Messenger.
Note to Messenger 8.1 users: for your first skin to work properly, replace the code below with this one.

Test Skin Example

Skininfo files can be very short or very long depending on the extent of the modifications your skin needs to perform. Here is an example of a very short skin file demonstrating how easy it is to make two single modifications to Messenger:

<SkinInfo>
    <Information>
        <Name>Test Skin</Name>
    </Information>

    <MessengerSkin>
        <ResGroup>
            <Restrictions>
                <MsgVersions>
                    <Version Major="8" Minor="5"/>
                </MsgVersions>
            </Restrictions>

            <Resources>
                <Replace>
                    <Strings>
                        <String Id="61288">Hello World!</String>
                    </Strings>

                    <Graphics><Pictures>
                        <Picture Id="20061">
                            <File>clouds.jpg</File>
                        </Picture>
                    </Pictures></Graphics>
                </Replace>
            </Resources>

        </ResGroup>
    </MessengerSkin>
</SkinInfo>

To be detected by Messenger Plus!, a skin only needs to be added in the proper directory by its creator. Of course, Messenger Plus! takes care of all of this when a Skin Pack is imported (public distribution) but developers of new skins need to do some of the work themselves. Here are the steps needed to make this sample work:

  1. Create a directory for your skin called Test Skin in the Messenger Plus!'s Skins directory. By default, this directory will be C:\Program Files\Messenger Plus! Live\Skins\Test Skin.

  2. Open-up your favorite text editor (we'll use Notepad for this example) and copy-paste the above code.

  3. Save the file in the Test Skin directory and name it SkinInfo.xml. The name of this file cannot be anything else than that, every skin needs one SkinInfo.xml file. If possible, when saving the file, choose "Unicode" for encoding as this will allow you to write text in the language of your choice and will speed-up the loading of your skin in Messenger.

    • Important: after the file has been saved, double check that its extension is xml as some text editors will automatically append txt to text files. Of course, your next skins should be created with a real XML editor as explained here so this won't be a problem in the future.

  4. Extract this picture in your skin's directory as clouds.jpg. You can use any other picture of your choice as long as you name it the same way (or you can also replace clouds.jpg in the XML code by the name of your own file). Messenger will generally indiscriminately accept GIF, JPG and PNG files for its pictures anywhere in the program.

    • Note about backgrounds: as you'll see below, this picture will be used in a background. Backgrounds can be stretched by a big factor depending on the size chosen by the user for his windows. For that reason, it is recommended that you use pictures of good quality, with a big enough resolution (at the very least 350*350, the more the better) and with a small compression factor (when using JPG). If you don't, your skin may look quite bad for some people.

  5. Close the Preferences panel of Messenger Plus! if Messenger was running and the panel was already opened.

Because skins are considered to be "installed" by default, that's all you need to do when creating a new skin (in contrast with scripts that need to be specifically marked as being installed in the Windows registry). Now open the Messenger Plus! Preferences panel, go to the Customize!\Skins section and if you did all of the above correctly, an entry called "Test Skin" should be displayed. Enable your new skin and restart Messenger.

The first visible result of this skin is a modification of the login screen, as seen in this screenshot. If your contact list does not open or opens totally black, it means that your skin was not created properly. The most probable cause of this error (in this example) is the absence of the clouds.jpg picture so make sure it was properly copied in C:\Program Files\Messenger Plus! Live\Skins\Test Skin.

Login Screen Skinned

What's been changed:

  1. New background using a custom picture. The new background is shared by many Messenger windows and will be automatically colorized with the user's default color if needed.

  2. The "Remember me" option is now called "Hello World!".

Piece by Piece Analysis

The skininfo data used for this example contains 4 blocks of interest, all of which you've already seen in previous sections. Let's see them again one by one, beginning with information about the skin itself:

<Information>
    <Name>Test Skin</Name>
</Information>

The Information block lists everything users may want to know about the skin. It is explained in details in *Packaging your Skin*. By default, all that's needed is a Name element which is used to display the skin's name (like in the Preferences panel). Much more information such as a description, a version and the developer's web site url can be specified here.

Following the skin's information is a Messenger resource group block that can be divided in 3 smaller blocks.

<Restrictions>
    <MsgVersions>
        <Version Major="8" Minor="5"/>
    </MsgVersions>
</Restrictions>

First is the restriction governing the use of the resource group. As you can see, one Messenger version is specified here to restrict the skin to Windows Live Messenger 8.5.x.x. More Version elements could be added to allow Messenger Plus! to load the skin for other versions of Messenger. The version could also be restricted more precisely by using the additional Build and Revision attributes.

The last two blocks describe the resources that are replaced in Messenger.

<Strings>
    <String Id="61288">Hello World!</String>
</Strings>
<Graphics>
    <Pictures>
        <Picture Id="20061">
            <File>clouds.jpg</File>
        </Picture>
    </Pictures>
</Graphics>

The first one is the "Remember me" string which is located at id 61288 (you can find this string in Strings & Colors\msglang_strings.txt in resources extracted from Messenger). The second one is the background picture used in many places in Messenger 8.5 (contact list, notification popups, etc...). The picture's id is 20061 (find it in and Graphics\Pictures) and its replacement data comes from the clouds.jpg file (loaded and sent to Messenger as-is).

Note about strings: you'll notice that many lines of text have the character & included somewhere in them. This is used by Messenger to know what letter can be used for Alt+ keyboard shortcuts. It is recommended to always include this character in your strings when it is present in the original one as sometimes, Messenger may add some extra text to your string to compensate for the missing shortcut. The letter that's marked in your new string does not need to be the same as the one that was marked in the original. Because & is a special character in XML, it needs to be written &amp;. To underline the first letter of the string mentioned above, you would write:

<Strings>
    <String Id="61288">&amp;Hello World!</String>
</Strings>

Testing and More

Now that you know how to create a simple skin, you'll need to practice to understand more about the skinning system offered by Messenger Plus!. Several subjects of importance are reviewed in Skins Essentials and for the more adventurous ones, Specialized Subjects will tell you all you need to do to create professional, advanced and out-of-the-ordinary skins.

Remember that despite the fact that only one picture and one string were modified in this example, you can modify any number of them in your file. All you need to do is add the elements one after the other. For example, you can add any number of String elements in Strings, one on each line to keep things organized. For Picture elements as for any other kind of resources, the same thing needs to be done. Don't let the child File element confuse you and remember that new lines are only needed to keep things organized, they are not required by the XML syntax like the example below demonstrates:

<Pictures>
    <Picture Id="20061"><File>clouds.jpg</File></Picture>
    <Picture Id="636"><File>header.png</File></Picture>
    ...
</Pictures>

While you'll be working on your skin, remember that testing is very important and must be your first priority before distributing anything publicly. Here are two of the main things you need to test:

  • Because some resources in Messenger are used in multiple places (the Picture Map.txt file is helpful but not exhaustive), verify every window you can think of in Messenger to make sure a resource replaced for one reason in one window does not cause nasty effects in a different window. If a change you made causes an important problem in Messenger, windows will appear in black or won't display at all.

  • When using several restrictions for your resource groups, make sure to test every possible combination, especially if your skin is intended to work on multiple versions of Messenger. Never authorize a version of Messenger that you have not tested with your skin and repeat your tests before releasing any update.

One last thing you should do before proceeding to the more specific sections of this documentation is to check out the schema reference of SkinInfo. Skins should always be developed in a real XML editor and learning how to use the schema file to validate your work will save you a lot of headaches. You'll then be able to proceed to Skins Essentials.

See Also

Introduction to Skinning, Integration with Messenger section, SkinInfo Information.


Working With Skins

Messenger Plus! Live

Skins Essentials

The following topics can be read in the order of your choice. Each section concentrates on one particular subject of interest, essential for every skin developer.

Windows Definitions and Styles

The Trace File

Using Pictures

Packaging Your Skin


Skins Essentials

Windows Definitions and Styles

To create and display its window, Messenger uses two different kind of files: definition files and style sheet files. Although each file is used for its own specific reasons, some of the properties of a window can be defined in both files by using a different syntax. Here is a quick description of the purpose of each file.

  • Definition File. This is the main file defining a window, it describes how the window is created and what elements/controls it contains. It is formatted like an XML file (although it will not validate against strict XML syntax) with element tags and attributes. Many elements include sub-elements to create more complex layouts. An id/class is attached to most elements to be used in the style file.

  • Style Sheet File. This file needs to be paired with a definition file to be meaningful. When an element is declared in the definition file, many of its attributes can be placed in the style sheet file. This creates a separation between the bones of the window and its actual look. Style files work and look like CSS files for web pages.

In Messenger 2009, those two file types are encoded in a format called UIB. Fortunately, you won't have to worry about that as Messenger Plus1 takes care of the decoding and the re-encoding for you. The UIB files extracted from Messenger should never be used or modified directly.

Note that this section of the documentation is only meant to introduce you to the windowing system of Messenger. It is not meant to completely document the way definition and style files are created for Messenger. Microsoft uses an internal library called DirectUI for its windows. This library is several years old and has never been documented for public use by Microsoft so you'll need patience and determination to make the best out of what you have. Once you get used to the basics of the system, you'll see that it's not that difficult to make Messenger display what you want: you don't need to understand everything, just look at the windows displayed by Messenger, look at their definition files and figure out how to make changes by trial and error.

Elements Definition

Let's start with how attributes are defined for the various elements of a window. Elements are often simply named element but can be called anything else such as button, urlelem, etc... character case does not matter as long as you close the element with the exact same name. Example:

  • <element></element> is valid,
  • <Element></Element> is also valid but
  • <element></Element> is not.

The syntax for sub-elements is identical to XML: each element needs a matching closing element but can also be closed with an ending slash if no sub-elements are needed. To demonstrate this, here are two identical examples:

  • <element id=atom(ai1)></element> allows to include sub-elements
  • <element id=atom(ai1) /> is closed and cannot contain sub-elements.

In the example above, id is an attribute and atom(ai1) is the value of the attribute. Once again, this works like in XML except that values are not enclosed in quotes if they don't refer to strings. The list of attributes available for each element depends on the element's kind, however, you'll find two attributes with a basic general use: id and class. Case does not matter here either so id can also be written Id or ID. These two attributes are used to match elements with their respective styles and to help Messenger identify which is which. The value of these attributes will often be a strong hint of what the element is about. Examples:

<element class="WindowLogo" ID=Atom(ai198)/>
<element id=atom(idSearchTextBackground) padding=rect(4,0,3,0) Height=0/>

In the first element, both a class and an ID are specified. Hopefully in this case, the class name is enough to understand that the element is about displaying the logo of the window. However, many other elements use numeric ids that are meaningless on their own. In such a case, you'll need to check the style file to find more information about the element.

Elements Styles

Style sheet files are organized with simple structures: for each element listed in the file, one or more attribute is specified. Attributes generally apply to specific elements based on their id and/or class and can also depend on some other attributes or internal states. Let's take a look at this example:

button[id=atom(accountStatusbtn)]
{
    AccDefAction:"Press";
    ShortcutString:"Account &information";
}

Each block of style is defined the same way: the first line identifies the condition for the style to be applied and the following attributes are placed between { } brackets. The first word of the first line is the element's name. In this case, the element's name is button meaning that this style will apply to elements defined as <button> in the definition file. Following the element's name is 0, 1 or more condition, each one specified between [ ]. The conditions can be two things:

  • An attribute value. This is what you'll see the most in style sheet files. Attributes specified as condition will often be id or class but can also be anything else recognized by the element. Attribute conditions are written using the [name=value] syntax.
  • An internal state. Internal states give real purpose to the style sheet files by allowing attributes to vary depending on the state of an element. States are indicated on their own without an attached value and their meaning is often straightforward. For example, [pressed] specifies that the attributes should be applied when the element is pressed (generally by clicking on it).

In the example above, one attribute value condition is specified as id=atom(accountStatusbtn). This means that the attributes specified between brackets will be applied to any element defined as <button id=atom(accountStatusbtn) ...>. Because this is the most important part of style files to understand, let's analyze two other examples:

button[class="WebcamStatusBtn"][enabled=false]
{
    alpha:128;
}
wledit[id=atom(WindowEmail)][keyfocused]
{
    contentalign:middleleft;
}

Can you guess what elements are touched by these styles before reading the answer? :-)

The first example has two conditions based on an attribute value. This simply means that for the style to be applied, a button element must be defined with class="WebcamStatusBtn" and be disabled. Note that attributes such as enabled can be changed at runtime by Messenger. This means that any element defined as <button class="WebcamStatusBtn" ...> can be touched by this style if Messenger disables the element after its creation. Of course, any element defined as <button class="WebcamStatusBtn" enabled=false ...> would use this style by default. Also, remember that attributes can be specified in any order so <button ... enabled=false ... class="WebcamStatusBtn"> would also receive this style.

The second example uses an internal state condition. This means that any <wledit id=atom(WindowEmail)> element that's considered being keyfocused will use this style. This kind of condition is useful to allow elements to change on their own following an action from the user. For example, buttons often use the pressed condition to look different when pressed or keyfocused to display a hint indicating that a control is currently active (if a keyboard is used instead of a mouse to select the control).

Styles in Definition Files

Because styles are just groups of attributes, every attribute that's specified in a style sheet file can also be specified directly in the definition file. Let's consider the following example of a style block and a matching definition:

button[id=atom(accountStatusbtn)]
{
    AccDefAction:"Press";
    ShortcutString:"Account information";
}
<button class="HIGToolbarButton" id=atom(accountStatusbtn) cmdid=692>

The style can be merged in the definition file simply by replacing : with = to create compatible attribute syntax.

<button class="HIGToolbarButton" id=atom(accountStatusbtn) cmdid=692
 AccDefAction="Press" ShortcutString="Account information">

If this line was used in the definition file and the style was removed from the style sheet file, the end result would still be the same. Styles are just that: extra attributes added to each element. One of the main reasons why you can't simply get rid of style files altogether is the use of internal state conditions. These conditions cannot be expressed in a definition file. This means that you need a style file to declare different attributes for different states as mentioned above with the wledit example. Also, because styles can be combined, it is sometimes practical to set some general conditions in the style sheet file. For instance:

button[enabled=false]
{
    foreground:rgb(193,193,193);
}

This would be useful to specify that any button (no id or class was specified) that's disabled uses a different foreground color defined as foreground=rgb(193,193,193). To specify a color that's based on the user's chosen color (which is blue by default), you'll need to check out the <Colors> elements in SkinInfo as colorized colors cannot be specified as data in Style Sheet files (these colors use a single Intensity attribute which modifies the brightness of the original RGB).

What's next?

To practice is to learn so if modifying the heart of Messenger windows is a subject that interests you, practice, practice, and practice again. The contact list's logon frame is a good starting point to experiment. Edit its files to reorganize elements and change some of the styles it uses. This window is not that complicated to decipher and it's the first one you see when starting Messenger (testing requires a lot of restarting so you won't want to spend too much time signing back-in if all you want to do is test some general ideas). Also, before jumping to any other section of this documentation, make sure to read about the trace file, it will save you a lot of time when things don't go as planned after editing one of Messenger's files.

Remember that when modifying definition files, it is always better not to remove whole elements from the original file. If you want to visually remove an element from a window, add a "visible=false" or "height=0" attribute. This way, Messenger will still be able to locate the element but it won't appear on screen. This is important to prevent internal problems and crashes. In cases where removing an element is inevitable, make sure to double your tests.

Replacing definition files and style files in your skininfo file is achieved by adding <Definition> and <Style> elements. Text files must be encoded in ANSI as Messenger does not support Unicode in this case. Also, instead of using text files, definition and style data can be embedded directly into skininfo by using the <Data> element (this not recommended if you want to keep things easy to maintain). Here is an example showing how to replace the files of the contact picker window (ids taken from Messenger 8.5) :

<Resources><Replace>
    <Windows>
        <Definitions>
            <Definition Id="45703">
                <File>contactpicker_newdef.txt</File>
            </Definition>
        </Definitions>

        <Styles>
            <Style Id="45703">
                <File>contactpicker_newstyle.txt</File>
            </Style>
        </Styles>
    </Windows>
</Replace></Resources>

One thing you'll need to learn to create good looking windows is the way to manipulate pictures in your files. This big subject is waiting for you in Using Pictures but remember to practice what you learnt here first!

See Also

Skins Essentials, The Trace File, Using Pictures.


Skins Essentials

The Trace File

Windows Definition and Style Sheet files are complex and subject to typing errors. Similarly to XML, these structured files will fail to load completely at the first mistake detected by Messenger. When editing hundreds of lines, finding the precise problem can be tedious without any other guidance than a black window displayed on your screen. For this reason, Messenger Plus! provides more information about these problems, when they occur, in a special diagnostic file.

When an error is detected, like a parsing problem in a definition or style sheet file, a file called Skin Trace.txt is created in your skin's directory. This file is always generated by default but if you want to make sure it won't be created on your users' systems when distributing your skin, you can set the TraceFile element in Information to false. What you'll get in this file is a description of the error with some additional information generated by Messenger if the problem occurred outside of the Messenger Plus! scope.

Error Reporting

Several kinds of error can be logged in the trace file and each of them come with its own particular kind of information. For example, if any error concerns the parsing of text files by Messenger, the number of the faulty line will be specified at the end of the message. If the problem is related to a missing or corrupted file detected while the skin was loaded, the name of the file will be indicated. Here is an example of an event generated because a character was removed in a definition file:

07/11/20 21:23:41| **** The trace has started ****
07/11/20 21:23:41| Skin: Test Skin
07/11/20 21:23:41| Messenger version: 8.5.1302.1018 (en-us)
07/11/20 21:23:41| Messenger Plus! version: 4.50.302
07/11/20 21:23:41| Last definition file loaded: 947
07/11/20 21:23:41| Last style sheet file loaded: 923
07/11/20 21:23:41| Last picture file loaded: 652
07/11/20 21:23:41| DUIParserFailure: parse error '/' 6

The last line shown in this example is the one generated by Messenger. in Windows Live Messenger 2009, the Messenger Plus! UIB parser generates similar errors but with more details such as the line and column number where the error occurred. Everything above it is added by Messenger Plus! for diagnostic purposes, if needed. Because the error itself sometimes won't specify the source in Messenger 8, it is useful to know which definition and style files were loaded by Messenger before the error occurred. So what you can guess from this trace is that an error occurred at line 6 of either the definition file of window 947 or the style sheet file of window 923. The date and time specified on the left is formatted as yy/mm/dd hh/mm/ss.

If a file mentioned in SkinInfo cannot be found or accessed, Messenger Plus! itself will report an error looking like this:

07/11/20 22:10:32| SkinLoader: Couldn't find file "pic329.png"

Remember that files that are not needed when your skin is loaded are not verified. This means for example that if you have a resource group declared for Messenger 8.5 and another one declared for Messenger 14.0 (Messenger 2009), you'll need to test your skin with both versions of Messenger to make sure the trace file does not report anything wrong with your files.

Additional Information

Note that only errors related to some of Messenger resources are reported in this file and that all errors may not be caught. This file should only be used as a supplement of information. The absence of this file in your directory does not mean the absence of problems in your skin. Also, it is important to remember that because it is assumed that you're using a real XML Editor to create your SkinInfo.xml file and that your editor automatically validates your file with the SkinInfo schema upon saving, no error directly related to SkinInfo will be written in this trace.

Some errors may be reported several times by Messenger, for example, when a window is opened and when it is closed. Do not worry about that and concentrate on the lines where the error was detected. The first error generated by Messenger is generally the one to look at (following errors possibly resulting from the first one). Also, remember that the real problem may be located on the lines above or below the one reported by Messenger. A typo made on a previous line may be causing the next one to fail from being interpreted properly.

One last tip about the trace file: remember to delete it from your directory before packaging your files for public distribution, you probably don't want to share all your past mistakes with your users :-).

See Also

Skins Essentials, Windows Definitions and Styles.


Skins Essentials

Using Pictures

If there was only one thing that interest skin developers in general it would certainly have to be pictures. Because Messenger windows are very graphical, a lot of pictures are used everywhere. Changing the alignment of pictures, stretching backgrounds and using the other multiple options related to graphics is what makes a difference in a window.

Replacing Existing Pictures

More than often, skin developers simply want to replace an existing picture, without modifying its attributes or its location. To achieve such a thing, all that's needed is a <Picture> element added in the <Replace> block of your skininfo file, as seen in the Test Skin example.

<Resources>
    <Replace>

        <Graphics><Pictures>
            <Picture Id="20061">
                <File>background.jpg</File>
            </Picture>

           <Picture Id="442">
                <File>colorbutton.png</File>
            </Picture>

            ...
        </Pictures></Graphics>

    </Replace>
</Resources>

Pictures can generally be replaced by other pictures of any other size and encoded in any other format. Of course, there are some exceptions to this rule so make sure to always test and see for yourself. Encrypted RLE pictures can generally be replaced with non encrypted pictures, with the exception of multi-picture RLE files. These files contain more than one picture, often used for different states of a single element (like a button). Because Messenger Plus! cannot re-encode pictures into the RLE format used by Microsoft, you won't be able to touch these pictures. In some cases, changing the style file of a window to use more than one picture id will help achieve similar results though.

Some other pictures also use what's called meta-attributes (this documentation will also refer to these as metadata). These special attributes are not visible in definition or style files and are binary coded into Messenger's own resources. This metadata can be used for several things such as masks (extracted pictures of this kind will be marked with resource type 4006) and background properties. Because the original metadata recorded in Messenger for a picture may not match the needs of your new file, remember to try replacing some of the attributes (see below) if you experience problems with some pictures. A good example of that can be found with some of the pictures used in toolbar buttons: you'll need to reset the metadata of these pictures by changing any attribute (like setting <Colorize> to false) if you want your new picture to be displayed properly.

Adding new Pictures

One of the special things Messenger Plus! allows you to do with its skinning system is to add brand new resources to Messenger. This means new pictures using new resource ids unknown by Messenger's original files. These pictures are assigned the id of your choice (between 59000 and 59999) and can be referenced in definition and style files just like any other Messenger picture. Here are the main advantages of this features:

  • You're not limited by the original number of pictures distributed with Messenger.
  • No need to double check every window to make sure a resource replaced in one place affects another place. For example, instead of replacing the background picture used in the contact list window and cause the same background to be used in many other windows, you can add a new picture with a new id and change the contact list's style file to use the different id.
  • You can specify new metadata for your new pictures. This is particularly useful if you want to use background pictures that are supposed to stretch automatically in your new layout or if you want to colorize them. This also prevents new backgrounds to look strange because of Messenger's original metadata for a particular picture id.

Adding a new picture is as easy as replacing one. Instead of putting your XML data in <Replace>, you'll just have to use the <New> element. In the following example, picture.png is added to the Messenger's picture resources with the new id of 59005.

<Resources>
    <New>
        <Pictures>
            <Picture Id="59005">
                <File>picture.png</File>
            </Picture>
        </Pictures>
    </New>
</Resources>

In addition to the usual source element (here, <File>), a <Metadata> element can also be specified if the picture is meant to be used as a background or be colorized. Here is how it works: by default, any background has a static size which is the size of the picture given in parameter. This means that if the size of the window increases or decreases, the background does not change: the picture is cut if the window is smaller and it is repeated if the window is bigger. As you may have already noticed, many backgrounds in Messenger stretch to follow the size of a window. This is where meta-attributes come into play. Here are the additional attributes you can specify for your pictures (note that Messenger may ignore them depending on how you declare your picture in your windows files) :

  • Untouched Margin Metadata. If not specified, backgrounds will be displayed in mosaics. Four elements are available for this metadata: <UMLeft>, <UMTop>, <UMRight> and <UMBottom>. If at least one of these elements is set to something else than 0, the background will be stretched. The Untouched Margin parameters allow you to specify the size of the margin that must not be stretched. For example, if <UMLeft> is set to 3, the whole picture will be stretched except for the first 3 pixels on the left side of the picture. This is particularly useful when you want to add borders in your background pictures.

  • Colorization Metadata. By default, pictures are not colorized. This means that the picture won't change depending on the user's chosen color. If you want to emulate Messenger in your skin and have an adaptive background (a picture that will be converted to grayscale and recolorized with the user's color, if different than the default blue one), set <Colorize> to true.

The Neko-Koneko Examples

Let's put all of this theory into practice. Thanks to the use of new pictures, we're now able to refine the Test Skin example to make sure only the logon screen is affected by our modifications. Once again, this example assumes that you are using Windows Live Messenger 8.5. To reach our goal, we need to do two things:

  1. Specify a new picture with a new id for the background we want to use.
  2. Modify the appropriate style sheet file to replace the referenced old background with the new one.

Let's begin by adding the picture. This code is identical to what you've seen above except that a meta-attribute has been added so that the background gets colorized with the user's chosen color (the original background used by Messenger already uses that same attribute).

<New>
    <Pictures>

        <Picture Id="59000">
            <File>cat1.png</File>
            <Metadata>
                <Colorize>true</Colorize>
            </Metadata>
        </Picture>

    </Pictures>
</New>

If you were to create a skin with this resource data only, nothing would change in Messenger as the picture id is not used by any window file of Messenger (ids between 59000 and 59999 were specifically chosen for that reason as Microsoft does not assign anything in this range in Messenger). Let's change that: Go in the Windows\Styles directory of your extracted resources and find the file called msgres_4005_947.txt. Why do we know this is the file we want to modify? if you check in the Consolidated Windows directory, the 947 sub-directory is called 947 (logonFrame) and this hint can be confirmed by checking the style file and searching for a known string appearing in the window such as "Remember my password".

Open the file and search for the id of the background. In Test Skin we've already established that in Messenger 8.5, the picture used for this purpose is 20061. But don't take our word for it and see by yourself in the Pictures subdirectory of Consolidated Windows\947 (logonFrame). If you're trying to adapt this example to a different version of Messenger, you won't have any choice but to search for the id used in your own version.

Now that we know the id of the background, search for it in the style file. The background is referenced in only one place:

...
Element[id=atom(mainwndcontainer)]
{
    Background:rcbkd(20061);
}
...

Change 20061 for 59000 and save the file with a new name: NekoLogonStyle.txt. A new directory needs to be created for this example so the final destination of the file should be something like Skins\Neko-Koneko Example\NekoLogonStyle.txt in Messenger Plus!'s main directory.

The style of the mainwndcontainer element should now look like this in your new style sheet file:

Element[id=atom(mainwndcontainer)]
{
    Background:rcbkd(59000);
}

That's it for the style file. Pictures used in this example can be found here, extract both cat1.png and cat2.png in your skin's directory. You now have the 3 necessary resource files, all that's left to create is the appropriate sinking. Create a new SkinInfo.xml file and copy this data into it to finalize the skin:

<SkinInfo>
    <Information>
        <Name>Neko-Koneko 1</Name>
    </Information>

    <MessengerSkin><ResGroup>
        <Restrictions>
            <MsgVersions>
                <Version Major="8" Minor="5"/>
            </MsgVersions>
        </Restrictions>

        <Resources>
            <New>
                <Pictures>
                    <Picture Id="59000">
                        <File>cat1.png</File>
                        <Metadata>
                            <Colorize>true</Colorize>
                        </Metadata>
                    </Picture>
                </Pictures>
            </New>

            <Replace>
                <Windows><Styles>
                    <Style Id="947">
                        <File>NekoLogonStyle.txt</File>
                    </Style>
                </Styles></Windows>
            </Replace>
        </Resources>
    </ResGroup></MessengerSkin>
</SkinInfo>

With purple set as the user's chosen color, the end-result should look like that:

Neko-Koneko 1

What's been changed:

  1. New background using a custom picture with a new id. The background is specific only to the logon window and will be automatically colorized with the user's color if needed.

  2. The background is displayed in mosaics, the picture is repeated both horizontally and vertically.

If the window appears all in black, check the following:

  • Is there a cat1.png picture file in your skin's directory?
  • Did you modify the style file properly?

If you saw the cats in your logon screen, you successfully created a skin with a new picture and a modified style file, congratulations! As a final exercise, let's look at how a stretched background would be implemented in the same way. For this example we'll use the same style sheet file but with a new picture called cat2.png. All you need to do is replace the <New> block of your skininfo file with the following one:

<New>
    <Pictures>

        <Picture Id="59000">
            <File>cat2.png</File>
            <Metadata>
                <UMLeft>5</UMLeft>
                <UMTop>5</UMTop>
                <UMRight>5</UMRight>
                <UMBottom>5</UMBottom>
            </Metadata>
        </Picture>

    </Pictures>
</New>

As you can see, the Colorize element has been removed so the background will keep its original colors, disregarding the choice of the user. Untouched margins have been added for 5 pixels on each sides. This allows our picture to include a bluish border that won't stretch with the rest of the picture. Here is the result of this modification:

Neko-Koneko 2

What's been changed:

  1. New background using a custom picture with a new id. The background is specific only to the logon window and is never colorized.

  2. The background is stretched to keep the cat in the lower right corner, proportionally to the rest of the window. The blue border keeps its size on every side.

Tip: If you still fail to understand what the UM elements do in this example, try changing one or two to 0 and it should become clearer to you.

Doing More with Pictures

The subject of how to manipulate images properly in Messenger is a rather big one and the goal of this documentation is only to introduce you to the various elements of the Messenger interface. You'll learn more by practicing and testing your ideas. Many things can be done by playing with layouts, padding, alignment and child elements. Check the files of Messenger, try to understand how things work and do your best! remember that there are big differences between static images (rcimg) and backgrounds (rcbkg) so always experiment with both. The most interesting results can only be achieved with time, once you'll have understood how to put all the pieces together.

Creating the best looking skin in the world means nothing if there is no proper way to distribute it. Your last lesson awaits you in Packaging Your Skin.

See Also

Skins Essentials, Packaging Your Skin.


Skins Essentials

Packaging Your Skin

Distribution is something that's often overlooked in the world of software. Many developers either zip their files and assume their users will know what to do with them or use generic installers that can't always react properly to certain exceptions.

If you've already worked with Messenger Plus! scripts before, this section won't be a surprise to you as the exact same principle is used. Skins are distributed in what's called a Skin Pack. To create a skin pack, compress all the files of your skin into a zip archive using your favorite zip tool (such as Winzip) and change the extension of the file from ".zip" to ".plsk". That's all you need to do to create a working distribution package for your skin.

Directories and sub-directories can be used to organize the skin's files, however, SkinInfo.xml must always be at the root of the archive. If no skininfo file can be found, Messenger Plus! will consider the Skin Pack to be invalid. Skin Packs can be imported from the Messenger Plus! preferences and are also registered in the shell: double-clicking on a plsk file while being signed-in in Messenger will automatically trigger the display of the Import Skin window.

Note to webmasters: because Skin Packs are actually zip files with a different extension, some servers may detect the real file type and automatically send a ".zip" to your visitors, preventing them to properly import the file once it's been downloaded. On Apache, this problem can be fixed by adding an AddType directive in your .htaccess file. If you're experiencing the problem on a server that you do not control, just re-zip your plsk file to protect its extension inside a new archive or contact your server's administrator.

Although the only information required in your skininfo file is <Name>, it is recommended to take advantage of a maximum of other elements to improve the experience of your future users. All the information that's allowed for a skin is listed in the schema file of SkinInfo. Here are some of them:

  • Name. The name of your skin as displayed in every window of Messenger Plus! when needed. This name is also used to create the destination directory of your skin during importation. Do not specify a version number here.
  • Description. This text can be several lines long and is displayed during the importation of your skin.
  • AboutUrl. If you have a web site, specify it here. Users will have access to your site from the Import window and the Skin menu in Messenger.
  • Version. The version of your skin, to identify updates. It is displayed next to the name of your skin, as-is.
  • Screenshot. Before reading the name or the description of your skin, people will want to know what the skin actually looks like. A picture file can be specified here for that reason. It will be displayed in a square, resized if needed, and will be visible in both the Import Skin window and the Preferences panel. It's not very big so avoid adding screenshots of entire windows here.
  • Compatibility. This element is important as it informs Messenger Plus! about the version(s) of Messenger that are compatible with your skin. Versions specified here won't restrict any part of your skin from being loaded but will provide visual clues to the user if the skin is incompatible.

Here is an example of a skininfo file created for Test Skin that uses all the elements described above:

<SkinInfo>
    <Information>
        <Name>Test Skin</Name>
        <Description>This skin is for documentation purposes only.</Description>
        <AboutUrl>http://www.msgplus.net</AboutUrl>
        <Version>1.00</Version>

        <Screenshot>
            <File>screenshot.png</File>
        </Screenshot>

        <Compatibility>
            <MsgVersion Major="8" Minor="5"/>
        </Compatibility>
    </Information>

    ...
</SkinInfo>

Once a skin is packed properly, it can be redistributed without any constraint and by any means you judge appropriate. Remember to instruct your visitors to download the latest version of Messenger Plus! Live as well as Skin Packs are not recognized by older versions of the software. If your skin uses features that were added in subsequent versions of Messenger Plus! and you want to prevent importation in incompatible versions, add a Version attribute to your <SkinInfo> element. It is also highly recommended to specify an <UpdateId> and a <BuildNumber> so that Messenger Plus! can properly notify the users of your skin when you release a new version in the public database.

Here is the list of schema versions that can be used:

  • Messenger Plus! Live 4.50 : skin schema version 1.
  • Messenger Plus! Live 4.60 : skin schema version 2.
  • Messenger Plus! Live 4.70 : skin schema version 3.
  • Messenger Plus! Live 4.80 : skin schema version 4.

So, for example, if you used a DateRange restriction in your skin (added in Messenger Plus! 4.60) and want to make sure the restriction is always considered when the skin is loaded, you would have to define the root element of your skininfo file as:

<SkinInfo Version="2">
    ...
</SkinInfo>

If you've read all the sections of Skins Essentials, you now have the knowledge to create great skins with Messenger Plus!. When you'll feel comfortable enough using the system, go read about the Specialized Subjects. These additional sections will brief you about the cool features available to those who want to do more than the average developer.

Good luck!

See Also

Skins Essentials, Specialized Subjects.


Messenger Plus! Live

Specialized Subjects

The following topics can be read in the order of your choice. Each section concentrates on one particular subject of interest and will help you get a full understanding of the Messenger Plus! skinning system.

Restrictions: How and Why?

Reshaping Your Windows

User Modifiable Options

Options for Advanced Users

Skinning Messenger Plus! Itself

Encoding and Decoding UIB


Specialized Subjects

Restrictions: How and Why?

The subject of restrictions should already be familiar to you if you've read How Does it Work?. If you haven't, please do so before reading the rest of this section as it contains important information needed to understand the content of this page.

Reasons For Restrictions

During the development of more complex skins, some special requirements may become apparent to you. For example, you want to change the text somewhere in a Messenger window and you don't want the modification to look bad in localized versions of Messenger. Without restrictions, the only way to do this properly would be to create two different versions of your skin and distribute them separately. If you then want to add a third and fourth language, maintaining all the different versions of the same skin can quickly become troublesome.

Languages are used here as an example to illustrate the need for a more general feature: being able to specify resources that depend on external factors. This ability can be found in the Messenger Plus! skinning system through the use of restrictions. Restrictions represent the first key element you'll need to learn to do more in your skins and stop feeling constrained in a static environment.

Resource groups exist because of restrictions. In all the examples you've seen so far in this documentation, the use of resource groups was limited to its most primary use: one resource group with one version restriction to create one specific target for the skin. Adding more resource groups to your skin becomes a necessity when you start considering issues such as language and you don't want to copy/paste big chunk of data because of a single line of text. If we keep on using the example of localization, here is how the problem cited above could be solved:

Resource Group 1
      Restriction: version
      Replace resources: pictures, definitions, style

Resource Group 2
      Restriction: version, language (English)
      Replace resources: strings (English)

Resource Group 3
      Restriction: version, language (French)
      Replace resources: strings (French)

In the first group, most resources are defined with a single version restriction to target the appropriate Messenger version. Everything that does not include text written in a specific language is included in this group. A specific group is then created for each of the languages supported, defining only the resources that are language-specific. When the skin is loaded, Messenger Plus! analyses every group one by one and load their content if the set of restriction is valid in the current environment. Here are some examples of loading sequences that could happen with the above conditions:

  • In a non matching version of Messenger, no group is loaded.
  • In a matching English version of Messenger, Group 1 and Group 2 are loaded.
  • In a matching French version of Messenger, Group 1 and Group 3 are loaded.
  • In matching Spanish version of Messenger, Group1 only is loaded.

Be careful about the last example: you must never forget to add a default for specific restrictions. In the example above, if you wanted to restrict the whole skin to either English or French users of Messenger, then a matching language restriction would have to be added in Group 1.

Resource Group 1
      Restriction: version, language (English, French)
      Replace resources: pictures, definitions, style

If you want your skin to be available to anybody, load English by default and still support French, just remove the language restriction from Group 2.

Resource Group 2
      Restriction: version, language (English)
      Replace resources: strings (English)

Resource groups don't have numbers in skininfo files but Messenger Plus! loads the groups in the order they're specified. So if Group 2 was to include the default English strings with no language restriction, everything would work fine: English strings are always loaded by the skinning system when parsing Group 2 and if the restrictions of Group 3 are matching (French version of Messenger), then the strings are loaded again in French. Resources that are redefined in several groups are simply reloaded while the groups are analyzed sequentially. This means that the last definition of a resource is the one that's used in Messenger. If you were to switch Group 2 and Group 3, then the strings would always be displayed in English as the second group would be loaded conditionally in a French version of Messenger and the third group would always be loaded without language restriction, replacing any localized version of the text.

Messenger Versions

One important role of restrictions is the specification of Messenger versions. This is the only mandatory restriction that's required by Messenger Plus! to load a resource group. Restricting versions is required because you can't know what the next version of Messenger will be like and you certainly don't want to crash the all the users who've trusted your work in the last couple of months because they've just upgraded their Messenger. Versions restrictions allow you create a single skin that will work on every known version of Messenger. Version compatibility is the first cause of trouble for users who are interested in installing a skin and restrictions solve that problem transparently, without any hassle for the developer.

Let's re-use the logic of the previous language example. The problem is different but the implementation is the same and this time, we'll write it in proper XML. Consider this: you want to create a skin that replaces two pictures and a window definition file in Messenger. The skin needs to work with both Messenger 8.1 and Messenger 8.5. After analysis, you notice that the window definition file is different for each versions but the pictures' ids are the same. Here is the resulting skininfo data:

<MessengerSkin>

    <!-- Pictures for Messenger 8.1 and 8.5 -->
    <ResGroup>
        <Restrictions>
            <MsgVersions>
                <Version Major="8" Minor="1"/>
                <Version Major="8" Minor="5"/>
            </MsgVersions>
        </Restrictions>

        <Resources><Replace>
            <Graphics><Pictures>
                <Picture Id="162">
                    <File>away.png</File>
                </Picture>
                <Picture Id="163">
                    <File>busy.png</File>
                </Picture>
            </Pictures></Graphics>
        </Replace></Resources>
    </ResGroup>

    <!-- Definition File for Messenger 8.1 -->
    <ResGroup>
        <Restrictions>
            <MsgVersions>
                <Version Major="8" Minor="1"/>
            </MsgVersions>
        </Restrictions>

        <Resources><Replace>
            <Windows><Definitions>
                <Definition Id="920">
                    <File>convodef_81.txt</File>
                </Definition>
            </Definitions></Windows>
        </Replace></Resources>
    </ResGroup>

    <!-- Definition File for Messenger 8.5 -->
    <ResGroup>
        <Restrictions>
            <MsgVersions>
                <Version Major="8" Minor="5"/>
            </MsgVersions>
        </Restrictions>

        <Resources><Replace>
            <Windows><Definitions>
                <Definition Id="920">
                    <File>convodef_85.txt</File>
                </Definition>
            </Definitions></Windows>
        </Replace></Resources>
    </ResGroup>
</MessengerSkin>

XML tends to make simple things look bigger than what they really are so the interesting parts have been formatted in bold. In this code, you can see 3 different resource groups, each one with a different set of restrictions and resources. Here is the result of this skin:

  • Windows Live Messenger 8.1

    • Picture 162: away.png
    • Picture 163: busy.png
    • Definition file for Window 920: convodef_81.txt

  • Windows Live Messenger 8.5

    • Picture 162: away.png
    • Picture 163: busy.png
    • Definition file for Window 920: convodef_85.txt

Combining Restrictions

Because many kinds of restrictions exist in Messenger Plus! (as seen in the schema of SkinInfo), it is important to understand how they combine with each other. The rule is simple: restrictions of a same kind combine with a logical OR and groups of different kinds combine with an AND. In the example shown above, the first group specifies two restrictions of the same kind: Messenger version 8.1 and Messenger version 8.5. This is interpreted as "Use this group if the version of Messenger is either 8.1 OR 8.5".

Let's say you add a language restriction in the mix to target only American English versions of Messenger, like this:

<Restrictions>
    <MsgVersions>
        <Version Major="8" Minor="1"/>
        <Version Major="8" Minor="5"/>
    </MsgVersions>

    <MsgLanguages>
        <Language IsoCode="en-us"/>
    </MsgLanguages>
</Restrictions>

It would be interpreted as "Use this group if the version of Messenger is either 8.1 OR 8.5, AND the language of Messenger is English-US". So you'd need either Messenger 8.1 English-US or Messenger 8.5 English-US.

If a second language restriction is added for French, as show here:

<Restrictions>
    <MsgVersions>
        <Version Major="8" Minor="1"/>
        <Version Major="8" Minor="5"/>
    </MsgVersions>

    <MsgLanguages>
        <Language IsoCode="en-us"/>
        <Language IsoCode="fr-fr"/>
    </MsgLanguages>
</Restrictions>

The resulting interpretation would be "Use this group if the version of Messenger is either 8.1 OR 8.5, AND the language of Messenger is either English-US or French-FR". The skin would be applied to Messenger 8.1 English-US, Messenger 8.5 English-US, Messenger 8.1 French-FR and Messenger 8.5 French-FR.

Note that in the particular case of languages, it is possible to exclude a language instead of including it using the FilterMode attribute. For example, if you know your skin works with every localized version of Messenger 8.5 but does not work with the Traditional Chinese one, you can write the corresponding restriction as:

<Restrictions>
    <MsgVersions>
        <Version Major="8" Minor="5"/>
    </MsgVersions>

    <MsgLanguages FilterMode="exclude">
        <Language IsoCode="zh-tw"/>
    </MsgLanguages>
</Restrictions>

Unlimited Possibilities

Messenger Plus! gives you access to several basic restrictions for your skin and more restriction kinds may be added in the future. However, what would happen if you wanted to add your own rules into your files? this would mean allowing users to change your skin at runtime with some kind of modifiable options. Fortunately, the system already supports this feature and calls it Skin Options. All you need to know about that subject can be found in the following section.

See Also

Specialized Subjects, How Does it Work?.


Specialized Subjects

Reshaping Your Windows

Changing the look of windows is one thing but being able to actually reshape one of them opens a new world of possibilities. This subject has never been tackled with before in the world of Messenger skins. For that reason, this section will try to give you all the information you need to know about shapes in general.

Messenger Plus! Live lets you do the following two things: change the shape of some of Messenger windows and modify their sizing information. Only the contact list and the chat windows can be re-shaped but the feature will be extended to more windows in the future if there's enough demand for it. In order to simplify things, only the Contact List will be analyzed in this documentation, however, the same principles apply to all windows. Everything you put in <ContactList> can be put in <ChatWnd> to re-shape chat windows.

The skininfo elements that will allow you to perform these modifications are <Region> and <Dimensions>, both can be found in the root of <SkinInfo> (see schema file for more details). Note that these two elements are common to every resource group specified in your skin and that they'll only be loaded if at least one Messenger resource is replaced by a group. Here is a summary of the possibilities offered by these elements:

  • Region. A new shape for the contact list window can be specified here. By default, the shape of Messenger's contact list is a rectangle with rounded corners. The new shape can be anything of your choice, does not depend on the original shape and is created with a group of rectangles and pictures.
  • Dimensions. Two different things can be defined here: size restrictions for the width and height of the contact list and a new set of resizing border areas that allow people to resize your newly shaped window the way you want. You'll see more about that later on.

Regions in Action

Let's start with a picture demonstrating what <Region> can do for your skin:

Skin with a Shape

What's been changed:

  1. The contact list is using a new shape. The inside of the eyes is excluded from the region so the eyes are transparent and are not part of the window.

  2. The size of the window is fixed, it can't be resized.

  3. Some elements such as additional help links have been removed.

  4. A very simple close button displaying an "X" is added in the top right corner of the window.

As you can see, "anything of your choice" really means anything. In this example (author's note: please be tolerant, I'm a software developer, not a graphic designer), the shape of the window is created with a single black and white picture. More complex shapes can be created by combining several pictures and rectangles to create cool (and more useful) results. It is important to note that the inside of the eyes is not part of the shape. Clicking inside them activates the window below. This was done to demonstrate that regions are not necessarily just about the outside border of a window.

It is up to you to find good ways to exploit this feature for your creations. Remember however that the contact list window isn't just about the logon frame. Using the shape of a cat's head as model, it would really be difficult (but not impossible) to make a decent arrangement for the contact list itself (displaying your name, list of contacts, toolbars, ...). Also, because borders can't be smoothed with per-pixel transparency, you should avoid adding big round shapes in your design as they'll tend to look bad if the window is resized or too big.

This example uses two picture files: one for the region mask and the other for the actual background as displayed:

Region Mask | Logon Frame Background
cathead_region.png | cathead_bkg.jpg

A picture mask works like this: by default, anything that is white is considered to be transparent. The color used for transparency can be changed to any other RGB value if needed. If a transparent GIF or PNG picture is used for the mask, all the transparent pixels are considered to be the same as the key color. This means that the transparent areas will still look transparent but if your picture has some white in it, it will be considered transparent as well. For that reason, using transparent pictures for masks is not recommended as it can lead to unexpected problems.

The background is a simple picture added as a new resource in the skininfo file. It works exactly like in the Neko-Koneko example demonstrated in Using Pictures: a new resource id is created for the background and the style sheet file is modified to use this new id for the main background element. Note that although some areas are supposed to be transparent, you should always fill the whole picture appropriately. Remember that some users choose to display the generic default Windows border around the contact list (with the title bar and menus). In that specific case, regions are not applied and the entire picture will be visible.

Creation of a New Shape

A <Region> element contains a single <ContactList> element that in turns contains a list of <Rectangle> and <Image> elements. Rectangles allow you to quickly create rough shapes. Use them whenever possible as they require less memory and less cpu usage when the window is resized. Keep the images for anything that you can't do with the rectangles. Every element is interpreted in the order specified in the file and each element can either be added or subtracted from the final region. New regions are completely empty by default.

Coordinates for the rectangles and the images can be specified in pixels or in percentage of the total width and height of the window (pixels are used by default). Positions can be specified from any border of the window (you can specify 0,0 in the bottom/right corner of the window if needed instead of in the top/left corner). Here is an example using two rectangles:

<Region>
    <ContactList>
        <Rectangle>
            <Left Unit="percent">30</Left>
            <Top  Unit="percent">0</Top>
            <Width Unit="percent">70</Width>
            <Height Unit="percent">100</Height>
        </Rectangle>

        <Rectangle>
            <Left>0</Left>
            <Top>0</Top>
            <Width Unit="percent">30</Width>
            <Height Unit="percent">35</Height>
        </Rectangle>
    </ContactList>
</Region>

If you copy paste this code in a skininfo file to test it, remember to also replace at least one resource, like a string. If no resource replacement is detected, Messenger Plus! will assume that the skin does not need a particular shape and will ignore anything talked about in this section.

Here is the region resulting from the code (green areas are the part of the window that will be visible on screen):

Note that if instead of aligning the second rectangle with the top you wanted to align it with the bottom, you'd need to replace the "<Top>0</Top>" line with "<Bottom>0</Bottom>".

Now that we've got the basic shape of our window, let's see how to smooth its corners a little. We'll concentrate on the top/left and top/right corners for this demonstration but the same method can be applied everywhere. If we keep the shape as it is now, you'll notice that to round the corners, we'll need to remove pixels from the current region. Because we want something that's not rectangular, we'll use a picture (you could recreate the same thing with small rectangles as well but that would be a lot of code).

Pictures are used exactly the same way as rectangles and have the same coordinate system. If the width or height is not specified, the size of the picture will be used so remember that if you want your picture mask to be applied on the whole window like in the Cat Head example above, you'll need to specify 100% for the width and height.

Here is the additional XML code to be added after the rectangle code (if it was added before, it would have no effect on the region as it would be subtracting a shape out of nothing).

<Region>
    <ContactList>
        ...

        <Image Integration="subtract">
            <Source>
                <File>border-TL.png</File>
            </Source>
            <Position>
                <Left>0</Left>
                <Top>0</Top>
            </Position>
        </Image>

        <Image Integration="subtract">
            <Source>
                <File>border-TR.png</File>
            </Source>
            <Position>
                <Right>0</Right>
                <Top>0</Top>
            </Position>
        </Image>
    </ContactList>
</Region>

The final region using these two pictures would be:

Sizing Borders

When you change the shape of the contact list window, Messenger Plus! does not modify the internal sizing margins recognized by Messenger automatically. As far as Messenger is concerned, the margins are still on the very left, top, right and bottom borders of the whole window and in the example above, this would prevent users from resizing their contact list on most of the left side as it's not aligned with the left border of the window anymore.

Although this may seem to be a trivial problem at first glance, complex shapes (like in Cat Head) can rapidly render most if not all sizing borders inaccessible, preventing users to modify the size of the window entirely. Without additional code, our example can currently be represented like this:

Of course, Messenger Plus! gives you a way to correct the situation in your skininfo file. New border areas can be defined and associated or the resizing operation of your choice. For each area, you specify an area kind telling Messenger whether the border is supposed to be part of the left, the top, the right or the bottom side of the window. Corners like top/left and top/right for diagonal operations are also supported.

All of this is done in the <ContactList> element of <Dimensions> (in the root of <SkinInfo>, like <Region>). Multiple <BorderArea> elements are added in <Borders>, one for each new resizing area defined in the window. More than one area can be defined with the same border kind if needed. Is some areas overlap, the first one listed is used. Here is the code needed to add the missing left and bottom resizing borders to the example above:

...
<Dimensions>
    <ContactList>
        <Borders>
            <BorderArea Kind="SizeBottom">
                <Left Unit="percent">0</Left>
                <Top Unit="percent">34</Top>
                <Width Unit="percent">30</Width>
                <Height Unit="percent">1</Height>
            </BorderArea>

            <BorderArea Kind="SizeLeft">
                <Left Unit="percent">30</Left>
                <Top Unit="percent">35</Top>
                <Width Unit="percent">1</Width>
                <Height Unit="percent">65</Height>
            </BorderArea>
        </Borders>
    </ContactList>
</Dimensions>

In this code, a first area is created for the small horizontal border on the top left. A bottom border of the size of the entire line is used (30% in width like the second rectangle, starting at 34% of the height from the top to reach 35%, the total height of the second rectangle, creating a border that uses 1% of the height). Same thing for the second area created for the long vertical border of the window, this time a left border. Everything is done in percentages to match the shape itself and to simplify the example. In real world scenarios, it is generally better to specify the width and height of these borders in pixels, not in percentage.

The entire outer border of the new window's shape is now resizable. Note that your new shapes don't necessarily have to be resizable from every border. That's also why Messenger Plus! does not attempt to do any of this automatically. The choice is given to you to only allow specific parts of your layout to accept sizing operations.

Fixed Dimensions

Adding new sizing borders is one thing but what if your skin is so complex that it needs some restrictions concerning its size? Not every skin can be designed to fit in any kind of deformed shape. For that reason, Messenger Plus! lets you impose restrictions on the size of the contact list window. The size can either be fixed or restrained between a predefined minimum and maximum value. Note that what you specify here is the size of the window's client area: if the generic Windows borders and menus are shown, the total size of the window will be bigger but at least, your skin will be safe (that's not something you need to care about though).

Size restrictions can be applied indifferently to the width and the height of the contact list by using the <Size> element of <Dimensions>\<Contactlist>. If a fixed or a maximum size is set, the window's ability to maximize is disabled. Here is an example showing how to restrict the size to a set of fixed values (as used for Cat Head) :

<Dimensions>
    <ContactList>
        <Size>
            <Width>
                <Fixed>450</Fixed>
            </Width>
            <Height>
                <Fixed>448</Fixed>
            </Height>
        </Size>
    </ContactList>
</Dimensions>

If instead you prefer restricting the window's height to be between 100 and 800, the <Height> element needs to be written like this:

<Height>
    <Minimum>100</Minimum>
    <Maximum>800</Maximum>
</Height>

Conclusion

You now know about all the components that allow new shapes to be designed. If needed, click here to get a Skin Pack that sums-up the examples you've studied in this section. Note that this pack is not meant to be used as a standalone skin as it will cause parts of your contact list to be inaccessible (only the shape is modified in this example, definition files and style files would need to be changed as well to match the shape, like in Cat Head).

Creating new shapes and modifying the default resizing behavior of Messenger can be time consuming but if used wisely, this feature alone will help place your skin in a very different category. Remember that when people search for skins, the first thing they generally have in mind is "I want to change how my Messenger looks" and a change of shape can never go unnoticed.

Shape modifications shouldn't be over used though. Early excitement over this kind of feature must not take over commonsense. The contact list is the entry point of Messenger and if only one shape had to be changed, it would certainly have to be the shape of this window. Adding too many bizarre things to your skin may alienate your users in the long run and doing a proper shape modification for the contact list is guaranteed to keep you occupied for quite some time already :-).

See Also

Specialized Subjects, Using Pictures.


Specialized Subjects

User Modifiable Options

Skins often tend to modify key elements of the Messenger interface. In addition to changes to the look of the windows, things like buttons, toolbars, links and menus are often modified or removed by them. The main problem with functional changes such as these is that in most cases, no choice is given to the user. Skins that are distributed in static hard-patch packages present themselves as one single entity doing all sorts of things, some of which users may dislike.

Instead of requiring from the developer to decide everything on behalf of his users, Messenger Plus! skins allow the creation of sets of user modifiable options. These options are displayed together in a special window, accessible from the skin menu and the preferences panel, which can also be customized to incorporate things like a banner, additional links to your web site, etc... Messenger Plus! takes care of all the technical details, all you need to do is declare the name of an option and use it the way you deem necessary.

Declaring New Options

User options are declared in the <Skin>\<Properties> child of the <Options> element. Every property has a name, a type and a default. Additional display elements such as DispLabel and DispHelp are also available to create more user friendly option panels. Here are the two current types of properties offered by Messenger Plus!:

  • BoolVal. A simple true/false value. It can be used for options that only require to be either enabled or disabled and is represented with a checkbox control by default.
  • MultiVal. A value that can be set to any given string. Use it for options that require a selection to be made in a list. It is represented with a combobox (dropdown) control by default.

Options only allow users to make a choice between predefined values that you created for them. The Messenger Plus! skinning system does not allow variable options (example: strings entered in an edit box) for security reasons. You can never be sure of what users can specify in a non-controlled environment and this may lead to crashes in Messenger.

All the options you specify in your skininfo file are automatically displayed by Messenger Plus! in a option panel created specifically for your skin. Every option is displayed in the order specified in the file and Messenger Plus! takes care of reading/saving the properties in the Windows' registry. If an option is changed, Messenger Plus! also asks the user if Messenger should be restarted immediately for the options to be applied. A restart is always required for new option values to be applied because of optimizations made in Messenger and Messenger Plus! itself.

Here is an example of how to declare two options for your skin, one boolean and the other one list-based. Note that spaces are not allowed in the Name attributes.

<Options>
    <Skin>
        <Properties>
            <BoolVal Name="ChangeBkg">
                <Default>true</Default>
            </BoolVal>

            <MultiVal Name="RememberMeTxt">
                <Values>
                    <Value>hello</Value>
                    <Value>goodbye</Value>
                    <Value>farewell</Value>
                </Values>
                <Default>hello</Default>
            </MultiVal>
        </Properties>
    </Skin>
</Options>

That's all you've got to do for Messenger Plus! to recognize and take care of your options!. If you add this code to the Test Skin file and restart Messenger, you'll notice that a "Skin's Options" menu is now available for it.

Here is the window that Messenger Plus! will generate for these options:

As you can see, the default values are properly set in this screen. Because skins are loaded when Messenger starts-up, the options are global to every user registered in a given Windows' account. Options are displayed with their name by default but DispLabel elements and attributes should always be used for added clarity. Using display names will also allow you to change the text displayed in your options window without risking to alter the internal name of your option and breaking some of your skin's code as a result (seen later in this section).

Both BoolVal and MultiVal accept <DispLabel> elements. Values specified in a MultiVal also accept DispElement but as an attribute. If additional information is required to explain the purpose of an option, a <DispHelp> element can be added for tooltip creation. Let's modify the example's code to take advantage of all of this:

<Options>
    <Skin>
        <Properties>
            <BoolVal Name="ChangeBkg">
                <DispLabel>Change the background picture</DispLabel>
                <DispHelp>This option displays a cloudy sky</DispHelp>
                <Default>true</Default>
            </BoolVal>

            <MultiVal Name="RememberMeTxt">
                <DispLabel>New "Remember Me" label</DispLabel>
                <Values>
                    <Value DispLabel="Hello World!">hello</Value>
                    <Value DispLabel="Goodbye Planet!">goodbye</Value>
                    <Value DispLabel="Farewell Kosmos!">farewell</Value>
                </Values>
                <Default>hello</Default>
            </MultiVal>
        </Properties>
    </Skin>
</Options>

The updated screenshot shows a window that's now appropriate for general public use. The tooltip added by <DispHelp> will be shown only when the mouse cursor is left a couple of seconds hovering above the ChangeBkg checkbox.

Of course, declaring the options is just half of the story. Let's see how to put these variables into good use.

Option Restrictions

As you saw in Restrictions: How and Why?, resource groups can be paired to blocks of restrictions for conditional loading. User options are one of the restrictions you can use for each resource group. Thanks to them, you can now easily design different resources to match different options.

Options can be specified as restrictions in two different ways that could be called "basic" and "advanced". Several options can be grouped together in a restriction block and the principle is the same as with any other restriction kind: grouping is made with a logical OR so the resources will be loaded as long as one of the option conditions is considered valid. Conditions are specified in what's called an Option Set. With the basic method, each <OptionSet> element specifies a single option and is represented in XML like this:

<Restrictions>
    <SkinOptions>
        <OptionSet>
            <BoolVal Name="ChangeBkg">true</BoolVal>
        </OptionSet>

        <OptionSet>
            <MultiVal Name="RememberMeTxt">goodbye</MultiVal>
        </OptionSet>
    </SkinOptions>
</Restrictions>

The example above can be read as "Load this groups if ChangeBkg is true OR RememberMeTxt is goodbye". Let's say that you want to use a more elaborate condition such as "ChangeBkg is true AND RememberMeTxt is farewell": to do that you'll need to use the advanced method.

Option sets can use condition strings instead of single option element. These strings allow a mix of AND and OR with an unlimited number of options. Here are a couple of examples:

  • ChangeBkg = true
  • RememberMeTxt != "hello"
  • ChangeBkg = true AND RememberMeTxt != "hello"
  • ChangeBkg = false OR RememberMeTxt = "goodbye"
  • RememberMeTxt = "hello" OR RememberMeTxt = "hello" AND ChangeBkg = false

Condition strings use a simple syntax that recognizes the following operators:

  • =
  • !=
  • AND
  • OR

Boolean values are either true or false and strings are enclosed between "" or ''. The \, " and ' characters must be escaped if written in a string (written \\, \", and \'). != stands for 'not equal to'. Parenthesis are not supported: conditions are evaluated from left to right and OR operators have grouping priority over AND. Any number of space characters can be used to separate each entity. Operators are case sensitive but options' names and values are not.

Priority of operators means that the last example in the list above is read by Messenger Plus! as (RememberMeTxt = "hello" OR RememberMeTxt = "hello") AND ChangeBkg = false. The reason why OR conditions are grouped is because to write RememberMeTxt = "hello" OR (RememberMeTxt = "hello" AND ChangeBkg = false) you simply need to add two different option sets. If you're not familiar with programming languages, this may not make much sense to you right now but if you start using condition strings, you'll quickly get used to how they work. For now, let's just see how to rewrite the example above with one condition string:

<OptionSet>
    <Conditions>ChangeBkg=true OR RememberMeTxt="goodbye"</Conditions>
</OptionSet>

Test Skin Revisited

Let's use what we've learned here to improve the Test Skin project. This new skin allows the user to enable or disable the new background and offers two alternatives for the "Remember Me" text replacement. To make sure you've understood the content of this section correctly, please try to do the modifications yourself on the original code and compare your solution with the one below.

<SkinInfo>
    <Information>
        <Name>Test Skin Revisited</Name>
    </Information>

    <Options><Skin>
        <Properties>
            <BoolVal Name="ChangeBkg">
                <DispLabel>Change the background picture</DispLabel>
                <Default>true</Default>
            </BoolVal>

            <MultiVal Name="RememberMeTxt">
                <DispLabel>New "Remember Me" label</DispLabel>
                <Values>
                    <Value DispLabel="Hello World!">hello</Value>
                    <Value DispLabel="Goodbye Planet!">goodbye</Value>
                </Values>
                <Default>hello</Default>
            </MultiVal>
        </Properties>
    </Skin></Options>

    <MessengerSkin>

        <!-- background replacement -->
        <ResGroup>
            <Restrictions>
                <MsgVersions>
                    <Version Major="8" Minor="5"/>
                </MsgVersions>
                <SkinOptions>
                  <OptionSet>
                    <BoolVal Name="ChangeBkg">true</BoolVal>
                  </OptionSet>
                </SkinOptions>
            </Restrictions>

            <Resources><Replace>
                <Graphics><Pictures>
                    <Picture Id="20061">
                        <File>clouds.jpg</File>
                    </Picture>
                </Pictures></Graphics>
            </Replace></Resources>
        </ResGroup>

        <!-- "hello" alternative to Remember Me -->
        <ResGroup>
            <Restrictions>
                <MsgVersions>
                    <Version Major="8" Minor="5"/>
                </MsgVersions>
                <SkinOptions>
                  <OptionSet>
                    <MultiVal Name="RememberMeTxt">hello</MultiVal>
                  </OptionSet>
                </SkinOptions>
            </Restrictions>

            <Resources><Replace>
                <Strings>
                    <String Id="61288">Hello World!</String>
                </Strings>
            </Replace></Resources>
        </ResGroup>

        <!-- "goodbye" alternative to Remember Me -->
        <ResGroup>
            <Restrictions>
                <MsgVersions>
                    <Version Major="8" Minor="5"/>
                </MsgVersions>
                <SkinOptions>
                  <OptionSet>
                    <Conditions>RememberMeTxt = "goodbye"</Conditions>
                  </OptionSet>
                </SkinOptions>
            </Restrictions>

            <Resources><Replace>
                <Strings>
                    <String Id="61288">Goodbye Planet!</String>
                </Strings>
            </Replace></Resources>
        </ResGroup>
    </MessengerSkin>
</SkinInfo>

It's Not Over Yet

The subject of options cannot be dealt with in a single section of documentation. Much more can be done with what you've just learnt so once you'll have practiced what is shown here, go read about Options for Advanced Users.

See Also

Specialized Subjects, Options for Advanced Users.


Specialized Subjects

Options for Advanced Users

In User Modifiable Options, you've learnt how to create options for your skins. In this section, you'll learn the way to use these options for conditional compilation of Messenger's windows files, how to create custom option panels and about boxes for your skin and more.

Restriction Options in Windows Files

Adding options in the restrictions of your resource groups is very practical for pictures, strings and other similar resources. However, for definition and style files, it can quickly become troublesome: options requiring modification in those files eventually combine together, requiring lots of different versions of the same definition file (3 options alone would require 8 versions of the same file to accommodate all the possible combinations).

You can solve this problem by adding conditions directly into your definition and style sheet files. When Messenger Plus! loads this kind of resource, it searches for specific condition tags and uses them to conditionally include parts of the file. Those tags are normally written <*PlusSkin ... *></*PlusSkin*> and are case sensitive. They can be inserted anywhere in the files and tags can be embedded in one another. Here is how it works:

  • A tag named <*PlusSkin *> is found in a definition file or a style sheet file.

  • A Conditions attribute is found in the tag, written as Conditions(condition string). Messenger Plus! marks the tag as being recognized and proceeds with its analysis:

    • The condition string is extracted from the Conditions attribute.
    • A closing tag formatted as </*PlusSkin*> is searched in the file.
    • Depending on the result of the condition string, the block of text is kept or removed.
    • The opening and closing tags are removed.

Everything that's specified between the opening and the closing tag is subject to the condition string. The string is analyzed exactly the same way as when specified in the <Conditions> element of a restriction block. A complete opening tag looks like this:

<*PlusSkin Conditions(option = value) *>

If the condition is valid, the content specified between the tags is kept as-is, if not, it is removed from the file in memory before being sent to Messenger. In both cases, the PlusSkin tags are completely removed from the file, leaving no trace of them being there in the first place. When the content is kept, its text is analyzed the same way for possible sub condition tags.

Let's say you want to add an option in your skin called DispSignAuto that lets the user decides whether or not the "Sign me in automatically" checkbox is displayed in the logon window: open the definition file of the logon frame window (id 947 in Messenger 8.5) and search for the checkbox (it's using id=atom(idMakeDefaultUserChk) in Messenger 8.5). Here is how it may look like:

<Checkbox id=atom(idMakeDefaultUserChk) Class="CheckBox">
    <ButtonIcon LayoutPos=Left/>
    <ButtonText LayoutPos=Client/>
</Checkbox>

To conditionally include this block of text in your skin without having to make a duplicate of the file, you need to include the block in a condition tag, like this:

<*PlusSkin Conditions(DispSignAuto = true) *>
    <Checkbox id=atom(idMakeDefaultUserChk) Class="CheckBox">
        <ButtonIcon LayoutPos=Left/>
        <ButtonText LayoutPos=Client/>
    </Checkbox>
</*PlusSkin*>

If you had an additional option to add or remove the ButtonText element from this text, it could be added the same way in the existing condition block (note: this is for demonstration purposes only, removing this element won't necessarily do anything visible).

<*PlusSkin Conditions(DispSignAuto = true) *>
    <Checkbox id=atom(idMakeDefaultUserChk) Class="CheckBox">
        <ButtonIcon LayoutPos=Left/>

        <*PlusSkin Conditions(AnotherOption = false) *>
            <ButtonText LayoutPos=Client/>
        </*PlusSkin*>
    </Checkbox>
</*PlusSkin*>

Because condition strings can also be used in style sheet files, you can now add many options in your skin to let the user decide on minor but important details such as colors, text formatting, etc... don't hesitate to use this technique whenever possible to make your skin more enjoyable for everyone!

Options' Values

Sometimes, it may be easier to link an option's value directly with what's inserted in the definition files. Let's consider the following example which uses a boolean option named ShowButton.

<*PlusSkin Conditions(ShowButton = true) *>
    <Element visible=true>
        ...
    </Element>
</*PlusSkin*>
<*PlusSkin Conditions(ShowButton = false) *>
    <Element visible=false>
        ...
    </Element>
</*PlusSkin*>

Although the two conditions could be inserted directly next to visible=, this piece of code shows an apparent need for simplification, which can be done using the ValueOf statement. Using this technique, the code can be simplified like this:

<Element visible=<*PlusSkin ValueOf(ShowButton)*/> >
    ...
</Element>

Any option's value can be inserted directly into a file, without additional conditions, simply by using ValueOf. You'll notice that because no data is necessary in this case, the element can be closed directly with /> to avoid adding the usual bigger </*PlusSkin*>. Note that string option's values are inserted without quotes so it is your responsibility to add them in between the PlusSkin element, if needed.

Environment based conditions

In Messenger Plus! Live 4.60 and above, environment conditions can be used the same way option conditions are. This is done with the Environment statement. Instead of specifying one of your options' names, you simply need to specify one of the known property names supported by the system. Here is an example of how to include an element based on the current version of Messenger.

<*PlusSkin Environment(MsgVersion = "8.5") *>
    <Element>
        ...
    </Element>
</*PlusSkin*>

Here are the properties you can use for your environment conditions:

  • MsgLang. The current language of Messenger, same as the MsgLanguage restriction type. Example: "en-us".
  • MsgVersion. The current version of Messenger. It can be written either as Major.Minor, Major.Minor.Build or Major.Minor.Build.Revision. Example: "8.5".
  • PlusVersion. The current version of Messenger Plus!. It can be written either as Major.Minor or Major.Minor.Build. Example: "4.50.312".

Note: you cannot mix environment conditions and options based conditions in one tag. If you want to use both kinds of conditions, you need to define two different <*PlusSkin*> tags, embedded in one another.

Messenger Plus! Options

If you're a user of Messenger Plus!, you know that the software changes some elements of the Messenger windows to add its own features. The most obvious modification is the addition of icons in the contact list's and the chat windows' toolbars. Although these changes are coded to automatically adapt to most skins, some definition files with advanced modifications may prevent Messenger Plus! to include its material, inclusion may not be suitable for your skin or you may simply want to relocate those features elsewhere.

Skininfo files can request that these modifications do not take place automatically when the skin is loaded. All that's needed is one of the following elements, added in <Options>\<MessengerPlus>:

  • AllowContactListChange. Specifies if Messenger Plus! should try to add its icons in the contact list and the contact cards of Messenger.
  • AllowChatWndChange. Specifies if Messenger Plus! should try to add its icons in the toolbar of chat windows.

This code will prevent Messenger Plus! from adding its icons in the main toolbar of chat windows:

<Options>
    <MessengerPlus>
        <AllowChatWndChange>false</AllowChatWndChange>
    </MessengerPlus>
</Options>

Because most users expect Messenger Plus! features to be accessible in every skin, removing them with these options also means adding them back manually in your windows. If you're familiar enough with definition files to do such a thing, all you need to know is that your buttons need a cmdid attribute ranging from 7801 to 7810. This represents the command ids used by Messenger Plus! in Messenger's windows and any element that sends this id will trigger the same response as the original (like displaying a menu).

Custom Option Panels

What good is it to skin Messenger if you don't even have control over your own option panel and about box? doing such a thing is possible with a Messenger Plus! interface file. Before you read the rest of this section, please check out Skinning Messenger Plus! Itself. All the basics about Messenger Plus! windows can be found there and you'll need this information to fully understand what's next.

By default, Messenger Plus! creates a generic child window template for your skin's options. Every option is listed, one on each line and skininfo elements such as DispLabel and DispHelp are used to display the appropriate labels. With a custom template, none of this happens and you're free to do anything you like. You create your own template, from scratch, you include the options you want in it, you can add extra elements such as pictures to improve the look of the window and you can even use different control types for your options. In addition to all of that, custom templates can be created in multiple languages to accommodate different localized versions of Messenger.

Here is the result of a custom template created for Test Skin Revisited:

Customized Option Panel

This option panel has a bigger title that's colorized, a picture of the clouds background and the "Remember me" options are in a list box instead of a combo box. You may also notice that the text displayed in the checkbox and list items is different from what was specified in the skininfo file.

Option panels are created like any other Messenger Plus! window but they need to use <ChildTmpl/> as Messenger Plus! will embed your creation into a standard frame with OK/Cancel buttons. The option panel file is loaded like any another Messenger Plus! skinned interface: you specify the directory where the file is located and Messenger Plus! takes care of the rest. Images referenced in your option panel are loaded from the Images subdirectory. The main difference with <PlusSkin> is that for option panels, you also need to specify the interface file name as well as the window's ids.

Here is an example of how to declare a custom option panel in skininfo:

<Options>
  <Skin>
    ...

    <OptionInterface>
        <InterfaceDir>OptionPanel</InterfaceDir>
        <InterfaceFile>OptInterfaces.xml</InterfaceFile>

        <WindowIds>
            <WindowId Language="en-us">SkinOpt</WindowId>
        </WindowIds>
    </OptionInterface>
  </Skin>
</Options>

In this example, the window's template will be loaded from %skindir%\OptionPanel\OptInterfaces.xml. In this file, the software will locate window's id SkinOpt and will display its content in the option panel. Images for this window will be loaded from %skindir%\OptionPanel\Images. Click here to get the interface window's code and picture used in the example above.

You'll notice that "en-us" was specified as the window's language. A Language attribute is required for every <WindowId> element and in this case, it simply means that the text in the window is displayed in English. The system allows you to create localized versions of the window but you don't have to do that if you don't want to. One <WindowId> element can be specified for each language code that you support (Messenger Plus! compares the code with the one specified in Messenger) and if no matching language can be found, the first window in the list is loaded and its language code is ignored.

For example, if you also had a French version of your panel available for French users, you would write:

<WindowIds>
    <WindowId Language="en-us">SkinOpt</WindowId>
    <WindowId Language="fr-fr">SkinOptFrench</WindowId>
</WindowIds>

With this code, the SkinOptFrench window will be loaded in French versions of Messengers only and the SkinOpt window will be loaded for any other language (because it's the first windows that's specified).

You can add any element and controls you wants in your option panel using any Id of your choice. Everything will be displayed as-is by Messenger Plus! and connections will be made only in the following circumstances:

  • A CheckBoxControl or a RadioControl is found with the same id as one of your BoolVal properties' name.
  • A ComboBoxControl or a ListBoxControl is found with the same id as one of your MultiVal properties' name.
  • A ButtonControl or a LinkControl is found with id AboutUrl.
  • A ButtonControl or a LinkControl is found with id AboutWnd (Messenger Plus! 4.60 and above).
  • A LinkControl is found with a caption equal to an http or https link (Messenger Plus! 4.60 and above).

As you can see, properties can be associated with more than one kind of control. For MultiVal properties, listboxes and comboboxes can be used exactly the same way, however, there's a particularity to using radio button controls for BoolVal properties. Each property can only be associated to one control so if you add two radio buttons, you'll need two properties, you cannot specify that one radio button is for true and the other one is for false (this would result in the creation of two mutually exclusive properties).

In Messenger Plus! 4.60 and above, the AboutWnd id can be used to add a button linking to your own customized about box. When the control is clicked, Messenger Plus! searches for the id of an about box defined in your skininfo in <AboutIds>. About box windows are defined like option windows and are associated to a language to allow localization. Example:

<AboutIds>
    <AboutId Language="en-us">SkinAbout</AboutId>
</AboutIds>

Finally, the AboutUrl id can be used to add a button linking to your web site (as specified in the <Information> block). Other link controls in the window are analyzed for possible url recognition. If the caption of a link control contains no space and begins with either "http://" or "https://", the corresponding address is automatically opened in the default web browser when the control is clicked. Any other control with any other id won't be associated to your properties and will only serve as decoration. Here is the interface code that was used to associate the two properties of Test Skin Revisited to the interface shown in the screenshot:

<Control xsi:type="ListBoxControl" Id="RememberMeTxt">
    <Position Top="37" Width="97" Left="5" Height="40"/>
    <Items>
        <Item Id="goodbye">This is goodbye</Item>
        <Item Id="hello">This is hello</Item>
    </Items>
</Control>

<Control xsi:type="CheckBoxControl" Id="ChangeBkg">
    <Position Top="88" Width="150" Left="5"/>
    <Caption>Change &amp;background picture to:</Caption>
</Control>

One last thing you can notice in this code is the <Item> elements specified in the list box control. They are not required: if <Items> is not present or empty, all the values specified in the MultiVal property are listed in order, with their DispLabel, exactly like in the generic template. If you want to translate their display label, change their order or prevent users from selecting some of the values specified in your skin (while in beta tests for example), use <Item> elements and set the Id attribute to correspond to the the value's name.

Conclusion

Options in Messenger Plus! skins is a vast subject. Like it is the case for so many other things, spend time working with the feature and you'll quickly forget about the technical details. The only thing that will remain from this learning experience is the fun of designing new windows, adding special options to your skin, etc... this section almost concludes the Specialized Subjects chapter. If you've read all the sections of all the chapters of this documentation, congratulations and thank you very much for your time. We hope to see your creations online soon!

See Also

Specialized Subjects, User Modifiable Options, Skinning Messenger Plus! Itself.


Specialized Subjects

Skinning Messenger Plus! Itself

If you're really maniac about customizing every last bit of Messenger, then you may be interested in customizing the windows of Messenger Plus! itself. Messenger Plus! uses its own proprietary windowing system that's not so difficult to understand and modify, or you may say, it's way easier to modify Messenger Plus! windows than it is to modify Messenger ones (Messenger uses a more complex system that allows more liberty in the layout).

Windows Interface Files

In order to use the interface system of Messenger Plus!, you will need to get used to the way XML interface files are constructed and this may require a little bit of time. Interface files contain a lot of different kinds of elements and attributes, here is an example of what a simple window with a label and a button looks like:

<Interfaces>

    <Window Id="WndTest" Version="1">
        <Attributes>
            <Caption>Test Window</Caption>
        </Attributes>

        <TitleBar>
            <Title><Text>Hello!</Text></Title>
        </TitleBar>

        <Position ClientWidth="170" ClientHeight="45"/>
        <DialogTmpl/>

        <Controls>
            <Control xsi:type="StaticControl" Id="LblTop">
                <Position Left="10" Top="10" Width="150"/>
                <Caption>Hello world!</Caption>
            </Control>

            <Control xsi:type="ButtonControl" Id="BtnClose">
                <Position Left="115" Top="25" Width="50"/>
                <Caption>Close</Caption>
            </Control>
        </Controls>
    </Window>

</Interfaces>

All interface files must be saved in Unicode (UTF16). Many windows can be declared in the <Interfaces> root element, each one constructed with the same basic principle: first, a <Window> element is declared with two attributes: Id (used by Messenger Plus! to locate the correct template for each window) and Version (don't worry about that and set it to 1 when creating new windows). Inside the <Window> element are a couple of interesting sub elements:

  • <Attributes>. You'll often see this element in various other places. In a <Window> element. it is used to define optional attributes for the window such as <Caption> (which is the caption of the window displayed in the task bar), <TopMost> (to make the window appear above every other), ...
  • <TitleBar>. Most Messenger Plus! windows display a title bar baring a Messenger Plus! logo, the name of the window and system buttons to minimize, maximum or close the window. Everything related to the title bar is defined in this element.
  • <Position>. Used to define the default width and height of the client area, this element can also be used to specify that the window can be resized. You may want to notice that the size is specified in Dialog Units, not Pixels. Every positions and sizes defined in interface files uses Dialog Units by default which allows the windows to adapt on various dpi settings (if this does not make any sense to you, forget about it).
  • <DialogTmpl>. This empty element is very important as it defines one of possible three choices for each window: dialog, window or child window. Most of the windows you'll see in Messenger Plus! will be based on the dialog template which defines a double border and allows different kinds of extra settings such as a bottom bar. Custom option panels are based on the child window template.
  • <Controls>. This is where you'll define all the controls displayed in the window like static controls (text labels), buttons, checkboxes, lists, ...

Let's take a look at the controls defined in this window:

  • Each control has the same basic structure. A control is always defined with a <Control> element and two mandatory attributes: xsi:type and Id. xsi::type specifies the kind of control that's being defined, like a a static control (label) or a button. Id is the unique identifier of the control in the window. No control can have the same Id in a given window or the creation of the window will fail (remember that as it can easily be the cause of copy/paste frustrations). The Id can be anything you want but cannot contain any space character. Although it is considered to be a good practice to prefix your identifiers with the kind of control you're defining (like "Btn" for buttons), it is not mandatory.
  • Next comes <Position>. This element is required for any kind of control. The Left and Top attributes are always mandatory, Width is generally required too, however, Height can be optional for controls that don't need it. For example, in the case of a single line static control and a button, the Height parameter is automatically computed by Messenger Plus! to prevent inconsistencies through out the windows. You can always specify your own value though.
  • Elements that come after <Position> are generally type dependant, meaning that each kind of control has its own set of possible elements and attributes. Here, we see <Caption> being used in both controls, however, we could also have used <BackgroundColor> for the static control and <Image> for the button which are elements reserved for each type of control respectively.

The Interface Windows schema file and its documentation can be found in the schema reference section of this documentation. Study it and use it as a constant reference when editing interface files.

Skinning Messenger Plus!

Remember the "Messenger Plus! Resources" option of the Resource Extractor that you were told to ignore in Integration with Messenger? it's time to take off the gloves and to extract this special set of resources! you've probably already guessed it by now, this option will create a Messenger Plus! subdirectory, in your extracted resources directory, containing all the interface files of Messenger Plus! as well as all the pictures it uses.

The windows of Messenger Plus! are structured this way: many xml files are used and each one of them includes the definition of several windows. The only ones not accessible to the skinning system are the Log Viewer windows (technical limitation) and the Uninstaller windows (security reasons). Each xml files is self contained and makes no external references except for picture files. All the pictures can be found in the Images subdirectory and use PNG encoding by default. Skins can replace windows and picture files alike. It is important to note that each window is loaded separately, replacing a file doesn't necessarily mean replacing a whole set of windows. When you want to skin one of Messenger Plus!'s windows, just create a new xml file with the new window's code in it and save the file in your interfaces directory, using the name of your choice (it just needs to have an .xml extension). When Messenger Plus! will search for the window's template, it will read all your xml files to find a corresponding window's id.

Here is an example of skininfo code declaring skinned interfaces for Messenger Plus! :

<PlusSkin>
    <ResGroup>
        <PlusVersion Major="4" Minor="50"/>
        <InterfaceDir>PlusWindows</InterfaceDir>
    </ResGroup>
</PlusSkin>

<PlusSkin> is the last element that can be defined under <SkinInfo>. Like <MessengerSkin>, it uses resource groups but in a much simpler fashion. Resource groups are not combined here, the first one found to match the current version of Messenger Plus! is used, that's all. Here is a description of the supported elements:

  • PlusVersion. This element restricts the group to a given version of Messenger Plus!. A Language ISO code attribute can also be specified to be compared to Messenger Plus!'s current translation (see .ini files in the Languages directory of Messenger Plus!).
  • InterfaceDir. Name of the subdirectory in your skin's directory where the interface files can be found.

In the example above, Messenger Plus! would search for its interface files in %skindir%\PlusWindows and the new/modified pictures for the interfaces would need to be in %skindir%\PlusWindows\Pictures. Note that Messenger Plus! will always search in its own resources if a picture or a window is missing so don't redistribute copies of unmodified resources with your skin. Also, you must always keep the current control ids intact and not remove any of them from any window, with the exception of static controls: if you want to modify the text of a label, you'll have to modify its id as Messenger Plus! will automatically replace the text of known controls with their corresponding localized versions.

Testing Your Windows

Complex windows created with XML data can become difficult to visualize and testing them in Messenger itself can sometimes cause additional complications and unnecessary delays. For those reasons, a special tool called "Interface Tester" was created to help developers preview their creations quickly and without hassle (the same tool is also provided to script developers).

The software can be downloaded and run from any directory and Messenger Plus! Live needs to be properly installed on the system (Messenger does not need to run). "Interface Tester" will be able to properly preview any file that is located in a sub-directory of the Messenger Plus!'s "Skins" directory.

In addition to displaying your windows on screen, "Interface Tester" is also capable of validating your XML files if the schema file is copied in the same directory and if MSXML 5.0 or above is installed on your system (you can get MSXML at microsoft.com, Windows Vista users don't need it). It is highly recommended that you do not redistribute any file that does not validate against the most current version of the Interface Windows' Schema File. If a file is considered to be invalid, "Interface Tester" will refuse to load it and will display an error message explaining the problem.

Download "Messenger Plus! Live - Interface Tester"

Note that this software is provided as-is, as a development tool only. It is not meant for general public use and must not be redistributed without direct authorization.

See Also

Specialized Subjects.


Specialized Subjects

Encoding and Decoding UIB

This section sheds some light on the UIB data encoding mechanism introduced in Windows Live Messenger 2009. For developers of Messenger Plus! skins, it is purely informative and you won't miss anything by skipping it. Other software developers however may be interested to learn more about the mysterious "4010" resource type, what it's about and more importantly, how to work with it.

UIB: What is that?

UIB is the acronym of... well, we honestly don't know, and that alone sums-up the problem. The best guess we could come up with is User Interface Blob but only a developer of one of the Windows Live teams at Microsoft could give you the real answer. This new data type appeared in Messenger in one of the latest betas of 2008 and it now completely replaces the old windows' definitions and styles types ("4004" and "4005").

Many have speculated about the reasons causing this change but speed-optimization was probably on top of the list when Microsoft decided to do it. Previously, Messenger had to parse 2 text files every time a different window was open in Messenger. Parsing text was time consuming, especially for some of the more complex windows as the program needed to handle all sorts of syntax variations. A nice side-effect, for add-on and patch developers, as well as skinners, was that the plain text file was easy to modify to achieve all sorts of visual results. Messenger Plus! itself relied on those text files to add its buttons in various Messenger windows and to let skin developers change the windows' structures.

In its latest releases, Messenger comes bundled with an encoded version of the 2 text files previously describing each window. These new files are kept in resource type "4010" and are called UIB files by some people because of the "UIB" tag that starts each and every file. Note that it is important to make a difference between "encoded" and "encrypted". The UIB files in Messenger are not encrypted and can be understood with some research and patience, which is what was done in Messenger Plus!.

How are UIB files handled by Messenger Plus! ?

Support for UIB files was added in Messenger Plus! Live 4.80. Encoded files are automatically decoded by the Resource Extractor when skinners need to take a peek at what's inside Messenger. When the text files are distributed in a skin, Messenger Plus! re-encodes them automatically when a window is loaded. In order to make the transition as smooth as possible for developers used to the old system, Messenger Plus! produces decoded versions of the UIB files that are almost identical to what used to be seen in Messenger 8. The only noticeable difference is the <*PlusSkin */> line that starts every file and gives Messenger Plus! some important information regarding its origins. This will be mostly useful for future versions of the UIB system and for that reason, that line must be kept in place in all the files.

Like before, 2 text files are generated for each window: a definition file and a style sheet file. Both are required to re-create a UIB file, however, Messenger Plus! skins are exempt of this restriction: when a skin is loaded, if either a definition file or a style file is missing for one window, Messenger Plus! decodes the internal UIB data to generate the missing piece before re-encoding the whole thing. It slows things down a little but this way, nothing needs to be changed in the way you're used to write your skins. Also, because Messenger Plus! is now in charge of all the parsing when encoding, the Skin Trace file now includes more detailed information about errors encountered while loading a window. This also allows Plus! to load the original version of the window in case an error occurs, which is handy for end-users but means you need to be extra-careful when doing changes in your skin. Always check if a trace file has been generated after testing your skin and you'll be fine.

This is all fine if you stay in the environment provided by Plus! but what if you simply want to use the encoding and decoding functionalities for your own purposes?

Adding UIB encoding and decoding to your software

The world of Messenger has always been full of add-ons and patches of all kinds. Messenger Plus! was the first one and there's no reason why it should be the last, at least not so soon. Unfortunately, some of the changes brought by Windows Live Messenger 2009 made us fear some programs wouldn't be able to survive the upgrade. For that reason, we decided that UIB encoding and decoding should be offered to everybody which is what was finally done in Messenger Plus! Live 4.80.

A lot of work was necessary to create the two fully-functional parsers that decode and re-encode the files. If you're the developer of a program that changes Messenger's windows files, you can let Messenger Plus! do the work without worrying about it anymore. Two options are offered to you:

  • If you need to make live changes to the windows files, for example, when applying options selected by your users at run time, your program will need to call MPTools.exe on your users' computers to decode and re-encode the file after it's been modified.
  • If you only need to make static changes in one particular version of Messenger and redistribute the result, then you can use the same MPTools.exe program on your own computer and distribute the re-encoded UIB file directly.

MPTools.exe is a program that's distributed with Messenger Plus!. It makes all sorts of calls to the main program for all kinds of reasons, it's a helper tool. Although it was also distributed in previous versions of Messenger Plus!, it was not meant to be used directly by end-users or other developers. This is not the case anymore as MPTools.exe can now decode and encode UIB files when the proper command line parameters are used.

Here is an example of how to decode a UIB file:

MPTools.exe /UIB=Decode /Src="C:\uibfile.uib" /Def="C:\deffile.txt" /Style="C:\stylefile.txt"

And here is another example of how to re-create a UIB file:

MPTools.exe /UIB=Encode /Def="C:\deffile.txt" /Style="C:\stylefile.txt" /Dest="C:\uibfile.txt"

Pretty straightforward isn't it? When decoding, the only input parameter that's needed is the UIB file you'll have to extract from Messenger's own resources (resource type "4010"). It can also be a UIB file that you previously generated with this tool. The decoding process produces two text files as specified in output parameters. If needed, only /Def or /Style can be set to speed things up (note however that you'll always need the two files to re-create a UIB file).

When encoding, the two required input parameters are the definition file and the style text file. These files are subject to the same rules previously applied by Messenger which means you should take great care when modifying them. MPTools.exe, unlike skins loaded by Plus!, does not produce detailed errors so don't hesitate to create a quick skin to make your life easier when testing new ideas. The one single output parameter is, of course, the name of the UIB file you want to be generated.

MPTools.exe is silent and will never prompt anything to the user if the proper parameters are specified. Fully-qualified paths should always be specified in the parameters and existing files will be overwritten when needed. As far as knowing the result of the operation, you have two ways to detect a success:

  • Check if the output file(s) were generated (nothing is written on disk in case of failure).
  • Verify the result code returned by the program. A result between 0 and 9 (inclusive) means failure. Results between 10 and 19 (inclusive) mean success.

Distribution

As mentioned above, you have the choice to either distribute a pre-encoded version of the UIB file or make live changes on your end-users computers. Rest assured that the UIB files generated by Messenger Plus! Live are 100% compatible with Messenger and do not require Messenger Plus! at all to be loaded. The first option may look more appealing to some as Messenger Plus! is not required on the end-user's computer but keep in mind that this also means you'll need to distribute updates of your program every time Microsoft changes the way UIB files are encoded in Messenger.

Messenger Plus! Live is a widely distributed add-on and its requirement shouldn't stop anybody from using your program. If you chose to make live changes to the Messenger's resources, check if Messenger Plus! is installed in your own setup. You also need to check if the user is using a recent version of Plus! that include UIB support. This can be done easily by checking the SoftwareBuild value in HKEY_LOCAL_MACHINE\SOFTWARE\Patchou\Messenger Plus! Live. If the value is 4351 or above, you're good to go!

MPTools.exe cannot and must not be redistributed on its own. It depends on other files in the Messenger Plus! directory to function properly. If Messenger Plus! is not detected on the system (you can simply check if the registry value mentioned contains a valid value), you may choose to do one of the following:

  • Invite the user to go to msgplus.net to download the latest version of Messenger Plus! Live.
  • Download Messenger Plus!, launch the setup and let the user complete the installation (recommended way).
  • Download Messenger Plus! and launch the setup in silent mode to quickly and transparently install Plus! on your users' computers. Make sure to display a notification while doing so to keep things straight.

Note: when downloading Messenger Plus!, always use http://download.msgpluslive.net/setup/MsgPlusLive-Setup.exe to automatically get the latest public version of the software. It is not recommended to bundle the setup directly but you're allowed to do so if necessary.

Finally, when launching MPTools.exe, you have to be careful of two things:

  • Get the path where Messenger Plus! is installed on the user's computer from the AppDir value in HKEY_LOCAL_MACHINE\SOFTWARE\Patchou\Messenger Plus! Live. Do not hardcode the path thinking it's always located in Program Files. "MPTools.exe" will always be called by that name though. As long as you load it from the proper directory, you'll have no problem.
  • Wait for the process to end before checking the result. This may seem obvious but this is a common mistake.

Summary

Skin developers working in Messenger Plus! do not have to worry at all about what UIB is. For all the other developers, we hope that the encoding and decoding functionalities provided by our external tool will help keep your Messenger projects alive and kicking. Don't hesitate to visit our forum if you have any suggestion for improvements.

See Also

Specialized Subjects.


XML Schema Reference

Messenger Plus! Live

XML Schemas Reference

XML Schema files are used to validate XML files. They can also be used as technical documentation to know more about the elements and attributes that are read by Messenger Plus! in a given XML file.

Skinning Windows Live Messenger

Read about SkinInfo XML files

Manipulating Messenger Plus! Windows

Read about PlusInterface XML files


XML Schema Reference

Messenger Plus! Live

SkinInfo Schema Reference

XML Schema files are used to validate XML files. They can also be used as technical documentation to know more about the elements and attributes that are read by Messenger Plus! in a given XML file.

Information

Read about SkinInfo XML files

Full diagram of SkinInfo

Built-in documentation of the Schema file for SkinInfo

Schema Files

Get the Schema file for SkinInfo


XML Schemas Reference

SkinInfo Information

SkinInfo.xml is the only file required for any skin to be recognized by Messenger Plus!. The file needs to be placed in the skin's main directory. It is read when the skin is loaded or imported and contains several information related to the skin such as its name, its description, resources it replaces in Messenger, etc... its presence is also mandatory if the skin has to be exported into a Skin Pack.

Although this documentation has pages describing the most important elements of skininfo, many additional attributes and elements are supported for some features. These additional elements and attributes are only documented in the schema file. For that reason, you should always keep the schema's documentation on hand while reading on a particular subject to make sure you're not missing something that may help you understand or do something you thought was not possible.

The Schema file for SkinInfo can be temporarily placed in your skin's directory to validate your XML. The schema file must not be redistributed with your skin (it is useless in a public environment) so please remember not to include it in your Skin Pack. Here is how to write the first element of your XML file to make your XML editor aware of the schema file:

<SkinInfo xmlns="urn:msgplus:skins"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="urn:msgplus:skins PlusSkins.xsd">

    <Information>
        ...
    </Information>
</SkinInfo>

It is considered to be a good practice to always link your xml files to their respective schemas to prevent any possible run time error caused by a mistake in your XML. This header is not added in any example of this documentation for clarity reasons only. You should add it yourself every time you create a new skininfo file, without exception.

XML files tend to grow rapidly and you'll soon be thankful for the validation layer brought by the schema file. The modified SkinInfo element as specified above will allow your XML editor to confirm that your file is formatted correctly, with the proper elements and attributes, and that Messenger Plus! will be able to read it properly, thus removing a lot of common errors caused by misreading the documentation.

If your XML editor does not come with graphical browsing of the schema file, you can view a documentation generated by XMLSpy in the SkinInfo Schema Documentation section (some information may be missing in this documentation). Detailed information about each element can be found in the various other sections of this documentation. A view of the full diagram can also be found here.

See Also

SkinInfo Schema File, Schema Documentation, SkinInfo Diagram.


XML Schemas Reference

SkinInfo Diagram

See Also

SkinInfo Schema File, Schema Documentation.


Interface Windows - Schema Documentation

SkinInfo Schema Documentation

element SkinInfo
diagram
children Information Region Dimensions Fonts Options MessengerSkin PlusSkin
attributes
Name Type Use Default Fixed annotation
Version xs:unsignedInt
documentation
Set to 4 to force Messenger Plus! 4.80 requirement. Do not use this attribute to specify the version of your skin.

attribute SkinInfo/@Version
type xs:unsignedInt
annotation
documentation
Set to 4 to force Messenger Plus! 4.80 requirement. Do not use this attribute to specify the version of your skin.

element SkinInfo/Information
diagram |
children | Name Description AboutUrl Version Screenshot Compatibility TraceFile UpdateId BuildNumber AllowAutoUpdate

 element SkinInfo/Information/Name
type xs:string
annotation
documentation
Name of this skin (do not specify a version here). This will also be used to create the destination directory of the skin upon installation.

element SkinInfo/Information/Description
type xs:string
properties
minOcc | 0
maxOcc | 1
annotation
documentation
Describe your skin here. New lines are accepted. It is recommended to specify the versions of Messenger this skin supports.

element SkinInfo/Information/AboutUrl
type xs:string
properties
minOcc | 0
maxOcc | 1
annotation
documentation
Use this element to set an http link to the web site related to this skin.

element SkinInfo/Information/Version
type xs:string
properties
minOcc | 0
maxOcc | 1
annotation
documentation
Version tag added next to Name when Messenger Plus! displays this skin's information.

element SkinInfo/Information/Screenshot
diagram
properties
minOcc | 0
maxOcc | 1
children File
annotation
documentation
It is highly recommended to include a small screenshot of what your skin looks like.

element SkinInfo/Information/Screenshot/File
type xs:string
annotation
documentation
Can be PNG, JPG, GIF. The maximum size of this picture is 86*86, if bigger, the picture will be resized automatically.

element SkinInfo/Information/Compatibility
diagram
properties
minOcc | 0
maxOcc | 1
children MsgVersion
annotation
documentation
Identifies the versions of Messenger that are compatible with your skin. It is recommended to always specify this information.

element SkinInfo/Information/Compatibility/MsgVersion
diagram
properties
minOcc | 1
maxOcc | unbounded
attributes
Name | Type | Use | Default | Fixed | annotation
Major | xs:unsignedInt | required |  |  |
Minor | xs:unsignedInt | required |  |  |
Build | xs:unsignedInt | optional |  |  |
Revision | xs:unsignedInt | optional |  |  |
annotation
documentation
Messenger versions specified here help Messenger Plus! provide visual clues about compatibility. These elements won't prevent any part of your skin from being loaded.

element SkinInfo/Information/TraceFile
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Specifies if a trace file should be produced in the skin's directory. Should be set to false in public distributions.

element SkinInfo/Information/UpdateId
type restriction of xs:string
facets
minLength | 6
maxLength | 8
annotation
documentation
Unique id of this skin.This is how this skin will be internally recognized in the database. Allowed characters: alphanumeric and underscores.

element SkinInfo/Information/BuildNumber
type restriction of xs:unsignedInt
facets
minInclusive | 1
maxInclusive | 99999
annotation
documentation
Build number of this skin. If the online database has this skin with a higher build number, it triggers the auto-update.

element SkinInfo/Information/AllowAutoUpdate
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element SkinInfo/Region
diagram
properties
minOcc | 0
maxOcc | 1
children ContactList ChatWnd ChatWndTabbed
annotation
documentation
A region allows you to cut a window in the shape of your choice.

element SkinInfo/Region/ContactList
diagram
type | extension of RegionType
properties
minOcc | 0
maxOcc | 1
children | Rectangle Image

element SkinInfo/Region/ChatWnd
diagram
type | extension of RegionType
properties
minOcc | 0
maxOcc | 1
children | Rectangle Image

element SkinInfo/Region/ChatWndTabbed
diagram
type | extension of RegionType
properties
minOcc | 0
maxOcc | 2
children | Rectangle Image
attributes
Name Type Use Default Fixed annotation
Position derived by: xs:string optional all
documentation
Only one element can be specified for each possible position of the group bar. If "all" is specified, no other element is accepted.
annotation
documentation
If present, this element will be used instead of ChatWnd in tabbed chat windows.

attribute SkinInfo/Region/ChatWndTabbed/@Position
type restriction of xs:string
properties
default | all
use | optional
facets
enumeration | all
enumeration | top
enumeration | left
annotation
documentation
Only one element can be specified for each possible position of the group bar. If "all" is specified, no other element is accepted.

element SkinInfo/Dimensions
diagram
properties
minOcc | 0
maxOcc | 1
children ContactList ChatWnd ChatWndTabbed
annotation
documentation
Here you can specify size restrictions and resizing borders for your skin.

element SkinInfo/Dimensions/ContactList
diagram
type | DimensionsType
properties
minOcc | 0
maxOcc | 1
children | Size Borders

element SkinInfo/Dimensions/ChatWnd
type | DimensionsType
properties
minOcc | 0
maxOcc | 1
children | Size Borders

element SkinInfo/Dimensions/ChatWndTabbed
diagram
type | extension of DimensionsType
properties
minOcc | 0
maxOcc | 2
children | Size Borders
attributes
Name Type Use Default Fixed annotation
Position derived by: xs:string optional all
documentation
Only one element can be specified for each possible position of the group bar. If "all" is specified, no other element is accepted.
annotation
documentation
If present, this element will be used instead of ChatWnd in tabbed chat windows.

attribute SkinInfo/Dimensions/ChatWndTabbed/@Position
type restriction of xs:string
properties
default | all
use | optional
facets
enumeration | all
enumeration | top
enumeration | left
annotation
documentation
Only one element can be specified for each possible position of the group bar. If "all" is specified, no other element is accepted.

element SkinInfo/Fonts
diagram
properties
minOcc | 0
maxOcc | 1
children Font
annotation
documentation
Allows your skin to use custom fonts distributed as separated files.

element SkinInfo/Fonts/Font
type xs:string
properties
minOcc | 1
maxOcc | unbounded
annotation
documentation
The font files specified here are loaded for the Messenger and Messenger Plus! processes only. Supported extensions: fon, fnt, ttf, ttc, fot and otf.

element SkinInfo/Options
diagram
properties
minOcc | 0
maxOcc | 1
children MessengerPlus Messenger Skin

element SkinInfo/Options/MessengerPlus
diagram
properties
minOcc | 0
maxOcc | 1
children AllowContactListChange AllowChatWndChange TabbedChatBar
annotation
documentation
Request some specific behaviour from Messenger Plus!.

element SkinInfo/Options/MessengerPlus/AllowContactListChange
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Specifies if Messenger Plus! should try to add its icons in the contact list and the contact cards.

element SkinInfo/Options/MessengerPlus/AllowChatWndChange
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Specifies if Messenger Plus! should try to add its icons in chat windows.

element SkinInfo/Options/MessengerPlus/TabbedChatBar
diagram
properties
minOcc | 0
maxOcc | 1
children Color1 Color2
annotation
documentation
Use this element if tabbed chats don't display properly in your modified chat windows.

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color1
diagram |
children | Position R G B

 element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color1/Position
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
X | xs:unsignedInt | required |  |  |
Y | xs:unsignedInt | required |  |  |
annotation
documentation
Messenger Plus! will use the color displayed at this position to create some of the colors for the group bar.

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color1/R
type xs:unsignedByte

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color1/G
type xs:unsignedByte

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color1/B
type xs:unsignedByte

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color2
diagram |
children | Position R G B

 element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color2/Position
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
X | xs:unsignedInt | required |  |  |
Y | xs:unsignedInt | required |  |  |

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color2/R
type xs:unsignedByte

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color2/G
type xs:unsignedByte

element SkinInfo/Options/MessengerPlus/TabbedChatBar/Color2/B
type xs:unsignedByte

element SkinInfo/Options/Messenger
diagram
properties
minOcc | 0
maxOcc | 1
children ResetUserColor ResetUserScenes
annotation
documentation
Messenger specific options.

element SkinInfo/Options/Messenger/ResetUserColor
diagram
type extension of xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
attributes
Name | Type | Use | Default | Fixed | annotation
R | xs:unsignedByte
G | xs:unsignedByte
B xs:unsignedByte
documentation
New color to set. If not specified, the color is reset to the default one.
annotation
documentation
If true, the user color is reset when the skin is enabled/installed (currently signed-in user only).

element SkinInfo/Options/Messenger/ResetUserScenes
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
If true, the user's current scene is removed in Messenger 2009 (applies to all users).

element SkinInfo/Options/Skin
diagram
properties
minOcc | 0
maxOcc | 1
children Properties OptionInterface
annotation
documentation
Options specific to this skin. They can be used to help the user customize the skin.

element SkinInfo/Options/Skin/Properties
diagram
properties
minOcc | 0
maxOcc | 1
children BoolVal MultiVal
annotation
documentation
These properties can be used for conditional replacement of some resources. They will be displayed in a special window automatically created by Messenger Plus! for the skin.

element SkinInfo/Options/Skin/Properties/BoolVal
diagram
children DispLabel DispHelp Default
attributes
Name Type Use Default Fixed annotation
Name xs:string required
documentation
No space allowed.
annotation
documentation
Simple true/false option. Displays a checkbox by default.

element SkinInfo/Options/Skin/Properties/BoolVal/DispLabel
type xs:string
properties
minOcc | 0
maxOcc | 1

element SkinInfo/Options/Skin/Properties/BoolVal/DispHelp
properties
minOcc | 0
maxOcc | 1
annotation
documentation
This will display in a tooltip associated to the control.

element SkinInfo/Options/Skin/Properties/BoolVal/Default
type xs:boolean

element SkinInfo/Options/Skin/Properties/MultiVal
diagram
children DispLabel DispHelp Values Default
attributes
Name Type Use Default Fixed annotation
Name xs:string required
documentation
No space allowed.
annotation
documentation
Multiple string option. Displays a combobox with the given choices by default.

element SkinInfo/Options/Skin/Properties/MultiVal/DispLabel
type xs:string
properties
minOcc | 0
maxOcc | 1

element SkinInfo/Options/Skin/Properties/MultiVal/DispHelp
properties
minOcc | 0
maxOcc | 1
annotation
documentation
This will display in a tooltip associated to the control.

element SkinInfo/Options/Skin/Properties/MultiVal/Values
diagram
children Value
annotation
documentation
Possible values associated with this property.

element SkinInfo/Options/Skin/Properties/MultiVal/Values/Value
diagram
type extension of xs:string
properties
minOcc | 2
maxOcc | unbounded
attributes
Name | Type | Use | Default | Fixed | annotation
DispLabel | xs:string | optional |  |  |
annotation
documentation
Values are not case sensitive.

element SkinInfo/Options/Skin/Properties/MultiVal/Default
type xs:string
annotation
documentation
The default value specified here must be part of the Values list.

element SkinInfo/Options/Skin/OptionInterface
diagram
properties
minOcc | 0
maxOcc | 1
children InterfaceDir InterfaceFile WindowIds AboutIds
annotation
documentation
Advanced skinners can create their own Messenger Plus! window to display their options,

element SkinInfo/Options/Skin/OptionInterface/InterfaceDir
type xs:string
annotation
documentation
Directory where the interface file is located along with the possible Images sub-directory.

element SkinInfo/Options/Skin/OptionInterface/InterfaceFile
type xs:string
annotation
documentation
XML file where the WindowIds can be located.

element SkinInfo/Options/Skin/OptionInterface/WindowIds
diagram
children WindowId
annotation
documentation
List of window ids corresponding to the option window. By default, the first one in the list is used if no localized version exists for the current language.

element SkinInfo/Options/Skin/OptionInterface/WindowIds/WindowId
diagram
type extension of xs:string
properties
minOcc | 1
maxOcc | unbounded
attributes
Name Type Use Default Fixed annotation
Language xs:string required
documentation
ISO code of the language used in this window. The language of Messenger will be matched with this code. Example: "en-us".
annotation
documentation
Id of the window used to display the options. Control types must be respected with matching names (ex: for a BoolVal property named Option1, create a checkbox with "Option1" as Id).

element SkinInfo/Options/Skin/OptionInterface/AboutIds
diagram
properties
minOcc | 0
maxOcc | 1
children AboutId
annotation
documentation
List of window ids corresponding to an optional About Box window. The option window must have a control with id "AboutWnd".

element SkinInfo/Options/Skin/OptionInterface/AboutIds/AboutId
diagram
type extension of xs:string
properties
minOcc | 1
maxOcc | unbounded
attributes
Name | Type | Use | Default | Fixed | annotation
Language | xs:string | required |  |  |

element SkinInfo/MessengerSkin
diagram
children ResGroup
annotation
documentation
Declare your Messenger skin data here.

element SkinInfo/MessengerSkin/ResGroup
diagram
properties
minOcc | 1
maxOcc | unbounded
children Restrictions Resources
annotation
documentation
All the resource groups specified here are processed sequentially and their data is combined. If a resource is redefined in multiple groups, its last definition will be used.

element SkinInfo/MessengerSkin/ResGroup/Restrictions
diagram
children MsgVersions MsgLanguages PlusVersions SkinOptions DateRanges
annotation
documentation
The restrictions specified here control whether or not this resource group is loaded.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/MsgVersions
diagram
children Version
annotation
documentation
Versions of Messenger required for inclusion. At least one version is required for each resource group.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/MsgVersions/Version
diagram
properties
minOcc | 1
maxOcc | unbounded
attributes
Name | Type | Use | Default | Fixed | annotation
Major xs:unsignedInt required
documentation
Note: remember that Messenger 9 is actually version 14.
Minor | xs:unsignedInt | required
Build | xs:unsignedInt | optional
Revision | xs:unsignedInt | optional
annotation
documentation
Important: the build and revision numbers are switched in some versions of Messengers. The attributes in this file always assume the Major.Minor.Build.Revision order.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/MsgLanguages
diagram
properties
minOcc | 0
maxOcc | 1
children Language
attributes
Name | Type | Use | Default | Fixed | annotation
FilterMode | derived by: xs:string | optional | include |  |
annotation
documentation
Languages of Messenger to include or exclude.

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/MsgLanguages/@FilterMode
type restriction of xs:string
properties
default | include
use | optional
facets
enumeration | include
enumeration | exclude

element SkinInfo/MessengerSkin/ResGroup/Restrictions/MsgLanguages/Language
diagram
properties
minOcc | 1
maxOcc | unbounded
attributes
Name Type Use Default Fixed annotation
IsoCode xs:string required
documentation
For example, specify "en-us" for English (United States).

element SkinInfo/MessengerSkin/ResGroup/Restrictions/PlusVersions
diagram
properties
minOcc | 0
maxOcc | 1
children Version
annotation
documentation
Versions of Messenger Plus! required for this resource group to be included.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/PlusVersions/Version
diagram
properties
minOcc | 1
maxOcc | unbounded
attributes
Name | Type | Use | Default | Fixed | annotation
Major | xs:unsignedInt | required |  |  |
Minor | xs:unsignedInt | required |  |  |
Build | xs:unsignedInt | optional |  |  |

element SkinInfo/MessengerSkin/ResGroup/Restrictions/SkinOptions
diagram
properties
minOcc | 0
maxOcc | 1
children OptionSet
annotation
documentation
Options supported by this skin.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/SkinOptions/OptionSet
diagram
properties
minOcc | 1
maxOcc | unbounded
children BoolVal MultiVal Conditions
annotation
documentation
This restriction will be valid if any of the option sets specified here is positive.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/SkinOptions/OptionSet/BoolVal
diagram
type extension of xs:boolean
attributes
Name | Type | Use | Default | Fixed | annotation
Name | xs:string | required |  |  |

element SkinInfo/MessengerSkin/ResGroup/Restrictions/SkinOptions/OptionSet/MultiVal
diagram
type extension of xs:string
attributes
Name | Type | Use | Default | Fixed | annotation
Name | xs:string | required |  |  |

element SkinInfo/MessengerSkin/ResGroup/Restrictions/SkinOptions/OptionSet/Conditions
type xs:string
annotation
documentation
Allows for more complex conditions to be set such as "Option1 = Value1 OR Option2 = Value2". Only AND and OR are accepted along with the = and != operators.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges
diagram
properties
minOcc | 0
maxOcc | 1
children DateRange
annotation
documentation
Date ranges when this resource group is to be included. Useful to change the content of a skin depending on the season.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange
diagram
properties
minOcc | 1
maxOcc | unbounded
children Start End
annotation
documentation
Note: the current date is analyzed only when Messenger is started.

element SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/Start
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
Day | derived by: xs:int | required |  |  |
Month | derived by: xs:int | required |  |  |
Year | derived by: xs:int |  |  |  |
annotation
documentation
Included

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/Start/@Day
type restriction of xs:int
properties
use required
facets
minInclusive | 1
maxInclusive | 31

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/Start/@Month
type restriction of xs:int
properties
use required
facets
minInclusive | 1
maxInclusive | 12

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/Start/@Year
type restriction of xs:int
facets
minInclusive | 1990
maxInclusive | 2100

element SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/End
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
Day | derived by: xs:int | required |  |  |
Month | derived by: xs:int | required |  |  |
Year | derived by: xs:int |  |  |  |
annotation
documentation
Excluded

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/End/@Day
type restriction of xs:int
properties
use required
facets
minInclusive | 1
maxInclusive | 31

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/End/@Month
type restriction of xs:int
properties
use required
facets
minInclusive | 1
maxInclusive | 12

attribute SkinInfo/MessengerSkin/ResGroup/Restrictions/DateRanges/DateRange/End/@Year
type restriction of xs:int
facets
minInclusive | 1990
maxInclusive | 2100

element SkinInfo/MessengerSkin/ResGroup/Resources
diagram
children New Replace
annotation
documentation
At least one New or one Replace resource must be specified.

element SkinInfo/MessengerSkin/ResGroup/Resources/New
diagram
properties
minOcc | 0
maxOcc | 1
children Colors Pictures
annotation
documentation
Add new resources to Messenger.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Colors
diagram
properties
minOcc | 0
maxOcc | 1
children Color

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Colors/Color
diagram
type | extension of ColorType
properties
minOcc | 1
maxOcc | unbounded
children | R G B A Colorize I A Direction GradientStart GradientEnd
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:unsignedInt required
documentation
New resource Id to assign to the color.
Destination | derived by: xs:string | msgres
annotation
documentation
New color resources, mainy useful when adding a variant of the base color of Messenger.

attribute SkinInfo/MessengerSkin/ResGroup/Resources/New/Colors/Color/@Id
type restriction of xs:unsignedInt
properties
use required
facets
minInclusive | 59000
maxInclusive | 59999
annotation
documentation
New resource Id to assign to the color.

attribute SkinInfo/MessengerSkin/ResGroup/Resources/New/Colors/Color/@Destination
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures
diagram
properties
minOcc | 0
maxOcc | 1
children Picture
annotation
documentation
Can be PNG, JPG or GIF.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture
diagram
properties
minOcc | 1
maxOcc | unbounded
children File Module ResName ResType Metadata
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:unsignedInt required
documentation
New resource Id to assign to the picture.
Destination | derived by: xs:string | msgres

attribute SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/@Id
type restriction of xs:unsignedInt
properties
use required
facets
minInclusive | 59000
maxInclusive | 59999
annotation
documentation
New resource Id to assign to the picture.

attribute SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/@Destination
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/File
type xs:string
annotation
documentation
Path to image file.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/ResType
type xs:string
properties
minOcc | 0
maxOcc | 1
default | #4000
annotation
documentation
Resource type. Add # for numeric types.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata
diagram
properties
minOcc | 0
maxOcc | 1
children Colorize FrameCount UMLeft UMTop UMRight UMBottom File
annotation
documentation
Additional information about the picture, such as masks and stretching.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/Colorize
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the background will be recolorized with the user's chosen color if the color is not the set to 'default'.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/FrameCount
type xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 1
annotation
documentation
Number of frames in the picture. The picture will be divided horizontally in equal parts based on this number. Use this when specifying pictures that are to be used as animations.

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/UMLeft
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255
annotation
documentation
Size of the untouched left margin, in pixels (this margin won't be stetched)

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/UMTop
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/UMRight
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/UMBottom
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255

element SkinInfo/MessengerSkin/ResGroup/Resources/New/Pictures/Picture/Metadata/File
type xs:string
annotation
documentation
Path to a mask file (for advanced users).

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace
diagram
properties
minOcc | 0
maxOcc | 1
children Strings Colors Rectangles Windows Graphics StandardUI
annotation
documentation
Replace existing resources in Messenger.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Strings
diagram
properties
minOcc | 0
maxOcc | 1
children String
annotation
documentation
rcstr and rcint values used in style files.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Strings/String
diagram
type extension of xs:string
properties
minOcc | 1
maxOcc | unbounded
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msglang |  |
annotation
documentation
String data to replace the existing one. Arguments present in the original string such as %1 must be kept in the new one. The \ character is used for escaping.

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Strings/String/@Source
type restriction of xs:string
properties
default msglang
facets
enumeration | msglang
enumeration | msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Colors
diagram
properties
minOcc | 0
maxOcc | 1
children Color
annotation
documentation
rcclr and some rcbkd values used in style files.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Colors/Color
diagram
type | extension of ColorType
properties
minOcc | 1
maxOcc | unbounded
children | R G B A Colorize I A Direction GradientStart GradientEnd
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msgres |  |
annotation
documentation
Replacement colors if you want to keep the color ids specified in the style files.

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Colors/Color/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles
diagram
properties
minOcc | 0
maxOcc | 1
children Rectangle
annotation
documentation
rcrect values used in style files.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles/Rectangle
diagram
properties
minOcc | 1
maxOcc | unbounded
children Left Top Right Bottom
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msgres |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles/Rectangle/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles/Rectangle/Left
type xs:integer

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles/Rectangle/Top
type xs:integer

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles/Rectangle/Right
type xs:integer

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Rectangles/Rectangle/Bottom
type xs:integer

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows
diagram
properties
minOcc | 0
maxOcc | 1
children Definitions Styles

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions
diagram
properties
minOcc | 0
maxOcc | 1
children Definition

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition
diagram
properties
minOcc | 1
maxOcc | unbounded
children File Data Module ResName ResType
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msgres |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition/File
type xs:string
annotation
documentation
Path to the new window definition text file. Must be ANSI.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition/Data
type xs:string
annotation
documentation
New window definition text. Should be written in a CDATA block.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Definitions/Definition/ResType
type xs:string
properties
minOcc | 0
maxOcc | 1
default | #4004
annotation
documentation
Resource type. Add # for numeric types.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles
diagram
properties
minOcc | 0
maxOcc | 1
children Style

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style
diagram
properties
minOcc | 1
maxOcc | unbounded
children File Data Module ResName ResType
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msgres |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style/File
type xs:string
annotation
documentation
Path to the new window style text file. Must be ANSI.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style/Data
type xs:string
annotation
documentation
New window style text. Should be written in a CDATA block.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Windows/Styles/Style/ResType
type xs:string
properties
minOcc | 0
maxOcc | 1
default | #4005
annotation
documentation
Resource type. Add # for numeric types.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics
diagram
properties
minOcc | 0
maxOcc | 1
children Pictures Bitmaps Icons Cursors

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures
diagram
properties
minOcc | 0
maxOcc | 1
children Picture
annotation
documentation
Can be PNG, JPG, GIF or a special RLE encrypted format.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture
diagram
properties
minOcc | 1
maxOcc | unbounded
children File Module ResName ResType Metadata
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msgres |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration | msgres
enumeration | msgvsta

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/File
type xs:string
annotation
documentation
Path to image file. Can be any picture format, it does not need to match the original format used in the Messenger resources.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/ResType
type xs:string
properties
minOcc | 0
maxOcc | 1
default | #4000
annotation
documentation
Resource type. Add # for numeric types.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata
diagram
properties
minOcc | 0
maxOcc | 1
children Colorize FrameCount UMLeft UMTop UMRight UMBottom File
annotation
documentation
Additional information about the picture, such as masks and stretching. If not specified, the exiting mask set in Messenger for this resource id is used, if any.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/Colorize
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the background will be recolorized with the user's chosen color if the color is not the set to 'default'.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/FrameCount
type xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 1
annotation
documentation
Number of frames in the picture. The picture will be divided horizontally in equal parts based on this number. Use this when specifying pictures that are to be used as animations.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/UMLeft
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255
annotation
documentation
Size of the untouched left margin, in pixels (this margin won't be stetched)

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/UMTop
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/UMRight
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/UMBottom
type restriction of xs:unsignedShort
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 255

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Pictures/Picture/Metadata/File
type xs:string
annotation
documentation
Path to a mask file (replaces resources of type 4006. For advanced users).

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Bitmaps
diagram
properties
minOcc | 0
maxOcc | 1
children Bitmap
annotation
documentation
This is for old BMP bitmaps used in rare places in the program.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Bitmaps/Bitmap
diagram
properties
minOcc | 1
maxOcc | unbounded
children File Module ResName
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msgres |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Bitmaps/Bitmap/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration | msgres
enumeration | msgexe

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Bitmaps/Bitmap/File
type xs:string
annotation
documentation
Path to bitmap file, has to be a BMP file.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Bitmaps/Bitmap/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Bitmaps/Bitmap/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons
diagram
properties
minOcc | 0
maxOcc | 1
children Icon IconGroup
annotation
documentation
New icons need to have the exact same properties as the original ones.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/Icon
diagram
children Module ResName
attributes
Name | Type | Use | Default | Fixed | annotation
Id xs:unsignedInt required
documentation
Note: this is the Id of a single icon format, not the whole icon group.
Source | derived by: xs:string | msgres

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/Icon/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration | msgres
enumeration | msgexe
enumeration | msgvsta

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/Icon/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/Icon/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name. The first icon of the group will be used.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/IconGroup
diagram
children File
attributes
Name | Type | Use | Default | Fixed | annotation
Id xs:unsignedInt required
documentation
Note: this is the Id of an entire icon group.
Source | derived by: xs:string | msgres

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/IconGroup/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration | msgres
enumeration | msgexe

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Icons/IconGroup/File
type xs:string
annotation
documentation
Path to icon file, has to be an ICO file with the proper number of sub-formats.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Cursors
diagram
properties
minOcc | 0
maxOcc | 1
children Cursor

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Cursors/Cursor
diagram
children Module ResName
attributes
Name | Type | Use | Default | Fixed | annotation
Id xs:unsignedInt required
documentation
Note: this is the Id of a single cursor frame, not the whole cursor group.
Source | derived by: xs:string | msgres

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Cursors/Cursor/@Source
type restriction of xs:string
properties
default msgres
facets
enumeration msgres

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Cursors/Cursor/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Graphics/Cursors/Cursor/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name. The first cursor of the group will be used.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI
diagram
properties
minOcc | 0
maxOcc | 1
children Dialogs Menus

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Dialogs
diagram
properties
minOcc | 0
maxOcc | 1
children Dialog

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Dialogs/Dialog
diagram
properties
minOcc | 1
maxOcc | unbounded
children Module ResName
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msglang |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Dialogs/Dialog/@Source
type restriction of xs:string
properties
default msglang
facets
enumeration msglang

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Dialogs/Dialog/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Dialogs/Dialog/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Menus
diagram
properties
minOcc | 0
maxOcc | 1
children Menu

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Menus/Menu
diagram
properties
minOcc | 1
maxOcc | unbounded
children Module ResName
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:unsignedInt | required |  |  |
Source | derived by: xs:string |  | msglang |  |

attribute SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Menus/Menu/@Source
type restriction of xs:string
properties
default msglang
facets
enumeration msglang

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Menus/Menu/Module
type xs:string
annotation
documentation
Path to resource DLL.

element SkinInfo/MessengerSkin/ResGroup/Resources/Replace/StandardUI/Menus/Menu/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element SkinInfo/PlusSkin
diagram
properties
minOcc | 0
maxOcc | 1
children ResGroup
annotation
documentation
Allows you to add a skin for Messenger Plus! along with your skin for Messenger. Use only if you want to modify the look of the windows of Messenger Plus!.

element SkinInfo/PlusSkin/ResGroup
diagram
properties
minOcc | 0
maxOcc | unbounded
children PlusVersion SkinOptions TabbedChatBar InterfaceDir
annotation
documentation
All the resource groups specified here are processed sequencially until one matching version of Messenger Plus! is found (with optional matching skin options). Different groups do not combine.

element SkinInfo/PlusSkin/ResGroup/PlusVersion
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
Major | xs:unsignedInt | required
Minor | xs:unsignedInt | optional
Build | xs:unsignedInt | optional
Language xs:string optional
documentation
ISO code as specified in the translation ini file.
annotation
documentation
Version of Messenger Plus! that's compatible with this resource group.

element SkinInfo/PlusSkin/ResGroup/SkinOptions
diagram
properties
minOcc | 0
maxOcc | 1
children OptionSet
annotation
documentation
Include only depending on the options supported by this skin.

element SkinInfo/PlusSkin/ResGroup/SkinOptions/OptionSet
diagram
properties
minOcc | 1
maxOcc | unbounded
children BoolVal MultiVal Conditions
annotation
documentation
This group will be valid if any of the option sets specified here is positive.

element SkinInfo/PlusSkin/ResGroup/SkinOptions/OptionSet/BoolVal
diagram
type extension of xs:boolean
attributes
Name | Type | Use | Default | Fixed | annotation
Name | xs:string | required |  |  |

element SkinInfo/PlusSkin/ResGroup/SkinOptions/OptionSet/MultiVal
diagram
type extension of xs:string
attributes
Name | Type | Use | Default | Fixed | annotation
Name | xs:string | required |  |  |

element SkinInfo/PlusSkin/ResGroup/SkinOptions/OptionSet/Conditions
type xs:string

element SkinInfo/PlusSkin/ResGroup/TabbedChatBar
diagram
properties
minOcc | 0
maxOcc | 1
children Background
annotation
documentation
Use this element if tabbed chats don't display properly in your modified chat windows.

element SkinInfo/PlusSkin/ResGroup/TabbedChatBar/Background
diagram
type | extension of DrawElementType
properties
minOcc | 0
maxOcc | 2
children | Picture
attributes
Name Type Use Default Fixed annotation
Position derived by: xs:string optional all
documentation
Only one element can be specified for each possible position of the group bar. If "all" is specified, no other element is accepted.
annotation
documentation
Add a customized background in the tabbed chat bar.

attribute SkinInfo/PlusSkin/ResGroup/TabbedChatBar/Background/@Position
type restriction of xs:string
properties
default | all
use | optional
facets
enumeration | all
enumeration | top
enumeration | left
annotation
documentation
Only one element can be specified for each possible position of the group bar. If "all" is specified, no other element is accepted.

element SkinInfo/PlusSkin/ResGroup/InterfaceDir
type xs:string
properties
minOcc | 0
maxOcc | 1
annotation
documentation
This directory will be used by Messenger Plus! to locate all the files it needs to display its interfaces. See documentation for more details.

complexType ColorType
diagram
children R G B A Colorize I A Direction GradientStart GradientEnd
used by
elements SkinInfo/MessengerSkin/ResGroup/Resources/New/Colors/Color SkinInfo/MessengerSkin/ResGroup/Resources/Replace/Colors/Color ColorType/GradientEnd ColorType/GradientStart
annotation
documentation
A color can be defined in 3 different possible ways.

element ColorType/R
type xs:unsignedByte

element ColorType/G
type xs:unsignedByte

element ColorType/B
type xs:unsignedByte

element ColorType/A
type xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 255
annotation
documentation
Transparency.

element ColorType/Colorize
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Enables colorization for advanced users. The RGB values are used as is for the default color. Colorization's intensity is computed as (min(r,g,b)+max(r,g,b)) / 2.

element ColorType/I
type xs:unsignedByte
annotation
documentation
Intensity.

element ColorType/A
type xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 255
annotation
documentation
Transparency.

element ColorType/Direction
type restriction of xs:string
facets
enumeration | horizontal
enumeration | vertical
annotation
documentation
Note: Messenger 14 only supports horizontal gradients.

element ColorType/GradientStart
diagram |
type | ColorType
children | R G B A Colorize I A Direction GradientStart GradientEnd

 element ColorType/GradientEnd
type | ColorType
children | R G B A Colorize I A Direction GradientStart GradientEnd

 complexType DimensionsType
diagram
children Size Borders
used by
elements SkinInfo/Dimensions/ChatWnd SkinInfo/Dimensions/ChatWndTabbed SkinInfo/Dimensions/ContactList

element DimensionsType/Size
diagram
properties
minOcc | 0
maxOcc | 1
children Width Height
annotation
documentation
Allows you to constrain the size of a window if the skin does not adapt well to certain sizes (like, for example, very small width and height).

element DimensionsType/Size/Width
diagram
properties
minOcc | 0
maxOcc | 1
children Fixed Minimum Maximum
annotation
documentation
Width of the client area of the window.

element DimensionsType/Size/Width/Fixed
type xs:unsignedInt
annotation
documentation
The width of the contact list is fixed to this amount of pixels and cannot be modified by the user.

element DimensionsType/Size/Width/Minimum
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1

element DimensionsType/Size/Width/Maximum
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1

element DimensionsType/Size/Height
diagram
properties
minOcc | 0
maxOcc | 1
children Fixed Minimum Maximum
annotation
documentation
Height of the client area of the window.

element DimensionsType/Size/Height/Fixed
type xs:unsignedInt
annotation
documentation
The height of the contact list is fixed to this amount of pixels and cannot be modified by the user.

element DimensionsType/Size/Height/Minimum
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1

element DimensionsType/Size/Height/Maximum
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1

element DimensionsType/Borders
diagram
properties
minOcc | 0
maxOcc | 1
children BorderArea
annotation
documentation
Redefines the sizing borders of the window. Valid only if a Region is specified.

element DimensionsType/Borders/BorderArea
diagram
properties
minOcc | 1
maxOcc | unbounded
children Left Top Width Height
attributes
Name Type Use Default Fixed annotation
Kind derived by: xs:string required
documentation
Specifies the meaning of this border when clicked and/or dragged.
annotation
documentation
All the elements are processed in order, if areas overlap, the last one specified is used. If two compatible areas overlap, they are combined (for example, Left and Top combine as TopLeft).

attribute DimensionsType/Borders/BorderArea/@Kind
type restriction of xs:string
properties
use required
facets
enumeration | SizeLeft
enumeration | SizeTop
enumeration | SizeRight
enumeration | SizeBottom
enumeration | SizeTopLeft
enumeration | SizeTopRight
enumeration | SizeBottomLeft
enumeration | SizeBottomRight
annotation
documentation
Specifies the meaning of this border when clicked and/or dragged.

element DimensionsType/Borders/BorderArea/Left
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
This coordinate can be fixed or relative to the width of the contact list.

attribute DimensionsType/Borders/BorderArea/Left/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
This coordinate can be fixed or relative to the width of the contact list.

element DimensionsType/Borders/BorderArea/Top
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
This coordinate can be fixed or relative to the height of the contact list.

attribute DimensionsType/Borders/BorderArea/Top/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
This coordinate can be fixed or relative to the height of the contact list.

element DimensionsType/Borders/BorderArea/Width
diagram
type extension of xs:double
attributes
Name | Type | Use | Default | Fixed | annotation
Unit | derived by: xs:string | optional | pixels |  |
annotation
documentation
Negative values are allowed.

attribute DimensionsType/Borders/BorderArea/Width/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent

element DimensionsType/Borders/BorderArea/Height
diagram
type extension of xs:double
attributes
Name | Type | Use | Default | Fixed | annotation
Unit | derived by: xs:string | optional | pixels |  |
annotation
documentation
Negative values are allowed.

attribute DimensionsType/Borders/BorderArea/Height/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent

complexType DrawElementType
diagram
children Picture
used by
element SkinInfo/PlusSkin/ResGroup/TabbedChatBar/Background

element DrawElementType/Picture
diagram
children File Mosaic Colorize
annotation
documentation
One single picture that fills all the available space.

element DrawElementType/Picture/File
type xs:string
annotation
documentation
Path to image file. Can be PNG, JPG, GIF.

element DrawElementType/Picture/Mosaic
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | ResizeToFit
facets
enumeration | ResizeToFit
enumeration | HVRepeat

element DrawElementType/Picture/Colorize
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

complexType RegionType
diagram
children Rectangle Image
used by
elements SkinInfo/Region/ChatWnd SkinInfo/Region/ChatWndTabbed SkinInfo/Region/ContactList

element RegionType/Rectangle
diagram
children Left Right Top Bottom Width Height
attributes
Name Type Use Default Fixed annotation
Integration derived by: xs:string optional add
documentation
Subtracting shapes gives you a finer control for complex designs.
annotation
documentation
Adds or subtracts a rectangular shape to the region.

attribute RegionType/Rectangle/@Integration
type restriction of xs:string
properties
default | add
use | optional
facets
enumeration | add
enumeration | subtract
annotation
documentation
Subtracting shapes gives you a finer control for complex designs.

element RegionType/Rectangle/Left
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The horizontal position can be fixed or relative to the width of the contact list.

attribute RegionType/Rectangle/Left/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The horizontal position can be fixed or relative to the width of the contact list.

element RegionType/Rectangle/Right
diagram
type extension of xs:double
attributes
Name | Type | Use | Default | Fixed | annotation
Unit | derived by: xs:string | optional | pixels |  |

attribute RegionType/Rectangle/Right/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent

element RegionType/Rectangle/Top
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The vertical position can be fixed or relative to the Height of the contact list.

attribute RegionType/Rectangle/Top/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The vertical position can be fixed or relative to the Height of the contact list.

element RegionType/Rectangle/Bottom
diagram
type extension of xs:double
attributes
Name | Type | Use | Default | Fixed | annotation
Unit | derived by: xs:string | optional | pixels |  |

attribute RegionType/Rectangle/Bottom/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent

element RegionType/Rectangle/Width
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The width can be fixed or relative to the width of the contact list.

attribute RegionType/Rectangle/Width/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The width can be fixed or relative to the width of the contact list.

element RegionType/Rectangle/Height
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The height can be fixed or relative to the height of the contact list.

attribute RegionType/Rectangle/Height/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The height can be fixed or relative to the height of the contact list.

element RegionType/Image
diagram
children Source ExcludedColor Position
attributes
Name | Type | Use | Default | Fixed | annotation
Integration | derived by: xs:string | optional | add |  |
annotation
documentation
Adds the shape of an image to the region. Can be PNG, GIF or JPG (be careful of compression artifacts in JPG).

attribute RegionType/Image/@Integration
type restriction of xs:string
properties
default | add
use | optional
facets
enumeration | add
enumeration | subtract

element RegionType/Image/Source
diagram
children File Module ResName ResType
annotation
documentation
Load the image from a file or a resource DLL.

element RegionType/Image/Source/File
type xs:string
annotation
documentation
Path to image file.

element RegionType/Image/Source/Module
type xs:string
annotation
documentation
Path to resource DLL.

element RegionType/Image/Source/ResName
type xs:string
annotation
documentation
Resource name. Add # for numeric name.

element RegionType/Image/Source/ResType
type xs:string
annotation
documentation
Resource type. Add # for numeric types.

element RegionType/Image/ExcludedColor
diagram
properties
minOcc | 0
maxOcc | 1
children Red Green Blue
annotation
documentation
Specifies the color used for "transparency". Anything that is NOT this color will be included in the region. Default is "white" RGB(255,255,255).

element RegionType/Image/ExcludedColor/Red
type restriction of xs:unsignedByte
facets
minInclusive | 0
maxInclusive | 255

element RegionType/Image/ExcludedColor/Green
type restriction of xs:unsignedByte
facets
minInclusive | 0
maxInclusive | 255

element RegionType/Image/ExcludedColor/Blue
type restriction of xs:unsignedByte
facets
minInclusive | 0
maxInclusive | 255

element RegionType/Image/Position
diagram |
children | Left Right Top Bottom Width Height

 element RegionType/Image/Position/Left
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The horizontal position can be fixed or relative to the width of the contact list.

attribute RegionType/Image/Position/Left/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The horizontal position can be fixed or relative to the width of the contact list.

element RegionType/Image/Position/Right
diagram
type extension of xs:double
attributes
Name | Type | Use | Default | Fixed | annotation
Unit | derived by: xs:string | optional | pixels |  |

attribute RegionType/Image/Position/Right/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent

element RegionType/Image/Position/Top
diagram
type extension of xs:double
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The vertical position can be fixed or relative to the Height of the contact list.

attribute RegionType/Image/Position/Top/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The vertical position can be fixed or relative to the Height of the contact list.

element RegionType/Image/Position/Bottom
diagram
type extension of xs:double
attributes
Name | Type | Use | Default | Fixed | annotation
Unit | derived by: xs:string | optional | pixels |  |

attribute RegionType/Image/Position/Bottom/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent

element RegionType/Image/Position/Width
diagram
type extension of xs:double
properties
minOcc | 0
maxOcc | 1
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The width can be fixed or relative to the width of the contact list.
annotation
documentation
Stretches the image horizontally.

attribute RegionType/Image/Position/Width/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The width can be fixed or relative to the width of the contact list.

element RegionType/Image/Position/Height
diagram
type extension of xs:double
properties
minOcc | 0
maxOcc | 1
attributes
Name Type Use Default Fixed annotation
Unit derived by: xs:string optional pixels
documentation
The height can be fixed or relative to the height of the contact list.
annotation
documentation
Stretches the image vertically.

attribute RegionType/Image/Position/Height/@Unit
type restriction of xs:string
properties
default | pixels
use | optional
facets
enumeration | pixels
enumeration | percent
annotation
documentation
The height can be fixed or relative to the height of the contact list.


XML Schema Reference

Messenger Plus! Live

Messenger Plus! Interfaces Schema Reference

XML Schema files are used to validate XML files. They can also be used as technical documentation to know more about the elements and attributes that are read by Messenger Plus! in a given XML file.

Information

Read about PlusInterface XML files

Built-in documentation of the Schema file for PlusInterface

Schema Files

Get the Schema file for PlusInterface


XML Schemas Reference

Messenger Plus! Interfaces Information

Interface files are what's used by Messenger Plus! to display its own windows. These files are not particularly complicated to understand and use a much simpler/straightforward structure than Messenger's own system. That being said, Messenger Plus! interfaces use a lot of different kinds of objects and attributes. You'll need to get familiar with many of them if you want to create or modify a Messenger Plus! window file (useful when skinning Messenger Plus! itself or when creating custom option panels for your skin).

The Schema file for Interface Windows can be temporarily placed in the interface directory of your choice to validate your XML files. However, the schema must not be redistributed with your skin (it would only be dead weight anyway). Here is how to write the first element of your XML file to make your XML editor aware of the schema file:

<Interfaces xmlns="urn:msgplus:interface"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="urn:msgplus:interface PlusInterface.xsd">

    <Window>
        ...
    </Window>
</Interfaces>

It is considered to be a good practice to always link your xml files to their respective schemas to prevent any possible run time error caused by a mistake in your XML. This header is not added in any example of this documentation for clarity reasons only. You should add it yourself every time you create a new interface file or modify an existing one, without exception.

The best examples you can get for interface window files are probably the windows of Messenger Plus! itself. Those files can easily be extracted with Messenger Plus!'s own resource extractor if needed. If your XML Editor does not come with graphical browsing of the schema file, you can view a documentation generated by XMLSpy in the Interface Windows Schema Documentation section.

Important: remember that Messenger Plus! interface files are not to be mixed with Messenger's own definition and style files. When skinning Windows Live Messenger, any file related to Messenger Plus! interfaces won't be of any use to you so make sure you don't get confused by mixing both documentations.

See Also

Interface Window Schema File, Schema Documentation.


Interface Windows - Schema Documentation

 Interface Windows Schema Documentation

Interfaces
Window
Element
ElementGroup
ArrowElement
FigureElement
Image
LineElement
PlaceHolderElement
Control
BrowserControl
ButtonControl
CheckBoxControl
CodeEditControl
ComboBoxControl
DateTimeControl
EditControl
HotKeyControl
LinkControl
ListBoxControl
ListViewControl
MenuButtonControl
ProgressControl
RadioControl
RichEditControl
RichStaticControl
ScrollBarControl
SliderControl
SpinControl
StaticControl
TreeViewControl
ArcChunk
BezierChunk
Color
ColorInfo
GlobalColor
ImageElement
LineChunk
Menu
PathChunk
TextElement

element Interfaces
diagram
children pli:GlobalColors pli:Window
attributes
Name | Type | Use | Default | Fixed | annotation
Name | derived by: xs:string | optional |  |  |
Version | xs:float |  |  |  |
Description | xs:string |  |  |  |
identity constraints
 | Name | Refer | Selector | Field(s)
key | keyWindowName |  | Window | @Name

attribute Interfaces/@Name
type restriction of xs:string
properties
use optional
facets
minLength 1

attribute Interfaces/@Version
type xs:float

attribute Interfaces/@Description
type xs:string

element Interfaces/GlobalColors
diagram
properties
minOcc | 0
maxOcc | 1
children pli:GlobalColor

element Interfaces/GlobalColors/GlobalColor
diagram
type | pli:GlobalColor
properties
minOcc | 0
maxOcc | unbounded
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required |  |  |

element Interfaces/Window
diagram
type | pli:Window
properties
minOcc | 1
maxOcc | unbounded
children | pli:Attributes pli:TitleBar pli:Position pli:DialogTmpl pli:WindowTmpl pli:ChildTmpl pli:Elements pli:ElementGroups pli:Controls
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed. For scripts windows, punctuation is replaced by underscores.
Version xs:unsignedInt required
documentation
Used by the program to know is a custom interface is up to date.
TranslationSection xs:string
documentation
Use to override the name of the section where the translation for this window will be read.
Description | xs:string

complexType ArcChunk
diagram
type | extension of pli:PathChunk
properties
base pli:PathChunk
children | pli:Left pli:Top pli:Width pli:Height pli:StartAngle pli:SweepAngle

element ArcChunk/Left
type xs:int

element ArcChunk/Top
type xs:int

element ArcChunk/Width
type restriction of xs:unsignedInt
facets
minInclusive 1

element ArcChunk/Height
type restriction of xs:unsignedInt
facets
minInclusive 1

element ArcChunk/StartAngle
type restriction of xs:int
facets
minInclusive | 0
maxInclusive | 360
annotation
documentation
Clockwise angle between the horizontal axis of the ellipse and the starting point of the arc.

element ArcChunk/SweepAngle
type restriction of xs:int
facets
minInclusive | 0
maxInclusive | 360
annotation
documentation
Clockwise angle between the starting point and the ending point of the arc.

complexType ArrowElement
diagram
type | extension of pli:Element
properties
base pli:Element
children | pli:Position pli:Attributes pli:Color
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element ArrowElement/Attributes
diagram |
children | pli:Orientation

 element ArrowElement/Attributes/Orientation
type restriction of xs:string
facets
enumeration | Left
enumeration | Right

element ArrowElement/Color
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 complexType BezierChunk
diagram
type | extension of pli:PathChunk
properties
base pli:PathChunk
children | pli:X1 pli:Y1 pli:X2 pli:Y2 pli:X3 pli:Y3 pli:X4 pli:Y4

element BezierChunk/X1
type xs:int

element BezierChunk/Y1
type xs:int
annotation
documentation
Starting point

element BezierChunk/X2
type xs:int

element BezierChunk/Y2
type xs:int
annotation
documentation
First control point

element BezierChunk/X3
type xs:int

element BezierChunk/Y3
type xs:int
annotation
documentation
Second control point

element BezierChunk/X4
type xs:int

element BezierChunk/Y4
type xs:int
annotation
documentation
Ending point

complexType BrowserControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element BrowserControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:HasBorder pli:AllowFindText pli:AllowPrint

element BrowserControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element BrowserControl/Attributes/AllowFindText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Display the Find Text window when the user hits Ctrl+F

element BrowserControl/Attributes/AllowPrint
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Display the Print window when the user hits Ctrl+P

element BrowserControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

complexType ButtonControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:StandardLook pli:CustomGradient pli:Image pli:Font pli:TextColor pli:Caption pli:CustomLook
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element ButtonControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Align pli:IsDefault pli:MoveWhenPushed pli:DwmAnimations

element ButtonControl/Attributes/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | center
facets
enumeration | left
enumeration | center
enumeration | right

element ButtonControl/Attributes/IsDefault
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
This button is clicked when the user presses Enter.

element ButtonControl/Attributes/MoveWhenPushed
type restriction of xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 0
facets
minInclusive | 0
maxInclusive | 3
annotation
documentation
Move the button when it's pressed by this number of pixel (only for the default look).

element ButtonControl/Attributes/DwmAnimations
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Default
facets
enumeration | Default
enumeration | Allow
enumeration | Disallow
annotation
documentation
Specifies if transition animations are allowed for this control in Windows Vista and above.

element ButtonControl/StandardLook
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
Template | derived by: xs:string |  | Grey |  |

attribute ButtonControl/StandardLook/@Template
type restriction of xs:string
properties
default Grey
facets
enumeration | Grey
enumeration | Blue
enumeration | Transparent
enumeration | Transparent2
enumeration | Clear

element ButtonControl/CustomGradient
diagram |
children | pli:Normal pli:Hot pli:Pushed

 element ButtonControl/CustomGradient/Normal
diagram
children pli:Color1 pli:Color2 pli:ColorBorder pli:Shadow
attributes
Name | Type | Use | Default | Fixed | annotation
Interpolation | derived by: xs:string |  | Smooth |  |

attribute ButtonControl/CustomGradient/Normal/@Interpolation
type restriction of xs:string
properties
default Smooth
facets
enumeration | Smooth
enumeration | Average
enumeration | Strong

element ButtonControl/CustomGradient/Normal/Color1
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ButtonControl/CustomGradient/Normal/Color2
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ButtonControl/CustomGradient/Normal/ColorBorder
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
annotation
documentation
If not present, Color2 is used instead.

element ButtonControl/CustomGradient/Normal/Shadow
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ButtonControl/CustomGradient/Hot
diagram
children pli:Color1 pli:Color2 pli:ColorBorder pli:Shadow
attributes
Name | Type | Use | Default | Fixed | annotation
Interpolation | derived by: xs:string |  | Smooth |  |

attribute ButtonControl/CustomGradient/Hot/@Interpolation
type restriction of xs:string
properties
default Smooth
facets
enumeration | Smooth
enumeration | Average
enumeration | Strong

element ButtonControl/CustomGradient/Hot/Color1
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ButtonControl/CustomGradient/Hot/Color2
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ButtonControl/CustomGradient/Hot/ColorBorder
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element ButtonControl/CustomGradient/Hot/Shadow
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ButtonControl/CustomGradient/Pushed
diagram
children pli:Color1 pli:Color2 pli:ColorBorder pli:Shadow
attributes
Name | Type | Use | Default | Fixed | annotation
Interpolation | derived by: xs:string |  | Smooth |  |

attribute ButtonControl/CustomGradient/Pushed/@Interpolation
type restriction of xs:string
properties
default Smooth
facets
enumeration | Smooth
enumeration | Average
enumeration | Strong

element ButtonControl/CustomGradient/Pushed/Color1
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ButtonControl/CustomGradient/Pushed/Color2
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ButtonControl/CustomGradient/Pushed/ColorBorder
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element ButtonControl/CustomGradient/Pushed/Shadow
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ButtonControl/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | 1
children | pli:Name pli:Format pli:AllowAutoMirror
attributes
Name | Type | Use | Default | Fixed | annotation
Align | derived by: xs:string |  | Left |  |
Margin | xs:int |  | 2 |  |
annotation
documentation
Only valid is Align is Center

attribute ButtonControl/Image/@Align
type restriction of xs:string
properties
default Left
facets
enumeration | Left
enumeration | Right

attribute ButtonControl/Image/@Margin
type xs:int
properties
default 2

element ButtonControl/Image/AllowAutoMirror
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
If true, the image will automatically be mirrored (inversed on the X axis) if the parent window is right-to-left.

element ButtonControl/Font
diagram
properties
minOcc | 0
maxOcc | 1
children pli:FaceName pli:Bold pli:Italic pli:Underlined pli:Strikeout pli:Size
annotation
documentation
Changes various settings of the default font.

element ButtonControl/Font/FaceName
type xs:string
properties
minOcc | 0
maxOcc | 1

element ButtonControl/Font/Bold
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element ButtonControl/Font/Italic
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element ButtonControl/Font/Underlined
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element ButtonControl/Font/Strikeout
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element ButtonControl/Font/Size
type xs:double
properties
minOcc | 0
maxOcc | 1
default | 8
annotation
documentation
The size is in points.

element ButtonControl/TextColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element ButtonControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

element ButtonControl/CustomLook
diagram
children pli:FocusRect pli:Base pli:Normal pli:Hot pli:Pushed pli:Disabled
annotation
documentation
When using custom look, the control cannot be resized.

element ButtonControl/CustomLook/FocusRect
diagram
children pli:Left pli:Top pli:Right pli:Bottom
annotation
documentation
Margins used to compute the position of the focus rectangle based on the position of the control.

element ButtonControl/CustomLook/FocusRect/Left
type xs:int

element ButtonControl/CustomLook/FocusRect/Top
type xs:int

element ButtonControl/CustomLook/FocusRect/Right
type xs:int

element ButtonControl/CustomLook/FocusRect/Bottom
type xs:int

element ButtonControl/CustomLook/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Base elements are displayed for every state.

element ButtonControl/CustomLook/Base/Element
diagram
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element ButtonControl/CustomLook/Normal
diagram |
children | pli:Element

 element ButtonControl/CustomLook/Normal/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element ButtonControl/CustomLook/Hot
diagram |
children | pli:Element

 element ButtonControl/CustomLook/Hot/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element ButtonControl/CustomLook/Pushed
diagram |
children | pli:Element

 element ButtonControl/CustomLook/Pushed/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element ButtonControl/CustomLook/Disabled
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element

element ButtonControl/CustomLook/Disabled/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

complexType CheckBoxControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:TextColor pli:Caption pli:CustomLook
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element CheckBoxControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Has3States pli:DwmAnimations

element CheckBoxControl/Attributes/Has3States
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element CheckBoxControl/Attributes/DwmAnimations
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Default
facets
enumeration | Default
enumeration | Allow
enumeration | Disallow
annotation
documentation
Specifies if transition animations are allowed for this control in Windows Vista and above.

element CheckBoxControl/TextColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
annotation
documentation
Alpha not supported.

element CheckBoxControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

element CheckBoxControl/CustomLook
diagram
children pli:FocusRect pli:Base pli:Normal pli:Hot pli:Pushed pli:Disabled
annotation
documentation
When using custom look, the control cannot be resized.

element CheckBoxControl/CustomLook/FocusRect
diagram
children pli:Left pli:Top pli:Right pli:Bottom
annotation
documentation
Margins used to compute the position of the focus rectangle based on the position of the control.

element CheckBoxControl/CustomLook/FocusRect/Left
type xs:int

element CheckBoxControl/CustomLook/FocusRect/Top
type xs:int

element CheckBoxControl/CustomLook/FocusRect/Right
type xs:int

element CheckBoxControl/CustomLook/FocusRect/Bottom
type xs:int

element CheckBoxControl/CustomLook/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Base elements are displayed for every state.

element CheckBoxControl/CustomLook/Base/Element
diagram
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Normal
diagram |
children | pli:Base pli:Unchecked pli:Checked pli:ThirdChecked

 element CheckBoxControl/CustomLook/Normal/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element CheckBoxControl/CustomLook/Normal/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Normal/Unchecked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Normal/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Normal/Checked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Normal/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Normal/ThirdChecked
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element

element CheckBoxControl/CustomLook/Normal/ThirdChecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Hot
diagram |
children | pli:Base pli:Unchecked pli:Checked pli:ThirdChecked

 element CheckBoxControl/CustomLook/Hot/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element CheckBoxControl/CustomLook/Hot/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Hot/Unchecked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Hot/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Hot/Checked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Hot/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Hot/ThirdChecked
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element

element CheckBoxControl/CustomLook/Hot/ThirdChecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Pushed
diagram |
children | pli:Base pli:Unchecked pli:Checked pli:ThirdChecked

 element CheckBoxControl/CustomLook/Pushed/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element CheckBoxControl/CustomLook/Pushed/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Pushed/Unchecked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Pushed/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Pushed/Checked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Pushed/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Pushed/ThirdChecked
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element

element CheckBoxControl/CustomLook/Pushed/ThirdChecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Disabled
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Base pli:Unchecked pli:Checked pli:ThirdChecked

element CheckBoxControl/CustomLook/Disabled/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element CheckBoxControl/CustomLook/Disabled/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Disabled/Unchecked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Disabled/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Disabled/Checked
diagram |
children | pli:Element

 element CheckBoxControl/CustomLook/Disabled/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element CheckBoxControl/CustomLook/Disabled/ThirdChecked
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element

element CheckBoxControl/CustomLook/Disabled/ThirdChecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

complexType CodeEditControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true
annotation
documentation
Used internally for the script editor

element CodeEditControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:HasBorder pli:Template

element CodeEditControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element CodeEditControl/Attributes/Template
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | JScript
facets
enumeration JScript

complexType Color
diagram
type | extension of pli:ColorInfo
properties
base pli:ColorInfo
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
used by
elements Window/WindowTmpl/BackgroundColor RichEditControl/BackgroundColor StaticControl/BackgroundColor RichStaticControl/BackgroundColor EditControl/BorderColor ListBoxControl/BorderColor RichEditControl/BorderColor HotKeyControl/BorderColor DateTimeControl/BorderColor ListViewControl/BorderColor TreeViewControl/BorderColor ComboBoxControl/BorderColor BrowserControl/BorderColor FigureElement/Fill/PathGradient/CenterColor ImageElement/Colorization/Color TextElement/Color LineElement/Color RichStaticControl/Color ArrowElement/Color StaticControl/Color FigureElement/Border/Color Window/WindowTmpl/Borders/Color FigureElement/Fill/LinearGradient/Color1 ButtonControl/CustomGradient/Pushed/Color1 ButtonControl/CustomGradient/Hot/Color1 ButtonControl/CustomGradient/Normal/Color1 FigureElement/Fill/LinearGradient/Color2 ButtonControl/CustomGradient/Pushed/Color2 ButtonControl/CustomGradient/Hot/Color2 ButtonControl/CustomGradient/Normal/Color2 ButtonControl/CustomGradient/Pushed/ColorBorder ButtonControl/CustomGradient/Hot/ColorBorder ButtonControl/CustomGradient/Normal/ColorBorder LinkControl/HotTextColor FigureElement/Fill/PlainColor FigureElement/Fill/PathGradient/SurroundColor LinkControl/TextColor MenuButtonControl/TextColor CheckBoxControl/TextColor RadioControl/TextColor ButtonControl/TextColor

element Color/GlobalColor
type xs:string

complexType ColorInfo
diagram
children pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor
used by
complexTypes Color GlobalColor

element ColorInfo/Red
type restriction of xs:unsignedByte
facets
minInclusive | 0
maxInclusive | 255

element ColorInfo/Green
type restriction of xs:unsignedByte
facets
minInclusive | 0
maxInclusive | 255

element ColorInfo/Blue
type restriction of xs:unsignedByte
facets
minInclusive | 0
maxInclusive | 255

element ColorInfo/Alpha
type restriction of xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 255
facets
minInclusive | 0
maxInclusive | 255
annotation
documentation
For transparency.
Not always supported.

element ColorInfo/BaseColor
diagram
children pli:Hue pli:Saturation pli:Brightness pli:Transparency
annotation
documentation
This is the color used by Messenger to display its background. Can change depending on the user.

Not supported by every situation.

element ColorInfo/BaseColor/Hue
diagram
type extension of xs:double
properties
minOcc | 0
maxOcc | 1
default | 1
attributes
Name Type Use Default Fixed annotation
Combine derived by: xs:string optional percent
documentation
Percent: a value between 0 and 1 will decrease the amount (for example, 0.75 will make it 75% of its original value), a value above 1 will increase the amount. Power: the value can be negative or positive and is used to raise the original value with a power of the specified exponent.

attribute ColorInfo/BaseColor/Hue/@Combine
type restriction of xs:string
properties
default | percent
use | optional
facets
enumeration | percent
enumeration | power
annotation
documentation
Percent: a value between 0 and 1 will decrease the amount (for example, 0.75 will make it 75% of its original value), a value above 1 will increase the amount. Power: the value can be negative or positive and is used to raise the original value with a power of the specified exponent.

element ColorInfo/BaseColor/Saturation
diagram
type extension of xs:double
properties
minOcc | 0
maxOcc | 1
default | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Combine | derived by: xs:string | optional | percent |  |

attribute ColorInfo/BaseColor/Saturation/@Combine
type restriction of xs:string
properties
default | percent
use | optional
facets
enumeration | percent
enumeration | power

element ColorInfo/BaseColor/Brightness
diagram
type extension of xs:double
properties
minOcc | 0
maxOcc | 1
default | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Combine | derived by: xs:string | optional | percent |  |
annotation
documentation
Hue, Saturation and Brightness modify the existing HSB of the color (they don't replace them).

attribute ColorInfo/BaseColor/Brightness/@Combine
type restriction of xs:string
properties
default | percent
use | optional
facets
enumeration | percent
enumeration | power

element ColorInfo/BaseColor/Transparency
type restriction of xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 255
facets
minInclusive | 0
maxInclusive | 255
annotation
documentation
The transparency is directly applied to the color if specified.

complexType ComboBoxControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor pli:Images pli:Items
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true
annotation
documentation
Note: the height specified for the control is used to set the height of the dropdown list.

element ComboBoxControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:AcceptFiles pli:AllowEdit pli:AutoSort pli:OwnerDraw

element ComboBoxControl/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ComboBoxControl/Attributes/AllowEdit
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ComboBoxControl/Attributes/AutoSort
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Automatically sorts the items alphabetically. Only valid when no image is specified.

element ComboBoxControl/Attributes/OwnerDraw
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | None
facets
enumeration | None
enumeration | Fixed
enumeration | Variable

element ComboBoxControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element ComboBoxControl/Images
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Image
annotation
documentation
Every image needs to have the same size.

element ComboBoxControl/Images/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | unbounded
children | pli:Name pli:Format
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required |  |  |

attribute ComboBoxControl/Images/Image/@Id
type xs:string
properties
use required

element ComboBoxControl/Items
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Item
annotation
documentation
Items to be added at creation.

element ComboBoxControl/Items/Item
diagram
type extension of xs:string
properties
minOcc | 0
maxOcc | unbounded
attributes
Name Type Use Default Fixed annotation
Id xs:string optional
documentation
This id can used internally for some Messenger Plus! features such as skins.

attribute ComboBoxControl/Items/Item/@Id
type xs:string
properties
use optional
annotation
documentation
This id can used internally for some Messenger Plus! features such as skins.

complexType Control
diagram
properties
abstract true
children pli:Position pli:Help
used by
elements | Window/DialogTmpl/BottomBar/LeftControls/Control Window/DialogTmpl/BottomBar/RightControls/Control Window/Controls/Control
complexTypes | BrowserControl ButtonControl CheckBoxControl CodeEditControl ComboBoxControl DateTimeControl EditControl HotKeyControl LinkControl ListBoxControl ListViewControl MenuButtonControl ProgressControl RadioControl RichEditControl RichStaticControl ScrollBarControl SliderControl SpinControl StaticControl TreeViewControl
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

attribute Control/@Id
type restriction of xs:string
properties
use required
facets
minLength 1
annotation
documentation
No spaces allowed

attribute Control/@Enabled
type xs:boolean
properties
default | true
use | optional

attribute Control/@Visible
type xs:boolean
properties
default true

element Control/Position
diagram
children pli:Anchor pli:Units pli:TranslationAdjust pli:Origins
attributes
Name | Type | Use | Default | Fixed | annotation
Left | xs:int | required
Top | xs:int | required
Width | xs:unsignedInt | required
Height xs:unsignedInt optional
documentation
May not be needed depending on the control.

attribute Control/Position/@Left
type xs:int
properties
use required

attribute Control/Position/@Top
type xs:int
properties
use required

attribute Control/Position/@Width
type xs:unsignedInt
properties
use required

attribute Control/Position/@Height
type xs:unsignedInt
properties
use optional
annotation
documentation
May not be needed depending on the control.

element Control/Position/Anchor
diagram
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Horizontal | derived by: xs:string |  | LeftFixed |  |
Vertical | derived by: xs:string |  | TopFixed |  |
annotation
documentation
Changes the position/size of the control when the parent is resized.

attribute Control/Position/Anchor/@Horizontal
type restriction of xs:string
properties
default LeftFixed
facets
enumeration | LeftFixed
enumeration | RightFixed
enumeration | LeftRightFixed

attribute Control/Position/Anchor/@Vertical
type restriction of xs:string
properties
default TopFixed
facets
enumeration | TopFixed
enumeration | BottomFixed
enumeration | TopBottomFixed

element Control/Position/Units
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | AllDialog
facets
enumeration | AllDialog
enumeration | PosPixels
enumeration | SizePixels
enumeration | AllPixels
annotation
documentation
By default, all coordinates are in dialog units. This parameter changes the unit to pixels.

element Control/Position/TranslationAdjust
diagram
properties
minOcc | 0
maxOcc | 1
children pli:StaticCtrlIDLeft
annotation
documentation
Allows the control to change size dynamically depending on the size of the translated text.

element Control/Position/TranslationAdjust/StaticCtrlIDLeft
type xs:string
properties
minOcc | 0
maxOcc | 1
annotation
documentation
ID of the static control which width will be used to adjust the left position of this control.

element Control/Position/Origins
diagram
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Width | derived by: xs:string |  | Normal |  |
Height | derived by: xs:string |  | Normal |  |
annotation
documentation
Allows to specify a size that's relative to the opposite border of the window.

attribute Control/Position/Origins/@Width
type restriction of xs:string
properties
default Normal
facets
enumeration | Normal
enumeration | Reverse

attribute Control/Position/Origins/@Height
type restriction of xs:string
properties
default Normal
facets
enumeration | Normal
enumeration | Reverse

element Control/Help
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType DateTimeControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Format pli:BorderColor
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element DateTimeControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:AllowCalendar pli:ShowNone

element DateTimeControl/Attributes/AllowCalendar
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element DateTimeControl/Attributes/ShowNone
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Add a checkbox to disable the control.

element DateTimeControl/Format
diagram |
children | pli:Predefined pli:Custom

 element DateTimeControl/Format/Predefined
type restriction of xs:string
facets
enumeration | LongDate
enumeration | ShortDate
enumeration | Time
enumeration | DateTime

element DateTimeControl/Format/Custom
type restriction of xs:string
facets
minLength 1
annotation
documentation
See MSDN for more information.

element DateTimeControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

complexType EditControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor pli:DefaultText
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element EditControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Align pli:HasBorder pli:Multiline pli:VScroll pli:NumbersOnly pli:AcceptFiles pli:IsPassword pli:ReadOnly pli:WantReturn pli:HideSelection

element EditControl/Attributes/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right

element EditControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element EditControl/Attributes/Multiline
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element EditControl/Attributes/VScroll
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element EditControl/Attributes/NumbersOnly
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element EditControl/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element EditControl/Attributes/IsPassword
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element EditControl/Attributes/ReadOnly
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element EditControl/Attributes/WantReturn
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the edit box will process the Enter Key.

element EditControl/Attributes/HideSelection
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element EditControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element EditControl/DefaultText
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType Element
diagram
properties
abstract true
children pli:Position
used by
elements | RadioControl/CustomLook/Disabled/Checked/Element CheckBoxControl/CustomLook/Base/Element CheckBoxControl/CustomLook/Normal/Base/Element CheckBoxControl/CustomLook/Normal/Unchecked/Element CheckBoxControl/CustomLook/Normal/Checked/Element CheckBoxControl/CustomLook/Normal/ThirdChecked/Element CheckBoxControl/CustomLook/Hot/Base/Element CheckBoxControl/CustomLook/Hot/Unchecked/Element CheckBoxControl/CustomLook/Hot/Checked/Element CheckBoxControl/CustomLook/Hot/ThirdChecked/Element CheckBoxControl/CustomLook/Pushed/Base/Element CheckBoxControl/CustomLook/Pushed/Unchecked/Element CheckBoxControl/CustomLook/Pushed/Checked/Element CheckBoxControl/CustomLook/Pushed/ThirdChecked/Element CheckBoxControl/CustomLook/Disabled/Base/Element CheckBoxControl/CustomLook/Disabled/Unchecked/Element CheckBoxControl/CustomLook/Disabled/Checked/Element CheckBoxControl/CustomLook/Disabled/ThirdChecked/Element Window/Elements/Element ElementGroup/Elements/Element ButtonControl/CustomLook/Base/Element ButtonControl/CustomLook/Normal/Element ButtonControl/CustomLook/Hot/Element ButtonControl/CustomLook/Pushed/Element ButtonControl/CustomLook/Disabled/Element RadioControl/CustomLook/Base/Element RadioControl/CustomLook/Normal/Base/Element RadioControl/CustomLook/Normal/Unchecked/Element RadioControl/CustomLook/Normal/Checked/Element RadioControl/CustomLook/Hot/Base/Element RadioControl/CustomLook/Hot/Unchecked/Element RadioControl/CustomLook/Hot/Checked/Element RadioControl/CustomLook/Pushed/Base/Element RadioControl/CustomLook/Pushed/Unchecked/Element RadioControl/CustomLook/Pushed/Checked/Element RadioControl/CustomLook/Disabled/Base/Element RadioControl/CustomLook/Disabled/Unchecked/Element
complexTypes | ArrowElement FigureElement ImageElement LineElement PlaceHolderElement TextElement
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

attribute Element/@Id
type restriction of xs:string
properties
use required
facets
minLength 1
annotation
documentation
No spaces allowed

attribute Element/@Visible
type xs:boolean
properties
default true

element Element/Position
diagram
children pli:Anchor pli:Units
attributes
Name | Type | Use | Default | Fixed | annotation
Left | xs:int | required
Top | xs:int | required
Width | xs:unsignedInt | optional
Height xs:unsignedInt
documentation
May not be needed depending on the element.

attribute Element/Position/@Left
type xs:int
properties
use required

attribute Element/Position/@Top
type xs:int
properties
use required

attribute Element/Position/@Width
type xs:unsignedInt
properties
use optional

attribute Element/Position/@Height
type xs:unsignedInt
annotation
documentation
May not be needed depending on the element.

element Element/Position/Anchor
diagram
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Horizontal | derived by: xs:string |  | LeftFixed |  |
Vertical | derived by: xs:string |  | TopFixed |  |
annotation
documentation
Changes the position/size of the element when the parent is resized.

attribute Element/Position/Anchor/@Horizontal
type restriction of xs:string
properties
default LeftFixed
facets
enumeration | LeftFixed
enumeration | RightFixed
enumeration | LeftRightFixed

attribute Element/Position/Anchor/@Vertical
type restriction of xs:string
properties
default TopFixed
facets
enumeration | TopFixed
enumeration | BottomFixed
enumeration | TopBottomFixed

element Element/Position/Units
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
facets
enumeration | AllDialog
enumeration | PosPixels
enumeration | SizePixels
enumeration | AllPixels
annotation
documentation
By default, all coordinates are in dialog units. This parameter changes the unit to pixels.

complexType ElementGroup
diagram
children pli:Position pli:Transparency pli:Elements
used by
element Window/ElementGroups/ElementGroup
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

attribute ElementGroup/@Id
type restriction of xs:string
properties
use required
facets
minLength 1
annotation
documentation
No spaces allowed

attribute ElementGroup/@Visible
type xs:boolean
properties
default true

element ElementGroup/Position
diagram
children pli:Anchor pli:Units
attributes
Name | Type | Use | Default | Fixed | annotation
Left | xs:int | required |  |  |
Top | xs:int | required |  |  |
Width | xs:unsignedInt | required |  |  |
Height | xs:unsignedInt | required |  |  |

attribute ElementGroup/Position/@Left
type xs:int
properties
use required

attribute ElementGroup/Position/@Top
type xs:int
properties
use required

attribute ElementGroup/Position/@Width
type xs:unsignedInt
properties
use required

attribute ElementGroup/Position/@Height
type xs:unsignedInt
properties
use required

element ElementGroup/Position/Anchor
diagram
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Horizontal | derived by: xs:string |  | LeftFixed |  |
Vertical | derived by: xs:string |  | TopFixed |  |

attribute ElementGroup/Position/Anchor/@Horizontal
type restriction of xs:string
properties
default LeftFixed
facets
enumeration | LeftFixed
enumeration | RightFixed
enumeration | LeftRightFixed

attribute ElementGroup/Position/Anchor/@Vertical
type restriction of xs:string
properties
default TopFixed
facets
enumeration | TopFixed
enumeration | BottomFixed
enumeration | TopBottomFixed

element ElementGroup/Position/Units
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | AllDialog
facets
enumeration | AllDialog
enumeration | PosPixels
enumeration | SizePixels
enumeration | AllPixels

element ElementGroup/Transparency
diagram
properties
minOcc | 0
maxOcc | 1
children pli:General pli:FadeEffect pli:FadeDuration

element ElementGroup/Transparency/General
type restriction of xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 255
facets
minInclusive | 0
maxInclusive | 255
annotation
documentation
General transparency value applied on the whole group.

element ElementGroup/Transparency/FadeEffect
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | None
facets
enumeration | None
enumeration | Showing
enumeration | Hiding
enumeration | ShowingHiding

element ElementGroup/Transparency/FadeDuration
type restriction of xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 1000
facets
minInclusive 100
annotation
documentation
In milliseconds.

element ElementGroup/Elements
diagram |
children | pli:Element

 element ElementGroup/Elements/Element
diagram
type | pli:Element
properties
minOcc | 1
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

complexType FigureElement
diagram
type | extension of pli:Element
properties
base pli:Element
children | pli:Position pli:Figure pli:Border pli:Fill
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element FigureElement/Figure
diagram |
children | pli:Rectangle pli:RoundRect pli:Ellipse pli:Custom

 element FigureElement/Figure/Rectangle

element FigureElement/Figure/RoundRect
diagram |
children | pli:Radius

 element FigureElement/Figure/RoundRect/Radius
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 8

element FigureElement/Figure/Ellipse

element FigureElement/Figure/Custom
diagram |
children | pli:PathChunk

 element FigureElement/Figure/Custom/PathChunk
properties
minOcc | 1
maxOcc | unbounded

element FigureElement/Border
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Size pli:Color

element FigureElement/Border/Size
type restriction of xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 1
facets
minInclusive 1

element FigureElement/Border/Color
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element FigureElement/Fill
diagram
properties
minOcc | 0
maxOcc | 1
children pli:PlainColor pli:LinearGradient pli:PathGradient pli:Image

element FigureElement/Fill/PlainColor
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element FigureElement/Fill/LinearGradient
diagram
children pli:Color1 pli:Color2
attributes
Name Type Use Default Fixed annotation
Angle derived by: xs:int 0
documentation
Limited to horizontal, vertical and diagonal.

attribute FigureElement/Fill/LinearGradient/@Angle
type restriction of xs:int
properties
default 0
facets
minInclusive | -90
maxInclusive | 90
enumeration | -90
enumeration | -45
enumeration | 0
enumeration | 45
enumeration | 90
annotation
documentation
Limited to horizontal, vertical and diagonal.

element FigureElement/Fill/LinearGradient/Color1
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element FigureElement/Fill/LinearGradient/Color2
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element FigureElement/Fill/PathGradient
diagram |
children | pli:CenterColor pli:SurroundColor pli:CenterPoint pli:FocusScale

 element FigureElement/Fill/PathGradient/CenterColor
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element FigureElement/Fill/PathGradient/SurroundColor
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element FigureElement/Fill/PathGradient/CenterPoint
diagram
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
x | xs:int |  |  |  |
y | xs:int |  |  |  |

attribute FigureElement/Fill/PathGradient/CenterPoint/@x
type xs:int

attribute FigureElement/Fill/PathGradient/CenterPoint/@y
type xs:int

element FigureElement/Fill/PathGradient/FocusScale
diagram
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
x | derived by: xs:float |  |  |  |
y | derived by: xs:float |  |  |  |

attribute FigureElement/Fill/PathGradient/FocusScale/@x
type restriction of xs:float
facets
minInclusive | 0
maxInclusive | 1

attribute FigureElement/Fill/PathGradient/FocusScale/@y
type restriction of xs:float
facets
minInclusive | 0
maxInclusive | 1

element FigureElement/Fill/Image
diagram
type | extension of pli:Image
children | pli:Name pli:Format
attributes
Name | Type | Use | Default | Fixed | annotation
MarginX | xs:int |  |  |  |
MarginY | xs:int |  |  |  |

attribute FigureElement/Fill/Image/@MarginX
type xs:int

attribute FigureElement/Fill/Image/@MarginY
type xs:int

complexType GlobalColor
diagram
type | extension of pli:ColorInfo
properties
base pli:ColorInfo
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor
used by
element Interfaces/GlobalColors/GlobalColor
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required |  |  |

attribute GlobalColor/@Id
type xs:string
properties
use required

complexType HotKeyControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element HotKeyControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:HasBorder

element HotKeyControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element HotKeyControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

complexType Image
diagram
children pli:Name pli:Format
used by
elements ListViewControl/Images/LargeIcons/Image ListViewControl/Images/SmallIcons/Image ListViewControl/Images/StateIcons/Image TreeViewControl/Images/NormalIcons/Image TreeViewControl/Images/StateIcons/Image ComboBoxControl/Images/Image ButtonControl/Image MenuButtonControl/Image ImageElement/Image FigureElement/Fill/Image

element Image/Name
type restriction of xs:string
facets
minLength 1
annotation
documentation
This name represents either a resource or a file name without extension.

element Image/Format
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | PNG
facets
enumeration | PNG
enumeration | JPEG

complexType ImageElement
diagram
type | extension of pli:Element
properties
base pli:Element
children | pli:Position pli:Attributes pli:Image pli:Mosaic pli:Colorization pli:Transparency
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true
annotation
documentation
If a width and a height are specified, they act as clipping areas.

element ImageElement/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:AllowAutoMirror

element ImageElement/Attributes/AllowAutoMirror
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
If true, the image will automatically be mirrored (inversed on the X axis) if the parent window is right-to-left.

element ImageElement/Image
diagram
type | pli:Image
properties
minOcc | 0
maxOcc | 1
children | pli:Name pli:Format
annotation
documentation
The object is valid even without a defined image as the program can assign one itself.

element ImageElement/Mosaic
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Normal
facets
enumeration | Normal
enumeration | ResizeToFit
enumeration | HRepeat
enumeration | VRepeat
enumeration | HVRepeat
enumeration | CenterResize
annotation
documentation
To use this property, add a Width and a Height

element ImageElement/Colorization
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Color
attributes
Name | Type | Use | Default | Fixed | annotation
Enable | xs:boolean | required |  |  |
annotation
documentation
When this is enabled, the picture is converted to grayscale then colorized with the specified color.

attribute ImageElement/Colorization/@Enable
type xs:boolean
properties
use required

element ImageElement/Colorization/Color
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 element ImageElement/Transparency
type restriction of xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 255
facets
minInclusive | 0
maxInclusive | 255

complexType LineChunk
diagram
type | extension of pli:PathChunk
properties
base pli:PathChunk
children | pli:X1 pli:Y1 pli:X2 pli:Y2

element LineChunk/X1
type xs:int

element LineChunk/Y1
type xs:int

element LineChunk/X2
type xs:int

element LineChunk/Y2
type xs:int

complexType LineElement
diagram
type | extension of pli:Element
properties
base pli:Element
children | pli:Position pli:Attributes pli:Size pli:Color
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element LineElement/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:AntiAlias pli:StartCap pli:EndCap

element LineElement/Attributes/AntiAlias
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element LineElement/Attributes/StartCap
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Square
facets
enumeration | Flat
enumeration | Square
enumeration | Round
enumeration | Triangle

element LineElement/Attributes/EndCap
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Square
facets
enumeration | Flat
enumeration | Square
enumeration | Round
enumeration | Triangle

element LineElement/Size
type restriction of xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 1
facets
minInclusive 1

element LineElement/Color
diagram |
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

 complexType LinkControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:TextColor pli:HotTextColor pli:Caption
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element LinkControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Align pli:Underline

element LinkControl/Attributes/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right

element LinkControl/Attributes/Underline
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Always
facets
enumeration | Never
enumeration | WhenHot
enumeration | Always

element LinkControl/TextColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element LinkControl/HotTextColor
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element LinkControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType ListBoxControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor pli:Items
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element ListBoxControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:HasBorder pli:AcceptFiles pli:MultipleSel pli:ReadOnly pli:AutoSort pli:OwnerDraw

element ListBoxControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListBoxControl/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListBoxControl/Attributes/MultipleSel
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListBoxControl/Attributes/ReadOnly
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Prevents the user to select the list box's items.

element ListBoxControl/Attributes/AutoSort
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Automatically sorts the items alphabetically.

element ListBoxControl/Attributes/OwnerDraw
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | None
facets
enumeration | None
enumeration | Fixed
enumeration | Variable

element ListBoxControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element ListBoxControl/Items
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Item
annotation
documentation
Items to be added at creation.

element ListBoxControl/Items/Item
diagram
type extension of xs:string
properties
minOcc | 0
maxOcc | unbounded
attributes
Name Type Use Default Fixed annotation
Id xs:string optional
documentation
This id can used internally for some Messenger Plus! features such as skins.

attribute ListBoxControl/Items/Item/@Id
type xs:string
properties
use optional
annotation
documentation
This id can used internally for some Messenger Plus! features such as skins.

complexType ListViewControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:LargeIconView pli:SmallIconView pli:ListView pli:ReportView pli:TileView pli:BorderColor pli:Images pli:Columns pli:Groups
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element ListViewControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:HasBorder pli:AcceptFiles pli:AlwaysShowSelection pli:AutoSort pli:AllowEditText pli:MultipleSel pli:AutoTip pli:HotTrack

element ListViewControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListViewControl/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/Attributes/AlwaysShowSelection
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListViewControl/Attributes/AutoSort
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | NoAutoSort
facets
enumeration | NoAutoSort
enumeration | Ascending
enumeration | Descending

element ListViewControl/Attributes/AllowEditText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/Attributes/MultipleSel
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/Attributes/AutoTip
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Automatically display a tooltip for labels that are too large.

element ListViewControl/Attributes/HotTrack
diagram
type extension of xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
attributes
Name | Type | Use | Default | Fixed | annotation
UnderlineMode | derived by: xs:string |  | Cold |  |
annotation
documentation
Display labels like links.

attribute ListViewControl/Attributes/HotTrack/@UnderlineMode
type restriction of xs:string
properties
default Cold
facets
enumeration | Cold
enumeration | Hot

element ListViewControl/LargeIconView
diagram |
children | pli:ItemsAlign pli:WrapText pli:HasCheckboxes

 element ListViewControl/LargeIconView/ItemsAlign
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Top
facets
enumeration | Left
enumeration | Top

element ListViewControl/LargeIconView/WrapText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListViewControl/LargeIconView/HasCheckboxes
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/SmallIconView
diagram |
children | pli:ItemsAlign pli:WrapText pli:HasCheckboxes

 element ListViewControl/SmallIconView/ItemsAlign
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Top
facets
enumeration | Left
enumeration | Top

element ListViewControl/SmallIconView/WrapText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListViewControl/SmallIconView/HasCheckboxes
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/ListView
diagram |
children | pli:HasCheckboxes

 element ListViewControl/ListView/HasCheckboxes
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/ReportView
diagram |
children | pli:ColumnHeader pli:SortColHeader pli:HeaderDragDrop pli:HasCheckboxes pli:FullRowSelect pli:ShowGridLines

 element ListViewControl/ReportView/ColumnHeader
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListViewControl/ReportView/SortColHeader
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/ReportView/HeaderDragDrop
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Allow to move the columns with drag and drop.

element ListViewControl/ReportView/HasCheckboxes
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/ReportView/FullRowSelect
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element ListViewControl/ReportView/ShowGridLines
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/TileView

element ListViewControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element ListViewControl/Images
diagram
properties
minOcc | 0
maxOcc | 1
children pli:LargeIcons pli:SmallIcons pli:StateIcons
annotation
documentation
The images here must be 32bits. Each list of image needs to have images of the same size.

element ListViewControl/Images/LargeIcons
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Image

element ListViewControl/Images/LargeIcons/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | unbounded
children | pli:Name pli:Format pli:AllowAutoMirror
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required
IsOverlay xs:boolean false
documentation
An overlay is an icon displayed transparently on top of another one.

attribute ListViewControl/Images/LargeIcons/Image/@Id
type xs:string
properties
use required

attribute ListViewControl/Images/LargeIcons/Image/@IsOverlay
type xs:boolean
properties
default false
annotation
documentation
An overlay is an icon displayed transparently on top of another one.

element ListViewControl/Images/LargeIcons/Image/AllowAutoMirror
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the image will automatically be mirrored (inversed on the X axis) if the parent window is right-to-left.

element ListViewControl/Images/SmallIcons
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Image

element ListViewControl/Images/SmallIcons/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | unbounded
children | pli:Name pli:Format pli:AllowAutoMirror
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required
IsOverlay xs:boolean false
documentation
An overlay is an icon displayed transparently on top of another one.

attribute ListViewControl/Images/SmallIcons/Image/@Id
type xs:string
properties
use required

attribute ListViewControl/Images/SmallIcons/Image/@IsOverlay
type xs:boolean
properties
default false
annotation
documentation
An overlay is an icon displayed transparently on top of another one.

element ListViewControl/Images/SmallIcons/Image/AllowAutoMirror
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/Images/StateIcons
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Image
annotation
documentation
A state icon is displayed next to another one.

element ListViewControl/Images/StateIcons/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | unbounded
children | pli:Name pli:Format pli:AllowAutoMirror
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required |  |  |

attribute ListViewControl/Images/StateIcons/Image/@Id
type xs:string
properties
use required

element ListViewControl/Images/StateIcons/Image/AllowAutoMirror
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element ListViewControl/Columns
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Column
attributes
Name Type Use Default Fixed annotation
WidthFormat derived by: xs:string Relative
documentation
Specifies if the width of the columns is in percentage of the list's width or in pixels.

attribute ListViewControl/Columns/@WidthFormat
type restriction of xs:string
properties
default Relative
facets
enumeration | Relative
enumeration | Absolute
annotation
documentation
Specifies if the width of the columns is in percentage of the list's width or in pixels.

element ListViewControl/Columns/Column
diagram
properties
minOcc | 1
maxOcc | unbounded
children pli:ColumnId pli:Align pli:Label pli:HeaderImage pli:Width

element ListViewControl/Columns/Column/ColumnId
type restriction of xs:string
facets
minLength 1
annotation
documentation
Uniquely identifies the column internally.

element ListViewControl/Columns/Column/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Left
facets
enumeration | Left
enumeration | Center
enumeration | Right
annotation
documentation
The first column must be left aligned.

element ListViewControl/Columns/Column/Label
type extension of xs:string
properties
minOcc | 0
maxOcc | 1

element ListViewControl/Columns/Column/HeaderImage
diagram
type extension of xs:string
properties
minOcc | 0
maxOcc | 1
attributes
Name | Type | Use | Default | Fixed | annotation
Align | derived by: xs:string |  | Left |  |
annotation
documentation
The value of this element must be an image name from the SmallIcons list.

attribute ListViewControl/Columns/Column/HeaderImage/@Align
type restriction of xs:string
properties
default Left
facets
enumeration | Left
enumeration | Right

element ListViewControl/Columns/Column/Width
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
annotation
documentation
This parameter is optional only when only 1 column is present (relative width) or for the last column of the list (absolute width).

element ListViewControl/Groups
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Group

element ListViewControl/Groups/Group
diagram
properties
minOcc | 0
maxOcc | unbounded
children pli:GroupId pli:Align pli:Label

element ListViewControl/Groups/Group/GroupId
type restriction of xs:string
facets
minLength 1

element ListViewControl/Groups/Group/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Left
facets
enumeration | Left
enumeration | Center
enumeration | Right

element ListViewControl/Groups/Group/Label
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType Menu
diagram
children pli:MenuEntry pli:SubMenu pli:Separator
used by
elements MenuButtonControl/Menu Menu/SubMenu
attributes
Name Type Use Default Fixed annotation
Id derived by: xs:string required
documentation
No spaces allowed

attribute Menu/@Id
type restriction of xs:string
properties
use required
facets
minLength 1
annotation
documentation
No spaces allowed

element Menu/MenuEntry
diagram
type extension of xs:string
attributes
Name | Type | Use | Default | Fixed | annotation
Id | derived by: xs:string | required |  |  |

attribute Menu/MenuEntry/@Id
type restriction of xs:string
properties
use required
facets
minLength 1

element Menu/SubMenu
diagram
type | extension of pli:Menu
children | pli:MenuEntry pli:SubMenu pli:Separator
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Label | xs:string

attribute Menu/SubMenu/@Label
type xs:string

element Menu/Separator

complexType MenuButtonControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Menu pli:Image pli:TextColor pli:Caption
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element MenuButtonControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:AlwaysDisplayBorder pli:AdjustArrowPos pli:DwmAnimations

element MenuButtonControl/Attributes/AlwaysDisplayBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element MenuButtonControl/Attributes/AdjustArrowPos
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element MenuButtonControl/Attributes/DwmAnimations
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Default
facets
enumeration | Default
enumeration | Allow
enumeration | Disallow
annotation
documentation
Specifies if transition animations are allowed for this control in Windows Vista and above.

element MenuButtonControl/Menu
diagram
type | extension of pli:Menu
properties
minOcc | 0
maxOcc | 1
children | pli:MenuEntry pli:SubMenu pli:Separator
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
HPos | derived by: xs:string | CenterLeft
VPos | derived by: xs:string | Top

attribute MenuButtonControl/Menu/@HPos
type restriction of xs:string
properties
default CenterLeft
facets
enumeration | Left
enumeration | CenterLeft
enumeration | CenterRight
enumeration | Right

attribute MenuButtonControl/Menu/@VPos
type restriction of xs:string
properties
default Top
facets
enumeration | Top
enumeration | Bottom

element MenuButtonControl/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | 1
children | pli:Name pli:Format
attributes
Name | Type | Use | Default | Fixed | annotation
Margin | xs:int |  | 2 |  |

attribute MenuButtonControl/Image/@Margin
type xs:int
properties
default 2

element MenuButtonControl/TextColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element MenuButtonControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType PathChunk
properties
abstract true
used by
complexTypes ArcChunk BezierChunk LineChunk
annotation
documentation
This element is used to defined paths.

complexType PlaceHolderElement
diagram
type | extension of pli:Element
properties
base pli:Element
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true
annotation
documentation
This element does not display anything.

complexType ProgressControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Range pli:Marquee
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element ProgressControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Orientation

element ProgressControl/Attributes/Orientation
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Horizontal
facets
enumeration | Horizontal
enumeration | Vertical
annotation
documentation
If Vertical, the Width and Height are inversed.

element ProgressControl/Range
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Minimum pli:Maximum
annotation
documentation
Creates a real progress bar with a defined range. This is the default.

element ProgressControl/Range/Minimum
type xs:int
properties
default 0

element ProgressControl/Range/Maximum
type xs:int
properties
default 100

element ProgressControl/Marquee
properties
minOcc | 0
maxOcc | 1
annotation
documentation
Creates a progress bar with a marker that moves automatically.

complexType RadioControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Font pli:TextColor pli:Caption pli:CustomLook
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element RadioControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:IsNewGroup pli:DwmAnimations

element RadioControl/Attributes/IsNewGroup
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Set to true for the first radio in a group.

element RadioControl/Attributes/DwmAnimations
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Default
facets
enumeration | Default
enumeration | Allow
enumeration | Disallow
annotation
documentation
Specifies if transition animations are allowed for this control in Windows Vista and above.

element RadioControl/Font
diagram
properties
minOcc | 0
maxOcc | 1
children pli:FaceName pli:Bold pli:Italic pli:Underlined pli:Strikeout pli:Size
annotation
documentation
Changes various settings of the default font.

element RadioControl/Font/FaceName
type xs:string
properties
minOcc | 0
maxOcc | 1

element RadioControl/Font/Bold
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RadioControl/Font/Italic
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RadioControl/Font/Underlined
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RadioControl/Font/Strikeout
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RadioControl/Font/Size
type xs:double
properties
minOcc | 0
maxOcc | 1
default | 8
annotation
documentation
The size is in points.

element RadioControl/TextColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
annotation
documentation
Alpha not supported.

element RadioControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

element RadioControl/CustomLook
diagram
children pli:FocusRect pli:Base pli:Normal pli:Hot pli:Pushed pli:Disabled
annotation
documentation
When using custom look, the control cannot be resized.

element RadioControl/CustomLook/FocusRect
diagram
children pli:Left pli:Top pli:Right pli:Bottom
annotation
documentation
Margins used to compute the position of the focus rectangle based on the position of the control.

element RadioControl/CustomLook/FocusRect/Left
type xs:int

element RadioControl/CustomLook/FocusRect/Top
type xs:int

element RadioControl/CustomLook/FocusRect/Right
type xs:int

element RadioControl/CustomLook/FocusRect/Bottom
type xs:int

element RadioControl/CustomLook/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Base elements are displayed for every state.

element RadioControl/CustomLook/Base/Element
diagram
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Normal
diagram |
children | pli:Base pli:Unchecked pli:Checked

 element RadioControl/CustomLook/Normal/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element RadioControl/CustomLook/Normal/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Normal/Unchecked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Normal/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Normal/Checked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Normal/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Hot
diagram |
children | pli:Base pli:Unchecked pli:Checked

 element RadioControl/CustomLook/Hot/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element RadioControl/CustomLook/Hot/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Hot/Unchecked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Hot/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Hot/Checked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Hot/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Pushed
diagram |
children | pli:Base pli:Unchecked pli:Checked

 element RadioControl/CustomLook/Pushed/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element RadioControl/CustomLook/Pushed/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Pushed/Unchecked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Pushed/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Pushed/Checked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Pushed/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Disabled
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Base pli:Unchecked pli:Checked

element RadioControl/CustomLook/Disabled/Base
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element
annotation
documentation
Displayed for checked and unchecked.

element RadioControl/CustomLook/Disabled/Base/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Disabled/Unchecked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Disabled/Unchecked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element RadioControl/CustomLook/Disabled/Checked
diagram |
children | pli:Element

 element RadioControl/CustomLook/Disabled/Checked/Element
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

complexType RichEditControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor pli:BackgroundColor pli:DefaultText
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element RichEditControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Align pli:HasBorder pli:Multiline pli:NumbersOnly pli:AcceptFiles pli:IsPassword pli:ReadOnly pli:WantReturn pli:HideSelection pli:HorizontalScroll pli:AlwaysShowScrollBars pli:TextMode pli:LeftIdent pli:AllowRTL

element RichEditControl/Attributes/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right

element RichEditControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element RichEditControl/Attributes/Multiline
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element RichEditControl/Attributes/NumbersOnly
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element RichEditControl/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element RichEditControl/Attributes/IsPassword
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element RichEditControl/Attributes/ReadOnly
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element RichEditControl/Attributes/WantReturn
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the edit box will process the Enter Key.

element RichEditControl/Attributes/HideSelection
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element RichEditControl/Attributes/HorizontalScroll
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If false, the text wraps automatically.

element RichEditControl/Attributes/AlwaysShowScrollBars
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element RichEditControl/Attributes/TextMode
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Plain Text
facets
enumeration | Plain Text
enumeration | Rich Text

element RichEditControl/Attributes/LeftIdent
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 4
annotation
documentation
Left margin indentation for the whole control, in pixels.

element RichEditControl/Attributes/AllowRTL
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
If false, the control will not be right-to-left in a right-to-left window.

element RichEditControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element RichEditControl/BackgroundColor
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element RichEditControl/DefaultText
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType RichStaticControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Color pli:BackgroundColor pli:Font pli:Caption
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true
annotation
documentation
This is a static control displaying the content of a windowless rich edit control.

element RichStaticControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Align pli:TrimText pli:WrapText

element RichStaticControl/Attributes/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right

element RichStaticControl/Attributes/TrimText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Controls how to display the end of a string that does not fit in the given coordinates.

element RichStaticControl/Attributes/WrapText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If WrapText is enabled, trimming is disabled.

element RichStaticControl/Color
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
annotation
documentation
Transparency is not supported.

element RichStaticControl/BackgroundColor
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element RichStaticControl/Font
diagram
properties
minOcc | 0
maxOcc | 1
children pli:FaceName pli:Bold pli:Italic pli:Underlined pli:Strikeout

element RichStaticControl/Font/FaceName
type xs:string
properties
minOcc | 0
maxOcc | 1

element RichStaticControl/Font/Bold
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RichStaticControl/Font/Italic
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RichStaticControl/Font/Underlined
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RichStaticControl/Font/Strikeout
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element RichStaticControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType ScrollBarControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:VerticalBar pli:HorizontalBar
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element ScrollBarControl/VerticalBar
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
Align | derived by: xs:string | optional | Right |  |

attribute ScrollBarControl/VerticalBar/@Align
type restriction of xs:string
properties
default | Right
use | optional
facets
enumeration | Left
enumeration | Right

element ScrollBarControl/HorizontalBar
diagram
attributes
Name | Type | Use | Default | Fixed | annotation
Align | derived by: xs:string | optional | Bottom |  |

attribute ScrollBarControl/HorizontalBar/@Align
type restriction of xs:string
properties
default | Bottom
use | optional
facets
enumeration | Top
enumeration | Bottom

complexType SliderControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Range
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element SliderControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Orientation pli:TickMarks pli:AutoTicks pli:EnableSelRange

element SliderControl/Attributes/Orientation
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Horizontal
facets
enumeration | Horizontal
enumeration | Vertical
annotation
documentation
If Vertical, the Width and Height are inversed.

element SliderControl/Attributes/TickMarks
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Bottom
facets
enumeration | None
enumeration | Top
enumeration | Bottom

element SliderControl/Attributes/AutoTicks
type restriction of xs:unsignedByte
properties
minOcc | 0
maxOcc | 1
default | 25
facets
minInclusive | 0
maxInclusive | 100
annotation
documentation
This is a percentage of the total range. Set to 0 to disable auto ticks.

element SliderControl/Attributes/EnableSelRange
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element SliderControl/Range
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Minimum pli:Maximum

element SliderControl/Range/Minimum
type xs:int
properties
default 0

element SliderControl/Range/Maximum
type xs:int
properties
default 100

complexType SpinControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Range
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element SpinControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Orientation pli:AllowWrap

element SpinControl/Attributes/Orientation
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Horizontal
facets
enumeration | Horizontal
enumeration | Vertical

element SpinControl/Attributes/AllowWrap
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Automaticaly wrap from the maximum to the minimum value when reached.

element SpinControl/Range
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Minimum pli:Maximum

element SpinControl/Range/Minimum
type xs:int

element SpinControl/Range/Maximum
type xs:int

complexType StaticControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:Color pli:Transparency pli:BackgroundColor pli:Font pli:Caption
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element StaticControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Align pli:AlignRTL pli:VAlign pli:Trimming pli:WrapText pli:AutoAdjustWidth

element StaticControl/Attributes/Align
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right

element StaticControl/Attributes/AlignRTL
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right
annotation
documentation
If specified, the control will be aligned with this setting instead if the window is right-to-left.

element StaticControl/Attributes/VAlign
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | top
facets
enumeration | top
enumeration | center
enumeration | bottom

element StaticControl/Attributes/Trimming
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | EllipsisChar
facets
enumeration | Character
enumeration | Word
enumeration | EllipsisChar
enumeration | EllipsisWord
enumeration | EllipsisPath
annotation
documentation
Controls how to display the end of a string that does not fit in the given coordinates.

element StaticControl/Attributes/WrapText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element StaticControl/Attributes/AutoAdjustWidth
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
The width of the control will be reduced if necessary so that the caption fits exactly.

element StaticControl/Color
diagram
type | pli:Color
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
annotation
documentation
If this element is not present, the default color will be used.

element StaticControl/Transparency
type restriction of xs:unsignedInt
properties
default 255
facets
minInclusive | 0
maxInclusive | 255
annotation
documentation
Changes the Alpha value of the default color.

element StaticControl/BackgroundColor
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor
annotation
documentation
This element is required if using a transparent text color.

element StaticControl/Font
diagram
properties
minOcc | 0
maxOcc | 1
children pli:FaceName pli:Bold pli:Italic pli:Underlined pli:Strikeout pli:Size
annotation
documentation
Changes various settings of the default font.

element StaticControl/Font/FaceName
type xs:string
properties
minOcc | 0
maxOcc | 1

element StaticControl/Font/Bold
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element StaticControl/Font/Italic
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element StaticControl/Font/Underlined
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element StaticControl/Font/Strikeout
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element StaticControl/Font/Size
type xs:double
properties
minOcc | 0
maxOcc | 1
default | 8
annotation
documentation
The size is in points.

element StaticControl/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1

complexType TextElement
diagram
type | extension of pli:Element
properties
base pli:Element
children | pli:Position pli:Attributes pli:Align pli:Color pli:Font pli:Text
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true
TranslationId

attribute TextElement/@TranslationId

element TextElement/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:ProcessHotkey pli:WrapText pli:Trimming

element TextElement/Attributes/ProcessHotkey
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Ampersand characters are used to possibily indicate text shortcuts.

element TextElement/Attributes/WrapText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element TextElement/Attributes/Trimming
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | EllipsisChar
facets
enumeration | Character
enumeration | Word
enumeration | EllipsisChar
enumeration | EllipsisWord
enumeration | EllipsisPath
annotation
documentation
Controls how to display the end of a string that does not fit in the given coordinates.

element TextElement/Align
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Horizontal pli:Vertical
annotation
documentation
A width or height must be specified for this parameter to have a meaning.

element TextElement/Align/Horizontal
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | left
facets
enumeration | left
enumeration | center
enumeration | right

element TextElement/Align/Vertical
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
facets
enumeration | top
enumeration | center
enumeration | bottom
annotation
documentation
Only valid when WrapText is false.

element TextElement/Color
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element TextElement/Font
diagram
properties
minOcc | 0
maxOcc | 1
children pli:FaceName pli:Bold pli:Italic pli:Underlined pli:Strikeout pli:Size
annotation
documentation
Changes various settings of the default font.

element TextElement/Font/FaceName
type xs:string
properties
minOcc | 0
maxOcc | 1

element TextElement/Font/Bold
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element TextElement/Font/Italic
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element TextElement/Font/Underlined
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element TextElement/Font/Strikeout
type xs:boolean
properties
minOcc | 0
maxOcc | 1

element TextElement/Font/Size
type xs:double
properties
minOcc | 0
maxOcc | 1
default | 8
annotation
documentation
The size is in points.

element TextElement/Text
properties
minOcc | 0
maxOcc | 1

complexType TreeViewControl
diagram
type | extension of pli:Control
properties
base pli:Control
children | pli:Position pli:Help pli:Attributes pli:BorderColor pli:Images
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element TreeViewControl/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:HasBorder pli:AcceptFiles pli:AlwaysShowSelection pli:AllowEditText pli:HotTrack pli:SingleExpand pli:HasButtons pli:HasLines pli:HasCheckboxes

element TreeViewControl/Attributes/HasBorder
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element TreeViewControl/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element TreeViewControl/Attributes/AlwaysShowSelection
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element TreeViewControl/Attributes/AllowEditText
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element TreeViewControl/Attributes/HotTrack
type extension of xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
Display labels like links.

element TreeViewControl/Attributes/SingleExpand
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element TreeViewControl/Attributes/HasButtons
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element TreeViewControl/Attributes/HasLines
diagram
type extension of xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
attributes
Name | Type | Use | Default | Fixed | annotation
LineAtRoot | xs:boolean |  | true |  |

attribute TreeViewControl/Attributes/HasLines/@LineAtRoot
type xs:boolean
properties
default true

element TreeViewControl/Attributes/HasCheckboxes
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element TreeViewControl/BorderColor
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element TreeViewControl/Images
diagram
properties
minOcc | 0
maxOcc | 1
children pli:NormalIcons pli:StateIcons
annotation
documentation
The images here must be 32bits. Each list of image needs to have images of the same size.

element TreeViewControl/Images/NormalIcons
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Image

element TreeViewControl/Images/NormalIcons/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | unbounded
children | pli:Name pli:Format
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required
IsOverlay xs:boolean false
documentation
An overlay is an icon displayed transparently on top of another one.

attribute TreeViewControl/Images/NormalIcons/Image/@Id
type xs:string
properties
use required

attribute TreeViewControl/Images/NormalIcons/Image/@IsOverlay
type xs:boolean
properties
default false
annotation
documentation
An overlay is an icon displayed transparently on top of another one.

element TreeViewControl/Images/StateIcons
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Image
annotation
documentation
A state icon is displayed next to another one.

element TreeViewControl/Images/StateIcons/Image
diagram
type | extension of pli:Image
properties
minOcc | 0
maxOcc | unbounded
children | pli:Name pli:Format
attributes
Name | Type | Use | Default | Fixed | annotation
Id | xs:string | required |  |  |

attribute TreeViewControl/Images/StateIcons/Image/@Id
type xs:string
properties
use required

complexType Window
diagram
children pli:Attributes pli:TitleBar pli:Position pli:DialogTmpl pli:WindowTmpl pli:ChildTmpl pli:Elements pli:ElementGroups pli:Controls
used by
element Interfaces/Window
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed. For scripts windows, punctuation is replaced by underscores.
Version xs:unsignedInt required
documentation
Used by the program to know is a custom interface is up to date.
TranslationSection xs:string
documentation
Use to override the name of the section where the translation for this window will be read.
Description | xs:string

attribute Window/@Id
type restriction of xs:string
properties
use required
facets
minLength 1
annotation
documentation
No spaces allowed. For scripts windows, punctuation is replaced by underscores.

attribute Window/@Version
type xs:unsignedInt
properties
use required
annotation
documentation
Used by the program to know is a custom interface is up to date.

attribute Window/@TranslationSection
type xs:string
annotation
documentation
Use to override the name of the section where the translation for this window will be read.

attribute Window/@Description
type xs:string

element Window/Attributes
diagram
properties
minOcc | 0
maxOcc | 1
children pli:TopMost pli:AcceptFiles pli:NoActivate pli:ShowInTaskbar pli:SetForeground pli:Caption pli:LockOnClick

element Window/Attributes/TopMost
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element Window/Attributes/AcceptFiles
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the window accepts drag and drops.

element Window/Attributes/NoActivate
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
If true, the window does not activate when selected.

element Window/Attributes/ShowInTaskbar
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element Window/Attributes/SetForeground
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element Window/Attributes/Caption
type xs:string
properties
minOcc | 0
maxOcc | 1
annotation
documentation
The Caption of the window is the name displayed by Windows is various places like the taskbar.

element Window/Attributes/LockOnClick
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true
annotation
documentation
Set to true to allow the user to move the window by clicking anywhere in it.

element Window/TitleBar
diagram
properties
minOcc | 0
maxOcc | 1
children pli:AllowMinimize pli:AllowMaximize pli:AllowClose pli:DisableOnDeactivate pli:DefaultBackground pli:Title

element Window/TitleBar/AllowMinimize
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element Window/TitleBar/AllowMaximize
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false

element Window/TitleBar/AllowClose
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element Window/TitleBar/DisableOnDeactivate
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element Window/TitleBar/DefaultBackground
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | true

element Window/TitleBar/Title
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Prefix pli:Text
attributes
Name | Type | Use | Default | Fixed | annotation
TopMargin | xs:int |  | 0 |  |

attribute Window/TitleBar/Title/@TopMargin
type xs:int
properties
default 0

element Window/TitleBar/Title/Prefix
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Full
facets
enumeration | Image
enumeration | Software
enumeration | Full
enumeration | None
enumeration | Neutral

element Window/TitleBar/Title/Text
type xs:string
properties
minOcc | 0
maxOcc | 1

element Window/Position
diagram
children pli:Resizeable pli:IsAbsolute
attributes
Name | Type | Use | Default | Fixed | annotation
Width | xs:unsignedInt | optional |  |  |
Height | xs:unsignedInt | optional |  |  |
ClientWidth | xs:unsignedInt | optional |  |  |
ClientHeight | xs:unsignedInt | optional |  |  |
InitialPos | derived by: xs:string | optional | CenteredParent |  |

attribute Window/Position/@InitialPos
type restriction of xs:string
properties
default | CenteredParent
use | optional
facets
enumeration | Normal
enumeration | CenteredParent
enumeration | CenteredScreen
enumeration | Minimised
enumeration | Maximised
enumeration | Random

element Window/Position/Resizeable
diagram
properties
minOcc | 0
maxOcc | 1
children pli:MinWidth pli:MinHeight
attributes
Name | Type | Use | Default | Fixed | annotation
Allowed | derived by: xs:string | required |  |  |

attribute Window/Position/Resizeable/@Allowed
type restriction of xs:string
properties
use required
facets
enumeration | NotResizeable
enumeration | Horizontal
enumeration | Vertical
enumeration | BothSides

element Window/Position/Resizeable/MinWidth
type restriction of xs:unsignedInt
facets
minExclusive 0

element Window/Position/Resizeable/MinHeight
type restriction of xs:unsignedInt
facets
minExclusive 0

element Window/Position/IsAbsolute
type xs:boolean
properties
minOcc | 0
maxOcc | 1
default | false
annotation
documentation
By default, coordinates are in dialog units. This parameter changes the unit to pixels.

element Window/DialogTmpl
diagram |
children | pli:BkgBrightness pli:BottomBar

 element Window/DialogTmpl/BkgBrightness
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Default
facets
enumeration | Default
enumeration | Light

element Window/DialogTmpl/BottomBar
diagram
properties
minOcc | 0
maxOcc | 1
children pli:LeftControls pli:RightControls
attributes
Name Type Use Default Fixed annotation
Style derived by: xs:string required
documentation
Changes the look of the bottom bar.

attribute Window/DialogTmpl/BottomBar/@Style
type restriction of xs:string
properties
use required
facets
enumeration | None
enumeration | Plain
enumeration | Light
enumeration | Default
annotation
documentation
Changes the look of the bottom bar.

element Window/DialogTmpl/BottomBar/LeftControls
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Margin pli:Control

element Window/DialogTmpl/BottomBar/LeftControls/Margin
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 10
annotation
documentation
Adjusts the space between this button and the last one.

element Window/DialogTmpl/BottomBar/LeftControls/Control
diagram
type | pli:Control
children | pli:Position pli:Help
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element Window/DialogTmpl/BottomBar/RightControls
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Margin pli:Control

element Window/DialogTmpl/BottomBar/RightControls/Margin
type xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 10
annotation
documentation
Adjusts the space between this button and the next one.

element Window/DialogTmpl/BottomBar/RightControls/Control
diagram
type | pli:Control
children | pli:Position pli:Help
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

element Window/WindowTmpl
diagram |
children | pli:Corners pli:Borders pli:BackgroundColor pli:BkgBrightness

 element Window/WindowTmpl/Corners
diagram
properties
minOcc | 0
maxOcc | 1
children pli:RoundSize
attributes
Name | Type | Use | Default | Fixed | annotation
Shape | derived by: xs:string | optional | Round |  |

attribute Window/WindowTmpl/Corners/@Shape
type restriction of xs:string
properties
default | Round
use | optional
facets
enumeration | Round
enumeration | Rectangular

element Window/WindowTmpl/Corners/RoundSize
type restriction of xs:unsignedInt
properties
minOcc | 0
maxOcc | 1
default | 7
facets
minInclusive | 1
maxInclusive | 31
annotation
documentation
Only valid if shape is Round. Must be an odd value.

element Window/WindowTmpl/Borders
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Color
attributes
Name | Type | Use | Default | Fixed | annotation
Type | derived by: xs:string |  | Simple |  |

attribute Window/WindowTmpl/Borders/@Type
type restriction of xs:string
properties
default Simple
facets
enumeration | None
enumeration | Simple
enumeration | Dialog
enumeration | DialogLight

element Window/WindowTmpl/Borders/Color
diagram
type | pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element Window/WindowTmpl/BackgroundColor
type | extension of pli:Color
properties
minOcc | 0
maxOcc | 1
children | pli:Red pli:Green pli:Blue pli:Alpha pli:BaseColor pli:GlobalColor

element Window/WindowTmpl/BkgBrightness
type restriction of xs:string
properties
minOcc | 0
maxOcc | 1
default | Default
facets
enumeration | Default
enumeration | Light

element Window/ChildTmpl
annotation
documentation
A window with this template must not have Attributes or TitleBar. It is only meant to be included in other windows.

element Window/Elements
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Element

element Window/Elements/Element
diagram
type | pli:Element
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element Window/ElementGroups
diagram
properties
minOcc | 0
maxOcc | 1
children pli:ElementGroup

element Window/ElementGroups/ElementGroup
diagram
type | pli:ElementGroup
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position pli:Transparency pli:Elements
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Visible | xs:boolean | true

element Window/Controls
diagram
properties
minOcc | 0
maxOcc | 1
children pli:Control

element Window/Controls/Control
diagram
type | pli:Control
properties
minOcc | 0
maxOcc | unbounded
children | pli:Position pli:Help
attributes
Name | Type | Use | Default | Fixed | annotation
Id derived by: xs:string required
documentation
No spaces allowed
Enabled | xs:boolean | optional | true
Visible | xs:boolean | true

attributeGroup ClientPos
used by
element Window/Position
attributes
Name | Type | Use | Default | Fixed | annotation
ClientWidth | xs:unsignedInt | optional |  |  |
ClientHeight | xs:unsignedInt | optional |  |  |
annotation
documentation
Use this group to specify the size of the client area of the window. New versions should always use this by default.

attributeGroup ScreenPos
used by
element Window/Position
attributes
Name | Type | Use | Default | Fixed | annotation
Width | xs:unsignedInt | optional |  |  |
Height | xs:unsignedInt | optional |  |  |
annotation
documentation
Use this group to specify a fixed size for the window's frame.


Getting Started

Your First Skin - Messenger 8.1

Replace the code shown in Your First Skin with the following one if you're using Messenger 8.1

<SkinInfo>
    <Information>
        <Name>Test Skin</Name>
    </Information>

    <MessengerSkin>
        <ResGroup>
            <Restrictions>
                <MsgVersions>
                    <Version Major="8" Minor="1"/>
                </MsgVersions>
            </Restrictions>

            <Resources>
                <Replace>
                    <Strings>
                        <String Id="61288">Hello World!</String>
                    </Strings>

                    <Graphics><Pictures>
                        <Picture Id="20055">
                            <File>clouds.jpg</File>
                        </Picture>
                    </Pictures></Graphics>
                </Replace>
            </Resources>

        </ResGroup>
    </MessengerSkin>
</SkinInfo>

Differences with the original code: the Version tag specifies version 8.1 instead of version 8.5 and the Id of the Picture element is 20055 instead of 20061. Note however that changing the background of Messenger's 8.1 contact list using this method will result in a background that does not stretch properly when the window is resized. This code is only a demonstration meant to be used if you did not upgrade to a more recent version of Messenger yet.

See Also

Your First Skin.