tools/qdoc3/openedlist.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the tools applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 /*
  43   openedlist.cpp
  44 */
  45
  46 #include <qregexp.h>
  47
  48 #include "atom.h"
  49 #include "openedlist.h"
  50
  51 QT_BEGIN_NAMESPACE
  52
  53 static const char roman[] = "m\2d\5c\2l\5x\2v\5i";
  54
  55 OpenedList::OpenedList( Style style )
  56     : sty( style ), ini( 1 ), nex( 0 )
  57 {
  58 }
  59
  60 OpenedList::OpenedList( const Location& location, const QString& hint )
  61     : sty( Bullet ), ini( 1 )
  62 {
  63     QRegExp hintSyntax( "(\\W*)([0-9]+|[A-Z]+|[a-z]+)(\\W*)" );
  64
  65     if ( hintSyntax.exactMatch(hint) ) {
  66         bool ok;
  67         int asNumeric = hint.toInt( &ok );
  68         int asRoman = fromRoman( hintSyntax.cap(2) );
  69         int asAlpha = fromAlpha( hintSyntax.cap(2) );
  70
  71         if ( ok ) {
  72             sty = Numeric;
  73             ini = asNumeric;
  74         } else if ( asRoman > 0 && asRoman != 100 && asRoman != 500 ) {
  75             sty = ( hint == hint.toLower() ) ? LowerRoman : UpperRoman;
  76             ini = asRoman;
  77         } else {
  78             sty = ( hint == hint.toLower() ) ? LowerAlpha : UpperAlpha;
  79             ini = asAlpha;
  80         }
  81         pref = hintSyntax.cap( 1 );
  82         suff = hintSyntax.cap( 3 );
  83     } else if ( !hint.isEmpty() ) {
  84         location.warning( tr("Unrecognized list style '%1'").arg(hint) );
  85     }
  86     nex = ini - 1;
  87 }
  88
  89 QString OpenedList::styleString() const
  90 {
  91     switch ( style() ) {
  92     case Bullet:
  93     default:
  94         return ATOM_LIST_BULLET;
  95     case Tag:
  96         return ATOM_LIST_TAG;
  97     case Value:
  98         return ATOM_LIST_VALUE;
  99     case Numeric:
 100         return ATOM_LIST_NUMERIC;
 101     case UpperAlpha:
 102         return ATOM_LIST_UPPERALPHA;
 103     case LowerAlpha:
 104         return ATOM_LIST_LOWERALPHA;
 105     case UpperRoman:
 106         return ATOM_LIST_UPPERROMAN;
 107     case LowerRoman:
 108         return ATOM_LIST_LOWERROMAN;
 109     }
 110 }
 111
 112 QString OpenedList::numberString() const
 113 {
 114     return QString::number( number() );
 115 /*
 116     switch ( style() ) {
 117     case Numeric:
 118         return QString::number( number() );
 119     case UpperAlpha:
 120         return toAlpha( number() ).toUpper();
 121     case LowerAlpha:
 122         return toAlpha( number() );
 123     case UpperRoman:
 124         return toRoman( number() ).toUpper();
 125     case LowerRoman:
 126         return toRoman( number() );
 127     case Bullet:
 128     default:
 129         return "*";
 130     }*/
 131 }
 132
 133 QString OpenedList::toAlpha( int n )
 134 {
 135     QString str;
 136
 137     while ( n > 0 ) {
 138         n--;
 139         str.prepend( (n % 26) + 'a' );
 140         n /= 26;
 141     }
 142     return str;
 143 }
 144
 145 int OpenedList::fromAlpha( const QString& str )
 146 {
 147     int n = 0;
 148     int u;
 149
 150     for ( int i = 0; i < (int) str.length(); i++ ) {
 151         u = str[i].toLower().unicode();
 152         if ( u >= 'a' && u <= 'z' ) {
 153             n *= 26;
 154             n += u - 'a' + 1;
 155         } else {
 156             return 0;
 157         }
 158     }
 159     return n;
 160 }
 161
 162 QString OpenedList::toRoman( int n )
 163 {
 164     /*
 165       See p. 30 of Donald E. Knuth's "TeX: The Program".
 166     */
 167     QString str;
 168     int j = 0;
 169     int k;
 170     int u;
 171     int v = 1000;
 172
 173     for ( ;; ) {
 174         while ( n >= v ) {
 175             str += roman[j];
 176             n -= v;
 177         }
 178
 179         if ( n <= 0 )
 180             break;
 181
 182         k = j + 2;
 183         u = v / roman[k - 1];
 184         if ( roman[k - 1] == 2 ) {
 185             k += 2;
 186             u /= 5;
 187         }
 188         if ( n + u >= v ) {
 189             str += roman[k];
 190             n += u;
 191         } else {
 192             j += 2;
 193             v /= roman[j - 1];
 194         }
 195     }
 196     return str;
 197 }
 198
 199 int OpenedList::fromRoman( const QString& str )
 200 {
 201     int n = 0;
 202     int j;
 203     int u;
 204     int v = 0;
 205
 206     for ( int i = str.length() - 1; i >= 0; i-- ) {
 207         j = 0;
 208         u = 1000;
 209         while ( roman[j] != 'i' && roman[j] != str[i].toLower() ) {
 210             j += 2;
 211             u /= roman[j - 1];
 212         }
 213         if ( u < v ) {
 214             n -= u;
 215         } else {
 216             n += u;
 217         }
 218         v = u;
 219     }
 220
 221     if ( str.toLower() == toRoman(n) ) {
 222         return n;
 223     } else {
 224         return 0;
 225     }
 226 }
 227
 228 QT_END_NAMESPACE