Partager via

À propos du modèle objet texte

  • Article

Le modèle d’objet texte (TOM) définit un ensemble d’interfaces de manipulation de texte prises en charge à des degrés divers par plusieurs solutions de texte Microsoft, y compris le contrôle d’édition enrichi. Cette rubrique fournit une vue d’ensemble générale du TOM. Il traite des sujets suivants.

Objets TOM version 2

TOM version 2 (TOM 2) étend le modèle objet texte d’origine ; les nouvelles interfaces sont dérivées des anciennes. L’API TOM mise à jour prend en charge les nouvelles propriétés de format de caractères et de paragraphes, un modèle de table, une sélection multiple et la prise en charge des objets inline pour les mathématiques et ruby.

L’objet TOM 2 de niveau supérieur est défini par l’interface ITextDocument2 , qui a des méthodes pour créer et récupérer des objets plus bas dans la hiérarchie des objets. Pour un traitement simple de texte brut, vous pouvez obtenir un objet ITextRange2 à partir d’un objet ITextDocument2 et tout faire avec. Si vous devez ajouter une mise en forme de texte enrichi, vous pouvez obtenir des objets ITextFont2 et ITextPara2 à partir d’un objet ITextRange2 . ITextFont2 fournit l’équivalent de programmation de la boîte de dialogue format-police Microsoft Word, et ITextPara2 fournit l’équivalent de la boîte de dialogue format-paragraphe Word.

En plus de ces trois objets de niveau inférieur, TOM 2 a un objet de sélection (ITextSelection2), qui est un objet ITextRange2 avec une sélection mise en surbrillance et certaines méthodes orientées interface utilisateur.

Les objets de plage et de sélection incluent des méthodes orientées écran qui permettent aux programmes d’examiner du texte à l’écran ou du texte qui peut être fait défiler vers l’écran. Ces fonctionnalités permettent de rendre le texte accessible aux personnes malvoyantes, par exemple.

Chaque interface qui a le suffixe 2 hérite de l’interface correspondante sans le suffixe 2. Par exemple, ITextDocument2 hérite d’ITextDocument.

Les objets TOM 2 ont la hiérarchie suivante.

ITextDocument2         Top-level editing object
    ITextRange2        Primary text interface: a range of text
        ITextFont2     Character-attribute interface
        ITextPara2     Paragraph-attribute interface
        ITextRow       Table interface
    ITextSelection2    Screen highlighted text range
        ITextRange2    Selection inherits all range methods
    ITextDisplays      Displays collection (not yet defined)
    ITextStrings       Rich-text strings collection
    ITextStoryRanges2  Enumerator for stories in document

Un objet ITextDocument2 décrit une ou plusieurs plages contiguës de texte appelées stories. Les récits représentent différentes parties d’un document, telles que le texte main du document, les en-têtes et les pieds de page, les notes de bas de page, les annotations et les blocs de travail de texte enrichi. Un récit de bloc de travail est utilisé lors de la traduction entre des expressions mathématiques au format linéaire et un formulaire intégré. Un récit de bloc de travail est également utilisé lors de l’enregistrement du contenu d’une plage qui est la source de copie actuelle lorsque le contenu est sur le point d’être modifié.

Un objet ITextRange2 est défini par ses décalages de position de caractère de début et de fin et un objet story. Il n’existe pas indépendamment de son objet story parent, bien que son texte puisse être copié dans le Presse-papiers ou vers d’autres cibles. Un objet de plage de texte est différent de la feuille de calcul et d’autres objets de plage, qui sont définis par d’autres types de décalages ; par exemple, ligne/colonne ou position graphique (x, y). Un objet de plage de texte peut se modifier de différentes manières, peut retourner un doublon de lui-même et il peut être ordonné de copier ses positions de début et de fin des caractères et son pointeur d’histoire vers la sélection actuelle.

Un objet story explicite n’est pas nécessaire, car un objet ITextRange peut toujours être créé pour représenter une histoire donnée. En particulier, l’objet ITextDocument peut créer un objet ITextStoryRanges pour énumérer les récits dans le document en termes de plages avec des valeurs de position de début et de fin de caractère qui décrivent des récits complets (par exemple, 0 et tomForward).

Avec un objet ITextStoryRanges2 , un objet story explicite n’est pas nécessaire, car chaque histoire est décrite par un objet ITextRange2 . En particulier, l’objet ITextDocument2 peut créer un objet ITextStoryRanges2 pour énumérer les récits dans le document en termes de plages avec des valeurs de position de début et de fin de caractères qui décrivent des récits complets (par exemple, 0 et tomForward).

