Tutorial Using Unicode in Visual Basic 6.0 Updated 31-August-2010 14:43

Product  Compare Unicode Replacements for Visual Basic 6.0 ANSI Controls Single OCX UniSuitePlus_BDC0849A 32 Controls (Power Users) New controls 2010, ASM subclass. UniSuiteLite 14 Controls (Intermediate) New controls 2010, ASM subclass. UniSuiteFree 7 Controls (Beginner) New controls 2010, ASM subclass.

Copyright © 2003 - 2010 Unisuite/CyberActiveX Unicode and the Unicode Logo are trademarks of Unicode, Inc. Microsoft and Visual Basic are trademarks of Microsoft Corporation This is a work in progress so expect to see updates often. The latest version can always be found at www.unisuite.com Download a self-contained Compiled HTML(CHM) for off-line reference at http://www.unisuite.com/download/UnicodeTutorial.chm Send comments, suggestions, corrections, or contribute Unicode Vb source code to: webmaster@unisuite.com

Although Visual Basic 6.0 stores strings internally as Unicode(UTF-16) it has several limitations:

1. Ships with ANSI only controls (Label, Textbox, etc.).
2. Properties Window in IDE is ANSI only. Unicode strings are displayed as '????'
3. PropertyBag automatically converts Unicode strings to ANSI.
4. Clipboard functions are ANSI only.
5. Menus are ANSI only.

The purpose of this tutorial is to resolve these issues and provide working VB code solutions. The level of difficulty of these solutions vary but in general require intimate knowledge of ActiveX Controls and Classes. Subclassing and API programming are a must to gain functionality that Vb does not directly support.

The amount of information gathered during development of Unicode aware controls was so overwhelming that it made sense to organize it and this Tutorial proved to be an ideal place to bring eveything together under one roof.

Tutorial Development Tools
Microsoft® Frontpage® 2003
Microsoft® Platform SDK Feb 2007 Edition for Vista
Visual Basic 6.0 - Service Pack 6 It is highly recommended that you use the Latest Vb6 runtime libraries. Release Date: 29-Mar-2004 Size: 1,039.8 Kb List of Fixes VB6.0-KB290887-X86.exe

 

Note: Dates in this tutorial are displayed as dd-mmm-yyyy (Example: 11-Mar-2004) to eliminate any ambiguities.

*  These issues are resolved in Vb.Net although you will have to go through a learning curve to get up to speed with the language.
    Review these tables to determine the minimum system requirements:

1. System Requirements Visual Basic .NET 2003 Standard.
2. System Requirements Visual Studio .NET 2003.

This flowchart shows basic program flow of:

1. Send ANSI/DBCS text to ANSI Controls or ANSI API.
2. Send Unicode text to Unicode Controls
3. Send Unicode text to ANSI/Unicode API using MSLU.
4. Convert UTF8 to Unicode.
5. Convert ANSI/DBCS to Unicode.
6. Get Charset/Codepage from LCID.

Note: You should have a utility on your system called CharMap.Exe which will allow you to browse and select Unicode characters.
 

SBCS(Single-Byte) and DBCS(Double-Byte) Character Sets are different character sets from Unicode.
 

Character codes for "A" in ANSI, Unicode, and DBCS

CharSet from Platform SDK wingdi.h

* DBCS - Double-Byte Character Set

DBCS is actually not the correct terminology for what Windows uses. It is actually MBCS where a character can be 1 or 2 bytes. To illustrate this consider the following code which will take a Unicode string of English and Chinese characters, convert to a byte array of MBCS Chinese, dump the byte array to the immediate window, and finally convert it back to a Unicode string to display in a Unicode aware textbox. The byte array when converted using Chinese(PRC) LCID = 2052 contains single bytes for the english characters and double bytes for the Unicode characters. This proves that it is MBCS and not DBCS:

The following demos shows how to display Chinese on an English-U.S. system without changing your Regional settings 

Example of VbTextBox using DBCS Charset 134, CHINESE_GB2312

• Set your TextBox to any Font that supports script CHINESE_GB2312 (Listview1.Font.Charset=134). Example "Arial Unicode MS". Make sure you select the CHINESE_GB2312 script from the Font Dialog box.

• Add this DBCS string:
  TextBox1 = "CHS: ¡¡ÄãÕæµÄÄܹ»ÔÚÎı¾¿òÖÐʹÓñ³¾°Í¼Æ¬£¬"
  

• Warning: If you apply an XP Theme to the TextBox below via an IDE Manifest it will display ANSI instead of DBCS.

Example of Vb ListView using DBCS Charset 134, CHINESE_GB2312
 

• Set your Listiew to any Font that supports script CHINESE_GB2312 (Listview1.Font.Charset=134). Example "Arial Unicode MS". Make sure you select the CHINESE_GB2312 script from the Font Dialog box.

• In report mode add this DBCS string:
  ListItems.Add , , "CHS: ¡¡ÄãÕæµÄÄܹ»ÔÚÎı¾¿òÖÐʹÓñ³¾°Í¼Æ¬£¬"
  

.

See MSDN for more information about DBCS:
Issues Specific to the Double-Byte Character Set (DBCS)
ANSI, DBCS, and Unicode: Definitions
Calling Windows API Functions
DBCS Sort Order and String Comparison
DBCS String Manipulation Functions
DBCS-Enabled KeyPress Event
Designing an International-Aware User Interface
Font, Display and Print Considerations in a DBCS Environment
Identifiers in a DBCS Environment
Processing Files That Use Double-Byte Characters
 

DBCS String Conversion

StrConv Function

The global options of the StrConv function are converting uppercase to lowercase, and vice versa. In addition to those options, the function has several DBCS-specific options. For example, you can convert narrow letters to wide letters by specifying vbWide in the second argument of this function. You can convert one character type to another, such as hiragana to katakana in Japanese. StrConv enables you to specify a LocaleID for the string, if different than the system's LocaleID.

You can also use the StrConv function to convert Unicode characters to ANSI/DBCS characters, and vice versa. Usually, a string in Visual Basic consists of Unicode characters. When you need to handle strings in ANSI/DBCS (for example, to calculate the number of bytes in a string before writing the string into a file), you can use this functionality of the StrConv function.

The easiest way to add Unicode test strings to your project is to make a resource file with a Unicode aware editor and compile it with RC.exe. That way you can test your controls without having to cut/paste the strings when you need them.
Use Notepad if you are on NT or later, WordPad or UltraEdit if using Win9x.
Download the complete resource file with source here.

"Welcome" in several languages

"Hello" in several languages
* Needs Code2000 Font to see this

Other methods for creating a string at Vb Runtime:

Note: Under the hood StrConv inserts a BOM (FEFF) before the CJK Unified Ideographs.

More stuff to play with:

XP now supports a total of 136 locales, which includes the 126 locales supported by Windows 2000 and adds the following:

•  Divehi – Maldives
•  Galician – Spain
•  Gujarati – India
•  Kannada – India
•  Kyrgyz (Cyrillic) – Republic of Kyrgyzstan
•  Mongolian (Cyrillic) – Mongolia
•  Punjabi (Gurmukhi) – India
•  Syriac – Syria
•  Telugu – India
•  Invariant locale

Other international features New to XP:

• New Indic and Arabic scripts(Gujarati, Gurmukhi, Telugu, Kannada, Syriac, Divehi).
• More robust font display for East Asian languages.
• Improved Regional Settings support.
• Largely improved MUI support.
• New Location (GEO).
• Support for GB18030.

New Locales in Windows XP Service Pack 2

Windows XP Service Pack 2 introduces 25 additional locales and another 11 with Service Pack 2 Update:

These locales are automatically installed when you update Windows XP to SP2. You can select new locales in Regional and Language Options. They are not supported in Windows Server 2003.

International Locale Codes
 

Click Icon to your left to Load Table.
 Please Wait...

Related resources

• FAQs about Locales & Languages
• ISO 8859 character sets
• Character sets recognized by Internet Explorer
• NLS Information for Microsoft Windows XP
• Windows codepages
• Locales and Language Groups
• List of Windows XP's Three Letter Acronyms for Languages
• Windows 2000 - List of Locale IDs and Language Groups
• Windows XP - List of Locale IDs, Input Locale, and Language Collection

Also see Table above

Table of Known Code Pages

* DBCS - Double-Byte Character Set
* This is a pseudo codepage. There is no corresponding NLS file. This code page ID can only be used with WideCharToMultiByte() and MultiByteToWideChar() API calls.

Fonts used on Windows XP-SP1:

Win2000/XP/Office2000/Office2003 should already have Arial Unicode MS installed.
Win98 users will need a Unicode font to render Unicode glyphs.

Also see Multilingual Unicode TrueType Fonts on the Internet.

