Exemplo n.º 1
0
void wordright(editor_t *ed, int select)
  {
  int pos, end, phase, next;

  update_selection(ed, select);
  pos = ed->linepos + ed->col;
  end = text_length(ed);
  next = next_line(ed, ed->linepos);
  phase = 0;
  while (pos < end)
    {
    int ch = get(ed, pos);
    if (phase == 0)
      {
      if (wordchar(ch)) phase = 1;
      }
    else
      {
      if (!wordchar(ch)) break;
      }

    pos++;
    if (pos == next)
      {
      ed->linepos = next;
      next = next_line(ed, ed->linepos);
      ed->line++;
      ed->refresh = 1;
      }
    }
  ed->col = pos - ed->linepos;
  if (ed->line >= ed->topline + ed->lines)
    {
    ed->toppos = next_line(ed, ed->toppos);
    ed->topline++;
    }

  ed->lastcol = ed->col;
  adjust(ed);
  }
Exemplo n.º 2
0
void wordleft(editor_t *ed, int select)
  {
  int pos, phase;

  update_selection(ed, select);
  pos = ed->linepos + ed->col;
  phase = 0;
  while (pos > 0)
    {
    int ch = get(ed, pos - 1);
    if (phase == 0)
      {
      if (wordchar(ch)) phase = 1;
      }
    else
      {
      if (!wordchar(ch))
        break;
      }

    pos--;
    if (pos < ed->linepos)
      {
      ed->linepos = prev_line(ed, ed->linepos);
      ed->line--;
      ed->refresh = 1;
      }
    }
  ed->col = pos - ed->linepos;
  if (ed->line < ed->topline)
    {
    ed->toppos = ed->linepos;
    ed->topline = ed->line;
    }

  ed->lastcol = ed->col;
  adjust(ed);
  }
Exemplo n.º 3
0
int countWords (const char string[])
{
    int i, wordCount = 0;
    bool lookingForWord = true, wordchar (const char c), numchar (const char c);

    for ( i = 0; string[i] != '\0'; ++i )
        if ( wordchar (string[i]) || numchar (string[i]) )
        {
            if ( lookingForWord )
            {
                ++wordCount;
                lookingForWord = false;
            }
        }
        else
            lookingForWord = true;

    return wordCount;
}
Exemplo n.º 4
0
int weditstr(WINDOW *win, char *buf, int field)
{
    char org[MAXSTRLEN], *tp, *bp = buf;
    bool defdisp = TRUE, stop = FALSE, insert = FALSE;
    int cury, curx, begy, begx;
    chtype oldattr;
    WINDOW *wedit;
    int c = 0;

    if ((field >= MAXSTRLEN) || (buf == NULL) ||
        ((int)strlen(buf) > field - 1))
        return ERR;

    strcpy(org, buf);   /* save original */

    wrefresh(win);
    getyx(win, cury, curx);
    getbegyx(win, begy, begx);

    wedit = subwin(win, 1, field, begy + cury, begx + curx);
    oldattr = wedit->_attrs;
    colorbox(wedit, EDITBOXCOLOR, 0);

    keypad(wedit, TRUE);
    curs_set(1);

    while (!stop)
    {
        idle();
        repainteditbox(wedit, bp - buf, buf);

        switch (c = wgetch(wedit))
        {
        case ERR:
            break;

        case KEY_ESC:
            strcpy(buf, org);   /* restore original */
            stop = TRUE;
            break;

        case '\n':
        case KEY_UP:
        case KEY_DOWN:
            stop = TRUE;
            break;

        case KEY_LEFT:
            if (bp > buf)
                bp--;
            break;

        case KEY_RIGHT:
            defdisp = FALSE;
            if (bp - buf < (int)strlen(buf))
                bp++;
            break;

        case '\t':            /* TAB -- because insert
                                  is broken on HPUX */
        case KEY_IC:          /* enter insert mode */
        case KEY_EIC:         /* exit insert mode */
            defdisp = FALSE;
            insert = !insert;

            curs_set(insert ? 2 : 1);
            break;

        default:
            if (c == erasechar())       /* backspace, ^H */
            {
                if (bp > buf)
                {
                    memmove((void *)(bp - 1), (const void *)bp, strlen(bp) + 1);
                    bp--;
                }
            }
            else if (c == killchar())   /* ^U */
            {
                bp = buf;
                *bp = '\0';
            }
            else if (c == wordchar())   /* ^W */
            {
                tp = bp;

                while ((bp > buf) && (*(bp - 1) == ' '))
                    bp--;
                while ((bp > buf) && (*(bp - 1) != ' '))
                    bp--;

                memmove((void *)bp, (const void *)tp, strlen(tp) + 1);
            }
            else if (isprint(c))
            {
                if (defdisp)
                {
                    bp = buf;
                    *bp = '\0';
                    defdisp = FALSE;
                }

                if (insert)
                {
                    if ((int)strlen(buf) < field - 1)
                    {
                        memmove((void *)(bp + 1), (const void *)bp,
                                strlen(bp) + 1);

                        *bp++ = c;
                    }
                }
                else if (bp - buf < field - 1)
                {
                    /* append new string terminator */

                    if (!*bp)
                        bp[1] = '\0';

                    *bp++ = c;
                }
            }
        }
    }

    curs_set(0);

    wattrset(wedit, oldattr);
    repainteditbox(wedit, bp - buf, buf);
    delwin(wedit);

    return c;
}
Exemplo n.º 5
0
/* Move backwards/forwards from ptr (no longer than to start) in an
 * UTF8 text until the beginning of an extended token or (if space,
 * until beginning of the next/last word)
 * A token in this function means some combination of words linked
 * together with a single character of any of the configured set of
 * legal connector characters.
 * @return The number of bytes moved
 */