L’interface ITextRow et les méthodes ITextRange::Move et ITextRange::Expand permettent d’insérer, d’interroger et de modifier des tables.

Conventions d’interface TOM

Toutes les méthodes TOM retournent des valeurs HRESULT . En général, les méthodes TOM retournent les valeurs standard suivantes.

  • E_OUTOFMEMORY
  • E_INVALIDARG
  • E_NOTIMPL
  • E_FILENOTFOUND
  • E_ACCESSDENIED
  • E_FAIL
  • CO_E_RELEASED
  • NOERROR (identique à S_OK)
  • S_FALSE

N’oubliez pas que si la modification instance associée à un objet TOM tel que ITextRange est supprimée, l’objet TOM devient inutile et toutes ses méthodes retournent CO_E_RELEASED.

En plus des valeurs de retour HRESULT , de nombreuses méthodes incluent des paramètres de sortie, qui sont des pointeurs utilisés pour retourner des valeurs. Pour toutes les interfaces, vous devez case activée tous les paramètres de pointeur pour vous assurer qu’ils ne sont pas nuls avant de les utiliser. Si vous passez une valeur null à une méthode qui nécessite un pointeur valide, la méthode retourne E_INVALIDARG. Les pointeurs de sortie facultatifs avec des valeurs null sont ignorés.

Utilisez des méthodes avec des préfixes Get et Set pour obtenir et définir des propriétés. Les variables booléennes utilisent tomFalse (0) pour FALSE et tomTrue (-1) pour TRUE.

Les constantes TOM sont définies dans le type d’énumération tomConstants et commencent par le préfixe tom, par exemple tomWord.

The tomBool Type

De nombreuses méthodes TOM utilisent un type spécial de variable appelé « tomBool » pour les attributs de texte enrichi qui ont des états binaires. Le type tomBool est différent du type booléen , car il peut prendre quatre valeurs : tomTrue, tomFalse, tomToggle et tomUndefined. Les valeurs tomTrue et tomFalse indiquent true et false. La valeur tomToggle est utilisée pour activer une propriété. La valeur tomUndefined , plus traditionnellement appelée NINCH, est une valeur spéciale sans entrée, sans changement qui fonctionne avec les longs, les floats et les COLORREF. Pour les chaînes, tomUndefined (ou NINCH) est représenté par la chaîne null. Pour les opérations de définition de propriété, l’utilisation de tomUndefined ne modifie pas la propriété cible. Pour les opérations d’obtention de propriétés, tomUndefined signifie que les caractères de la plage ont des valeurs différentes (il donne la zone de case activée grisée dans les boîtes de dialogue de propriété).

Math BuildUp et Build Down

Vous pouvez utiliser la méthode ITextRange2::BuildUpMath pour convertir des expressions mathématiques au format linéaire en versions intégrées. La méthode ITextRange2::Linearize effectue la conversion inverse, appelée linéarisation ou build down, pour convertir des versions prédéfinies d’expressions mathématiques au format linéaire. La fonctionnalité de génération de mathématiques est utile lorsque vous devez exporter du texte brut ou activer certains types de modification.

TOM RTF

Dans TOM, l’échange de texte enrichi peut être effectué par des ensembles d’appels de méthode explicites ou par des transferts de texte enrichi au format RTF (Rich Text Format). Cette section fournit des tables de mots de contrôle RTF pour les propriétés de paragraphe et pour les propriétés de caractères.

Mots de contrôle de paragraphe TOM RTF

