private void rewriteCompletion() {
    StringBuilder sb = new StringBuilder();

    boolean toUpperCase = false;
    for (char c : completion.toCharArray()) {
      if (Character.isLetterOrDigit(c)) {
        sb.append(toUpperCase ? Character.toUpperCase(c) : Character.toLowerCase(c));
        toUpperCase = false;
      } else {
        sb.append(c);
        toUpperCase = true;
      }
    }
    completion = sb.toString();
  }
Beispiel #2
0
 /**
  * ** Filters an ID String, convertering all letters to lowercase and ** removing invalid
  * characters ** @param text The ID String to filter ** @return The filtered ID String
  */
 public static String FilterID(String text) {
   // ie. "sky.12", "acme@123"
   if (text != null) {
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i < text.length(); i++) {
       char ch = Character.toLowerCase(text.charAt(i));
       if (DBRecordKey.isValidIDChar(ch)) {
         sb.append(ch);
       }
     }
     return sb.toString();
   } else {
     return "";
   }
 }
Beispiel #3
0
 public void keyTyped(char ch) {
   if (this.emuSys != null) {
     if (this.emuSys.getSwapKeyCharCase()) {
       if (Character.isUpperCase(ch)) {
         ch = Character.toLowerCase(ch);
       } else if (Character.isLowerCase(ch)) {
         ch = Character.toUpperCase(ch);
       }
     }
     if (this.emuSys.getConvertKeyCharToISO646DE()) {
       this.emuSys.keyTyped(TextUtil.toISO646DE(ch));
     } else {
       this.emuSys.keyTyped(ch);
     }
   }
 }
Beispiel #4
0
 private static String correctSymbol(String symbol) { // converts to correct case
   if (DIAGNOSTICS) {
     System.out.println("In correctSymbols.");
     System.out.println("Correcting capatalization of " + symbol);
   }
   symbol = symbol.toUpperCase(); // cap all chars
   if (DIAGNOSTICS) {
     System.out.println("all caps symbol is " + symbol);
   }
   if (symbol.length() > 1) {
     if (DIAGNOSTICS) {
       System.out.println("Symbol contains more than 1 character.");
     }
     // copy first (correctly capped) char into new string
     String corrected_symbol = new String(symbol.substring(0, 1));
     // make sure second letter is lower case (always)
     Character tmp = new Character(symbol.charAt(1));
     corrected_symbol += tmp.toLowerCase(symbol.charAt(1));
     return corrected_symbol;
   }
   return symbol;
 }
