Static void checkSticky(Char *note, boolean *attrib)
{
short i = 2;
short l;
Char c;
Char a[256];
if (*note == '\0')
return;
l = strlen(note);
while (i <= l) {
c = note[i-1];
if (islower(c)) {
if (i < l && note[i] == ':') {
delete1(note, i + 1);
l--;
attrib[c - 'a'] = !attrib[c - 'a'];
} else
attrib[c - 'a'] = false;
}
i++;
}
attribs(a, note);
for (c = 'z'; c >= 'a'; c--) {
if (attrib[c - 'a'] && pos1(c, a) == 0)
insertChar(c, note, 3);
}
}
int dp(node* dict, char prefix[], char suffix[], int n) {
if (!suffix[0]) {
if (lookup(dict, prefix))
return n;
else
return 0;
}
if (n <= 0)
return 0;
if (doubleLookup(dict, prefix, suffix))
return n;
char choices[ALPHABET_SIZE];
int nchoices, i, j, result;
nchoices = i = j = result = 0;
getChoices(dict, prefix, choices, &nchoices);
int results[2 + 2 * nchoices];
results[i++] = accept(dict, prefix, suffix, n);
results[i++] = delete(dict, prefix, suffix, n);
for (j = 0; j < nchoices; ++j)
results[i++] = swap(dict, prefix, suffix, n, choices[j]);
for (j = 0; j < nchoices; ++j)
results[i++] = insertChar(dict, prefix, suffix, n, choices[j]);
for (i = 0; i < 2 + 2 * nchoices; i++)
result = results[i] > result ? results[i] : result;
return result;
}
static void
insertStr(struct edit *edit, char *str)
{
while (*str) {
insertChar(edit, *str);
str++;
}
}
/*
* IMSpace - handle a space in insert mode
*/
vi_rc IMSpace( void )
{
startNewLineUndo();
CheckAbbrev( abbrevBuff, &abbrevCnt );
abbrevCnt = 0;
return( insertChar( FALSE, TRUE ) );
} /* IMSpace */
void MyMultiEdit::keyPressEvent( QKeyEvent *e )
{
if( e->key() == Key_Tab )
{
insertChar('\t');
return;
}
QMultiLineEdit::keyPressEvent(e);
return;
}
static bool insertString( input_buffer *input, char *str )
{
while( *str != '\0' ) {
if( !insertChar( input, *str++ ) ) {
return( false );
}
}
return( true );
} /* insertString */
void PrefCharacter::slotDlgSpecCharClosed()
{
if (m_dlgSpecChar)
{
disconnect(m_dlgSpecChar, SIGNAL(insertChar(QChar)), this, SLOT(slotSpecChar(QChar)));
disconnect(m_dlgSpecChar, SIGNAL(finished()), this, SLOT(slotDlgSpecCharClosed()));
m_dlgSpecChar->deleteLater();
m_dlgSpecChar = 0;
}
}
/* paste from clipboard */
static void paste(text_t *data) {
char *clipbuf=TCOD_sys_clipboard_get();
if ( clipbuf ) {
if ( data->sel_start != MAX_INT ) {
deleteSelection(data);
}
while (*clipbuf) {
insertChar(data,*clipbuf++);
}
}
}
/*
* IMEscapeNextChar - handle ^Q and ^V in insert mode
*/
vi_rc IMEscapeNextChar( void )
{
vi_rc rc;
startNewLineUndo();
LastEvent = '^';
rc = insertChar( FALSE, FALSE );
EditFlags.EscapedInsertChar = TRUE;
return( rc );
} /* IMEscapeNextChar */
SpecialCharDialog::SpecialCharDialog( QWidget* parent, const char* name, bool modal, WFlags fl)
:SpecialCharDialogS( parent, name, modal, fl )
{
connect ( FilterLineEdit, SIGNAL(textChanged(const QString&)),
SLOT(filterChars(const QString&)) );
connect ( CharsListBox, SIGNAL(doubleClicked(QListBoxItem*)),
SLOT(insertCode()) );
connect (buttonOk, SIGNAL(clicked()), SLOT(insertCode()));
connect (buttonChar, SIGNAL(clicked()), SLOT(insertChar()));
connect (buttonCancel, SIGNAL(clicked()), SLOT(cancel()));
filterChars("");
}
void PrefCharacter::slotSelectSpecChar()
{
QString s = CharacterTree->currentItem()->text(2);
QChar c = s[0];
if (m_dlgSpecChar == 0)
{
m_dlgSpecChar = new DlgSpecChar(this, Prefs::editorFont(), c);
connect(m_dlgSpecChar, SIGNAL(insertChar(QChar)), this, SLOT(slotSpecChar(QChar)));
connect(m_dlgSpecChar, SIGNAL(finished()), this, SLOT(slotDlgSpecCharClosed()));
}
m_dlgSpecChar->show();
}
void
TextBuffer::insertSpan( std::string s, TextSpan &span ) {
startEdit( span.begin, span.end );
if ( !span.empty() ) removeSpan(span);
for ( t_CKUINT i=0; i < s.size(); i++) {
if ( s[i] == '\n' ) insertLine( span.end );
else insertChar( s[i], span.end );
}
endEdit ( span.begin, span.end );
}
/* Put a character into a text buffer overwriting any text under the cursor */
void W_EDITBOX::overwriteChar(QChar ch)
{
if (ch == '\0') return;
ASSERT(insPos <= aText.length(), "overwriteChar: Invalid insertion point");
if (insPos == aText.length())
{
// At end of string.
insertChar(ch);
return;
}
/* Store the character */
aText[insPos] = ch;
/* Update the insertion point */
++insPos;
}
/*
* IMChar - insert a character in insert mode
*/
vi_rc IMChar( void )
{
if( CurrentFile == NULL ) {
return( ERR_NO_ERR );
}
CurrentFile->need_autosave = TRUE;
startNewLineUndo();
if( EditFlags.EscapedInsertChar ) {
DisplayWorkLine( SSKillsFlags( LastEvent ) ||
SSKillsFlags( WorkLine->data[CurrentPos.column - 1] ) );
WorkLine->data[CurrentPos.column - 1] = LastEvent;
GoToColumn( CurrentPos.column + 1, WorkLine->len + 1 );
EditFlags.EscapedInsertChar = FALSE;
return( ERR_NO_ERR );
}
return( insertChar( TRUE, TRUE ) );
} /* IMChar */
/*
* IMCloseBracket - handle a ')' being entered in insert mode
*/
vi_rc IMCloseBracket( void )
{
vi_rc rc;
i_mark pos;
startNewLineUndo();
insertChar( TRUE, FALSE );
if( EditFlags.ShowMatch ) {
ReplaceCurrentLine();
rc = FindMatch( &pos );
if( rc == ERR_NO_ERR ) {
tempMatch( &pos );
}
GetCurrentLine();
}
GoToColumn( CurrentPos.column + 1, WorkLine->len + 1 );
return( ERR_NO_ERR );
} /* IMCloseBracket */
int main(void) {
DList* mainList;
mainList = startList(); // Starts the list with NULL value
mainList = insertChar(mainList, 'C');
//mainList = insertChar(mainList, 'H');
//mainList = insertChar(mainList, 'E');
//mainList = insertChar(mainList, 'R');
//mainList = insertChar(mainList, 'R');
//mainList = insertChar(mainList, 'Y');
printList(mainList);
mainList = freeListChar(mainList, 'C');
printf("Remove: \n");
printList(mainList);
return EXIT_SUCCESS;
}
/* Put a character into a text buffer overwriting any text under the cursor */
bool W_EDITBOX::overwriteChar(QChar ch)
{
if (ch == QChar('\0'))
{
return false;
}
ASSERT(insPos <= aText.length(), "overwriteChar: Invalid insertion point");
dirty = true;
if (insPos == aText.length())
{
// At end of string.
return insertChar(ch);
}
/* Store the character */
aText[insPos] = ch;
/* Update the insertion point */
++insPos;
return true;
}
void ExternalInputSource::pushCharRef(Char ch, const NamedCharRef &ref)
{
ASSERT(cur() == start());
noteCharRef(startIndex() + (cur() - start()), ref);
insertChar(ch);
}
//listens to key presses when selected, records all keyboard input
void textIn::keyListen(sf::Event &e){
try{
//if there are any text objects to cycle through
if(text.size() != 0){
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) && caretIndex > 0){
//this is on the condition that the caret is not moved to the back of the box when it is
//writing text that is longer than the box, the user can delete stuff rather than go back
//to see what they have written as this kind of input box is very small and needs to be lower in
//overhead
if(caret2.getPosition().x - 16 > getPosX()){
caretIndex--;
setCaret(caretPosition.at(caretIndex), getPosY(), getHeight());
}
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right) && (caretIndex < caretPosition.size() -1)){
caretIndex++;
setCaret(caretPosition.at(caretIndex), getPosY(), getHeight());
}
}
//this is not key pressed event at all this is textEntered its entirely different
if (e.type == sf::Event::TextEntered){
if (e.text.unicode < 128 && getSelected()){
//if the same key as the last one was pressed not too recently
if(lastKey == e.text.unicode ){
//if a second has passed
if(getTicks(0.7)){
//if the caret is next to the front most text object append text to the front of the vector else
//insert the character to the point where the caret is colliding
if(text.size() == 0 || caretX > (text.back().getPosition().x + text.back().getLocalBounds().width) - 10){
addChar(e.text.unicode);
}else{
insertChar( textIndex(), e.text.unicode);
}
}
//if backspace has been hit
}else if( 8 == e.text.unicode){
//if the caret is next to the front most text object remove the front most object with remove char
//else remove the character at the point where the caret is colliding
if( text.size() == 0 || caretX > (text.back().getPosition().x + text.back().getLocalBounds().width) - 10){
removeChar();
}else{
if(caretIndex != 0)
removeChar(textIndex());
}
//if the caret is next to the front most text object append text to the front of the vector else
//insert the character to the point where the caret is colliding
}else if(text.size() == 0 || caretX > (text.back().getPosition().x + text.back().getLocalBounds().width) - 10) {
addChar(e.text.unicode);
lastKey = e.text.unicode;
getTicks(0.03);
}else{
insertChar(textIndex(), e.text.unicode);
lastKey = e.text.unicode;
getTicks(0.03);
}
}
}
}catch(...){
std::cout<< "mystery error in key listen function caught";
//seems to stabilise mystery eror 75% of the time
resetPositions();
}
}
void W_EDITBOX::run(W_CONTEXT *psContext)
{
/* Note the edit state */
unsigned editState = state & WEDBS_MASK;
/* Only have anything to do if the widget is being edited */
if ((editState & WEDBS_MASK) == WEDBS_FIXED)
{
return;
}
/* If there is a mouse click outside of the edit box - stop editing */
int mx = psContext->mx;
int my = psContext->my;
if (mousePressed(MOUSE_LMB) && (mx < x || mx > x + width || my < y || my > y + height))
{
screenClearFocus(psContext->psScreen);
return;
}
/* note the widget state */
iV_SetFont(FontID);
/* Loop through the characters in the input buffer */
bool done = false;
utf_32_char unicode;
for (unsigned key = inputGetKey(&unicode); key != 0 && !done; key = inputGetKey(&unicode))
{
// Don't blink while typing.
blinkOffset = wzGetTicks();
int len = 0;
/* Deal with all the control keys, assume anything else is a printable character */
switch (key)
{
case INPBUF_LEFT :
/* Move the cursor left */
insPos = MAX(insPos - 1, 0);
/* If the cursor has gone off the left of the edit box,
* need to update the printable text.
*/
if (insPos < printStart)
{
printStart = MAX(printStart - WEDB_CHARJUMP, 0);
fitStringStart();
}
debug(LOG_INPUT, "EditBox cursor left");
break;
case INPBUF_RIGHT :
/* Move the cursor right */
len = aText.length();
insPos = MIN(insPos + 1, len);
/* If the cursor has gone off the right of the edit box,
* need to update the printable text.
*/
if (insPos > printStart + printChars)
{
printStart = MIN(printStart + WEDB_CHARJUMP, len - 1);
fitStringStart();
}
debug(LOG_INPUT, "EditBox cursor right");
break;
case INPBUF_UP :
debug(LOG_INPUT, "EditBox cursor up");
break;
case INPBUF_DOWN :
debug(LOG_INPUT, "EditBox cursor down");
break;
case INPBUF_HOME :
/* Move the cursor to the start of the buffer */
insPos = 0;
printStart = 0;
fitStringStart();
debug(LOG_INPUT, "EditBox cursor home");
break;
case INPBUF_END :
/* Move the cursor to the end of the buffer */
insPos = aText.length();
if (insPos != printStart + printChars)
{
fitStringEnd();
}
debug(LOG_INPUT, "EditBox cursor end");
break;
case INPBUF_INS :
if (editState == WEDBS_INSERT)
{
editState = WEDBS_OVER;
}
else
{
editState = WEDBS_INSERT;
}
debug(LOG_INPUT, "EditBox cursor insert");
break;
case INPBUF_DEL :
delCharRight();
/* Update the printable text */
fitStringStart();
debug(LOG_INPUT, "EditBox cursor delete");
break;
case INPBUF_PGUP :
debug(LOG_INPUT, "EditBox cursor page up");
break;
case INPBUF_PGDN :
debug(LOG_INPUT, "EditBox cursor page down");
break;
case INPBUF_BKSPACE :
/* Delete the character to the left of the cursor */
delCharLeft();
/* Update the printable text */
if (insPos <= printStart)
{
printStart = MAX(printStart - WEDB_CHARJUMP, 0);
}
fitStringStart();
debug(LOG_INPUT, "EditBox cursor backspace");
break;
case INPBUF_TAB :
debug(LOG_INPUT, "EditBox cursor tab");
break;
case INPBUF_CR :
case KEY_KPENTER: // either normal return key || keypad enter
/* Finish editing */
focusLost(psContext->psScreen);
screenClearFocus(psContext->psScreen);
debug(LOG_INPUT, "EditBox cursor return");
return;
break;
case INPBUF_ESC :
debug(LOG_INPUT, "EditBox cursor escape");
break;
default:
if (keyDown(KEY_LCTRL) || keyDown(KEY_RCTRL))
{
switch (key)
{
case KEY_V:
aText = wzGetSelection();
insPos = aText.length();
/* Update the printable text */
fitStringEnd();
debug(LOG_INPUT, "EditBox paste");
break;
default:
break;
}
break;
}
/* Dealt with everything else this must be a printable character */
if (editState == WEDBS_INSERT)
{
insertChar(unicode);
}
else
{
overwriteChar(unicode);
}
len = aText.length();
/* Update the printable chars */
if (insPos == len)
{
fitStringEnd();
}
else
{
fitStringStart();
if (insPos > printStart + printChars)
{
printStart = MIN(printStart + WEDB_CHARJUMP, len - 1);
if (printStart >= len)
{
fitStringStart();
}
}
}
break;
}
}
/* Store the current widget state */
state = (state & ~WEDBS_MASK) | editState;
}
/* update returns false if enter has been pressed, true otherwise */
bool TCOD_text_update (TCOD_text_t txt, TCOD_key_t key) {
int cx,cy,oldpos;
text_t * data = (text_t*)txt;
TCOD_IFNOT(data && data->con ) return false;
oldpos = data->cursor_pos;
/* for real-time keyboard : only on key release */
if ( key.pressed ) {
/* process keyboard input */
switch (key.vk) {
case TCODK_BACKSPACE: /* get rid of the last character */
if ( data->sel_start != MAX_INT ) {
deleteSelection(data);
} else {
deleteChar(data);
}
break;
case TCODK_DELETE:
if ( key.shift ) {
/* SHIFT-DELETE : cut to clipboard */
cut(data);
} else {
if ( data->sel_start != MAX_INT ) {
deleteSelection(data);
} else if ( data->text[data->cursor_pos] ) {
data->cursor_pos++;
deleteChar(data);
}
}
break;
/* shift + arrow / home / end = selection */
/* ctrl + arrow = word skipping. ctrl + shift + arrow = word selection */
case TCODK_LEFT:
if ( data->multiline && key.shift && data->sel_end == -1) {
data->sel_end = data->cursor_pos;
}
if ( data->cursor_pos > 0 ) {
if ( key.lctrl || key.rctrl ) {
previous_word(data);
} else data->cursor_pos--;
selectStart(data,oldpos,key);
}
break;
case TCODK_RIGHT:
if ( data->multiline && key.shift && data->sel_start == MAX_INT ) {
data->sel_start = data->cursor_pos;
}
if ( data->text[data->cursor_pos] ) {
if ( key.lctrl || key.rctrl ) {
next_word(data);
} else data->cursor_pos++;
selectEnd(data,oldpos,key);
}
break;
case TCODK_UP :
get_cursor_coords(data,&cx,&cy);
if ( data->multiline && key.shift && data->sel_end == -1) {
data->sel_end = data->cursor_pos;
}
set_cursor_pos(data,cx,cy-1,false);
selectStart(data,oldpos,key);
break;
case TCODK_DOWN :
get_cursor_coords(data,&cx,&cy);
if ( data->multiline && key.shift && data->sel_start == MAX_INT ) {
data->sel_start = data->cursor_pos;
}
set_cursor_pos(data,cx,cy+1,false);
selectEnd(data,oldpos,key);
break;
case TCODK_HOME:
get_cursor_coords(data,&cx,&cy);
if ( data->multiline && key.shift && data->sel_end == -1) {
data->sel_end = data->cursor_pos;
}
if ( key.lctrl || key.rctrl ) {
set_cursor_pos(data,0,0,true);
} else {
set_cursor_pos(data,0,cy,true);
}
selectStart(data,oldpos,key);
break;
case TCODK_END:
get_cursor_coords(data,&cx,&cy);
if ( data->multiline && key.shift && data->sel_start == MAX_INT ) {
data->sel_start = data->cursor_pos;
}
if ( key.lctrl || key.rctrl ) {
set_cursor_pos(data,data->w,data->h,true);
} else {
set_cursor_pos(data,data->w-1,cy,true);
}
selectEnd(data,oldpos,key);
break;
case TCODK_ENTER: /* validate input */
case TCODK_KPENTER:
if ( data->sel_start != MAX_INT ) {
deleteSelection(data);
}
if ( data->multiline ) {
get_cursor_coords(data,&cx,&cy);
if ( cy < data->h-1 ) insertChar(data,'\n');
} else {
data->input_continue = false;
}
break;
case TCODK_TAB :
if (data->tab_size ) {
int count=data->tab_size;
if ( data->sel_start != MAX_INT ) {
deleteSelection(data);
}
while ( count > 0 ) {
insertChar(data,' ');
count--;
}
}
break;
default: { /* append a new character */
if ( (key.c == 'c' || key.c=='C' || key.vk == TCODK_INSERT) && (key.lctrl || key.rctrl) ) {
/* CTRL-C or CTRL-INSERT : copy to clipboard */
copy(data);
} else if ( (key.c == 'x' || key.c=='X') && (key.lctrl || key.rctrl) ) {
/* CTRL-X : cut to clipboard */
cut(data);
} else if ( ((key.c == 'v' || key.c=='V') && (key.lctrl || key.rctrl))
|| ( key.vk == TCODK_INSERT && key.shift )
) {
/* CTRL-V or SHIFT-INSERT : paste from clipboard */
paste(data);
} else if (key.c > 31) {
if ( data->sel_start != MAX_INT ) {
deleteSelection(data);
}
insertChar(data,(char)(key.c));
}
break;
}
}
}
return data->input_continue;
}
BOOL CALLBACK AnsiCharPanel::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG :
{
_listView.init(_hInst, _hSelf);
int codepage = (*_ppEditView)->getCurrentBuffer()->getEncoding();
_listView.setValues(codepage==-1?0:codepage);
_listView.display();
return TRUE;
}
case WM_NOTIFY:
{
switch (((LPNMHDR)lParam)->code)
{
case NM_DBLCLK:
{
LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) lParam;
int i = lpnmitem->iItem;
if (i == -1)
return TRUE;
insertChar((unsigned char)i);
return TRUE;
}
case LVN_KEYDOWN:
{
switch (((LPNMLVKEYDOWN)lParam)->wVKey)
{
case VK_RETURN:
{
int i = ListView_GetSelectionMark(_listView.getHSelf());
if (i == -1)
return TRUE;
insertChar((unsigned char)i);
return TRUE;
}
default:
break;
}
}
break;
default:
break;
}
}
return TRUE;
case WM_SIZE:
{
int width = LOWORD(lParam);
int height = HIWORD(lParam);
::MoveWindow(_listView.getHSelf(), 0, 0, width, height, TRUE);
break;
}
default :
return DockingDlgInterface::run_dlgProc(message, wParam, lParam);
}
return DockingDlgInterface::run_dlgProc(message, wParam, lParam);
}
void markDebeamed(voice_index voice, Char *note)
{
if (isVocal(voice) && afterSlur(voice) == 0 && unbeamVocal() &&
pos1(duration(voice), flagged) > 0)
insertChar('a', note, 2);
}
/*
* IMCloseBrace - handle '}' in insert mode
*/
vi_rc IMCloseBrace( void )
{
int i, j;
int ts;
fcb *cfcb;
line *cline;
vi_rc rc;
int newcol;
i_mark pos;
startNewLineUndo();
insertChar( TRUE, FALSE );
newcol = CurrentPos.column + 1;
if( EditFlags.ShowMatch ) {
ReplaceCurrentLine();
rc = FindMatch( &pos );
if( rc == ERR_NO_ERR ) {
tempMatch( &pos );
}
GetCurrentLine();
}
if( EditFlags.CMode ) {
i = 0;
while( isspace( WorkLine->data[i] ) ) {
i++;
}
if( WorkLine->data[i] == '}' ) {
/*
* added a {, so:
* find matching }
* find out indentation of that line
* shift current line over to that indentation
* set current indentation to that
*/
ReplaceCurrentLine();
rc = findMatchingBrace( &pos );
if( rc == ERR_NO_ERR ) {
newcol = VirtualColumnOnCurrentLine( CurrentPos.column );
CGimmeLinePtr( pos.line, &cfcb, &cline );
i = FindStartOfALine( cline );
i = GetVirtualCursorPosition( cline->data, i );
j = i - VirtualColumnOnCurrentLine( CurrentPos.column );
ts = EditVars.ShiftWidth;
if( j > 0 ) {
EditVars.ShiftWidth = j;
Shift( CurrentPos.line, CurrentPos.line, '>', FALSE );
} else if( j < 0 ) {
EditVars.ShiftWidth = -j;
Shift( CurrentPos.line, CurrentPos.line, '<', FALSE );
}
EditVars.ShiftWidth = ts;
newcol = 1 + RealColumnOnCurrentLine( j + newcol );
}
GetCurrentLine();
}
}
GoToColumn( newcol, WorkLine->len + 1 );
return( ERR_NO_ERR );
} /* IMCloseBrace */
Xchar ExternalInputSource::fill(Messenger &mgr)
{
ASSERT(cur() == end());
while (end() >= bufLim_) {
// need more data
while (so_ == 0) {
if (soIndex_ >= sov_.size())
return eE;
if (soIndex_ > 0)
info_->noteStorageObjectEnd(bufLimOffset_ - (bufLim_ - end()));
const StorageObjectSpec &spec = info_->spec(soIndex_);
if (mayNotExist_) {
NullMessenger nullMgr;
sov_[soIndex_]
= spec.storageManager->makeStorageObject(spec.specId, spec.baseId,
spec.search,
mayRewind_, nullMgr,
info_->id(soIndex_));
}
else
sov_[soIndex_]
= spec.storageManager->makeStorageObject(spec.specId, spec.baseId,
spec.search,
mayRewind_, mgr,
info_->id(soIndex_));
so_ = sov_[soIndex_].pointer();
if (so_) {
decoder_ = spec.codingSystem->makeDecoder();
info_->setDecoder(soIndex_, decoder_);
zapEof_ = spec.zapEof;
switch (spec.records) {
case StorageObjectSpec::asis:
recordType_ = asis;
insertRS_ = false;
break;
case StorageObjectSpec::cr:
recordType_ = cr;
break;
case StorageObjectSpec::lf:
recordType_ = lf;
break;
case StorageObjectSpec::crlf:
recordType_ = crlf;
break;
case StorageObjectSpec::find:
recordType_ = unknown;
break;
default:
CANNOT_HAPPEN();
}
soIndex_++;
readSize_ = so_->getBlockSize();
nLeftOver_ = 0;
break;
}
else
setAccessError();
soIndex_++;
}
size_t keepSize = end() - start();
const size_t align = sizeof(int)/sizeof(Char);
size_t readSizeChars = (readSize_ + (sizeof(Char) - 1))/sizeof(Char);
readSizeChars = roundUp(readSizeChars, align);
size_t neededSize; // in Chars
size_t startOffset;
// compute neededSize and readSize
unsigned minBytesPerChar = decoder_->minBytesPerChar();
if (nLeftOver_ == 0 && minBytesPerChar >= sizeof(Char)) {
// In this case we want to do decoding in place.
// FIXME It might be a win on some systems (Irix?) to arrange that the
// read buffer is on a page boundary.
if (keepSize >= size_t(-1)/sizeof(Char) - (align - 1) - insertRS_)
abort(); // FIXME throw an exception
// Now size_t(-1)/sizeof(Char) - (align - 1) - insertRS_ - keepSize > 0
if (readSizeChars
> size_t(-1)/sizeof(Char) - (align - 1) - insertRS_ - keepSize)
abort();
neededSize = roundUp(readSizeChars + keepSize + insertRS_, align);
startOffset = ((neededSize > bufSize_ ? neededSize : bufSize_)
- readSizeChars - insertRS_ - keepSize);
}
else {
// Needs to be room for everything before decoding.
neededSize = (keepSize + insertRS_ + readSizeChars
+ (nLeftOver_ + sizeof(Char) - 1)/sizeof(Char));
// Also must be room for everything after decoding.
size_t neededSize2
= (keepSize + insertRS_
// all the converted characters
+ (nLeftOver_ + readSize_)/minBytesPerChar
// enough Chars to contain left over bytes
+ ((readSize_ % minBytesPerChar + sizeof(Char) - 1)
/ sizeof(Char)));
if (neededSize2 > neededSize)
neededSize = neededSize2;
neededSize = roundUp(neededSize, align);
if (neededSize > size_t(-1)/sizeof(Char))
abort();
startOffset = 0;
}
if (bufSize_ < neededSize)
reallocateBuffer(neededSize);
Char *newStart = buf_ + startOffset;
if (newStart != start() && keepSize > 0)
memmove(newStart, start(), keepSize*sizeof(Char));
char *bytesStart = (char *)(buf_ + bufSize_ - readSizeChars) - nLeftOver_;
if (nLeftOver_ > 0 && leftOver_ != bytesStart)
memmove(bytesStart, leftOver_, nLeftOver_);
moveStart(newStart);
bufLim_ = end();
size_t nread;
if (so_->read((char *)(buf_ + bufSize_ - readSizeChars), readSize_,
mgr, nread)) {
if (nread > 0) {
const char *bytesEnd = bytesStart + nLeftOver_ + nread;
size_t nChars = decoder_->decode((Char *)end() + insertRS_,
bytesStart,
nLeftOver_ + nread
- (zapEof_ && bytesEnd[-1] == EOFCHAR),
&leftOver_);
nLeftOver_ = bytesEnd - leftOver_;
if (nChars > 0) {
if (insertRS_) {
noteRS();
*(Char *)end() = RS;
advanceEnd(end() + 1);
insertRS_ = false;
bufLim_ += 1;
bufLimOffset_ += 1;
}
bufLim_ += nChars;
bufLimOffset_ += nChars;
break;
}
}
}
else
so_ = 0;
}
ASSERT(end() < bufLim_);
if (insertRS_) {
noteRS();
insertChar(RS);
insertRS_ = false;
bufLimOffset_ += 1;
}
switch (recordType_) {
case unknown:
{
const Char *e = findNextCrOrLf(end(), bufLim_);
if (e) {
if (*e == '\n') {
recordType_ = lf;
info_->noteInsertedRSs();
*(Char *)e = RE;
advanceEnd(e + 1);
insertRS_ = true;
}
else {
if (e + 1 < bufLim_) {
if (e[1] == '\n') {
recordType_ = crlf;
advanceEnd(e + 1);
if (e + 2 == bufLim_) {
bufLim_--;
bufLimOffset_--;
insertRS_ = true;
}
}
else {
advanceEnd(e + 1);
recordType_ = cr;
info_->noteInsertedRSs();
insertRS_ = true;
}
}
else {
recordType_ = crUnknown;
advanceEnd(e + 1);
}
}
}
else
advanceEnd(bufLim_);
}
break;
case crUnknown:
{
if (*cur() == '\n') {
noteRS();
advanceEnd(cur() + 1);
recordType_ = crlf;
}
else {
advanceEnd(cur() + 1);
insertRS_ = true;
recordType_ = cr;
info_->noteInsertedRSs();
}
}
break;
case lf:
{
Char *e = (Char *)findNextLf(end(), bufLim_);
if (e) {
advanceEnd(e + 1);
*e = RE;
insertRS_ = true;
}
else
advanceEnd(bufLim_);
}
break;
case cr:
{
const Char *e = findNextCr(end(), bufLim_);
if (e) {
advanceEnd(e + 1);
insertRS_ = true;
}
else
advanceEnd(bufLim_);
}
break;
case crlf:
{
const Char *e = end();
for (;;) {
e = findNextLf(e, bufLim_);
if (!e) {
advanceEnd(bufLim_);
break;
}
// Need to delete final RS if not followed by anything.
if (e + 1 == bufLim_) {
bufLim_--;
bufLimOffset_--;
advanceEnd(e);
insertRS_ = true;
break;
}
noteRSAt(e);
e++;
}
}
break;
case asis:
advanceEnd(bufLim_);
break;
default:
CANNOT_HAPPEN();
}
return nextChar();
}
Local Char *processOther(Char *Result, Char *note_,
struct LOC_processLine *LINK)
{
Char note[256];
strcpy(note, note_);
switch (thisNote(LINK->voice)) {
case other:
if (note[0] == grace_group) {
if (strlen(note) == 1)
LINK->ngrace = 1;
else
LINK->ngrace = pos1(note[1], digits);
if (LINK->ngrace > 0)
LINK->ngrace--;
}
break;
/* For a zword, take note of pitch but do not change the contents */
/* Add spurious duration because repitch expects duration to be present */
case zword:
strcpy(LINK->cutnote, note);
predelete(LINK->cutnote, 1);
insertChar('4', LINK->cutnote, 2);
checkOctave(LINK->voice, LINK->cutnote);
renewPitch(LINK->voice, LINK->cutnote);
break;
case lyrtag:
extractLyrtag(LINK->voice, note);
break;
case rbrac:
endBeam(LINK->voice);
break;
case rparen:
case rlparen:
endSlur(LINK->voice, note);
break;
case lbrac:
beginBeam(LINK->voice, note);
break;
case lparen:
maybeDotted(note, LINK);
beginSlur(LINK->voice, note);
break;
case mword:
error3(LINK->voice, "Meter change must be the first word of its bar");
break;
case atword:
lyricsAdjust(LINK->voice, note);
break;
}
return strcpy(Result, note);
}
void genericAction(char *tmpBuffer, int size, char c)
{
if(isControl())
{
toggleControl();
setPressedChar(c);
// control character
switch(c)
{
case 'x':// cut
// make sure highlight bounds are correct
if(beginHighlight == -1 || endHighlight == -1)
{
return;
}
if(beginHighlight > endHighlight)
{
quickSwap(&beginHighlight, &endHighlight);
}
// perform cut
setClipboardRange(tmpBuffer, beginHighlight, endHighlight);
removeText(tmpBuffer, size);
moveKBCursorAbsolute(beginHighlight);
// reset the edit mode
clearFakeHighlight();
select = 0;
break;
case 'c':// copy
// make sure highlight bounds are correct
if(beginHighlight == -1 || endHighlight == -1)
{
return;
}
if(beginHighlight > endHighlight)
{
quickSwap(&beginHighlight, &endHighlight);
}
// perform copy
setClipboardRange(tmpBuffer, beginHighlight, endHighlight);
// reset the edit mode
clearFakeHighlight();
select = 0;
break;
case 'v':// paste
if(beginHighlight != -1 && endHighlight != -1)
{
if(beginHighlight > endHighlight)
{
quickSwap(&beginHighlight, &endHighlight);
}
// we need to overwrite, but first check to make sure we don't overdo it
if(strlen(tmpBuffer) - (endHighlight - beginHighlight) + strlen(getClipboard()) > size)
{
// after removing the current text and adding the new text, we are going over the size
return;
}
// remove the current text
removeText(tmpBuffer, size);
moveKBCursorAbsolute(beginHighlight);
clearFakeHighlight();
select = 0;
// cursor is now where we want to add the new text
// we know also that there is enough room, so just insert the text
// ensure we are inserting, even if overwrite
uint16 tInsert = insert;
insert = 1;
char *tAdd = getClipboard();
// loop and add chars
while(*tAdd != 0)
{
insertChar(tmpBuffer, size, *tAdd);
tAdd++;
}
// reset insert
insert = tInsert;
}
else
{
if(strlen(tmpBuffer) + strlen(getClipboard()) > size)
{
// after adding the new text, we are going over the size
return;
}
clearFakeHighlight();
select = 0;
// add the text
char *tAdd = getClipboard();
// loop and add chars
while(*tAdd != 0)
{
insertChar(tmpBuffer, size, *tAdd);
tAdd++;
}
}
break;
}
}
else
{
if(getKBCursor() < 0)
{
moveKBCursorAbsolute(0);
}
else if(getKBCursor() >= size)
{
moveKBCursorAbsolute(size - 1);
}
if(beginHighlight != -1 && endHighlight != -1)
{
if(beginHighlight > endHighlight)
{
quickSwap(&beginHighlight, &endHighlight);
}
// we have to clear out the data before performing the action
removeText(tmpBuffer, size);
// move the cursor
moveKBCursorAbsolute(beginHighlight);
// reset the edit mode
clearFakeHighlight();
select = 0;
if(c == BSP || c == DEL)
{
// we've done the work required, exit
return;
}
}
if(c == BSP)
{
// backspace
if(getKBCursor() == 0) // handle backspacing nothing
{
return;
}
int z;
for(z=getKBCursor()-1;z<=size;z++)
{
tmpBuffer[z] = tmpBuffer[z+1];
}
moveKBCursorRelative(CURSOR_BACKWARD);
}
else if(c == DEL)
{
// del
if(tmpBuffer[getKBCursor()] == 0) // handle deleting nothing
{
return;
}
moveKBCursorRelative(CURSOR_FORWARD);
int z;
for(z=getKBCursor()-1;z<=size;z++)
{
tmpBuffer[z] = tmpBuffer[z+1];
}
moveKBCursorRelative(CURSOR_BACKWARD);
}
else
{
// normal add
insertChar(tmpBuffer, size, c);
}
tmpBuffer[size] = 0;
}
}
void DlgSpecChar::slotUser1( )
{
emit insertChar(chr());
closeDialog();
}
void DlgSpecChar::slotDoubleClicked()
{
emit insertChar(chr());
closeDialog();
}
/*
* getStringInWindow: main routine
*/
static bool getStringInWindow( input_buffer *input )
{
vi_key event;
bool old_mode;
ReadingAString = true;
initInput( input );
input->last_str = alloca( input->buffer_length );
memset( input->last_str, 0, input->buffer_length );
if( input->h != NULL ) {
input->curr_hist = input->h->curr;
}
for( ;; ) {
event = GetNextEvent( false );
event = cursorKeyFilter( input, event );
event = historyFilter( input, event );
event = specialKeyFilter( input, event );
switch( event ) {
case VI_KEY( NULL ):
break;
case VI_KEY( SHIFT_TAB ):
case VI_KEY( TAB ):
if( !fileComplete( input, event ) ) {
endColumn( input );
break;
}
/* fall through */
case VI_KEY( ENTER ):
if( input->buffer[0] == NO_ADD_TO_HISTORY_KEY ) {
strcpy( &input->buffer[0], &input->buffer[1] );
} else {
addHistory( input );
}
/* fall through */
case VI_KEY( ESC ):
finiInput( input );
/*
* this call may not be necessary if the file complete window has
* already closed of natural causes but it doesn't harm anything
* if called when not needed - so we leave it here.
*/
FinishFileComplete();
ReadingAString = false;
return( event != VI_KEY( ESC ) );
case VI_KEY( INS ):
input->overstrike = !input->overstrike;
if( !EditFlags.NoInputWindow ) {
NewCursor( input->window.id, input->overstrike ? EditVars.NormalCursorType : EditVars.InsertCursorType );
}
break;
case VI_KEY( CTRL_END ):
saveStr( input );
input->buffer[input->curr_pos] = '\0';
break;
case VI_KEY( CTRL_X ):
case VI_KEY( CTRL_U ):
saveStr( input );
input->buffer[0] = '\0';
endColumn( input );
break;
case VI_KEY( CTRL_INS ):
swapString( input );
break;
case VI_KEY( CTRL_V ):
case VI_KEY( CTRL_Q ):
insertChar( input, '^' );
displayLine( input );
// here we have a bit of a kluge
input->curr_pos -= 1;
event = GetNextEvent( false );
saveStr( input );
old_mode = input->overstrike;
input->overstrike = true;
insertChar( input, event );
input->overstrike = old_mode;
break;
case VI_KEY( ALT_END ):
/* just want to redraw the line - for windows */
break;
default:
if( (event >= 32 && event < 256) || event == VI_KEY( CTRL_A ) ) {
saveStr( input );
if( !insertChar( input, event ) ) {
MyBeep();
}
}
}
if( !EditFlags.NoInputWindow ) {
displayLine( input );
}
}
} /* getStringInWindow */