Mot de contrôle Signification
\ fi n Retrait de première ligne (la valeur par défaut est zéro).
\Garder Conservez le paragraphe intact.
\ keepn Conservez le paragraphe suivant.
\ li n Retrait gauche (la valeur par défaut est zéro).
\ noline Aucune numérotation de ligne.
\ nowidctlpar Désactivez le contrôle veuve/orphelin.
\ pagebb Page de saut avant le paragraphe.
\ par Nouveau paragraphe.
\ pard Réinitialise les propriétés de paragraphe par défaut.
\Ql Aligné à gauche (valeur par défaut).
\Qr Aligné à droite.
\Qj Justifié.
\Qc Centré.
\ ri n Retrait droit (la valeur par défaut est zéro).
\ s n Style n.
\ sa n Espace après (la valeur par défaut est zéro).
\ sb n Espace avant (la valeur par défaut est zéro).
\ sl n En cas d’absence ou si n=1000, l’espacement des lignes est déterminé par le caractère le plus haut de la ligne (espacement d’une seule ligne) ; si n> zéro, au moins cette taille est utilisée ; si n est < zéro, exactement | n| est utilisé. L’espacement de ligne est l’espacement de plusieurs lignes si \ slmult 1 suit.
\ slmult m Suit \ sl. m = zéro : Espacement de ligne au moins ou exacte, comme décrit par \ sl n. m = 1 : espacement des lignes = n/240 fois l’espacement d’une seule ligne.
\ to n Position de la tabulation de la barre, en twips, à partir de la marge gauche.
\ tldot Points de leader de tabulation.
\ tleq Signe égal du leader de tabulation.
\ tlhyphe Traits d’union du leader de tabulation.
\ tlth Ligne épaisse du leader de la tabulation.
\ tlul Soulignement du leader de tabulation.
\ tqc Onglet centré.
\ tqdec Onglet Décimal.
\ tqr Onglet Vider à droite.
\ tx n Position de tabulation, en twips, à partir de la marge gauche.

 

MOTS DE CONTRÔLE DE FORMAT DE CARACTÈRES TOM RTF

Mot de contrôle Signification
\ animation n Définit le type d’animation sur n.
\B Gras.
\Casquettes Toutes les majuscules.
\ cf n Couleur de premier plan (la valeur par défaut est tomAutocolor).
\ cs n Style de caractère n.
\ dn n Position de l’indice en demi-points (la valeur par défaut est 6).
\Embo En relief.
\ f n Numéro de police, n fait référence à une entrée dans la table de polices.
\ fs n Taille de police en demi-points (la valeur par défaut est 24).
\ mettre en surbrillance n Couleur d’arrière-plan (la valeur par défaut est tomAutocolor).
\Je Italique.
\ impr Empreinte.
\ lang n Applique une langue à un caractère. n est un nombre correspondant à une langue. Le mot de contrôle \ plain réinitialise la propriété language à la langue définie par \ deflang n dans les propriétés du document.
\ nosupersub Désactive l’exposant ou l’indice.
\ outl Contour.
\Plaine Réinitialise les propriétés de mise en forme des caractères à une valeur par défaut définie par l’application. Les propriétés de mise en forme de caractères associées (décrites dans la section Propriétés de caractères associées dans la spécification RTF) sont également réinitialisées.
\ scaps Petites capitales.
\Shad Ombre.
\Strike Barré.
\ sub Applique l’indice au texte et réduit la taille des points en fonction des informations de police.
\Super Applique l’exposant au texte et réduit la taille des points en fonction des informations de police.
\Ul Soulignement continu. \ ul0 désactive tous les sous-ensembles.
\Uld Soulignement en pointillés.
\ uldb Double soulignement.
\ ulnone Arrête toute mise en avant.
\ ulw Word soulignement.
\ up n Position d’exposant en demi-points (la valeur par défaut est 6).
\C Texte masqué.

 

Recherche de texte enrichi

Vous pouvez utiliser des méthodes TOM pour rechercher du texte enrichi tel que défini par une plage de texte. Trouver un texte aussi riche exactement est souvent nécessaire dans le traitement de texte, bien qu’il n’ait jamais été réalisé dans un traitement de texte « ce que vous voyez est ce que vous obtenez » (WYSIWYG). Il existe clairement un domaine plus large de correspondance de texte enrichi qui permet d’ignorer certaines propriétés de mise en forme de caractères (ou d’inclure la mise en forme de paragraphe et/ou le contenu d’objet), mais ces généralisations dépassent le cadre de cette section.

L’un des objectifs de cette fonctionnalité est d’utiliser une boîte de dialogue Rechercher en texte enrichi pour définir le texte enrichi que vous souhaitez localiser dans un document. La boîte de dialogue est implémentée à l’aide d’un contrôle d’édition enrichi et les méthodes TOM sont utilisées pour effectuer la recherche dans le document. Vous pouvez copier le texte enrichi souhaité à partir du document dans la boîte de dialogue Rechercher , ou l’entrer et le mettre en forme directement dans la boîte de dialogue Rechercher .