Beispiel #5
0
  private String processLineSeq(String line) {
    /* should probably be left commented out (unless debugging) */
    // lg.entering (getClass ().getName (), String.format ("processLineSeq (%s)", line));

    /* keep track of line length so that we avoid overflows and/or
     * reallocations */
    int len = line.length();

    /* StringBuilder is a faster StringBuffer for single-threaded apps, we
     * define the capacity as length of line (+ a margin of 7 since
     * ligatures are multibytes characters) before processing which avoids
     * any unneeded realloc */
    StringBuilder pline = new StringBuilder(len + 7); /* processed line */
    /* For instance, the f_i ligature code point is U+fb01, which needs
     * 3 bytes to be written in UTF-8 (you may check with any hexdump
     * program that fi is indeed written as 0xef 0xac 0x81 so we are going to
     * need (3-2=)1 more byte. For the f_f_i ligature (ffi) whose codepoint is
     * U+fb03 and UTF-8 encoding is 0xef 0xac 0x83 we are using exactly the
     * same number of bytes (in UTF-8). Same principle applies to the
     * ellipsis, in ASCII encoding we need 3 bytes (one for each dot 0x2e),
     * in UTF-8 we also need 3 bytes to encode … / U+2026 i.e., 0xe2 0x80
     * 0xa6 */

    for (int index = 0; index < len; index++) {

      char c = line.charAt(index);

      if (bIsOpenTag) {

        /* if we are inside a tag we don’t want to change anything
         * otherwise we might end up with an unreadable hexadecimal
         * number (using ff ligature), an unknow tag name, … */
        pline.append(c);
        /* TBD: we could add a test to check for malformed HTML tags
         * e.g., <xxx <yyy> zzz> */
        if (c == '>') bIsOpenTag = false;

      } else {

        switch (c) {

            // case ',': /* to speed up processing a bit as we don’t need to */
            // case ' ': /* pass every test on these glyphs */
            // pline.append (c);
            // break;

            // ij and IJ ligatures deactivated since with some fonts
            // e.g., New Century Schoolbook, kerning is *really* bad
            // for instance in “ouija” or “mija” the ij is overlapping
            // the letter right after while being very far from the
            // letter before.
            //
            // case 'i': /* most frequent case first */
            //     // System.out.println ("we found a i");
            //     /* check first it is not the end */
            //     if (tc.do_UseLigatures () && index + 1 < len) {
            //         /* then check following char for a ‘j’ */
            //         if (line.charAt (index + 1) == 'j') {

            //             pline.append ('\u0133'); /* ij */
            //             ++index;

            //         } else pline.append (c);

            //     } else pline.append (c);

            //     break;

            // case 'I':
            //     // System.out.println ("we found a I");
            //     if (tc.do_UseLigatures () && index + 1 < len) {

            //         if (line.charAt (index + 1) == 'J') {

            //             pline.append ('\u0132'); /* IJ */
            //             ++index;

            //         } else pline.append (c);

            //     } else pline.append (c);

            //     break;

          case 'a':
          case 'A':
            /* if user requires ligatures and we’re not at the end of
             * the line and we haven’t found ‘ae’, ‘AE’, ‘Ae’ or ‘aE’ yet… */
            if (tc.do_UseLigatures() && index + 1 < len && !baePresent) {

              if (Character.toLowerCase(line.charAt(index + 1)) == 'e') {

                baePresent = true;
              }
            }
            /* Never make any change here. As we never know when ae
             * ligature is possible or not it is up to the user to do it */
            pline.append(c);

            break;

            /* NB: we cannot do the same for œ because it is too common,
             * we find it almost everywhere e.g., «does», «doesn’t» */

          case '\'':
            if (tc.do_UsePunctuation()) {

              pline.append('\u2019'); /* ’ */

            } else pline.append(c);

            break;

          case '.':
            if (tc.do_UsePunctuation()) {

              if (index + 2 < len) {
                  /* [ 0 .. (n-3) ] */

                if (line.charAt(index + 1) == '.') {

                  if (line.charAt(index + 2) == '.') {

                    pline.append('\u2026'); /* … */
                    index += 2;

                  } else {
                    /* case only two points, assume user wanted
                     * a (missing) third */
                    pline.append('\u2026'); /* … */
                    ++index;
                  }

                } else pline.append(c);

              } else if (index + 1 < len) {
                  /* [ (n-2) .. (n-1) ], (n-1) <=> EOL */

                if (line.charAt(index + 1) == '.') {
                  /* case only two points at end of line, assume
                   * user wanted a (missing) third */
                  pline.append('\u2026'); /* …  */
                  ++index;

                } else pline.append(c);

              } else pline.append(c);

            } else pline.append(c);

            break;

          case ';':
          case '?':
            /* case ':': /* temporarily deactivated extra spacing in front of a colon
             * ’cause it looks really bad in front of ‘:’ after name (HI subs) or when
             * displaying a time between hours and minutes */
            if (tc.do_UseFrenchSpacing() && index > 0)
              if (line.charAt(index - 1) != ' ')
                pline.append('\u2009'); /* U+2009 is a thin space */
            /* pline.append (' '); */
            /* U+0020 is a normal (ASCII) space */

            /* no change to the character itself */
            pline.append(c);
            break;

          case '!':
            if (tc.do_UseFrenchSpacing() && index > 0) {

              char prevc = line.charAt(index - 1);
              if (prevc != ' ' && prevc != '?') pline.append('\u2009'); /* U+2009 is a thin space */
              /* pline.append (' '); */
              /* U+0020 is a normal (ASCII) space */
            }
            /* no change to the character itself */
            pline.append(c);
            break;

          case 'f':
            if (tc.do_UseLigatures()) {

              if (index + 2 < len) {

                if (line.charAt(index + 1) == 'f') {
                  /* always check for ffi before fi */
                  switch (line.charAt(index + 2)) {

                      // case 't':
                      // pline.append ('\ue097'); /*  */
                      // index += 2;
                      // break;

                    case 'i':
                      pline.append('\ufb03'); /* ffi */
                      index += 2;
                      break;

                    case 'l':
                      pline.append('\ufb04'); /* ffl */
                      index += 2;
                      break;

                    default:
                      pline.append('\ufb00'); /* ff */
                      ++index;
                  }

                } else {

                  switch (line.charAt(index + 1)) {
                    case 'i':
                      pline.append('\ufb01'); /* fi */
                      ++index;
                      break;

                    case 'l':
                      pline.append('\ufb02'); /* fl */
                      ++index;
                      break;

                      // case 't':
                      //     pline.append ('\ufb05'); /* ſt */
                      //     ++index;
                      //     break;

                    default:
                      pline.append(c);
                  }
                }

              } else if (index + 1 < len) {
                  /* case two last chars of line */

                switch (line.charAt(index + 1)) {
                  case 'f':
                    pline.append('\ufb00'); /* ff */
                    ++index;
                    break;

                  case 'i':
                    pline.append('\ufb01'); /* fi */
                    ++index;
                    break;

                  case 'l':
                    pline.append('\ufb02'); /* fl */
                    ++index;
                    break;

                    // case 't':
                    //     pline.append ('\ufb05'); /* ſt */
                    //     ++index;
                    //     break;

                  default:
                    pline.append(c);
                }

              } else pline.append(c); /* case last char of line is ‘f’ */

            } else pline.append(c); /* case not using ligatures */

            break;

          case 'c':
            if (tc.do_UseOldLigatures()) {

              if (index + 1 < len) {

                switch (line.charAt(index + 1)) {
                  case 'h':
                    pline.append('\ue085'); /*  */
                    ++index;
                    break;

                  case 'k':
                    pline.append('\ue086'); /*  */
                    ++index;
                    break;

                  case 't':
                    pline.append('\ue087'); /*  */
                    ++index;
                    break;

                  default:
                    pline.append(c);
                }

              } else pline.append(c);

            } else pline.append(c);

            break;

          case 'T':
            if (tc.do_UseOldLigatures()) {

              if (index + 1 < len) {

                if (line.charAt(index + 1) == 'h') {

                  pline.append('\ue062'); /*  */
                  ++index;

                } else pline.append(c);

              } else pline.append(c);

            } else pline.append(c);

            break;

          case '"':
            /* if first char is a quote then make it a left quote
             * always, fix a bug when users write many left quotes and
             * only one right for a long quote that runs on several lines */
            if (tc.do_UsePunctuation()) {

              if (index == 0) {

                pline.append(ldquo);

              } else pline.append(bIsOpenQuote ? rdquo : ldquo);

            } else pline.append(c);

            bIsOpenQuote = (index == 0) ? true : (!bIsOpenQuote);

            break;

          case '<':
            bIsOpenTag = true;
            pline.append(c);
            break;

          case '-': /* TBD: replace '--' by en-dash U+2013 and '---' by em-dash  U+2014 */
            if (tc.do_UseTypoDash()) {

              if (index + 1 < len) {

                char nextc = line.charAt(index + 1);
                switch (nextc) {
                  case '-': /* or '\u002d' */
                    pline.append(tydash);
                    ++index;
                    break;

                  case '<': /* HTML tag, '\u003c' */
                  case '\u2009': /* Unicode thin space */
                  case ' ': /* ' ' or '\u0020' */
                    pline.append(tydash);
                    break;

                  default: /* between words: always a simple
                           dash unless it’s the first char */
                    pline.append(index == 0 ? tydash : c);
                }

              } else pline.append(tydash); /* case End Of Line */

            } else pline.append(c); /* case no typographic dash */

            break;

          case '`': /* TBD: replace `` by “ and '' by ” */
            if (tc.do_UsePunctuation()) {
              pline.append('\u2018'); /* ‘ */
            } else pline.append(c);
            break;

          case '0':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf730'); /*  */
            } else pline.append(c);
            break;

          case '1':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf731'); /*  */
            } else pline.append(c);
            break;

          case '2':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf732'); /*  */
            } else pline.append(c);
            break;

          case '3':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf733'); /*  */
            } else pline.append(c);
            break;

          case '4':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf734'); /*  */
            } else pline.append(c);
            break;

          case '5':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf735'); /*  */
            } else pline.append(c);
            break;

          case '6':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf736'); /*  */
            } else pline.append(c);
            break;

          case '7':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf737'); /*  */
            } else pline.append(c);
            break;

          case '8':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf738'); /*  */
            } else pline.append(c);
            break;

          case '9':
            if (tc.do_UseOldStyleNums()) {
              pline.append('\uf739'); /*  */
            } else pline.append(c);
            break;

          default:
            pline.append(c);
        }
      }
    }

    /* should probably be left commented out (unless debugging) */
    // lg.exiting (getClass ().getName (), String.format ("processLineSeq (%s)", pline));

    // return reference of modified string
    return new String(pline);
  }
 public ceylon.language.Character lowercase() {
   return instance(java.lang.Character.toLowerCase(value));
 }