Sample Font Support for several Languages
Test Platform WinXP-SP1

Sample	Arial Unicode MS	Code 2000	* Microsoft Tahoma or Arial	* Microsoft Sans Serif	Bitstream Cyberbit	TITUS Cyberbit Basic
ARA: مـرحبــاً
CHS: 欢迎
CHT: 歡迎
GEO: სასურველი
GRK: Καλώς ήλθατε
HEB: בִּרוּבִים חַבָּאִים
HIN: रवागत
JPN: よろてそ
KOR: 여보세요
PAN: ਜੀ ਆਇਆਂ ਨੂੰ
RUS: Добро пожаловать
TAM: 쏅얧주ø
THA: การต้อนรับ
URD: स्वागत
VIE: tính từ

* Tahoma, Arial do not support all these languages but works due to Uniscribe Font Fallback. Apparently MS San Serif does not use or support Font Fallback. Font Fallback is only available on Platforms Win2000 or later.

Microsoft Layer for Unicode Technology(UNICOWS.DLL)

While you can make a separate programs for specific platforms it is often desirable to make one program that will work on all platforms. By using Microsoft Layer for Unicode Technology (Unicows.DLL, 240kb), a single executable can run on both NT-based and Win9x Platforms. In this case you can use DrawTextW or TextOutW Lib "Unicows" for all platforms.

1. The Unicows.Dll forwards calls to the system API if you are running on NT, 2000, or XP platforms.

2. MSLU does not support the display of characters that the system cannot display. Therefore do not expect to see Chinese under Win98 English even though you have installed a font that supports Chinese(Arial Unicode MS for example). For more info see Newsgroup microsoft.public.platformsdk.mslayerforunicode and http://trigeminal.com/usenet/usenet035.asp.

Use this conditional compilation directive to test your code with and without Unicows:

#If UNICOWS Then Public Declare Function DrawTextW Lib "UNICOWS" (ByVal hdc As Long, ByVal lpStr As Long, ByVal nCount As Long, lpRect As RECT, ByVal wFormat As Long) As Long Public Declare Function MultiByteToWideChar Lib "UNICOWS" (ByVal CodePage As Long, ByVal dwFlags As Long, ByRef lpMultiByteStr As Any, ByVal cchMultiByte As Long, ByVal lpWideCharStr As Long, ByVal cchWideChar As Long) As Long Public Declare Function TextOutW Lib "UNICOWS" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal lpString As Long, ByVal nCount As Long) As Long Public Declare Function WideCharToMultiByte Lib "UNICOWS" (ByVal CodePage As Long, ByVal dwFlags As Long, ByVal lpWideCharStr As Long, ByVal cchWideChar As Long, ByRef lpMultiByteStr As Any, ByVal cchMultiByte As Long, ByVal lpDefaultChar As String, ByVal lpUsedDefaultChar As Long) As Long #Else Public Declare Function DrawTextW Lib "user32" (ByVal hdc As Long, ByVal lpStr As Long, ByVal nCount As Long, lpRect As RECT, ByVal wFormat As Long) As Long Public Declare Function MultiByteToWideChar Lib "kernel32" (ByVal CodePage As Long, ByVal dwFlags As Long, ByRef lpMultiByteStr As Any, ByVal cchMultiByte As Long, ByVal lpWideCharStr As Long, ByVal cchWideChar As Long) As Long Public Declare Function TextOutW Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal lpString As Long, ByVal nCount As Long) As Long Public Declare Function WideCharToMultiByte Lib "kernel32" (ByVal CodePage As Long, ByVal dwFlags As Long, ByVal lpWideCharStr As Long, ByVal cchWideChar As Long, ByRef lpMultiByteStr As Any, ByVal cchMultiByte As Long, ByVal lpDefaultChar As String, ByVal lpUsedDefaultChar As Long) As Long #End If

Under Project/Properties/Make set conditional compilation arguments to UNICOWS = -1 or UNICOWS = 0.

Note:

You may not need MSLU at all if your program uses only DrawText or TextOut. In this case you can simply wrap the ANSI and Wide versions into a Sub. Do not expect to see Unicode on Win9x platforms even if you are using a Unicode font such as Arial Unicode MS:

Uniscribe Architecture

In 1999 Microsoft introduced Uniscribe, a Windows system-level component that could take advantage of OpenType fonts. Microsoft Windows 2000 and applications Internet Explorer 5 and Office 2000 were released with support for Uniscribe built in.

For Windows 2000 and later, supports the processing of complex scripts, that is, those scripts that need special processing to properly render them. It includes a subset of the features found in GDI+ in Windows 2000 and Windows XP. The rules governing the shaping and positioning of glyphs are specified and catalogued in The Unicode Standard: Worldwide Character Encoding, Version 2.0, Addison-Wesley Publishing Company.
http://msdn.microsoft.com/library/en-us/mslu/winprog/other_existing_unicode_support.asp?frame=true
http://www.microsoft.com/msj/1198/multilang/multilang.aspx

A complex script has at least one of the following attributes:

• Allows bidirectional rendering.
• Has contextual shaping.
• Has combining characters.
• Has specialized word-breaking and justification rules.
• Filters out illegal character combinations.

You may wonder how WinXP displays Unicode correctly even when you haven't selected a Font which supports all the required characters.
"Font fallback: this mechanism, made available through Uniscribe (see section on Complex Scripts Support), provides a fallback font (or a default font) when dealing with complex scripts. If the selected font face does not include any glyphs for the complex script that is about to be displayed, Uniscribe selects a default hardcoded font for the given script. For example, if you have Hindi text and the font is Courier, then Uniscribe will use the Mangal font. This technique is internal to Uniscribe and developers can not add additional fonts to the list of fallback fonts."
Note: Set flags to SSA_FALLBACK

Uniscribe is installed with Internet Explorer 5.0 or later, MS Office, Win2000, WinXP. Here are some versions of Uniscribe I found (including one found on Win98SE):

Best results in tests run on Win98SE has been with Uniscribe version 1.0405.2415.1. Microsoft Office 2003 version has not been tested yet.

A Vb wrapper for this library can be found in Internationalization with Visual Basic by Michael S. Kaplan. It comes with a CD containing sample sourcecode. The sample includes a Uniscribe-aware version of ExtTextOutW. More info here.
 

A more complex C++ example can be found at "Supporting Multilanguage Text Layout and Complex Scripts with Windows NT 5.0". Dont be mislead by 'Windows NT 5.0' in the title because this demo also works on Win98. More info here.

This sample has been update and can be found on the Microsoft® Platform SDK(August 2002 Edition, Windows XP SP1) if you have it installed under C:\Program Files\Microsoft SDK\Samples\winui\globaldev\CSSamp. You may encounter problems compiling this due to missing or outdated files.

To build an application that supports Unicode on all Platforms AND uses Uniscribe you could use something similar to this:

Provides services for applications on international issues, including conversion between code pages, font linking, code page "guessing", line breaking, and more. Installed with Internet Explorer 5.5 or later.
http://msdn.microsoft.com/workshop/misc/mlang/mlang.asp
http://msdn.microsoft.com/workshop/misc/mlang/reference/objects/CMultiLanguage.asp
 

The only Vb wrapper for this library I can find is here.

Provides a programming interface(control) for formatting text. This can be used in lieu of Fm20.Dll Unicode TextBox. No distribution issues and comes with source code.

Rich Edit version	Unicode	New	DLL	XP - SP1	XP	Me	2000	NT	98	95
1.0			Riched32.dll	Emulator	Emulator		Emulator
2.0		Supports Unicode	Riched20.dll							May be installed
3.0		Expanded support for complex scripts, partly due to Uniscribe.	Riched20.dll
4.1		Hyphenation, page rotation, and Text Services Framework (TSF) support.	Msftedit.dll

Links:
http://msdn.microsoft.com/library/psdk/winui/richedit_5a7n.htm
http://msdn.microsoft.com/library/en-us/shellcc/platform/commctls/richedit/richeditcontrols.asp
About Rich Edit Controls
Tutorial 33: RichEdit Control: Basics

Rich Edit Controls

Control	Price	Unicode Aware NT/2000/XP	Link	Notes
vbAccelerator RichEdit control (164kb)	Free		http://www.vbaccelerator.com/codelib/richedit/richedit.htm	Source code included
ctl_riched.msi (330Kb)	Free		http://www.mvps.org/emorcillo/vb6/controls/index.shtml	Source code included

Screenshot

GDI+ ships with Windows XP and 2000(SP3). You can also install it on other windows platforms(98 or later). It is a free download from Microsoft at gdiplus_dnld.exe. It is Unicode aware on all platforms and allows you to draw high quality Unicode antialiased text. There is also support for rotation, skewing, and text outlining(Logo style).