L’exemple suivant montre comment utiliser des méthodes TOM pour rechercher du texte contenant des combinaisons de mise en forme exacte des caractères. L’algorithme recherche le texte brut dans la plage de correspondances, qui est nommée pr1. Si le texte brut est trouvé, il est pointé vers une plage d’essai nommée pr2. Ensuite, deux plages de points d’insertion (prip1 et prip2) sont utilisées pour parcourir la plage d’essai en comparant sa mise en forme de caractères à celle de pr1. Si elles correspondent exactement, la plage d’entrée (donnée par ppr) est mise à jour pour pointer vers le texte de la plage d’essai et la fonction retourne le nombre de caractères dans la plage correspondante. Deux objets ITextFont , pf1 et pf2, sont utilisés dans la comparaison de mise en forme de caractères. Ils sont attachés aux plages prip1 de points d’insertion et prip2.

LONG FindRichText (
    ITextRange **ppr,             // Ptr to range to search
    ITextRange *pr1)              // Range with rich text to find
{
    BSTR        bstr;             // pr1 plain-text to search for
    LONG        cch;              // Text string count
    LONG        cch1, cch2;       // tomCharFormat run char counts
    LONG        cchMatch = 0;     // Nothing matched yet
    LONG        cp;               // Handy char position
    LONG        cpFirst1;         // pr1 cpFirst
    LONG        cpFirst2;         // pr2 cpFirst
    ITextFont  *    pf1, *pf      // Fonts corresponding to IPs prip1 and prip2
    ITextRange *pr2;              // Range duplicate to search with
    ITextRange *prip1, *prip      // Insertion points to walk pr1, pr2

    if (!ppr || !*ppr || !pr1)
        return E_INVALIDARG;

    // Initialize range and font objects used in search
    if ((*ppr)->GetDuplicate(&pr2)    != NOERROR ||
        pr1->GetDuplicate(&prip1)     != NOERROR ||
        pr2->GetDuplicate(&prip2)     != NOERROR ||
        prip1->GetFont(&pf1)          != NOERROR ||
        prip2->GetFont(&pf2)          != NOERROR ||
        pr1->GetText(&bstr)           != NOERROR )
    {
        return E_OUTOFMEMORY;
    }

    pr1->GetStart(&cpFirst1);

    // Keep searching till rich text is matched or no more plain-text hits
    while(!cchMatch && pr2->FindText(bstr, tomForward, 0, &cch) == NOERROR)
    {
        pr2->GetStart(&cpFirst2);                 // pr2 is a new trial range
        prip1->SetRange(cpFirst1, cpFirst1);      // Set up IPs to scan match
        prip2->SetRange(cpFirst2, cpFirst2);      //  and trial ranges

        while(cch > 0 &&
            pf1->IsEqual(pf2, NULL) == NOERROR)   // Walk match & trial ranges
        {                                         //  together comparing font
            prip1->GetStart(&cch1);               //  properties
            prip1->Move(tomCharFormat, 1, NULL);
            prip1->GetStart(&cp);
            cch1 = cp - cch1;                     // cch of next match font run

            prip2->GetStart(&cch2);
            prip2->Move(tomCharFormat, 1, NULL);
            prip2->GetStart(&cp);
            cch2 = cp - cch2;                      // cch of next trial font run

            if(cch1 < cch)                         // There is more to compare
            {
                if(cch1 != cch2)                   // Different run lengths:
                    break;                         //  no formatting match
                cch = cch - cch1;                  // Matched format run
            }
            else if(cch2 < cch)                    // Trial range format run too
                break;                             //  short

            else                                   // Both match and trial runs
            {                                      //  reach at least to match
                pr2->GetEnd(&cp);                  //  text end: rich-text match
                (*ppr)->SetRange(cpFirst2, cp)     // Set input range to hit
                cchMatch = cp - cpFirst2;          //  coordinates and return
                break;                             //  length of matched string
            }
        }
    }
    pr2->Release();
    prip1->Release();
    prip2->Release();
    pf1->Release();
    pf2->Release();
    SysFreeString(bstr);

    return cchMatch;
}

Accessibilité TOM

TOM fournit une prise en charge de l’accessibilité via les interfaces ITextSelection et ITextRange . Cette section décrit les méthodes utiles pour l’accessibilité, ainsi que la façon dont un programme peut déterminer la position d’écran x, y d’un objet.