int SummaryDesc::complete_extended_token(unsigned char* start, ssize_t length,
        const unsigned char*& ptr, off_t increment)
{
    int moved = 0;
    const unsigned char *old_ptr = NULL;
    for (;;) {
        // Start by moving to the start/end of the word..
        moved += complete_word(start, length, ptr, increment);

        // Ensure that there is a quick way out of this at the end:
        if (start >= ptr || start + length <= ptr || ptr == old_ptr)
            return moved;

        // If we end up at the same place as last iteration, we need
        // to bail (done above) to avoid an infinite loop.
        old_ptr = ptr;

        // Store a pointer to the found break:
        const unsigned char* preptr = ptr;

        int prelen;
        // Position to previous/next character to check if this is a
        // "real" break:
        if (increment < 0) {
            prelen = Fast_UnicodeUtil::UTF8move(start, length,
                                                preptr, increment);
            if (!prelen)
                return moved;
        } else {
            prelen = 0;
        }

        // Handle default case ("ordinary" space)
        if (!word_connector(preptr)) {
            LOG(spam, "Not a word connector case (%c)", *preptr);
            return moved;
        }
        char wconn = *preptr;
        (void) wconn;
        LOG(spam, "Found word connector case candidate (%c)", wconn);

        // Read the character before/after the connector character:
        int addlen = Fast_UnicodeUtil::UTF8move(start, length,
                                                preptr, increment);
        if (!addlen)
            return moved; // Not possible to extend anything here

        // Only a single connector character that connects word
        // characters should lead us to include more words in the
        // normal sense:
        if (!wordchar(preptr))
            return moved;

	// If a block of chinese data does not contain any spaces we have to return
	// here in order to avoid searching all the way to the start/end.
	return moved;

        // Ok, found a separator case, include another word..

        moved += prelen + addlen;
        // If going forward, the word completer will look at the
        // previous char to see if we are at the start of a word, so
        // we have to move forward once here:
        if (increment > 0) {
            addlen = Fast_UnicodeUtil::UTF8move(start, length,
                                                preptr, increment);
            if (!addlen)
                return moved;
            moved += addlen;
        }
        ptr = preptr;

        LOG(spam, "Found proper word connector case (%c,%c) yet moved %d",
            wconn, *preptr, moved);
    }
}