home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / common / bidi.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  7.3 KB  |  259 lines
  1. /*
  2. *******************************************************************************
  3. *                                                                             *
  4. * COPYRIGHT:                                                                  *
  5. *   (C) Copyright International Business Machines Corporation, 1999           *
  6. *   Licensed Material - Program-Property of IBM - All Rights Reserved.        *
  7. *   US Government Users Restricted Rights - Use, duplication, or disclosure   *
  8. *   restricted by GSA ADP Schedule Contract with IBM Corp.                    *
  9. *                                                                             *
  10. *******************************************************************************
  11. *   file name:  ubidi.h
  12. *   encoding:   US-ASCII
  13. *   tab size:   8 (not used)
  14. *   indentation:4
  15. *
  16. *   created on: 1999sep15
  17. *   created by: Markus W. Scherer
  18. */
  19.  
  20. #ifndef BIDI_H
  21. #define BIDI_H
  22.  
  23. #include "utypes.h"
  24. #include "ubidi.h"
  25.  
  26. #ifndef XP_CPLUSPLUS
  27. #   error This is a C++ header file.
  28. #endif
  29.  
  30. /**
  31.  * BiDi is a C++ wrapper class for UBiDi.
  32.  * You need one BiDi object in place of one UBiDi object.
  33.  * For details on the API and implementation of the
  34.  * Unicode BiDi algorithm, see ubidi.h.
  35.  *
  36.  * @see UBiDi
  37.  */
  38. class U_COMMON_API BiDi {
  39. public:
  40.     /** @memo Default constructor, calls ubidi_open(). */
  41.     BiDi();
  42.  
  43.     /** @memo Constructor, calls ubidi_open(). */
  44.     BiDi(UErrorCode &rErrorCode);
  45.  
  46.     /** @memo Preallocating constructor, calls ubidi_openSized(). */
  47.     BiDi(UTextOffset maxLength, UTextOffset maxRunCount, UErrorCode &rErrorCode);
  48.  
  49.     /** @memo Destructor, calls ubidi_close(). */
  50.     ~BiDi();
  51.  
  52.     /** @memo Set this object for one paragraph's text. */
  53.     BiDi &
  54.     setPara(const UChar *text, UTextOffset length,
  55.             UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
  56.             UErrorCode &rErrorCode);
  57.  
  58.  
  59.     /** @memo Set this object for one line of the paragraph object's text. */
  60.     BiDi &
  61.     setLine(const BiDi &rParaBiDi,
  62.             UTextOffset start, UTextOffset limit,
  63.             UErrorCode &rErrorCode);
  64.  
  65.     /** @memo Get the directionality of the text. */
  66.     UBiDiDirection
  67.     getDirection() const;
  68.  
  69.     /** @memo Get the length of the text. */
  70.     UTextOffset
  71.     getLength() const;
  72.  
  73.     /** @memo Get the paragraph level of the text. */
  74.     UBiDiLevel
  75.     getParaLevel() const;
  76.  
  77.     /** @memo Get the level for one character. */
  78.     UBiDiLevel
  79.     getLevelAt(UTextOffset charIndex) const;
  80.  
  81.     /** @memo Get an array of levels for each character. */
  82.     const UBiDiLevel *
  83.     getLevels(UErrorCode &rErrorCode);
  84.  
  85.     /** @memo Get a logical run. */
  86.     void
  87.     getLogicalRun(UTextOffset logicalStart,
  88.                   UTextOffset &rLogicalLimit, UBiDiLevel &rLevel) const;
  89.  
  90.     /** @memo Get the number of runs. */
  91.     UTextOffset
  92.     countRuns(UErrorCode &rErrorCode);
  93.  
  94.     /**
  95.      * @memo Get one run's logical start, length, and directionality,
  96.      *       which can be 0 for LTR or 1 for RTL.
  97.      */
  98.     UBiDiDirection
  99.     getVisualRun(UTextOffset runIndex, UTextOffset &rLogicalStart, UTextOffset &rLength);
  100.  
  101.     /** @memo Get the visual position from a logical text position. */
  102.     UTextOffset
  103.     getVisualIndex(UTextOffset logicalIndex, UErrorCode &rErrorCode);
  104.  
  105.     /** @memo Get the logical text position from a visual position. */
  106.     UTextOffset
  107.     getLogicalIndex(UTextOffset visualIndex, UErrorCode &rErrorCode);
  108.  
  109.     /**
  110.      * @memo Get a logical-to-visual index map (array) for the characters in the UBiDi
  111.      *       (paragraph or line) object.
  112.      */
  113.     void
  114.     getLogicalMap(UTextOffset *indexMap, UErrorCode &rErrorCode);
  115.  
  116.     /**
  117.      * @memo Get a visual-to-logical index map (array) for the characters in the UBiDi
  118.      *       (paragraph or line) object.
  119.      */
  120.     void
  121.     getVisualMap(UTextOffset *indexMap, UErrorCode &rErrorCode);
  122.  
  123.     /** @memo Same as ubidi_reorderLogical(). */
  124.     static void
  125.     reorderLogical(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap);
  126.  
  127.     /** @memo Same as ubidi_reorderVisual(). */
  128.     static void
  129.     reorderVisual(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap);
  130.  
  131.     /** @memo Same as ubidi_invertMap(). */
  132.     static void
  133.     invertMap(const UTextOffset *srcMap, UTextOffset *destMap, UTextOffset length);
  134.  
  135. protected:
  136.     UBiDi *pBiDi;
  137. };
  138.  
  139. /* Inline implementations. -------------------------------------------------- */
  140.  
  141. inline BiDi::BiDi() {
  142.     pBiDi=ubidi_open();
  143. }
  144.  
  145. inline BiDi::BiDi(UErrorCode &rErrorCode) {
  146.     if(U_SUCCESS(rErrorCode)) {
  147.         pBiDi=ubidi_open();
  148.         if(pBiDi==0) {
  149.             rErrorCode=U_MEMORY_ALLOCATION_ERROR;
  150.         }
  151.     } else {
  152.         pBiDi=0;
  153.     }
  154. }
  155.  
  156. inline BiDi::BiDi(UTextOffset maxLength, UTextOffset maxRunCount, UErrorCode &rErrorCode) {
  157.     pBiDi=ubidi_openSized(maxLength, maxRunCount, &rErrorCode);
  158. }
  159.  
  160. inline BiDi::~BiDi() {
  161.     ubidi_close(pBiDi);
  162.     pBiDi=0;
  163. }
  164.  
  165. inline BiDi &
  166. BiDi::setPara(const UChar *text, UTextOffset length,
  167.         UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
  168.         UErrorCode &rErrorCode) {
  169.     ubidi_setPara(pBiDi, text, length, paraLevel, embeddingLevels, &rErrorCode);
  170.     return *this;
  171. }
  172.  
  173.  
  174. inline BiDi &
  175. BiDi::setLine(const BiDi &rParaBiDi,
  176.         UTextOffset start, UTextOffset limit,
  177.         UErrorCode &rErrorCode) {
  178.     ubidi_setLine(rParaBiDi.pBiDi, start, limit, pBiDi, &rErrorCode);
  179.     return *this;
  180. }
  181.  
  182. inline UBiDiDirection
  183. BiDi::getDirection() const {
  184.     return ubidi_getDirection(pBiDi);
  185. }
  186.  
  187. inline UTextOffset
  188. BiDi::getLength() const {
  189.     return ubidi_getLength(pBiDi);
  190. }
  191.  
  192. inline UBiDiLevel
  193. BiDi::getParaLevel() const {
  194.     return ubidi_getParaLevel(pBiDi);
  195. }
  196.  
  197. inline UBiDiLevel
  198. BiDi::getLevelAt(UTextOffset charIndex) const {
  199.     return ubidi_getLevelAt(pBiDi, charIndex);
  200. }
  201.  
  202. inline const UBiDiLevel *
  203. BiDi::getLevels(UErrorCode &rErrorCode) {
  204.     return ubidi_getLevels(pBiDi, &rErrorCode);
  205. }
  206.  
  207. inline void
  208. BiDi::getLogicalRun(UTextOffset logicalStart,
  209.               UTextOffset &rLogicalLimit, UBiDiLevel &rLevel) const {
  210.     ubidi_getLogicalRun(pBiDi, logicalStart, &rLogicalLimit, &rLevel);
  211. }
  212.  
  213. inline UTextOffset
  214. BiDi::countRuns(UErrorCode &rErrorCode) {
  215.     return ubidi_countRuns(pBiDi, &rErrorCode);
  216. }
  217.  
  218. inline UBiDiDirection
  219. BiDi::getVisualRun(UTextOffset runIndex, UTextOffset &rLogicalStart, UTextOffset &rLength) {
  220.     return ubidi_getVisualRun(pBiDi, runIndex, &rLogicalStart, &rLength);
  221. }
  222.  
  223. inline UTextOffset
  224. BiDi::getVisualIndex(UTextOffset logicalIndex, UErrorCode &rErrorCode) {
  225.     return ubidi_getVisualIndex(pBiDi, logicalIndex, &rErrorCode);
  226. }
  227.  
  228. inline UTextOffset
  229. BiDi::getLogicalIndex(UTextOffset visualIndex, UErrorCode &rErrorCode) {
  230.     return ubidi_getLogicalIndex(pBiDi, visualIndex, &rErrorCode);
  231. }
  232.  
  233. inline void
  234. BiDi::getLogicalMap(UTextOffset *indexMap, UErrorCode &rErrorCode) {
  235.     ubidi_getLogicalMap(pBiDi, indexMap, &rErrorCode);
  236. }
  237.  
  238. inline void
  239. BiDi::getVisualMap(UTextOffset *indexMap, UErrorCode &rErrorCode) {
  240.     ubidi_getVisualMap(pBiDi, indexMap, &rErrorCode);
  241. }
  242.  
  243. inline void
  244. BiDi::reorderLogical(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap) {
  245.     ubidi_reorderLogical(levels, length, indexMap);
  246. }
  247.  
  248. inline void
  249. BiDi::reorderVisual(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap) {
  250.     ubidi_reorderVisual(levels, length, indexMap);
  251. }
  252.  
  253. inline void
  254. BiDi::invertMap(const UTextOffset *srcMap, UTextOffset *destMap, UTextOffset length) {
  255.     ubidi_invertMap(srcMap, destMap, length);
  256. }
  257.  
  258. #endif
  259.