Étant donné que les programmes d’accessibilité basés sur l’interface utilisateur fonctionnent généralement avec l’écran et la souris, une préoccupation courante consiste à trouver l’interface ITextDocument correspondante pour l’emplacement actuel de la souris (en coordonnées d’écran). Les sections suivantes présentent deux façons de déterminer l’interface appropriée :

Pour plus d’informations, consultez la spécification Microsoft Active Accessibility. Après avoir obtenu un objet à partir d’une position d’écran, vous pouvez utiliser pour une interface ITextDocument et appeler la méthode RangeFromPoint pour obtenir un objet de plage vide au niveau du cp correspondant à la position de l’écran.

Interface de la table d’objets en cours d’exécution

Une table d’objets en cours d’exécution (ROT) indique quelles instances d’objet sont actives. En interrogeant cette table, vous pouvez accélérer le processus de connexion d’un client à un objet lorsque l’objet est déjà en cours d’exécution. Pour que les programmes puissent accéder aux interfaces TOM via la table d’objets en cours d’exécution, un instance TOM avec une fenêtre doit s’inscrire dans le ROT à l’aide d’un moniker. Vous construisez le moniker à partir d’une chaîne contenant la valeur hexadécimale de son HWND. L’exemple de code suivant montre comment procéder.

// This TOM implementation code is executed when a new windowed 
// instance starts up. 
// Variables with leading underscores are members of this class.

HRESULT hr;
OLECHAR szBuf[10];            // Place to put moniker
MONIKER *pmk;

hr = StringCchPrintf(szBuff, 10, "%x", _hwnd);
if (FAILED(hr))
{
    //
    // TODO: write error handler
    //
}
CreateFileMoniker(szBuf, &pmk);
OleStdRegisterAsRunning(this, pmk, &_dwROTcookie);
....................
 
// Accessibility Client: 
//    Find hwnd for window pointed to by mouse cursor.

GetCursorPos(&pt);
hwnd = WindowFromPoint(pt);

// Look in ROT (running object table) for an object attached to hwnd

hr = StringCchPrintf(szBuff, 10, "%x", hwnd);
if (FAILED(hr))
{
    //
    // TODO: write error handler
    //
}
CreateFileMoniker(szBuf, &pmk);
CreateBindContext(0, &pbc);
pmk->BindToObject(pbc, NULL, IID_ITextDocument, &pDoc);
pbc->Release();

if( pDoc )
{
    pDoc->RangeFromPoint(pt.x, pt.y, &pRange);
    // ...now do whatever with the range pRange
}

Interface à partir des messages de fenêtre

Le message EM_GETOLEINTERFACE fournit une autre façon d’obtenir une interface IUnknown pour un objet à une position d’écran donnée. Comme décrit dans Interface à partir d’une table d’objets en cours d’exécution, vous obtenez un HWND pour la position de l’écran, puis envoyez ce message à ce HWND. Le message EM_GETOLEINTERFACE est riche spécifique à l’édition et retourne un pointeur vers une interface IRichEditOle dans la variable adressée par lParam.

Pointe Si un pointeur est retourné (veillez à définir l’objet vers lequel lParam pointe sur null avant d’envoyer le message), vous pouvez appeler sa méthode IUnknown::QueryInterface pour obtenir une interface ITextDocument . L'exemple de code suivant illustre cette approche.

    HWND    hwnd;
    ITextDocument *pDoc;
    ITextRange *pRange;
    POINT    pt;
    IUnknown *pUnk = NULL;
    
    GetCursorPos(&pt);
    hwnd = WindowFromPoint(pt);
    SendMessage(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&pUnk);
    if(pUnk && 
        pUnk->QueryInterface(IID_ITextDocument, &pDoc) == NOERROR)
    {
        pDoc->RangeFromPoint(pt.x, pt.y, &pRange);
        //  ... continue with rest of program
    }

Méthodes orientées accessibilité

Certaines méthodes TOM sont particulièrement utiles pour naviguer dans l’écran, tandis que d’autres méthodes TOM améliorent ce que vous pouvez faire lorsque vous arrivez à des lieux d’intérêt. Le tableau suivant décrit les méthodes les plus utiles.