To use Unicode in Win98 you must install a Unicode font such as Arial Unicode MS.Complex glyphs such as Chinese will render in Win98SE English version even though the operating system doesn't support this via DrawTextW or TextOutW! How does it do this? GDI+ uses Uniscribe under the hood to render Unicode.

You can find more information on using GDI+ in Visual Basic here

Note: Most examples you will find on the WEB use class wrappers which are geared to C++/.Net users. The Vb equivalent wrappers on PSC and VbAccelerator are not complete so you may want to stick with local GDIplus Declares or use a Type Library.

See advantage of using the TLB here.

Windows TextOut() APIs

From antiquity, the routines DrawText(), TextOut() and (more recently) ExtTextOut() have been the work-horse APIs used to draw text. Except on OS editions localized for regions of the world where complex scripts were needed, these routines did not do any complex script handling. And in fact they still do not, except on Windows 2000 and XP. On those operating systems, which come with Uniscribe as a standard system component, these standard APIs now do complex script shaping even for programs that have not been designed for it or are not expecting it.

If you are coding a User Control or subclassing a control to take advantage of Owner Draw or Custom Draw features then use API DrawTextW or TextOutW as follows:

'Sample Vb code Public Sub pDrawText(ByVal lhDC As Long, _ ByVal sText As String, _ ByRef rct As RECT, _ ByVal lFlags As Long) If LenB(sText) Then DrawTextW lhDC, StrPtr(sText), -1, rct, lFlags End If End Sub ' Public Function pTextOut(ByVal lhDC As Long, ByVal x As Long, ByVal y As Long, sText As String) TextOutW lhDC, x, y, StrPtr(sText), Len(sText) End Function

Note: lFlags values can be found here: DrawText Align Flags.

Updated 31-August-2010 14:43 -0300

Trademarks Unicode is a trademark of Unicode, Inc. Microsoft, Visual Basic, VB.NET, and C#.NET are trademarks of Microsoft Corporation. Credits Download original sGrid with source code free from http://www.vbaccelerator.com/codelib/sgrid/sgrid.htm   New version sGrid2 is now available with source code at http://www.vbaccelerator.com/home/VB/Code/Controls/S_Grid_2/S_Grid_2/article.asp.

The intrinsic controls that ship with Vb6 are not Unicode aware so you have several options.

• Use Windowless controls. If they are not installed you can find them on Visual Studio Disk#3 VbExtras at \COMMON\TOOLS\VB\WINLESS.
  You may find references on the WEB including MSDN and ltwtct98.chm claiming that these controls are Unicode-enabled. This is NOT true and you will get the infamous "????" when you try to set Unicode text.
• Coerce the Vb6 intrinsic controls to be Unicode aware.
   

  http://www.trigeminal.com (some source code available) The static controls(Frame, CheckBox, OptionButton, and CommandButton) work OK under WinXP. The Label and Edit controls works only if you have a single language and set the correct codepage. Multilanguage captions will display as "????". http://www.unitoolbox.com for a free set of the UniButton, UniFrame, UniOption, UniCheck, UniTreeView, UniCaption(Dialog captions) controls. You will need a Unicode aware TextBox for the property page. Purchase theirs or substitute with Fm20.DLL TextBox. These controls have been built using the techniques detailed in Michael S. Kaplan's book "Internationalization with Visual Basic" . Note: Most of the above techniques will not work under Themed WinXP under the following conditions: You are using a Vb6 manifest file in the IDE(Vb6.Exe.Manifest). You compile the application and include a Manifest file.. You embed a Manifest file as a resource.

   

• Purchase 3rd party controls which support Unicode. A package(suite) to replace Vb's instrinsic controls can run US$400 or more. Download demos of these controls and verify that they work under Themed WinXP. Also check to see if they work on Win98.
• Write your own API OwnerDraw controls (a formidable task):
   

  Use CreateWindowEx, adding properties and events via subclassing.. Add code to resolve Focus issues since Vb is not aware of controls created using CreateWindowEx. Create a custom property page for Unicode strings since Vb's IDE Property Page does not support Unicode. Resolve PropertyBag storage/retrieval issues so Unicode strings are not mangled into ANSI. Resolve XP Theme issue by applying theme internal to the control. Resort to Normal or Flat control if there is no XP Theme available. See www.vbaccelerator.com and http://www.freevbcode.com/ShowCode.Asp?ID=2835 for samples of owner-draw control code and techniques for applying XP Theme parts programtically. See http://www.unisuite.com/product008.htm for Unicode replacements for Vb ANSI controls..

   

• By far the easiest method is to use the MS Office Unicode aware controls embedded in FM20.DLL.

  Forms 2.0 Object Library (Unicode)
  Advantages	Disadvantages
  Although Microsoft does not recommend or provide support for use of these controls under Visual Basic they do appear to work well despite the disclaimer.	No Microsoft support.
  Easy way to get limited Unicode support in your projects.	No Uniscribe support (No Font fallback or Complex Scripts). Because of this the control Font must contain ALL the characters you are trying to render.
  Not redistributable however anyone can get it for free by downloading MS ActiveXControlPad.	No XP theme support.
  	Requires FM20ENU.Dll (installed only with US versions of Office).
  	Windowless controls thus no hWnd.
  	Requires at least VB6-SP4 to use IME(Input Method Editor).

  As can be seen above it is a easy way to get limited Unicode support in your projects but falls way short of something you would want to use in a Commercially distributed application.
   

  FM20ENU.Dll - Automatically installed with English versions of Office. Users who have installed Office with another language should check Windows\System32 folder for presence of this file. If it is not present you can download and install it free as part of ActiveXControlPad. You must have FM20ENU.Dll present to make Forms 2.0 Object Library controls available in Vb6. The symptoms are that the controls appear in the Vb Toolbox panel but an error occurs when you try to place one onto a form. Sample Vb code using the TextBox from FM20.DLL:   TextBox1.Text = "CHS: " & ChrW$(&H6B22) & ChrW$(&H8FCE)

   

   

UTF8 is a lossless method of encoding UTF16 Unicode in 1-3 bytes.

According to HTML standard, HTML files should be transmitted in Big-Endian format and using Byte-Order Mark (BOM) is recommended. Since Windows Native format is Little-Endian, to avoid the Endian conversion problem, it is recommended to use UTF-8 encoding in HTML files. In addition to converting your strings to UTF-8 add the following MetaTag to indicate your content as being UTF-8:

"<HEAD><meta http-equiv='Content-Type' content='text/html; charset=utf-8'></HEAD>"
 

Brute force conversions and API equivalents

Sample Grid saved as HTML(UTF-8 encoded). Supports Header, Filter Bar, Icons, Pictures, Backgrounds, Alignment, Unicode text, Cell ForeColor/BackColor, and Hyperlinks

DemoHeader - ExportHTML

