void PersistentState::deleteText() {
if (hasSelection())
_persistentCursor.removeSelectedText();
}
static bool hasSelection( QListViewItem * start ) {
for ( QListViewItem * item = start ; item ; item = item->nextSibling() )
if ( item->isSelected() || hasSelection( item->firstChild() ) )
return true;
return false;
}
void ChatScene::selectionToClipboard(QClipboard::Mode mode) {
if(!hasSelection())
return;
stringToClipboard(selection(), mode);
}
void ArtisticTextToolSelection::repaintDecoration()
{
if (hasSelection())
m_canvas->updateCanvas(outline().boundingRect());
}
void YDrawCell::delSelection( yzis::SelectionType selType )
{
if ( hasSelection( selType ) )
mSelections -= selType;
}
BOOL LLViewerTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
// Let scrollbar have first dibs
handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
// enable I Agree checkbox if the user scrolled through entire text
BOOL was_scrolled_to_bottom = (mScrollbar->getDocPos() == mScrollbar->getDocPosMax());
if (mOnScrollEndCallback && was_scrolled_to_bottom)
{
mOnScrollEndCallback(mOnScrollEndData);
}
if( !handled && mTakesNonScrollClicks)
{
if (!(mask & MASK_SHIFT))
{
deselect();
}
BOOL start_select = TRUE;
if( allowsEmbeddedItems() )
{
setCursorAtLocalPos( x, y, FALSE );
llwchar wc = 0;
if (mCursorPos < getLength())
{
wc = getWChar(mCursorPos);
}
LLInventoryItem* item_at_pos = LLEmbeddedItems::getEmbeddedItem(wc);
if (item_at_pos)
{
mDragItem = item_at_pos;
mDragItemChar = wc;
mDragItemSaved = LLEmbeddedItems::getEmbeddedItemSaved(wc);
gFocusMgr.setMouseCapture( this );
mMouseDownX = x;
mMouseDownY = y;
S32 screen_x;
S32 screen_y;
localPointToScreen(x, y, &screen_x, &screen_y );
LLToolDragAndDrop::getInstance()->setDragStart( screen_x, screen_y );
start_select = FALSE;
}
else
{
mDragItem = NULL;
}
}
if( start_select )
{
// If we're not scrolling (handled by child), then we're selecting
if (mask & MASK_SHIFT)
{
S32 old_cursor_pos = mCursorPos;
setCursorAtLocalPos( x, y, TRUE );
if (hasSelection())
{
/* Mac-like behavior - extend selection towards the cursor
if (mCursorPos < mSelectionStart
&& mCursorPos < mSelectionEnd)
{
// ...left of selection
mSelectionStart = llmax(mSelectionStart, mSelectionEnd);
mSelectionEnd = mCursorPos;
}
else if (mCursorPos > mSelectionStart
&& mCursorPos > mSelectionEnd)
{
// ...right of selection
mSelectionStart = llmin(mSelectionStart, mSelectionEnd);
mSelectionEnd = mCursorPos;
}
else
{
mSelectionEnd = mCursorPos;
}
*/
// Windows behavior
mSelectionEnd = mCursorPos;
}
else
{
mSelectionStart = old_cursor_pos;
mSelectionEnd = mCursorPos;
}
// assume we're starting a drag select
mIsSelecting = TRUE;
}
else
{
setCursorAtLocalPos( x, y, TRUE );
startSelection();
}
gFocusMgr.setMouseCapture( this );
}
handled = TRUE;
}
if (hasTabStop())
{
setFocus(TRUE);
handled = TRUE;
}
// Delay cursor flashing
resetKeystrokeTimer();
return handled;
}
void UITextEdit::paste(const std::string& text)
{
if(hasSelection())
del();
appendText(text);
}
void
HTMLView::enableCopyAction()
{
m_copy->setEnabled( hasSelection() );
}
void EvaChatView::slotSelectionChanged( )
{
copyAction->setEnabled( hasSelection() );
}
BOOL LLViewerTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
// let scrollbar have first dibs
handled = LLView::childrenHandleMouseUp(x, y, mask) != NULL;
// Used to enable I Agree checkbox if the user scrolled through entire text
BOOL was_scrolled_to_bottom = (mScrollbar->getDocPos() == mScrollbar->getDocPosMax());
if (mOnScrollEndCallback && was_scrolled_to_bottom)
{
mOnScrollEndCallback(mOnScrollEndData);
}
if( !handled && mTakesNonScrollClicks)
{
if( mIsSelecting )
{
// Finish selection
if( y > getTextRect().mTop )
{
mScrollbar->setDocPos( mScrollbar->getDocPos() - 1 );
}
else
if( y < getTextRect().mBottom )
{
mScrollbar->setDocPos( mScrollbar->getDocPos() + 1 );
}
setCursorAtLocalPos( x, y, TRUE );
endSelection();
updateScrollFromCursor();
}
if( !hasSelection() )
{
handleMouseUpOverSegment( x, y, mask );
}
handled = TRUE;
}
// Delay cursor flashing
resetKeystrokeTimer();
if( hasMouseCapture() )
{
if (mDragItem)
{
// mouse down was on an item
S32 dx = x - mMouseDownX;
S32 dy = y - mMouseDownY;
if (-2 < dx && dx < 2 && -2 < dy && dy < 2)
{
if(mDragItemSaved)
{
openEmbeddedItem(mDragItem);
}else
{
showUnsavedAlertDialog(mDragItem);
}
}
}
mDragItem = NULL;
gFocusMgr.setMouseCapture( NULL );
handled = TRUE;
}
return handled;
}
bool PolicyEditor::selectionReadActionsEnabled(){
return hasSelection();
}
bool PolicyEditor::modifySelectionActionsEnabled(){
return isEditable() && hasSelection();
}
bool PolicyEditor::copyEnabled(){
return hasSelection();
}
void TEditor::handleEvent( TEvent& event )
{
TView::handleEvent( event );
convertEvent( event );
Boolean centerCursor = Boolean(!cursorVisible());
uchar selectMode = 0;
if( selecting == True || (getShiftState() & 0x03) != 0 )
selectMode = smExtend;
switch( event.what )
{
case evMouseDown:
if( event.mouse.doubleClick == True )
selectMode |= smDouble;
do {
lock();
if( event.what == evMouseAuto )
{
TPoint mouse = makeLocal( event.mouse.where );
TPoint d = delta;
if( mouse.x < 0 )
d.x--;
if( mouse.x >= size.x )
d.x++;
if( mouse.y < 0 )
d.y--;
if( mouse.y >= size.y )
d.y++;
scrollTo(d.x, d.y);
}
setCurPtr(getMousePtr(event.mouse.where), selectMode);
selectMode |= smExtend;
unlock();
} while( mouseEvent(event, evMouseMove + evMouseAuto) );
break;
case evKeyDown:
if( event.keyDown.charScan.charCode == 9 ||
( event.keyDown.charScan.charCode >= 32 && event.keyDown.charScan.charCode < 255 ) )
{
lock();
if( overwrite == True && hasSelection() == False )
if( curPtr != lineEnd(curPtr) )
selEnd = nextChar(curPtr);
insertText( &event.keyDown.charScan.charCode, 1, False);
trackCursor(centerCursor);
unlock();
}
else
return;
break;
case evCommand:
switch( event.message.command )
{
case cmFind:
find();
break;
case cmReplace:
replace();
break;
case cmSearchAgain:
doSearchReplace();
break;
default:
lock();
switch( event.message.command )
{
case cmCut:
clipCut();
break;
case cmCopy:
clipCopy();
// hideSelect(); // JS 12.4.94
break;
case cmPaste:
clipPaste();
break;
case cmUndo:
undo();
break;
case cmClear:
deleteSelect();
break;
case cmCharLeft:
setCurPtr(prevChar(curPtr), selectMode);
break;
case cmCharRight:
setCurPtr(nextChar(curPtr), selectMode);
break;
case cmWordLeft:
setCurPtr(prevWord(curPtr), selectMode);
break;
case cmWordRight:
setCurPtr(nextWord(curPtr), selectMode);
break;
case cmLineStart:
setCurPtr(lineStart(curPtr), selectMode);
break;
case cmLineEnd:
setCurPtr(lineEnd(curPtr), selectMode);
break;
case cmLineUp:
setCurPtr(lineMove(curPtr, -1), selectMode);
break;
case cmLineDown:
setCurPtr(lineMove(curPtr, 1), selectMode);
break;
case cmPageUp:
setCurPtr(lineMove(curPtr, -(size.y-1)), selectMode);
break;
case cmPageDown:
setCurPtr(lineMove(curPtr, size.y-1), selectMode);
break;
case cmTextStart:
setCurPtr(0, selectMode);
break;
case cmTextEnd:
setCurPtr(bufLen, selectMode);
break;
case cmNewLine:
newLine();
break;
case cmBackSpace:
deleteRange(prevChar(curPtr), curPtr, True);
break;
case cmDelChar:
deleteRange(curPtr, nextChar(curPtr), True);
break;
case cmDelWord:
deleteRange(curPtr, nextWord(curPtr), False);
break;
case cmDelStart:
deleteRange(lineStart(curPtr), curPtr, False);
break;
case cmDelEnd:
deleteRange(curPtr, lineEnd(curPtr), False);
break;
case cmDelLine:
deleteRange(lineStart(curPtr), nextLine(curPtr), False);
break;
case cmInsMode:
toggleInsMode();
break;
case cmStartSelect:
startSelect();
break;
case cmHideSelect:
hideSelect();
break;
case cmIndentMode:
autoIndent = Boolean(!autoIndent);
break;
default:
unlock();
return;
}
trackCursor(centerCursor);
unlock();
break;
}
case evBroadcast:
switch( event.message.command )
{
case cmScrollBarChanged:
checkScrollBar( event, hScrollBar, delta.x );
checkScrollBar( event, vScrollBar, delta.y );
break;
default:
return;
}
}
clearEvent(event);
}
void UITextEdit::drawSelf(Fw::DrawPane drawPane)
{
if((drawPane & Fw::ForegroundPane) == 0)
return;
drawBackground(m_rect);
drawBorder(m_rect);
drawImage(m_rect);
drawIcon(m_rect);
//TODO: text rendering could be much optimized by using vertex buffer or caching the render into a texture
int textLength = m_text.length();
const TexturePtr& texture = m_font->getTexture();
if(!texture)
return;
if(hasSelection()) {
if(m_color != Color::alpha) {
g_painter->setColor(m_color);
for(int i=0;i<m_selectionStart;++i)
g_painter->drawTexturedRect(m_glyphsCoords[i], texture, m_glyphsTexCoords[i]);
}
for(int i=m_selectionStart;i<m_selectionEnd;++i) {
g_painter->setColor(m_selectionBackgroundColor);
g_painter->drawFilledRect(m_glyphsCoords[i]);
g_painter->setColor(m_selectionColor);
g_painter->drawTexturedRect(m_glyphsCoords[i], texture, m_glyphsTexCoords[i]);
}
if(m_color != Color::alpha) {
g_painter->setColor(m_color);
for(int i=m_selectionEnd;i<textLength;++i)
g_painter->drawTexturedRect(m_glyphsCoords[i], texture, m_glyphsTexCoords[i]);
}
} else if(m_color != Color::alpha) {
g_painter->setColor(m_color);
for(int i=0;i<textLength;++i)
g_painter->drawTexturedRect(m_glyphsCoords[i], texture, m_glyphsTexCoords[i]);
}
// render cursor
if(isExplicitlyEnabled() && m_cursorVisible && m_cursorInRange && isActive() && m_cursorPos >= 0) {
assert(m_cursorPos <= textLength);
// draw every 333ms
const int delay = 333;
int elapsed = g_clock.millis() - m_cursorTicks;
if(elapsed <= delay) {
Rect cursorRect;
// when cursor is at 0
if(m_cursorPos == 0)
cursorRect = Rect(m_rect.left()+m_padding.left, m_rect.top()+m_padding.top, 1, m_font->getGlyphHeight());
else
cursorRect = Rect(m_glyphsCoords[m_cursorPos-1].right(), m_glyphsCoords[m_cursorPos-1].top(), 1, m_font->getGlyphHeight());
if(hasSelection() && m_cursorPos >= m_selectionStart && m_cursorPos <= m_selectionEnd)
g_painter->setColor(m_selectionColor);
else
g_painter->setColor(m_color);
g_painter->drawFilledRect(cursorRect);
} else if(elapsed >= 2*delay) {
m_cursorTicks = g_clock.millis();
}
}
g_painter->resetColor();
}
AutocompleteQuery ParseMentionHashtagBotCommandQuery(
not_null<const Ui::InputField*> field) {
auto result = AutocompleteQuery();
const auto cursor = field->textCursor();
if (cursor.hasSelection()) {
return result;
}
const auto position = cursor.position();
const auto document = field->document();
const auto block = document->findBlock(position);
for (auto item = block.begin(); !item.atEnd(); ++item) {
const auto fragment = item.fragment();
if (!fragment.isValid()) {
continue;
}
const auto fragmentPosition = fragment.position();
const auto fragmentEnd = fragmentPosition + fragment.length();
if (fragmentPosition >= position || fragmentEnd < position) {
continue;
}
const auto format = fragment.charFormat();
if (format.isImageFormat()) {
continue;
}
bool mentionInCommand = false;
const auto text = fragment.text();
for (auto i = position - fragmentPosition; i != 0; --i) {
if (text[i - 1] == '@') {
if ((position - fragmentPosition - i < 1 || text[i].isLetter()) && (i < 2 || !(text[i - 2].isLetterOrNumber() || text[i - 2] == '_'))) {
result.fromStart = (i == 1) && (fragmentPosition == 0);
result.query = text.mid(i - 1, position - fragmentPosition - i + 1);
} else if ((position - fragmentPosition - i < 1 || text[i].isLetter()) && i > 2 && (text[i - 2].isLetterOrNumber() || text[i - 2] == '_') && !mentionInCommand) {
mentionInCommand = true;
--i;
continue;
}
return result;
} else if (text[i - 1] == '#') {
if (i < 2 || !(text[i - 2].isLetterOrNumber() || text[i - 2] == '_')) {
result.fromStart = (i == 1) && (fragmentPosition == 0);
result.query = text.mid(i - 1, position - fragmentPosition - i + 1);
}
return result;
} else if (text[i - 1] == '/') {
if (i < 2) {
result.fromStart = (i == 1) && (fragmentPosition == 0);
result.query = text.mid(i - 1, position - fragmentPosition - i + 1);
}
return result;
}
if (position - fragmentPosition - i > 127 || (!mentionInCommand && (position - fragmentPosition - i > 63))) {
break;
}
if (!text[i - 1].isLetterOrNumber() && text[i - 1] != '_') {
break;
}
}
break;
}
return result;
}
std::string UITextEdit::getSelection()
{
if(!hasSelection())
return std::string();
return m_text.substr(m_selectionStart, m_selectionEnd - m_selectionStart);
}
void FrameAxisWidget::paintEvent(QPaintEvent *)
{
if (!m_data || m_orientation != GraphAxisWidget::Horizontal) {
/* TODO: Vertical axis support */
return;
}
QPainter painter(this);
painter.setPen(Qt::black);
painter.setBrush(Qt::lightGray);
painter.drawRect(0, 0, width() - 1, height() - 1);
qint64 range = m_valueEnd - m_valueBegin;
double dxdv = width() / (double)range;
double scroll = dxdv * m_valueBegin;
int lastLabel = -9999;
/* Iterate over frames, drawing a label when there is space to do so */
for (unsigned i = 0; i < m_data->size(); ++i) {
static const int padding = 4;
qint64 start = m_data->frameStart(i);
qint64 end = m_data->frameEnd(i);
bool visible = false;
if (start > m_valueEnd) {
break;
}
if (end < m_valueBegin) {
visible = false;
}
double left = dxdv * start;
double right = dxdv * end;
QString text = QString("%1").arg(i);
int width = painter.fontMetrics().width(text) + padding * 2;
if (right > scroll) {
visible = true;
}
if (left - lastLabel > width) {
lastLabel = left + width;
if (visible) {
int textX;
if (left < scroll && right - left > width) {
if (right - scroll > width) {
textX = 0;
} else {
textX = right - scroll - width;
}
} else {
textX = left - scroll;
}
painter.drawText(textX + padding, 0, width - padding, height() - 5, Qt::AlignLeft | Qt::AlignVCenter, text);
painter.drawLine(left - scroll, height() / 2, left - scroll, height() - 1);
}
} else if (visible) {
painter.drawLine(left - scroll, height() * 3/4.0, left - scroll, height() - 1);
}
}
/* Draw selection */
if (hasSelection()) {
double left = (dxdv * m_selectionState->start) - scroll;
double right = (dxdv * m_selectionState->end) - scroll;
painter.setPen(Qt::green);
if (left >= 0 && left <= width()) {
painter.drawLine(left, 0, left, height());
}
if (right >= 0 && right <= width()) {
painter.drawLine(right, 0, right, height());
}
}
}
bool UITextEdit::onKeyPress(uchar keyCode, int keyboardModifiers, int autoRepeatTicks)
{
if(UIWidget::onKeyPress(keyCode, keyboardModifiers, autoRepeatTicks))
return true;
if(keyboardModifiers == Fw::KeyboardNoModifier) {
if(keyCode == Fw::KeyDelete && m_editable) { // erase right character
if(hasSelection() || !m_text.empty()) {
del(true);
return true;
}
} else if(keyCode == Fw::KeyBackspace && m_editable) { // erase left character
if(hasSelection() || !m_text.empty()) {
del(false);
return true;
}
} else if(keyCode == Fw::KeyRight && !m_shiftNavigation) { // move cursor right
clearSelection();
moveCursorHorizontally(true);
return true;
} else if(keyCode == Fw::KeyLeft && !m_shiftNavigation) { // move cursor left
clearSelection();
moveCursorHorizontally(false);
return true;
} else if(keyCode == Fw::KeyHome) { // move cursor to first character
if(m_cursorPos != 0) {
clearSelection();
setCursorPos(0);
return true;
}
} else if(keyCode == Fw::KeyEnd) { // move cursor to last character
if(m_cursorPos != (int)m_text.length()) {
clearSelection();
setCursorPos(m_text.length());
return true;
}
} else if(keyCode == Fw::KeyTab && !m_shiftNavigation) {
clearSelection();
if(UIWidgetPtr parent = getParent())
parent->focusNextChild(Fw::KeyboardFocusReason, true);
return true;
} else if(keyCode == Fw::KeyEnter && m_multiline && m_editable) {
appendCharacter('\n');
return true;
} else if(keyCode == Fw::KeyUp && !m_shiftNavigation && m_multiline) {
moveCursorVertically(true);
return true;
} else if(keyCode == Fw::KeyDown && !m_shiftNavigation && m_multiline) {
moveCursorVertically(false);
return true;
}
} else if(keyboardModifiers == Fw::KeyboardCtrlModifier) {
if(keyCode == Fw::KeyV && m_editable) {
paste(g_window.getClipboardText());
return true;
} else if(keyCode == Fw::KeyX && m_editable && m_selectable) {
if(hasSelection()) {
cut();
return true;
}
} else if(keyCode == Fw::KeyC && m_selectable) {
if(hasSelection()) {
copy();
return true;
}
} else if(keyCode == Fw::KeyA && m_selectable) {
if(m_text.length() > 0) {
selectAll();
return true;
}
}
} else if(keyboardModifiers == Fw::KeyboardShiftModifier) {
if(keyCode == Fw::KeyTab && !m_shiftNavigation) {
if(UIWidgetPtr parent = getParent())
parent->focusPreviousChild(Fw::KeyboardFocusReason, true);
return true;
} else if(keyCode == Fw::KeyRight || keyCode == Fw::KeyLeft) {
int oldCursorPos = m_cursorPos;
if(keyCode == Fw::KeyRight) // move cursor right
moveCursorHorizontally(true);
else if(keyCode == Fw::KeyLeft) // move cursor left
moveCursorHorizontally(false);
if(m_shiftNavigation)
clearSelection();
else {
if(!hasSelection())
m_selectionReference = oldCursorPos;
setSelection(m_selectionReference, m_cursorPos);
}
return true;
} else if(keyCode == Fw::KeyHome) { // move cursor to first character
if(m_cursorPos != 0) {
setSelection(m_cursorPos, 0);
setCursorPos(0);
return true;
}
} else if(keyCode == Fw::KeyEnd) { // move cursor to last character
if(m_cursorPos != (int)m_text.length()) {
setSelection(m_cursorPos, m_text.length());
setCursorPos(m_text.length());
return true;
}
}
}
return false;
}
QWidget *FormWindowCursor::selectedWidget(int index) const
{
return hasSelection()
? m_formWindow->selectedWidgets().at(index)
: m_formWindow->mainContainer();
}
QPainterPath ArtisticTextToolSelection::outline()
{
if (!hasSelection())
return QPainterPath();
CharIndex charPos = m_currentShape->indexOfChar(m_selectionStart);
if (charPos.first < 0)
return QPainterPath();
QPainterPath outline;
QPolygonF polygon;
QList<ArtisticTextRange> ranges = m_currentShape->text();
if (ranges.size() == 0) return outline;
int globalCharIndex = m_selectionStart;
int remainingChars = m_selectionCount;
while (remainingChars) {
const ArtisticTextRange ¤tRange = ranges[charPos.first];
int currentTextLength = currentRange.text().length();
while (charPos.second < currentTextLength && remainingChars > 0) {
const QPointF pos = m_currentShape->charPositionAt(globalCharIndex);
const qreal angle = m_currentShape->charAngleAt(globalCharIndex);
QTransform charTransform;
charTransform.translate( pos.x() - 1, pos.y() );
charTransform.rotate( 360. - angle );
QFontMetricsF metrics(currentRange.font());
polygon.prepend(charTransform.map(QPointF(0.0, -metrics.ascent())));
polygon.append(charTransform.map(QPointF(0.0, metrics.descent())));
// advance to next character
charPos.second++;
globalCharIndex++;
remainingChars--;
// next character has y-offset or we are at the end of this text range
const bool hasYOffset = currentRange.hasYOffset(charPos.second);
const bool atRangeEnd = charPos.second == currentTextLength;
const bool atSelectionEnd = remainingChars == 0;
if (hasYOffset || atRangeEnd || atSelectionEnd) {
if (hasYOffset || atRangeEnd) {
const QChar c = currentRange.text().at(charPos.second-1);
const qreal w = metrics.width(c);
polygon.prepend(charTransform.map(QPointF(w, -metrics.ascent())));
polygon.append(charTransform.map(QPointF(w, metrics.descent())));
} else {
const QPointF pos = m_currentShape->charPositionAt(globalCharIndex);
const qreal angle = m_currentShape->charAngleAt(globalCharIndex);
charTransform.reset();
charTransform.translate( pos.x() - 1, pos.y() );
charTransform.rotate( 360. - angle );
polygon.prepend(charTransform.map(QPointF(0.0, -metrics.ascent())));
polygon.append(charTransform.map(QPointF(0.0, metrics.descent())));
}
QPainterPath p;
p.addPolygon(polygon);
outline = outline.united(p);
polygon.clear();
}
}
// go to first character of next text range
charPos.first++;
charPos.second = 0;
}
// transform to document coordinates
return m_currentShape->absoluteTransformation(0).map(outline);
}
void EditableTextComponent::keyTyped(const KeyEventUnrecPtr e)
{
if(getEnabled() && getEditable() && !(e->getModifiers() &( KeyEvent::KEY_MODIFIER_ALT | KeyEvent::KEY_MODIFIER_CONTROL | KeyEvent::KEY_MODIFIER_META )))
{
if(e->getKeyChar()>31 && e->getKeyChar() < 127)
{
if(hasSelection())
{
deleteSelectedText();
setCaretPosition(_TextSelectionStart);
}
insert(std::string( 1,e->getKeyChar() ), _TextSelectionStart);
_TextSelectionStart = getCaretPosition();
_TextSelectionEnd = _TextSelectionStart;
}
if(e->getKey()== e->KEY_BACK_SPACE)
{
if(hasSelection())
{
deleteSelectedText();
}
else
{
//erase at the current caret position
Int32 DeleteIndex(getCaretPosition());
if(DeleteIndex != 0)
{
moveCaret(-1);
deleteRange(DeleteIndex-1, DeleteIndex);
}
}
}
if(e->getKey()== e->KEY_DELETE)
{
if(hasSelection())
{
deleteSelectedText();
}
else if(getText().size()>0)
{
//erase at the current caret position
deleteRange(getCaretPosition(), getCaretPosition()+1);
_TextSelectionStart = getCaretPosition();
_TextSelectionEnd = _TextSelectionStart;
}
}
}
switch(e->getKey())
{
case KeyEvent::KEY_RIGHT:
case KeyEvent::KEY_KEYPAD_RIGHT:
moveCaret(1);
break;
case KeyEvent::KEY_LEFT:
case KeyEvent::KEY_KEYPAD_LEFT:
moveCaret(-1);
break;
case KeyEvent::KEY_V:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
paste();
}
break;
case KeyEvent::KEY_C:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
copy();
}
break;
case KeyEvent::KEY_X:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
cut();
}
break;
case KeyEvent::KEY_A:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
selectAll();
}
break;
}
Inherited::keyTyped(e);
}
// Update somebody who works on the selection
long TextLabel::onUpdHaveSelection(FXObject* sender,FXSelector,void* ptr)
{
sender->handle(this,hasSelection()?FXSEL(SEL_COMMAND,ID_ENABLE):FXSEL(SEL_COMMAND,ID_DISABLE),ptr);
return 1;
}