Méthode Comment il favorise l’accessibilité
GetSelection Cette méthode obtient la sélection active qui peut être utilisée à diverses fins orientées vue, telles que la mise en surbrillance du texte et le défilement.
RangeFromPoint Lorsqu’elle est utilisée sur une sélection active, cette méthode est garantie d’obtenir une plage associée à une vue particulière.
Développez Agrandit une plage de texte afin que toutes les unités partielles qu’elle contient soient entièrement contenues. Par exemple, Expand(tomWindow) étend la plage pour inclure la partie visible de l’histoire de la plage.
GetDuplicate Lorsqu’elle est utilisée sur une sélection active, cette méthode est garantie d’obtenir une plage associée à une vue particulière. Consultez la description de RangeFromPoint.
GetPoint Obtient les coordonnées de l’écran pour la position du caractère de début ou de fin dans la plage de texte.
ScrollIntoView Fait défiler une plage de texte dans l’affichage.
Consigne Sélectionne le texte au niveau ou vers le haut jusqu’à un point spécifié.

 

Jeux de correspondances de caractères

Le paramètre variant des différentes méthodes Move* dans ITextRange, telles que MoveWhile et MoveUntil, peut prendre une chaîne explicite ou un index 32 bits de jeu de caractères. Les index sont définis par des plages Unicode ou des jeux de caractères GetStringTypeEx . La plage Unicode commençant à n et de longueur l (< 32768) est donnée par l’index n + (l << 16) + 0x80000000. Par exemple, les lettres grecques de base sont définies par CR_Greek = 0x805f0370 et les caractères ASCII imprimables sont définis par CR_ASCIIPrint = 0x805e0020. En outre, les méthodes MoveWhile et MoveUntil vous permettent de contourner rapidement une étendue de caractères dans un jeu de caractères GetStringTypeEx ou dans une étendue de caractères qui ne se trouve dans aucun de ces jeux de caractères.

Les jeux GetStringTypeEx sont spécifiés par les valeurs de Ctype1, Ctype2 et Ctype3, et sont définis comme suit.

Cset Signification
Ctype1 Combinaison de types CT_CTYPE1.
Ctype2 + tomCType2 N’importe quel type de CT_CTYPE2.
Ctype3 + tomCType3 Combinaison de types CT_CTYPE3.

 

Plus précisément, Ctype1 peut être n’importe quelle combinaison des éléments suivants.

Nom Ctype1 Valeur Signification
C1_UPPER 0x0001 Majuscules.
C1_LOWER 0x0002 Minuscules.
C1_DIGIT 0x0004 Décimaux.
C1_SPACE 0x0008 Espaces.
C1_PUNCT 0x0010 La ponctuation.
C1_CNTRL 0x0020 Caractères de contrôle.
C1_BLANK 0x0040 Caractères vides.
C1_XDIGIT 0x0080 Chiffres hexadécimaux.
C1_ALPHA 0x0100 Tout caractère linguistique (alphabétique, syllabaire ou idéographique).
C1_DEFINED 0x0200 Caractère défini, mais pas l’un des autres types C1_*.

 

Les types Ctype2 prennent en charge la disposition appropriée du texte Unicode. Les attributs de direction sont attribués afin que l’algorithme de disposition bidirectionnelle standardisé par Unicode produise des résultats précis. Ces types s’excluent mutuellement. Pour plus d’informations sur l’utilisation de ces attributs, consultez The Unicode Standard: Worldwide Character Encoding, Volumes 1 et 2, Addison-Wesley Publishing Company: 1991, 1992.

Nom CType2 Valeur Signification
Forte:
C2_LEFTTORIGHT 0x1 De gauche à droite.
C2_RIGHTTOLEFT 0x2 De droite à gauche
Faible:
C2_EUROPENUMBER 0x3 Numéro européen, chiffre européen.
C2_EUROPESEPARATOR 0x4 Séparateur numérique européen.
C2_EUROPETERMINATOR 0x5 Terminateur numérique européen.
C2_ARABICNUMBER 0x6 Numéro arabe.
C2_COMMONSEPARATOR 0x7 Séparateur numérique commun.
Neutre:
C2_BLOCKSEPARATOR 0x8 Séparateur de blocs.
C2_SEGMENTSEPARATOR 0x9 Séparateur de segments.
C2_WHITESPACE 0xA Espace blanc.
C2_OTHERNEUTRAL 0xB Autres neutres.
Non applicable :
C2_NOTAPPLICABLE 0x0 Aucune direction implicite.

 

Les types Ctype3 sont destinés à être des espaces réservés pour les extensions des types POSIX requis pour le traitement de texte général ou pour les fonctions de bibliothèque C standard.