Name	Multiline Headers CHS: 欢迎 JPN: よろてそ	Type	Modified	GEO: სასურველი	Col 6	Col 7	Col 8	Col 9	Col 10
	Insira o texto aqui		Insira o texto aqui	Insira o texto aqui	Insira o texto aqui	Insira o texto aqui	Insira o texto aqui	Insira o texto aqui	Insira o texto aqui
	0,707107	Type 1,Col3	2007-190	ARA: مـرحبــاً	Arabic	United Arab Emirates		Abu Dhabi	Row1,Col10
	316.615	Type 2,Col3	2008-359	CHS: 欢迎	Chinese Simplified	China		Beijing	Row2,Col10
	316.615	Type 3,Col3	2009-013	CHT: 歡迎	Chinese Traditional	Taiwan		Taipei	Row3,Col10
	www.unisuite.com	Type 4,Col3	2009-120	ENG: Welcome	English	United States		Washington, DC	Row4,Col10
	HTML Table   Language Unicode Chinese CHS: 欢迎 Japanese JPN: よろてそ Korean KOR: 여보세요 Portuguese PTB: Bem-vindo   Visit www.unisuite.com	Type 5,Col3			Georgian	Georgia		Tbilisi	Row5,Col10
	HTML Markers   sChinese CHS: 欢迎 sJapanese JPN: よろてそ sKorean KOR: 여보세요 Arabic, Roman, Alpha, Circle, Disc, Square, Upper/Lower Case.	Type 6,Col3			Greek	Greece		Athens	Row6,Col10
	491.467	Type 7,Col3	2005-201	HEB: בִּרוּבִים חַבָּאִים	Hebrew	Israel		Jerusalem	Row7,Col10
	276.606	Type 8,Col3	2005-299	HIN: रवागत	Hindi	India		New Delhi	Row8,Col10
	617.782	Type 9,Col3	2011-311	JPN: よろてそ	Japanese	Japan		Tokyo	Row9,Col10
	728.881	Type 10,Col3	2011-076	KOR: 여보세요	Korean	Korea		Seoul	Row10,Col10
	111.536	Type 11,Col3	2011-212	PAN: ਜੀ ਆਇਆਂ ਨੂੰ	Punjabi	Pakistan		Islamabad	Row11,Col10
	603.123	Type 12,Col3	2004-025	PTB: Bem-vindo	Portuguese(BR)	Brazil		Brasilia	Row12,Col10
	298.299	Type 13,Col3	2003-102	RUS: Добро пожаловать	Russian	Russian Federation		Moscow	Row13,Col10
	315.590	Type 14,Col3	2011-346	TAM: 쏅얧주ø	Tamil	India		New Delhi	Row14,Col10
	291.797	Type 15,Col3	2004-051	THA: การต้อนรับ	Thai	Thailand		Bangkok	Row15,Col10
	429.992	Type 16,Col3	2006-253	URD: स्वागत	Urdu	Pakistan		Islamabad	Row16,Col10
	663.936	Type 17,Col3	2005-049	VIE: tính từ	Vietnamese	Vietnam		Hanoi	Row17,Col10
	84.635	Type 18,Col3	2007-312	ARA: مـرحبــاً	Arabic	United Arab Emirates		Abu Dhabi	Row18,Col10
	823.354	Type 19,Col3	2006-088	CHS: 欢迎	Chinese Simplified	China		Beijing	Row19,Col10
	662.429	Type 20,Col3	2008-124	CHT: 歡迎	Chinese Traditional	Taiwan		Taipei	Row20,Col10
	588.293	Type 21,Col3	2009-330	ENG: Welcome	English	United States		Washington, DC	Row21,Col10
	23.728	Type 22,Col3	2007-317	GEO: სასურველი	Georgian	Georgia		Tbilisi	Row22,Col10
	710.879	Type 23,Col3	2007-165	GRK: Καλώς ήλθατε	Greek	Greece		Athens	Row23,Col10
	370.642	Type 24,Col3	2006-061	HEB: בִּרוּבִים חַבָּאִים	Hebrew	Israel		Jerusalem	Row24,Col10
	255.690	Type 25,Col3	2011-012	HIN: रवागत	Hindi	India		New Delhi	Row25,Col10

DemoFooter - ExportHTML

Exporting Unicode to a file usually involves prefixing the text with a BOM (Byte Order Mark). See the table above to see what prefix is required depending on the Unicode format. Using UTF-8 although it takes more space than UTF-16 is recommended since it is easier to transport to other platforms and easier to use in HTML.

See FileIO for methods on how to Read/Write Unicode files.

The VB Clipboard functions are ANSI only. If you need to access the Clipboard 'Unicode string' you must use format 'CF_UNICODETEXT = 13'. Code to do this can be found at http://www.vbaccelerator.com/home/VB/Code/Libraries/Clipboard/Customising_Clipboard_Use/article.asp

Standard Clipboard Formats

Windows Message Clipboard Constants

Windows Clipboard API's

Chart Updated 18-Jul-2007

These are the flags you can set when using API DrawTextW. Combine using the OR operator. Example: DT_CENTER OR DT_WORDBREAK

input string:   "A&bc&&d"
normal:         "Abc&d"
DT_NOPREFIX:    "A&bc&&d"

input string:    "A&bc&&d"
normal:          "Abc&d"
DT_HIDEPREFIX:   "Abc&d"

input string:    "A&bc&&d"

normal:          "Abc&d"

DT_PREFIXONLY:   " _   "

RTL(RightToLeft) provides support for languages such as Arabic, Hebrew, Urdu.

There are several Extended Style Constants used to enable Window Activation:

LTR (Default) [ ENG: Welcome ]	RTL [  العربية :ARA]	Comments
WS_EX_LEFT = &H0	WS_EX_RIGHT = &H1000	Alignment
WS_EX_LTRREADING = &H0	WS_EX_RTLREADING = &H2000	Read Direction
WS_EX_RIGHTSCROLLBAR = &H0	WS_EX_LEFTSCROLLBAR = &H4000	Vertical Scrollbar Alignment
	WS_EX_LAYOUTRTL = &H400000	Right to left mirroring
	WS_EX_NOINHERITLAYOUT = &H100000	Disable inheritence of mirroring by children

To test various Styles or Extended Styles put this code in a module:

Private Declare Function SetWindowLongA Lib "user32" (ByVal hwnd As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long Private Declare Function SetWindowLongW Lib "user32" (ByVal hwnd As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long Private Declare Function GetWindowLongA Lib "user32" (ByVal hwnd As Long, ByVal nIndex As Long) As Long Private Declare Function GetWindowLongW Lib "user32" (ByVal hwnd As Long, ByVal nIndex As Long) As Long Private Const GWL_EXSTYLE = (-20) Private Const GWL_STYLE = (-16) Public Sub pSetStylePlus(ByVal lHWnd As Long, _ ByVal lStyleFlags As Long, _ ByVal bState As Boolean, _ Optional ByVal bExtended As Boolean = False) Dim lStyle As Long Dim GWL As Long GWL = IIf(bExtended, GWL_EXSTYLE, GWL_STYLE) If (IsNt) Then lStyle = GetWindowLongW(lHWnd, GWL) Else lStyle = GetWindowLongA(lHWnd, GWL) End If If (bState) Then lStyle = lStyle Or lStyleFlags Else lStyle = lStyle And Not lStyleFlags End If If (IsNt) Then SetWindowLongW lHWnd, GWL, lStyle Else SetWindowLongA lHWnd, GWL, lStyle End IfEnd Sub

Notes:

CreateWindowEx:

• In most cases you should set the extended style when the control is created with CreateWindowEx.

• You can also set the style later by adding or removing a style flag. Use the code above to do this.

• In the case of ListView you must update both the main ListView and the Header component styles.
  There is no header component yet when the control is created with CreateWindowEx so you must update this after you have created a header in code.

• In the case of DTPicker you must also update the Calendar component.

• MonthView is only one component so it can be set when the control is created with CreateWindowEx.

UserControl:

• Setting RightToLeft on a UserControl does nothing on our two Platforms: Win98SE(English), and WinXP-SP1(Brazilian Portuguese) . It may in fact work if your OS is Hebrew or Arabic.

• You can use pSetStylePlus in the module above and UserControl.hWnd to enable various RTL styles.

• In some cases the control is correctly mirrored, i.e. ScrollBar is on the left, Icons are aligned right. However the text is mirrored which is not correct. This was corrected with the following code.
  SetLayout hdc, IIf(bRTL, LAYOUT_RTL, 0)

Suggested reading MSDN:

• Mirroring Awareness

• Implementing Mirror-Aware Controls

Activating Mirroring per Device Context

GetLayout(hdc) will return the current layout state.

Microsoft Visual Basic includes standard features to create and run Windows applications with full bi-directional language functionality. However, these features are operational only when Microsoft Visual Basic is installed in a bi-directional 32-bit Microsoft Windows environment, such as Arabic Microsoft Windows 95. Other bi-directional 32-bit Microsoft Windows environments are available as well.

The Right-To-Left property has been added to forms, controls, and other Visual Basic objects to provide an easy mechanism for creating objects with bi-directional characteristics.
Although Right-To-Left is a part of every Microsoft Visual Basic installation, it is operational only when Microsoft Visual Basic is installed in a bi-directional 32-bit Microsoft Windows environment.

This is frustrating since we may be developing on a non-BIDI environment but yet want to support BIDI.
Using WS_EX_LAYOUTRTL would seem the logical answer here but when you try to manipulate a UserControl using this Flag it does not work correctly on a non-BIDI OS.
The trick is to not bind the RightToLeft Property to the UserControl and owner-draw the control  to replicate both BIDI and normal modes.
Thus LTR would use something like "DT_LEFT" and RTL would use "DT_RIGHT Or DT_RTLREADING".
DT_SINGLELINE or DT_WORDBREAK and other options would be added to both alignments.

Here is what Microsoft has to say about "MiddleEast - Frequently Asked Questions"

http://www.microsoft.com/middleeast/msdn/faq.aspx

The part about installing Arabic Support to Win2000/XP/Vista is True.

You can take with a grain of salt these statements:

Just so you do not have to reinvent the wheel check out these hints:

1. If you pass a string to an API as 'String', VB will convert the Unicode string to ANSI first. Always use a pointer such as StrPtr(sText) to pass a Unicode string. You usually need to change the API Declare to a Long for this to work. This is not necessary if your Function is Declared in a TLB.
2. Advanced source code for OwnerDraw Controls can be found at http://www.vbaccelerator.com. Highly recommended. This is a gold mine.
3. Use COMMCTRL.Tlb from www.domaindlx.com/e_morcillo/. It has 95% of what you need to deal with owner draw and custom draw controls. It nicely wraps the Comctl32.Dll.
4. Owner Draw requires you to create the entire control from scratch in code including drawing and event handling.
5. Custom Draw allows you to override a specific portion of a control drawing cycle to modify its behaviour. Note that only certain controls allow this. The header control in Comctl32.Dll is one example(used in conjunction with Listview but can also be attached to a Grid control). Search MSDN for more info.
6. Beware of accents in your strings. If you are using ANSI then you can freely use characters 128..255 and they will appear correctly using DrawTextA or DrawTextW. However, if you intend your string to represent UTF-8 you must encode the characters 128..255. For example the sample string sPortuguese in ANSI is "português(BR)" & vbCrLf & "Ação já". The same string in Utf-8 is "português(BR)" & vbCrLf & "Ação já". It is then up to code that receives the Utf-8 to convert to Unicode(Utf-16) and then send it to DrawTextW.
7. Vb code support for Uniscribe and Mlang can be found here.
8. You may need to store your Unicode string caption locally if it is being converted to ANSI via a structure. Using OwnerDraw or CustomDraw you can then render the string using DrawTextW or TextOutW.
   Another situation can occur in classes where the string is passed ByRef via a Method(Sub) can be corrupted. The solution here is to create a Property in the class to hold the Unicode string.
   Note: This is very important. Make sure your string is not being converted to ANSI somewhere before it arrives at DrawTextW.
   This is easy to troublsehoot as long as you have the source code. Follow your string and substitute with ChrW$(-27073) until you find out where the string gets corrupted.
9. In general create controls with CreateWindowExW.
   This is not always necessary though. For example you can for example create a Balloon Tooltip with CreateWindowExA and use the Wide version of ToolInfo to successfully set a Unicode caption. SendMessage in this case uses TTM_ADDTOOLW, TTM_UPDATETIPTEXTW, and TTM_SETTITLEW for the wMsg parameter. You must also use StrPtr(sCaption) to supply the long pointer to the string.
10. Use Wide versions of UDTs. Note that they are usually identical to the ANSI version with exception of the strings which use a long string pointer in lieu of a string variable.
11. Use Wide versions of message constants. The values are often different for Unicode.
    Constants can be found in file "Microsoft SDK\include\CommCtrl.h" from the Platform SDK.
12. Some controls require sending a message to specifically set Unicode mode. The header control in Comctl32.Dll is one example(used in conjunction with Listview but can also be attached to a Grid control).

1. Eliminates cut and paste in your projects.
2. Eliminates typographical errors.
3. No Bloat. The final EXE uses only the Constants, Types, and Declares that are used by your project.
4. There is a common misconception that you need to ship the TLB. You never need to include the TLB in your deployment package unless there are implement interfaces. All relevant data is embedded in the EXE, DLL, or OCX.
5. Unicode strings are not corrupted when passed to functions since they are passed as a pointer without the explicit need of using StrPtr(sText) in your code.

Note:

• If you have trouble using a paticular function in a TLB declare it locally to isolate whether there is something wrong with the TLB or it is not something wrong with your code or method of supplying parameters. You do not need to unload the TLB to do this(i.e. the local Declare take precedence). Example:
  Private Declare Function LocalGdipGetEncoderParameterList Lib "gdiplus.dll" Alias "GdipGetEncoderParameterList" ( _
    ByVal Image As Long, _
     clsidEncoder As clsid, _
     ByVal size As Long, _
     ByVal lPtrBuff As Long) As GpStatus
• Beware of multiple TLBs loaded into the same project that may contain redundant declares and the order in which the TLBs are loaded. You may suspect a problem in a particluar TLB declare when in fact it is using a function declared differently in another TLB.
• If you have a local Declare then it takes precedence over a TLB Declare.

 

27	GB18030 Support Package

GB18030–2000 is a new Chinese character encoding standard. The standard contains many characters and has some tough new conformance requirements. GB18030-2000 encodes characters in sequences of one, two, or four bytes. These sequences are defined as follows:

•  Single-byte: 00-0x7f
•  Two-byte: 0x81-0xfe + 0x40-0x7e, 0x80-0xfe
•  Four-byte: 0x81-0xfe + 0x30-0x39 + 0x81-0xfe + 0x30-0x39

The government has said that it will enforce the standard first for platforms, and later for tools and applications.

Which Microsoft Platforms have
been approved for use in China?

GB18030 Support Package (English)
 

Also see Surrogate pairs.

When you save strings to the PropertyBag in User Controls they are automatically converted to ANSI. You can however save Unicode as a string of Hex values of the wide characters(AscW) and reconstruct the string upon retrieval.

A better(easier/faster) method to prevent ANSI conversion is to convert the string to a byte array and then to a variant before writing to the PropertyBag. The reverse process is used to read from the PropertyBag. Note that it is not necessary to dimension the byte array.

PropertyBag Wrapper Functions

'Purpose:Prevent ANSI conversion in PropBag.WriteProperty. 'Coerce String to ByteArray to Variant 'Example: PropBag.WriteProperty "Caption", UniToVar(m_Caption), m_def_Caption Public Function UniToVar(sText As String) As Variant Dim b() As Byte b = sText UniToVar = b End Function 'Purpose:Prevent ANSI conversion in PropBag.ReadProperty. 'Coerce Variant to ByteArray to String 'Example: m_Caption = VarToUni(PropBag.ReadProperty("Caption", m_def_Caption)) Public Function VarToUni(vVar As Variant) As String Dim b() As Byte b = vVar VarToUni = b End Function

An example of how to use these functions:

This preserves the Unicode in string m_Caption. In an OwnerDraw label control you would then do something like this:

DrawTextW hdc, StrPtr(m_Caption), -1, rct, m_Alignment

Note: The problem occurs only with writing so you can use the wrapper UniToVar to corrrectly save the Unicode and simply read it back using: m_Caption = PropBag.ReadProperty("Caption", m_def_Caption). Vb will automatically typecast the byte array to a string.

Note2: To input the Unicode Caption/Text in the IDE will require you to create a Propery Page that has a Unicode aware TextBox or RichEdit.

This is a method that allows you to input and store Unicode string captions/text without the need for a PropertyPage for Caption/Text or the need for persisting the caption as a ByteArray in the PropertyBag.

Using UniConverter.Zip(10Kb) convert your strings to UTF8 and simply paste the UTF8 string into the IDE Properties Window Caption/Text Property. You could also set them at runtime via code, resource file, database, or text file:

In your UserControl convert the UTF8 to Unicode and render with DrawTextW or TextOutExW. The code to perform the conversion can be found here or at UniConverter.Zip(10Kb). 

This applies to User Control Unicode Strings:

1. You cannot set Unicode strings from the IDE Properties Window since it only displays ANSI.
2. You can set them at runtime from code, a resource file, or a satellite DLL.
3. Make a Custom Property Page for your User Control. You can use the Property Page wizard to do this. Then replace the Vb TextBox with one that is Unicode aware. You may need to change the names created by the Wizard or just change the name of your Unicode control to Text1.
   Note: So you don't print '????' for strings in the Vb6 IDE Properties window you may also want to change your control code to this: Public Property Get Caption() As String If Ambient.UserMode Then Caption = m_Caption Else Caption = "(Unicode Text)" End If End Property Public Property Get Text() As String If Ambient.UserMode Then Text = m_Text Else Text = "(Unicode Text)" End If End Property
    
4. You will also need to modify the Property Bag so that it doesn't mangle your Unicode string.
5. Another option is to use UTF-8 which you can easily display in the properties window AND persist to the PropertyBag as an ANSI string. You will however have to convert the UTF-8 to Unicode UTF-16 at runtime to display the text.

Several methods are available to populate a Control or String variable with Unicode.

Keyboard Input Methods for WinXP

For more information see http://www.microsoft.com/globaldev/handson/dev/Unicode-KbdsonWindows.pdf

Using a Resource file is yet another method of storing your Unicode strings. A sample can be found on MSDN: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcsample/html/vcconUniresSampleDemonstratesUseOfUnicodeResourceFiles.asp.

Make sure you use a Unicode aware editor. In NT/2000/XP Notepad is OK. In Win98 you will need to use WordPad or UltraEdit32.

If you create a new resource file in Notepad the first time you save the file use "Save As" and specify the coding as Unicode. If your file has Unicode content and you attempt to save the file as ANSI you will receive a warning that you have Unicode content and must save as Unicode.
Compile this new file using resource compiler Rc.Exe. You may want to make a simple batch file to do this (make sure Rc.Exe is in an available path):

BuildRes.bat
-----------------
RC UnicodeStrings.rc
Pause 

Vb6 has no problem reading a Resource file that was saved in ANSI or Unicode format and LoadResString will read Unicode from the resource correctly.

The recommended approach for dealing with multilingual resources is the use of Satellite Resource Dlls. Information can be found at Satellite resource DLLs,

The Good, the Bad, and the Ugly

ForeverBlue2 Theme	Luna Theme(Silver)	Vb Button

As you can see from the above Screenshot XP Themes give a nice appearance to controls but they may have undesirable side effects when it comes to Unicode.

• If you manage to coerce a Vb ANSI control to display Unicode, you will more than likely lose the Unicode(displays as ???) when a Theme is applied. One exception to this is using a hook and calling API "SetWindowTextW" when you receive the HCBT_ACTIVATE message. This appears to work both with and without a XP Theme.

• You can circumvent this behaviour by creating from scratch an API Owner-Draw control where you apply the Theme manually and not via a Manifest file. API 'DrawThemeText' can be called just like DrawTextW where you supply a RECT, Pointer to a Unicode string, and an alignment Flag.

• You may also want to fix some of the anomalies(aka bugs) with XP Themes or even add new features. For example you can see from the above screenshot that the button corners are transparent, something you don't get using a Manifest. Using a Manifest a background rectangle is painted(API DrawThemeParentBackground).

• If no Theme is available or activated you can drop back to a standard or flat style control and use DrawTextW to output the Unicode text.

UxTheme.Dll Patch for WinXP

Ordinarily I would never recommend patching an Operating System DLL. However Microsoft does not allow 3rd party themes like the one shown above(ForeverBlue2). There are lots of free themes available for download. You can use a commercial program to apply these themes or you can apply a patch to UxTheme.Dll. Patches are supplied for both XP or XP-SP1. I have been using both these patches for over a year with no problems. If you are tired of the Micosoft Luna Theme then try this. You are on your own so make backups and follow the instructions carefully.
Now for the Link: http://www.belchfire.net/article205.html

Vb menus are ANSI only.

The quick fix is to ignore Vb menus and create Unicode Owner-Draw menus at run-time. Almost all the menu source code you will find on the WEB are ANSI only but you can easily modify them to accomodate Unicode.

There are two basic types of Owner-Draw menus available:

1. Modifies standard Vb menus to add icons, styles, etc. These are more difficult to adapt to Unicode.

2. Create menus from scratch at run-time. Here you can easily assign Unicode captions and then handle the strings appropriately when you render them.

3. You are also responsible for responding to WM_MEASUREITEM messages to set the menu width.

Owner-Draw Menus with Source Code

Link	Uses Vb Menus	Unicode	Notes
Menu System 4.1
CoolMenu (real icon menus)
vbAccelerator - PopupMenu - Transparent Menu Demonstration
vbAccelerator - Using the cNewMenu DLL to Create Start Menu/ICQ ...
vbAccelerator - PopupMenu - Context Menu Demonstration
Using the cNewMenu DLL to Create Start Menu/ICQ Style Pop-up ...
CoolMenu 1.3.2
MC API MENU CODE GENERATOR ver 2.0
CoolMenu (real icon menus)
SuperCode XP
Office XP Menus (No OCX)
LaVolpe Submenus v2
Update 11-Aug-2001 Enhanced VbAccelerator popup menus
First VB Menu Ownerdraw Engine
HookMenu 1.4			Subclassing Thunk
HookMenu 1.5			Subclassing Thunk

Download a simple demo of an MS Access database with Unicode here.
Also search MSDN or http://www.trigeminal.com for more info.

MS Access database supports Unicode and you can use:

• Microsoft ADO Data Control 6.0 (SP6) (OLEDB) to Bind your control to a Database.
• Microsoft ActiveX Data Objects 2.8 Library.

Note that your control must be Unicode aware such as MSHFlexGrid or Forms 2.0 Object Library Controls.

Question Marks and Garbage characters instead of Arabic text:
http://www.microsoft.com/middleeast/msdn/Questionmark.aspx

Table of Grid Controls

As you can see from the table below there are very few Grid Controls that are Unicode aware. This table was prepared by searching for keyword 'unicode' on Features page for each control.

Control	Unicode Aware NT/2000/XP	Unicode Aware Win98	Link	Notes
sGrid2			VbAccelerator sGrid2.	Source code provided
VSFlexGrid Pro			VSFlexGrid Pro 8.0	A version that supports Unicode is also included.
InaGrid			InaGrid	Supports Unicode on Win9x Platforms
Exontrol ExGrid			Exontrol ExGrid	ANSI and UNICODE versions available
Objective Grid 9.02			Rogue Wave Objective Grid for ActiveX
CyberActiveGrid			www.unisuite.com
Listview			Visual Studio
Listview			www.unisuite.com
MSFlexGrid			Visual Studio
MSHFlexGrid			Visual Studio
SCGrid			SCgrid
Janus GridEX Janus			Janus GridEx
True DBGrid Pro			True DBGrid Pro
UltraGrid			UltraGrid
Protoview Data Table(Infragistics)			DataTable
XpressQuantumGrid and Spread			XpressQuantumGrid
sGrid			www.VbAccelerator.com	Source code provided. Modify for Unicode
iGrid			www.10Tec.com
EasyGrid
DevGrid			DevGrid
FarPoint Spread 6			FarPoint Spread 6
Data Dynamics SharpGrid(#Grid)			SharpGrid(#Grid)
CTGrid			CTGrid
ActiveGrid			ActiveGrid
ContourCube			ContourCube
Data Widgets			Data Widgets
DataTable
FlyTreeX			FlyTreeX
Gridwiz			Gridwiz
itGrid			www.it-partners.com
Mabry Grid/X Control			www.mabry.com/gridx/
Rich Text Grid Control			RichText Grid Control
TList Pro			TList Pro
YDFGrid			YDFGrid

In addition to the examples already provided here are some other useful source codes:

	UniConverter.Zip(10Kb) Convert: UTF16 ð UTF8 UTF8  ð UTF16 UTF16 ð VB6 UTF8  ð VB6 Requires Office FM20.DLL Unicode TextBox.   UTF16 ð  "CHS: 欢迎" UTF8  ð  "CHS: 欢迎" VB6   ð  "CHS: " & ChrW$(&H6B22) & ChrW$(&H8FCE)
	InternationalLocales.Zip(67Kb) Enumerates LCID, CodePage, Months, Days, Numeric, Currency. Modified for Unicode. Requires Office FM20.DLL Unicode controls. Must have FM20ENU.DLL installed. Updated 9-Dec-2003 19:03 UTC. Added Today Icon, CharSetFromLocaleLCID. 130 Locales on WinXP-SP1 with Far East, Complex Scripts, and RightToLeft languages installed.
	WorldTimes.Zip(26Kb) Enumerates all supported locales and associated timezone information including daylight savings entry and exit dates. 27 reusable Date/Time functions. NOT Unicode aware. Uses Vb ANSI controls. Updated 13-Nov-2003 03:10 UTC.
	UniTooltip.Zip(16Kb) Class to create ANSI or Unicode aware Tooltip. Unicode on Win98 RTL for Arabic, Hebrew, Urdu Updated 16-Mar-2004.
	LoadStringEx.Zip(8Kb) Extract a Unicode string from resource. Unlike LoadString you can specify a language. Requires Office FM20.DLL Unicode controls. Must have FM20ENU.DLL installed. Released 24-Feb-2004.
Function to determine if RTL languages are installed courtesy of Keith LaVolpe.. ,	Private Declare Function GetProcAddress Lib "kernel32.dll" (ByVal hModule As Long, ByVal lpProcName As String) As Long Private Declare Function GetModuleHandleA Lib "kernel32" (ByVal lpModuleName As String) As Long Private Declare Function IsValidLanguageGroup Lib "kernel32.dll" (ByVal LanguageGroup As Long, ByVal dwFlags As Long) As Long Public Function IsRTLCapable() As Boolean    Const LGRPID_ARABIC As Long = &HD    Const LGRPID_HEBREW As Long = &HC    Const LGRPID_INSTALLED As Long = &H1    If GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsValidLanguageGroup") Then       If IsValidLanguageGroup(LGRPID_ARABIC, LGRPID_INSTALLED) Then          IsRTLCapable = True       Else          IsRTLCapable = IsValidLanguageGroup(LGRPID_HEBREW, LGRPID_INSTALLED)       End If    End If End Function
Function to determine if Far East languages are installed (adapted from code by Keith LaVolpe).	Private Declare Function GetProcAddress Lib "kernel32.dll" (ByVal hModule As Long, ByVal lpProcName As String) As Long Private Declare Function GetModuleHandleA Lib "kernel32" (ByVal lpModuleName As String) As Long Private Declare Function IsValidLanguageGroup Lib "kernel32.dll" (ByVal LanguageGroup As Long, ByVal dwFlags As Long) As Long   Public Function IsFarEastCapable() As Boolean    Const LGRPID_JAPANESE As Long = &H7    Const LGRPID_KOREAN As Long = &H8    Const LGRPID_SIMPLIFIED_CHINESE As Long = &HA    Const LGRPID_TRADITIONAL_CHINESE As Long = &H9    Const LGRPID_INSTALLED As Long = &H1    Dim i As Long    If GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsValidLanguageGroup") Then       For i = 7 To 10 'JPN - CHS          If IsValidLanguageGroup(i, LGRPID_INSTALLED) Then             IsFarEastCapable = True             Exit For          End If       Next    End If End Function

You can find various functions on the WEB that attempt to identify a string as Unicode:

Function	Author	Comments
Function IsUnicode(ByVal s As String) As Boolean    IsUnicode = Len(s) = LenB(s) End Function	MSDN ??	This is useless since it always returns True. Vb5/Vb6 always stores strings internally as Unicode. This is not analyzing the string.
Public Function IsUnicodeStr(s As String) As Boolean    'Returns True if s evaluates to a Unicode string    Dim dwRtnFlags As Long    dwRtnFlags = IS_TEXT_UNICODE_UNICODE_MASK    IsUnicodeStr = IsTextUnicode(ByVal s, Len(s), dwRtnFlags) End Function	MSDN ??	Returns False on 17 test strings, 2 of which are ANSI and the remaining Unicode. This function is only available on WinNT or later. Also available if MSLU if installed on Win9x. This should work so there is probably something wrong with the implementation.
Public Function IsUtf16(ByVal s As String) As Boolean    Dim i As Long    Dim lLen As Long    Dim lAscW As Long    lLen = Len(s)    For i = 1 To lLen       lAscW = AscW(Mid$(s, i))       If lAscW < 0 Then          lAscW = lAscW + 65536       End If       If (lAscW > 255) Then          IsUtf16 = True          Exit Function       End If Next End Function	UniSuite	Returns correct status for all 17 test strings. Note that this would also return True for a MBCS string so perhaps this function should be called NOT_ANSI. Nevertheless it was written using the assumption that the client is using Unicode/ANSI.
'Purpose:Returns True if string has a Unicode char. Public Function IsUnicode(s As String) As Boolean    Dim i As Long    Dim bLen As Long    Dim Map() As Byte    If LenB(s) Then       Map = s       bLen = UBound(Map)       For i = 1 To bLen Step 2          If (Map(i) > 0) Then             IsUnicode = True             Exit Function          End If       Next    End If End Function	UniSuite	Same functionality as above but much faster. No Mid$ or AscW.

These are visibly displayed graphic characters, not invisible composition controls.

We are in the process of replacing the bitmaps with the actual characters if we can find them(Example of IDS, IDS Example Represents Char). We would appreciate any help from native Chinese speakers.

Hex	Char	Font Code 2000	IDEOGRAPHIC DESCRIPTION CHARACTER	Nº DC	Example of IDS	Example of IDS Bitmap	IDS Example Represents Char	IDS Example Represents Bitmap
2FF0	⿰	⿰	CHARACTER LEFT TO RIGHT	2	⿰
2FF1	⿱	⿱	ABOVE TO BELOW	2	⿱ 天
2FF2	⿲	⿲	LEFT TO MIDDLE AND RIGHT	3	⿲
2FF3	⿳	⿳	ABOVE TO MIDDLE AND BELOW	3	⿳从从日	OK
2FF4	⿴	⿴	FULL SURROUND	2	⿴口
2FF5	⿵	⿵	SURROUND FROM ABOVE	2	⿵門
2FF6	⿶	⿶	SURROUND FROM BELOW	2	⿶凵 土	OK
2FF7	⿷	⿷	SURROUND FROM LEFT	2	⿷匚
2FF8	⿸	⿸	SURROUND FROM UPPER LEFT	2	⿸广
2FF9	⿹	⿹	SURROUND FROM UPPER RIGHT	2	⿹
2FFA	⿺	⿺	SURROUND FROM LOWER LEFT	2	⿺
2FFB	⿻	⿻	OVERLAID	2	⿻从工	OK	OK 巫

Supplementary Characters (Surrogate pairs)

There are two terms that describe the concept of surrogates more accurately:

•  Surrogate Pair, which is a coded character representation for a single abstract character that consists of a sequence of two code points, where the first point of the pair is a high–surrogate and the second is a low–surrogate. A high–surrogate is a Unicode code point in the range U+D800 through U+DBFF, and a low–surrogate is a Unicode code point in the range U+DC00 through U+DFFF.
•  Surrogate Code Point: a Unicode code point in the range U+D800 through U+DFFF. This term is reserved for use by UTF–16, where a pair of surrogate code points (a high–surrogate followed by a low–surrogate) "stand in" for a supplementary code point.

Surrogates or surrogate characters are misnomers because encoded characters cannot have a surrogate code point.

For more information, visit the Unicode Consortium's website, http://www.unicode.org.

Examples:

Char	Vb String	Codepoint	Unicode Block	Font
𠁎	ChrW$(&HD840) & ChrW$(&HDC4E)	2004E	CJK Unified Ideographs Extension B	DFSongStd

In order to see Surrogate Pairs you must have a font which contains the characters you desire to render:

'An example of a surrogate character from CJK extension B is (U+20001, or U+D840 U+DC01 in surrogate code point format). According to Dr. International:http://www.microsoft.com/globaldev/drintl/columns/015/default.mspx#Q13 The SimSun18030 font (simsun18030.ttc) in the GB18030 support package does not have the complete GB18030 repertoire. It is missing the entire CJK Extension B set, as well as other characters. It does have, however, CJK Extension A. A font that contains Simplified Chinese glyphs from both CJK Extension A and B sets is "SimSun (Founder Extended)" (SurSong.ttf in the system), or 宋体–方正超大字符集 (in Chinese). It is currently available in the Simplified Chinese (CHS) version of Office XP, or the Microsoft Office Proofing Tools. Click the link for more information and how to buy.

Here are several Functions for working with Surrogate Pairs::

Download modSurrogate:

72 8 Aug 03 The Unicode Standard 4.0

3.8 Surrogates

D25 High-surrogate code point: A Unicode code point in the range U+D800 to U+DBFF.
D25a High-surrogate code unit: A 16-bit code unit in the range D80016 to DBFF16, used in UTF-16 as the leading code unit of a surrogate pair.
D26 Low-surrogate code point: A Unicode code point in the range U+DC00 to U+DFFF.
D26a Low-surrogate code unit: A 16-bit code unit in the range DC0016 to DFFF16, used in UTF-16 as the trailing code unit of a surrogate pair.

• High-surrogate and low-surrogate code points are designated only for that use.

Conformance 3.9 Unicode Encoding Forms

• High-surrogate and low-surrogate code units are used only in the context of the UTF-16 character encoding form.

D27 Surrogate pair: A representation for a single abstract character that consists of a sequence of two 16-bit code units, where the first value of the pair is a high-surrogate code unit, and the second is a low-surrogate code unit.

• Surrogate pairs are used only in UTF-16. (See Section 3.9, Unicode Encoding Forms.)

• Isolated surrogate code units have no interpretation on their own. Certain other isolated code units in other encoding forms also have no interpretation on their own. For example, the isolated byte 8016 has no interpretation in UTF-8; it can only be used as part of a multibyte sequence. (See Table 3-6.)

• Sometimes high-surrogate code units are referred to as leading surrogates. Low-surrogate code units are then referred to as trailing surrogates. This is analogous to usage in UTF-8, which has leading bytes and trailing bytes.

• For more information, see Section 15.5, Surrogates Area, and Section 5.4, Handling Surrogate Pairs in UTF-16.

There is a common misconception that VbDate is a string. This is probably due to the fact that when you hover over a VbDate in the IDE you will see a formatted date(short date format). It is actually a double in disguise where the integer portion represents the date and the fractional(decimal) portion is the time of day. If a VbDate is applied to a label caption or textbox it will display the date as short date as defined in your regional configurations.

You can coerce a VbDate into a double by using code such as "Cdbl(Now)"

With all the Vb hacks needed to make things work in Unicode it is a pleasant surprise that Format$ with a date argument and FormatDateTime$ are Unicode aware. The problem lies in displaying these string values so you must use a Unicode aware control. If you don't have a Unicode control handy and you are using NT or later then you can simply use a Vb PictureBox and DrawTextW to display the results.

Sample code:

MSDN: Visual Basic 6.0

Here are several methods of Reading and Writing Unicode Files:

Download modUnicodeRW:

Sometimes your file is saved in the old DOS 8.3 covention, aka shortname. This is frustrating and you certainly wouldn't want to display a short filename to a user. The solution is API which can convert to and from short/long pathnames.

Download modPathName:

Due to several requests on various Forums here are some basic instructions on how to enable Unicode in VbAccelerator ListView/TreeView controls. Note that this is just the basics to enable Unicode in LV cells and TV items. It does not include the extra support for LV Header, Column Sorting, or RightToLeft.

You can save registry files either in text or Unicode format, but versions of Windows earlier than Win2K can't recognize Unicode files, so for those OS versions, you need to save the files in text format. In XP and Win2K, the registry editor is version 5, which you'll find specified in the first line of the exported registry file, which reads "Windows Registry Editor Version 5.00." Changing this header line (you can use a text editor such as notepad.exe to do so) to read REGEDIT4 will make the file compatible with earlier Windows OSs.

Since registry entries(Keys, Values) under Windows Registry 5.0 format can be Unicode you need to use the Wide versions of AdvApi32.DLL to manipulate keys and values. If you want to make a RegEdit clone you will also need Unicode aware versions of TreeView/ListView to render Unicode keys and values.

This snippet shows how one would implement registry functions that can run on all Platforms. We create a "Public Function RegOpenKeyEx" and then call the ANSI or Wide API versions as appropriate.

Private Declare Function RegOpenKeyExA Lib "advapi32" (ByVal hkey As Long, ByVal lpSubKey As String, ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As Long) As Long
Private Declare Function RegOpenKeyExW Lib "advapi32" (ByVal hkey As Long, ByVal lpSubKey As Long, ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As Long) As Long

'Purpose: ANSI/Unicode wrapper.
Public Function RegOpenKeyEx(ByVal hkey As Long, ByVal lpSubKey As String, ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As Long) As Long
   If Is2000 Then
      RegOpenKeyEx = RegOpenKeyExW(hkey, StrPtr(lpSubKey), ulOptions, samDesired, phkResult)
   Else
      RegOpenKeyEx = RegOpenKeyExA(hkey, lpSubKey, ulOptions, samDesired, phkResult)
   End If
End Function

If you plan on writing you own Registry class here is a wish list of features available in RegEdit and some commercial Registry Editors:

• Enumerate Keys
• Enumerate Values
• Get/Set/Delete/Create/Rename Keys.
• Get/Set/Delete Values.
• KeyExists/ValueExists/HasSubKey.
• Import/Export ð Windows Registry 5.0 format.

• Import/Export ð XML.

• Receive notification of registry changes via events.
• Search registry keys, values, and data with full regular expression support.
• Manipulate key names including extracting parent and base key names.

"According to Microsoft" Windows 95 and 98 were built upon 3.1, and they don't support Unicode. All applications written for Windows 98 should be ANSI applications.

Actually Windows 98 has a handful of Unicode APIs, which are listed in the below table. Other than these functions, the system DLLs for Windows 98 have export symbols for wide character functions as well, but they all return FALSE, and GetLastError would return ERROR_CALL_NOT_IMPLEMENTED which is defined as 120.

What is really missing in Win98 and necessary for serious work is the DrawTextW API:
Private Declare Function DrawTextW Lib "user32" (ByVal hdc As Long, ByVal lpStr As Long, ByVal nCount As Long, lpRect As rect, ByVal wFormat As Long) As Long

To get this in Win98 you will need to write a Uniscribe Wrapper that will emulate this function. This is not an easy task since there are 24 DrawText Alignment Flags that can be combined to specify how the text is to be formatted within the bounding rectangle.

Example of how to integrate the wrapper:

Public Sub DrawTextU(ByVal sText As String, ByRef rct as Rect, ByVal lFlags As Long)
   Dim lPtr As Long

   If (LenB(sText) = 0) Then Exit Sub

   If (IsNT) Then
      lPtr = StrPtr(sText)
      If Not (lPtr = 0) Then
         DrawTextW hdc, lPtr, -1, rct, lFlags
      End If
   Else 'Win9x
      If IsUnicode(sText) Then
         'Call Uniscribe Wrapper here
      Else
         DrawTextA hdc, sText, -1, rct, lFlags
      End If
   End If
End Sub

This class and demo show exactly how strings are stored in Visual Basic. They are stored as integers(0-65535). Since Vb does not have an unsigned integer we convert the VB signed Integer to a positive Long in the Demo. You can find the original submission by Chris Lucas at Planet Source Code http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=34787&lngWId=1 The original code has been modified to use a class. You can download the complete source code at http://www.unisuite.com/download/MapString.zip.

A Byte Array is an array of bytes that starts at LBound(usually 0 unless you change Option Base) and ends at UBound. Here are some examples:

An important note is that a Vb string ends with a null byte which is Chr$(0). A byte array ends with the last character of the string and has no null byte.

OK so Byte Arrays can also be used to load raw data such as WAV, GIF, JPG from resources. The Byte Array is then written to a temp file and then loaded back using LoadPicture(). In the case of WAV you can use the following Declare to pass a byte array:
Private Declare Function PlaySoundData Lib "winmm.dll" Alias "PlaySoundA" (lpData As Any, ByVal hModule As Long, ByVal dwFlags As Long) As Long

A better way to eliminate the temp file is to use IStream which is addressed in the next topic.

If you try to use Get/Put to write Unicode strings they are changed to ANSI via the Put method.

Put appears to use a proprietary format to write UDT data which is then readable by Get.
If you would like to study more about how this works in Vb6 see the link:
http://sandsprite.com/CodeStuff/Understanding_UDTs.html

It is also interesting that VB's Put and Get command were built to be pretty smart. We know that complex UDTs(such as "s As String" or "b() As Byte") aren't stored in memory as a continuous block, however the VB Put command is kind enough to pack the whole structure and data into a new format for us so that it is complete when dumping it to disk.

Example:

• Dim MyArray() As My Type
• ReDim MyArray(17)
• Populate array elements (try Unicode for s).
• Using Put, write the UBound(MyArray) as a Long followed by Put #FF, , MyArray.
• Using Get, read the UBound(MyArray), redimension a new array and then ready the array with Get #FF, , MyArray.
• If you examine the file you will notice that the strings are automatically changed to ANSI and Unicode characters become "?".

The solution for Unicode is simple. Just change the UDT to:

MyType
    b() As Byte
    i As Integer
   L as Long
End Type

Example (Write): MyArray(0).b = "CHS: " & ChrW$(&H6B22) & ChrW$(&H8FCE)
Example (Read): MyString =  MyArray(0).b

Now that strings are stored as a byte array they will not be corrupted and you can use Get/Put for Unicode strings in UDTs.

Many people shy away from IStream because they think it is too complex to implement or requires a Type Library. Neither is true. That is of course assuming you do not require the full repetoire of IStream Read/Seek, etc.

Where would you use IStream? A good example would be reading a Byte Array from a CUSTOM resource such as Jpg or Gif. Normally you would write the Byte Array to a temp file and then read it back in via LoadPicture().
This is very ineffiecient for the following reasons:

• You are adding 2 unnecessary file I/O calls. One to write the file and another to read it back.
• You need to create a unique filename so that you don't overwrite existing files.
• You need to delete this file after you are finished so as not to clutter up your disk with useless files.
   

Another place to use IStream is in conjunction with BLOBs from a Database. They could be strings or pictures. In any case you read the data into a Byte Array, convert to IStream, and finally pass it to a function that accepts Istream.

In the example here we are loading data from a Byte Array. This could be for example LoadResData from a CUSTOM resource such as Jpg or Gif. Almost all examples on the Web use a TLB but here we will define IStream here as IUnknown. Also note that the Declares use "As Any". Note that this sample code is used where IStream is required for input as in GDI+ CreateBitmapFromIStream. You also need to tweak the GDI+ Declares that use IStream to type IUnknown.

OK. This works where you require a stream but what about StdPicture objects. Not that much more complicated in that you need to prefix a picture header to the byte array and call OleCreatePictureIndirect. CopyMemory API is used to put this together.

These are the basics of how to make a Unicode aware calendar control. You can use the ComCtl32.Dll derived DTPicker or MonthCal but this will only display a calendar for the current LCID set in Control Panel/ Regional Settings.

To make a calendar that will work for any LCID:

• Use API EnumSystemLocales with Flag LCID_INSTALLED to build a collection of installed Locales for the users Platform. These can then be added to a ListBox.

• Add a Unicode aware ComboBox for MonthName selection and an UpDown Control for Year selection.

• Select an LCID for the calendar.

• Populate MonthName Combo using API GetLocaleInfoW.

• Owner draw the calendar using the current selected Year/Month.

Note that Vb supports both Gregorian and Hijri Calendars via VBA.Calendar = vbCalGreg or VBA.Calendar = vbCalHijri