Nom CType3 Valeur Signification
C3_NONSPACING 0x1 Marque de non-espacement.
C3_DIACRITIC 0x2 Marque de non-espacement diacritique.
C3_VOWELMARK 0x4 Marque de non-espacement de voyelle.
C3_SYMBOL 0x8 Symbole.
C3_KATAKANA 0x10 Caractère katakana.
C3_HIRAGANA 0x20 Caractère hiragana.
C3_HALFWIDTH 0x40 Caractère demi-largeur.
C3_FULLWIDTH 0x80 Caractère pleine largeur.
C3_IDEOGRAPH 0x100 Caractère idéographique.
C3_KASHIDA 0x200 Caractère arabe de Kashida.
C3_ALPHA 0x8000 Tous les caractères linguistiques (alphabétiques, syllabiques et idéographiques).
C3_NOTAPPLICABLE 0x0 Non applicable.

 

Un kit de développement d’édition (EDK) peut inclure des définitions d’index pVar pour les plages suivantes décrites dans la norme Unicode.

Jeu de caractères Plage Unicode Jeu de caractères Plage Unicode
ASCII 0x0— 0x7f ANSI 0x0—0xff
ASCIIPrint 0x20—0x7e Latin1 0x20—0xff
Latin1Supp 0xa0— 0xff LatinXA 0x100—0x17f
LatinXB 0x180—0x24f IPAX 0x250— 0x2af
SpaceMod 0x2b0—0x2ff Combinant 0x300—0x36f
Grec 0x370 — 0x3ff BasicGreek 0x370—0x3cf
GrecSymbols 0x3d0—0x3ff Cyrillique 0x400— 0x4ff
Arménien 0x530—0x58f Hébreu 0x590—0x5ff
BasicHebrew 0x5d0—0x5ea HebrewXA 0x590— 0x5cf
HebrewXB 0x5eb—0x5ff Arabe 0x600 — 0x6ff
BasicArabic 0x600—0x652 ArabicX 0x653—0x6ff
Devangari 0x900—0x97f Bangla (anciennement Bengali) 0x980—0x9ff
Gurmukhi 0xa00—0xa7f Goudjrati 0xa80—0xaff
Odia (anciennement Oriya) 0xb00—0xb7f Tamoul 0xb80—0xbff
Teluga 0xc00—0xc7f Kannada 0xc80—0xcff
Malayalam 0xd00—0xd7f Thaï 0xe00—0xe7f
Lao 0xe80—0xeff GeorgianX 0x10a0—0xa0cf
BascGeorgian 0x10d0—0x10ff Jamo 0x1100—0x11ff
LatinXAdd 0x1e00—0x1eff GreekX 0x1f00— 0x1fff
GenPunct 0x2000—0x206f Superscript 0x2070 — 0x207f
Indice 0x2080—0x208f SuperSubscript 0x2070—0x209f
Devise 0x20a0—0x20cf CombMarkSym 0x20d0—0x20ff
LetterLike 0x2100—0x214f NumberForms 0x2150—0x218f
Flèches 0x2190—0x21ff MathOps 0x2200—0x22ff
MiscTech 0x2300—0x23ff CtrlPictures 0x2400—0x243f
OptCharRecog 0x2440—0x245f EnclAlphaNum 0x2460—x24ff
BoxDrawing 0x2500—0x257f BlockElement 0x2580 — 0x259f
GeometShapes 0x25a0—0x25ff MiscSymbols 0x2600—0x26ff
Dingbats 0x2700— 0x27bf CJKSymPunct 0x3000—0x303f
Hiragana 0x3040— 0x309f Katakana 0x30a0— 0x30ff
Bopomofo 0x3100—0x312f HangûlJamo 0x3130—0x318f
CJLMisc 0x3190—0x319f EnclCJK 0x3200—0x32ff
CJKCompatibl 0x3300— 0x33ff Han 0x3400— 0xabff
Hangul 0xac00—0xd7ff UTF16Lead 0xd800—0xdbff
UTF16Trail 0xdc00—0xdfff PrivateUse 0xe000—0xf800
CJKCompIdeog 0xf900—0xfaff AlphaPres 0xfb00—0xfb4f
ArabicPresA 0xfb50—0xfdff CombHalfMark 0xfe20—0xfe2f
CJKCompForm 0xfe30—0xfe4f SmallFormVar 0xfe50— 0xfe6f
ArabicPresB 0xfe70—0xfefe HalfFullForm 0xff00— 0xffef
Spéciaux 0xfff0—0xfffd