Source Code (Use browser search to find items of interest.)
Class Index
kdevelop'KWriteView (./kdevelop/kdevelop/kwrite/kwview.h:204)
class KWriteView : public QWidget {
Q_OBJECT
friend KWriteDoc;
friend KWrite;
public:
// a drop-aware container should set HandleOwnURIDrops = false and handle all URI drops
// KWriteView will otherwise handle URI drops, but is slightly limited
// KWriteView always handles text drops
KWriteView(KWrite *, KWriteDoc *, bool HandleOwnURIDrops);
~KWriteView();
virtual void doCursorCommand(VConfig &, int cmdNum);
virtual void doEditCommand(VConfig &, int cmdNum);
void cursorLeft(VConfig &);
void cursorRight(VConfig &);
void wordLeft(VConfig &);
void wordRight(VConfig &);
void home(VConfig &);
void end(VConfig &);
void cursorUp(VConfig &);
void cursorDown(VConfig &);
void scrollUp(VConfig &);
void scrollDown(VConfig &);
void topOfView(VConfig &);
void bottomOfView(VConfig &);
void pageUp(VConfig &);
void pageDown(VConfig &);
void cursorPageUp(VConfig &);
void cursorPageDown(VConfig &);
void top(VConfig &);
void bottom(VConfig &);
void top_home(VConfig &c);
void bottom_end(VConfig &c);
protected slots:
void changeXPos(int);
void changeYPos(int);
protected:
void getVConfig(VConfig &);
void update(VConfig &);
void insLine(int line);
void delLine(int line);
void updateCursor();
void updateCursor(PointStruc &newCursor);
void updateCursor(PointStruc &newCursor, int flags);
void lineValues(int h);
void tagLines(int start, int end, int x1, int x2);
void tagAll();
void setPos(int x, int y);
void center();
void updateView(int flags);
void paintTextLines(int xPos, int yPos);
void paintCursor();
void paintBracketMark();
void placeCursor(int x, int y, int flags = 0);
bool isTargetSelected(int x, int y);
void doDrag();
virtual void focusInEvent(QFocusEvent *);
virtual void focusOutEvent(QFocusEvent *);
virtual void keyPressEvent(QKeyEvent *e);
virtual void mousePressEvent(QMouseEvent *);
virtual void mouseDoubleClickEvent(QMouseEvent *);
virtual void mouseReleaseEvent(QMouseEvent *);
virtual void mouseMoveEvent(QMouseEvent *);
virtual void paintEvent(QPaintEvent *);
virtual void resizeEvent(QResizeEvent *);
virtual void timerEvent(QTimerEvent *);
virtual void dragEnterEvent( QDragEnterEvent * );
// virtual void dragMoveEvent( QDragMoveEvent * );
// virtual void dragLeaveEvent( QDragLeaveEvent * );
virtual void dropEvent( QDropEvent * );
KWrite *kWrite;
KWriteDoc *kWriteDoc;
QScrollBar *xScroll;
QScrollBar *yScroll;
int xPos;
int yPos;
int mouseX;
int mouseY;
int scrollX;
int scrollY;
int scrollTimer;
PointStruc cursor;
bool cursorOn;
int cursorTimer;
int cXPos;
int cOldXPos;
int startLine;
int endLine;
bool exposeCursor;
int updateState;
// int updateLines[2];
int numLines;
LineRange *lineRanges;
int newXPos;
int newYPos;
QPixmap *drawBuffer;
BracketMark bm;
bool HandleURIDrops;
enum DragState { diNone, diPending, diDragging };
struct {
DragState state;
PointStruc start;
QTextDrag *dragObject;
} dragInfo;
signals:
// emitted when KWriteView is not handling its own URI drops
void dropEventPass(QDropEvent*);
};
kdevelop'KWriteView::KWriteView() (./kdevelop/kdevelop/kwrite/kwview.cpp:122)
KWriteView::KWriteView(KWrite *write, KWriteDoc *doc, bool HandleOwnDND)
: QWidget(write) {
kWrite = write;
kWriteDoc = doc;
QWidget::setCursor(ibeamCursor);
setBackgroundMode(NoBackground);
setFocusPolicy(StrongFocus);
move(2,2);
xScroll = new QScrollBar(QScrollBar::Horizontal,write);
yScroll = new QScrollBar(QScrollBar::Vertical,write);
connect(xScroll,SIGNAL(valueChanged(int)),SLOT(changeXPos(int)));
connect(yScroll,SIGNAL(valueChanged(int)),SLOT(changeYPos(int)));
xPos = 0;
yPos = 0;
scrollTimer = 0;
cursor.x = 0;
cursor.y = 0;
cursorOn = false;
cursorTimer = 0;
cXPos = 0;
cOldXPos = 0;
startLine = 0;
endLine = -1;
exposeCursor = false;
updateState = 0;
numLines = 0;
lineRanges = 0L;
newXPos = -1;
newYPos = -1;
drawBuffer = getBuffer(this);
bm.sXPos = 0;
bm.eXPos = -1;
doc->registerView(this);
setAcceptDrops(true);
HandleURIDrops = HandleOwnDND;
dragInfo.state = diNone;
}
kdevelop'KWriteView::~KWriteView() (./kdevelop/kdevelop/kwrite/kwview.cpp:173)
KWriteView::~KWriteView() {
kWriteDoc->removeView(this);
delete [] lineRanges;
releaseBuffer(this);
}
kdevelop'KWriteView::doCursorCommand() (./kdevelop/kdevelop/kwrite/kwview.cpp:180)
void KWriteView::doCursorCommand(VConfig &c, int cmdNum) {
switch (cmdNum) {
case cmLeft:
cursorLeft(c);
break;
case cmRight:
cursorRight(c);
break;
case cmWordLeft:
wordLeft(c);
break;
case cmWordRight:
wordRight(c);
break;
case cmHome:
home(c);
break;
case cmEnd:
end(c);
break;
case cmUp:
cursorUp(c);
break;
case cmDown:
cursorDown(c);
break;
case cmScrollUp:
scrollUp(c);
break;
case cmScrollDown:
scrollDown(c);
break;
case cmTopOfView:
topOfView(c);
break;
case cmBottomOfView:
bottomOfView(c);
break;
case cmPageUp:
pageUp(c);
break;
case cmPageDown:
pageDown(c);
break;
/* case cmCursorPageUp:
cursorPageUp(c);
break;
case cmCursorPageDown:
cursorPageDown(c);
break;*/
case cmTop:
top_home(c);
break;
case cmBottom:
bottom_end(c);
break;
}
}
kdevelop'KWriteView::doEditCommand() (./kdevelop/kdevelop/kwrite/kwview.cpp:240)
void KWriteView::doEditCommand(VConfig &c, int cmdNum) {
switch (cmdNum) {
case cmCopy:
kWriteDoc->copy(c.flags);
return;
case cmSelectAll:
kWriteDoc->selectAll();
return;
case cmDeselectAll:
kWriteDoc->deselectAll();
return;
case cmInvertSelection:
kWriteDoc->invertSelection();
return;
}
if (kWrite->isReadOnly()) return;
switch (cmdNum) {
case cmReturn:
if (c.flags & cfDelOnInput) kWriteDoc->delMarkedText(c);
kWriteDoc->newLine(c);
//emit returnPressed();
//e->ignore();
return;
case cmDelete:
if ((c.flags & cfDelOnInput) && kWriteDoc->hasMarkedText())
kWriteDoc->delMarkedText(c);
else kWriteDoc->del(c);
return;
case cmBackspace:
if ((c.flags & cfDelOnInput) && kWriteDoc->hasMarkedText())
kWriteDoc->delMarkedText(c);
else kWriteDoc->backspace(c);
return;
case cmKillLine:
kWriteDoc->killLine(c);
return;
case cmCut:
kWriteDoc->cut(c);
return;
case cmPaste:
if (c.flags & cfDelOnInput) kWriteDoc->delMarkedText(c);
kWriteDoc->paste(c);
return;
case cmUndo:
kWriteDoc->undo(c);
return;
case cmRedo:
kWriteDoc->redo(c);
return;
case cmIndent:
kWriteDoc->indent(c);
return;
case cmUnindent:
kWriteDoc->unIndent(c);
return;
case cmCleanIndent:
kWriteDoc->cleanIndent(c);
return;
}
}
kdevelop'KWriteView::cursorLeft() (./kdevelop/kdevelop/kwrite/kwview.cpp:304)
void KWriteView::cursorLeft(VConfig &c) {
cursor.x--;
if (c.flags & cfWrapCursor && cursor.x < 0 && cursor.y > 0) {
cursor.y--;
cursor.x = kWriteDoc->textLength(cursor.y);
}
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
update(c);
}
kdevelop'KWriteView::cursorRight() (./kdevelop/kdevelop/kwrite/kwview.cpp:315)
void KWriteView::cursorRight(VConfig &c) {
if (c.flags & cfWrapCursor) {
if (cursor.x >= kWriteDoc->textLength(cursor.y)) {
if (cursor.y == kWriteDoc->lastLine()) return;
cursor.y++;
cursor.x = -1;
}
}
cursor.x++;
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
update(c);
}
kdevelop'KWriteView::wordLeft() (./kdevelop/kdevelop/kwrite/kwview.cpp:329)
void KWriteView::wordLeft(VConfig &c) {
TextLine *textLine;
Highlight *highlight;
highlight = kWriteDoc->getHighlight();
textLine = kWriteDoc->textLine(cursor.y);
do {
if (cursor.x <= 0) {
//i think word left should always wrap (jochen wilhelmy)
if (/*c.flags & cfWrapCursor &&*/ cursor.y > 0) {
cursor.y--;
textLine = kWriteDoc->textLine(cursor.y);
cursor.x = textLine->length() -1;
} else break;
} else cursor.x--;
} while (cursor.x < 0 || !highlight->isInWord(textLine->getChar(cursor.x)));
while (cursor.x > 0 && highlight->isInWord(textLine->getChar(cursor.x -1)))
cursor.x--;
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
update(c);
}
kdevelop'KWriteView::wordRight() (./kdevelop/kdevelop/kwrite/kwview.cpp:352)
void KWriteView::wordRight(VConfig &c) {
TextLine *textLine;
Highlight *highlight;
int len;
highlight = kWriteDoc->getHighlight();
textLine = kWriteDoc->textLine(cursor.y);
len = textLine->length();
while (cursor.x < len && highlight->isInWord(textLine->getChar(cursor.x)))
cursor.x++;
do {
if (cursor.x >= len) {
if (cursor.y < kWriteDoc->lastLine()) {
cursor.y++;
textLine = kWriteDoc->textLine(cursor.y);
len = textLine->length();
cursor.x = 0;
} else break;
} else cursor.x++;
} while (cursor.x >= len || !highlight->isInWord(textLine->getChar(cursor.x)));
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
update(c);
}
kdevelop'KWriteView::home() (./kdevelop/kdevelop/kwrite/kwview.cpp:377)
void KWriteView::home(VConfig &c) {
cursor.x = 0;
cOldXPos = cXPos = 0;
update(c);
}
kdevelop'KWriteView::end() (./kdevelop/kdevelop/kwrite/kwview.cpp:384)
void KWriteView::end(VConfig &c) {
cursor.x = kWriteDoc->textLength(cursor.y);
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
update(c);
}
kdevelop'KWriteView::cursorUp() (./kdevelop/kdevelop/kwrite/kwview.cpp:392)
void KWriteView::cursorUp(VConfig &c) {
cursor.y--;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
}
kdevelop'KWriteView::cursorDown() (./kdevelop/kdevelop/kwrite/kwview.cpp:400)
void KWriteView::cursorDown(VConfig &c) {
int x;
if (cursor.y == kWriteDoc->lastLine()) {
x = kWriteDoc->textLength(cursor.y);
if (cursor.x >= x) return;
cursor.x = x;
cXPos = kWriteDoc->textWidth(cursor);
} else {
cursor.y++;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
}
update(c);
}
kdevelop'KWriteView::scrollUp() (./kdevelop/kdevelop/kwrite/kwview.cpp:415)
void KWriteView::scrollUp(VConfig &c) {
if (! yPos) return;
newYPos = yPos - kWriteDoc->fontHeight;
if (cursor.y == (yPos + height())/kWriteDoc->fontHeight -1) {
cursor.y--;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
}
}
kdevelop'KWriteView::scrollDown() (./kdevelop/kdevelop/kwrite/kwview.cpp:428)
void KWriteView::scrollDown(VConfig &c) {
if (endLine >= kWriteDoc->lastLine()) return;
newYPos = yPos + kWriteDoc->fontHeight;
if (cursor.y == (yPos + kWriteDoc->fontHeight -1)/kWriteDoc->fontHeight) {
cursor.y++;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
}
}
kdevelop'KWriteView::pageUp() (./kdevelop/kdevelop/kwrite/kwview.cpp:440)
void KWriteView::pageUp(VConfig &c) {
int lines = (endLine - startLine - 1);
if (lines <= 0)
lines = 1;
if (!(c.flags & cfPageUDMovesCursor) && yPos > 0) {
newYPos = yPos - lines * kWriteDoc->fontHeight;
if (newYPos < 0) newYPos = 0;
}
cursor.y -= lines;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
// cursorPageUp(c);
}
kdevelop'KWriteView::pageDown() (./kdevelop/kdevelop/kwrite/kwview.cpp:457)
void KWriteView::pageDown(VConfig &c) {
int lines = (endLine - startLine - 1);
if (!(c.flags & cfPageUDMovesCursor) && endLine < kWriteDoc->lastLine()) {
if (lines < kWriteDoc->lastLine() - endLine)
newYPos = yPos + lines * kWriteDoc->fontHeight;
else
newYPos = yPos + (kWriteDoc->lastLine() - endLine) * kWriteDoc->fontHeight;
}
cursor.y += lines;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
// cursorPageDown(c);
}
kdevelop'KWriteView::topOfView() (./kdevelop/kdevelop/kwrite/kwview.cpp:473)
void KWriteView::topOfView(VConfig &c) {
cursor.y = (yPos + kWriteDoc->fontHeight -1)/kWriteDoc->fontHeight;
cursor.x = 0;
cOldXPos = cXPos = 0;
update(c);
}
kdevelop'KWriteView::bottomOfView() (./kdevelop/kdevelop/kwrite/kwview.cpp:481)
void KWriteView::bottomOfView(VConfig &c) {
cursor.y = (yPos + height())/kWriteDoc->fontHeight -1;
if (cursor.y < 0) cursor.y = 0;
cursor.x = 0;
cOldXPos = cXPos = 0;
update(c);
}
/*
void KWriteView::cursorPageUp(VConfig &c) {
cursor.y -= endLine - startLine;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
}
void KWriteView::cursorPageDown(VConfig &c) {
cursor.y += endLine - startLine;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
update(c);
}
*/
// go to the top, same X position
kdevelop'KWriteView::top() (./kdevelop/kdevelop/kwrite/kwview.cpp:507)
void KWriteView::top(VConfig &c) {
// cursor.x = 0;
cursor.y = 0;
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
// cOldXPos = cXPos = 0;
update(c);
}
// go to the bottom, same X position
kdevelop'KWriteView::bottom() (./kdevelop/kdevelop/kwrite/kwview.cpp:517)
void KWriteView::bottom(VConfig &c) {
// cursor.x = 0;
cursor.y = kWriteDoc->lastLine();
cXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor,cursor,cOldXPos);
// cOldXPos = cXPos = 0;
update(c);
}
// go to the top left corner
kdevelop'KWriteView::top_home() (./kdevelop/kdevelop/kwrite/kwview.cpp:527)
void KWriteView::top_home(VConfig &c) {
cursor.y = 0;
cursor.x = 0;
cOldXPos = cXPos = 0;
update(c);
}
// go to the bottom right corner
kdevelop'KWriteView::bottom_end() (./kdevelop/kdevelop/kwrite/kwview.cpp:536)
void KWriteView::bottom_end(VConfig &c) {
cursor.y = kWriteDoc->lastLine();
cursor.x = kWriteDoc->textLength(cursor.y);
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
update(c);
}
kdevelop'KWriteView::changeXPos() (./kdevelop/kdevelop/kwrite/kwview.cpp:545)
void KWriteView::changeXPos(int p) {
int dx;
dx = xPos - p;
xPos = p;
if (QABS(dx) < width()) scroll(dx, 0); else QWidget::update();
}
kdevelop'KWriteView::changeYPos() (./kdevelop/kdevelop/kwrite/kwview.cpp:553)
void KWriteView::changeYPos(int p) {
int dy;
dy = yPos - p;
yPos = p;
lineValues(height());
if (QABS(dy) < height()) scroll(0, dy); else QWidget::update();
}
kdevelop'KWriteView::getVConfig() (./kdevelop/kdevelop/kwrite/kwview.cpp:563)
void KWriteView::getVConfig(VConfig &c) {
c.view = this;
c.cursor = cursor;
c.cXPos = cXPos;
c.flags = kWrite->configFlags;
c.wrapAt = kWrite->wrapAt;
}
kdevelop'KWriteView::update() (./kdevelop/kdevelop/kwrite/kwview.cpp:572)
void KWriteView::update(VConfig &c) {
/*
* we need to be sure to kill the selection on an attempted cursor
* movement even if the cursor doesn't physically move,
* but we need to be careful not to do some other things in this case,
* like we don't want to expose the cursor
*/
bool nullMove = (cursor.x == c.cursor.x && cursor.y == c.cursor.y);
// if (cursor.x == c.cursor.x && cursor.y == c.cursor.y) return;
// if (cursor.y != c.cursor.y || c.flags & cfMark) kWriteDoc->recordReset();
if (! nullMove) {
kWriteDoc->unmarkFound();
exposeCursor = true;
if (cursorOn) {
tagLines(c.cursor.y, c.cursor.y, c.cXPos -2, c.cXPos +3);
// tagLines(c.cursor.y, c.cursor.y, 0, 0xffffff);
cursorOn = false;
}
if (bm.sXPos < bm.eXPos) {
tagLines(bm.cursor.y, bm.cursor.y, bm.sXPos, bm.eXPos);
}
kWriteDoc->newBracketMark(cursor, bm);
}
if (c.flags & cfMark) {
if (! nullMove)
kWriteDoc->selectTo(c, cursor, cXPos);
} else {
if (!(c.flags & cfPersistent))
kWriteDoc->deselectAll();
}
}
/*
void KWriteView::insLine(int line) {
if (insert) {
if (start.y < startLine && end.y < startLine) {
startLine += dy;
endLine += dy;
yPos += dy*kWriteDoc->fontHeight;
} else if (start.y <= endLine || end.y <= endLine) {
if (dy == 0) {
if (start.y == cursor.y) cursorOn = false;
tagLines(start.y,start.y);
} else tagAll();
}
} else {
if (dy >= 0) tagLines(start.y,end.y); else tagLines(end.y,start.y);
}
}
*/
kdevelop'KWriteView::insLine() (./kdevelop/kdevelop/kwrite/kwview.cpp:632)
void KWriteView::insLine(int line) {
if (line <= cursor.y) {
cursor.y++;
}
if (line < startLine) {
startLine++;
endLine++;
yPos += kWriteDoc->fontHeight;
} else if (line <= endLine) {
tagAll();
}
//bookmarks
KWBookmark *b;
for (b = kWrite->bookmarks.first(); b != 0L; b = kWrite->bookmarks.next()) {
if (b->cursor.y >= line) {
b->cursor.y++;
b->yPos += kWriteDoc->fontHeight;
}
}
}
kdevelop'KWriteView::delLine() (./kdevelop/kdevelop/kwrite/kwview.cpp:655)
void KWriteView::delLine(int line) {
if (line <= cursor.y && cursor.y > 0) {
cursor.y--;
}
if (line < startLine) {
startLine--;
endLine--;
yPos -= kWriteDoc->fontHeight;
} else if (line <= endLine) {
tagAll();
}
//bookmarks
KWBookmark *b;
for (b = kWrite->bookmarks.first(); b != 0L; b = kWrite->bookmarks.next()) {
if (b->cursor.y > line) {
b->cursor.y--;
b->yPos -= kWriteDoc->fontHeight;
// if (b->yPos < 0) b->yPos = 0;
}
}
}
kdevelop'KWriteView::updateCursor() (./kdevelop/kdevelop/kwrite/kwview.cpp:679)
void KWriteView::updateCursor() {
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
}
kdevelop'KWriteView::updateCursor() (./kdevelop/kdevelop/kwrite/kwview.cpp:684)
void KWriteView::updateCursor(PointStruc &newCursor) {
updateCursor(newCursor, kWrite->config());
}
kdevelop'KWriteView::updateCursor() (./kdevelop/kdevelop/kwrite/kwview.cpp:688)
void KWriteView::updateCursor(PointStruc &newCursor, int flags) {
if (!(flags & cfPersistent)) kWriteDoc->deselectAll();
kWriteDoc->unmarkFound();
exposeCursor = true;
if (cursorOn) {
tagLines(cursor.y, cursor.y, cXPos -2, cXPos +3);
cursorOn = false;
}
if (bm.sXPos < bm.eXPos) {
tagLines(bm.cursor.y, bm.cursor.y, bm.sXPos, bm.eXPos);
}
kWriteDoc->newBracketMark(newCursor, bm);
cursor = newCursor;
cOldXPos = cXPos = kWriteDoc->textWidth(cursor);
}
kdevelop'KWriteView::lineValues() (./kdevelop/kdevelop/kwrite/kwview.cpp:709)
void KWriteView::lineValues(int h) {
int lines, z;
startLine = yPos/kWriteDoc->fontHeight;
endLine = (yPos + h -1)/kWriteDoc->fontHeight;
updateState = 0;
lines = endLine - startLine +1;
if (lines > numLines) {
numLines = lines*2;
delete [] lineRanges;
lineRanges = new LineRange[numLines];
}
for (z = 0; z < lines; z++) {
lineRanges[z].start = 0xffffff;
lineRanges[z].end = -2;
}
newXPos = newYPos = -1;
}
kdevelop'KWriteView::tagLines() (./kdevelop/kdevelop/kwrite/kwview.cpp:731)
void KWriteView::tagLines(int start, int end, int x1, int x2) {
LineRange *r;
int z;
start -= startLine;
if (start < 0) start = 0;
end -= startLine;
if (end > endLine - startLine) end = endLine - startLine;
if (x1 <= 0) x1 = -2;
if (x1 < xPos-2) x1 = xPos-2;
if (x2 > width() + xPos-2) x2 = width() + xPos-2;
if (x1 >= x2) return;
r = &lineRanges[start];
for (z = start; z <= end; z++) {
if (x1 < r->start) r->start = x1;
if (x2 > r->end) r->end = x2;
r++;
updateState |= 1;
}
}
/*
void KWriteView::tagLines(int start, int end) {
int line, z;
if (updateState < 3) {
if (start < startLine) start = startLine;
if (end > endLine) end = endLine;
if (end - start > 1) {
updateState = 3;
} else {
for (line = start; line <= end; line++) {
for (z = 0; z < updateState && updateLines[z] != line; z++);
if (z == updateState) {
updateState++;
if (updateState > 2) break;
updateLines[z] = line;
}
}
}
}
}
*/
kdevelop'KWriteView::tagAll() (./kdevelop/kdevelop/kwrite/kwview.cpp:778)
void KWriteView::tagAll() {
updateState = 3;
}
kdevelop'KWriteView::setPos() (./kdevelop/kdevelop/kwrite/kwview.cpp:782)
void KWriteView::setPos(int x, int y) {
newXPos = x;
newYPos = y;
}
kdevelop'KWriteView::center() (./kdevelop/kdevelop/kwrite/kwview.cpp:787)
void KWriteView::center() {
newXPos = 0;
newYPos = cursor.y*kWriteDoc->fontHeight - height()/2;
if (newYPos < 0) newYPos = 0;
}
kdevelop'KWriteView::updateView() (./kdevelop/kdevelop/kwrite/kwview.cpp:793)
void KWriteView::updateView(int flags) {
int fontHeight;
int oldXPos, oldYPos;
int w, h;
int z;
bool b;
int xMax, yMax;
int cYPos;
int cXPosMin, cXPosMax, cYPosMin, cYPosMax;
int dx, dy;
int pageScroll;
//debug("upView %d %d %d %d %d", exposeCursor, updateState, flags, newXPos, newYPos);
if (exposeCursor || flags & ufDocGeometry) {
emit kWrite->newCurPos();
} else {
if (updateState == 0 && newXPos < 0 && newYPos < 0) return;
}
if (cursorTimer) {
killTimer(cursorTimer);
cursorTimer = startTimer(KApplication::cursorFlashTime() / 2);
cursorOn = true;
}
oldXPos = xPos;
oldYPos = yPos;
/* if (flags & ufPos) {
xPos = newXPos;
yPos = newYPos;
exposeCursor = true;
}*/
if (newXPos >= 0) xPos = newXPos;
if (newYPos >= 0) yPos = newYPos;
fontHeight = kWriteDoc->fontHeight;
cYPos = cursor.y*fontHeight;
z = 0;
do {
w = kWrite->width() - 4;
h = kWrite->height() - 4;
xMax = kWriteDoc->textWidth() - w;
b = (xPos > 0 || xMax > 0);
if (b) h -= 16;
yMax = kWriteDoc->textHeight() - h;
if (yPos > 0 || yMax > 0) {
w -= 16;
xMax += 16;
if (!b && xMax > 0) {
h -= 16;
yMax += 16;
}
}
if (!exposeCursor) break;
// if (flags & ufNoScroll) break;
/*
if (flags & ufCenter) {
cXPosMin = xPos + w/3;
cXPosMax = xPos + (w*2)/3;
cYPosMin = yPos + h/3;
cYPosMax = yPos + ((h - fontHeight)*2)/3;
} else {*/
cXPosMin = xPos + 4;
cXPosMax = xPos + w - 8;
cYPosMin = yPos;
cYPosMax = yPos + (h - fontHeight);
// }
if (cXPos < cXPosMin) {
xPos -= cXPosMin - cXPos;
}
if (xPos < 0) xPos = 0;
if (cXPos > cXPosMax) {
xPos += cXPos - cXPosMax;
}
if (cYPos < cYPosMin) {
yPos -= cYPosMin - cYPos;
}
if (yPos < 0) yPos = 0;
if (cYPos > cYPosMax) {
yPos += cYPos - cYPosMax;
}
/*
if (cXPos < xPos + 4) {
xPos = cXPos - 8;
if (xPos < 0) xPos = 0;
}
if (cXPos > xPos + w - 4) {
xPos = cXPos - w +8;
}
if (cYPos < yPos) {
yPos = cYPos;
if (yPos < 0) yPos = 0;
}
if (cYPos > yPos + (h-fontHeight)) {
yPos = cYPos - (h-fontHeight);
}
*/
z++;
} while (z < 2);
if (xMax < xPos) xMax = xPos;
if (yMax < yPos) yMax = yPos;
if (xMax > 0) {
pageScroll = w - (w % fontHeight) - fontHeight;
if (pageScroll <= 0)
pageScroll = fontHeight;
xScroll->blockSignals(true);
xScroll->setGeometry(2,h + 2,w,16);
xScroll->setRange(0,xMax);
xScroll->setValue(xPos);
xScroll->setSteps(fontHeight,pageScroll);
xScroll->blockSignals(false);
xScroll->show();
} else xScroll->hide();
if (yMax > 0) {
pageScroll = h - (h % fontHeight) - fontHeight;
if (pageScroll <= 0)
pageScroll = fontHeight;
yScroll->blockSignals(true);
yScroll->setGeometry(w + 2,2,16,h);
yScroll->setRange(0,yMax);
yScroll->setValue(yPos);
yScroll->setSteps(fontHeight,pageScroll);
yScroll->blockSignals(false);
yScroll->show();
} else yScroll->hide();
//startLine = yPos / fontHeight;
//endLine = (yPos + h -1) / fontHeight;
/*
if (endLine < startLine) {
endLine = startLine;
visibleLines = 0;
} else {
visibleLines = (h - (h % fontHeight)) / fontHeight;
}
*/
if (w != width() || h != height()) {
lineValues(h);
resize(w,h);
} else {
dx = oldXPos - xPos;
dy = oldYPos - yPos;
b = updateState == 3;
if (flags & ufUpdateOnScroll) {
b |= dx || dy;
} else {
b |= QABS(dx)*3 > w*2 || QABS(dy)*3 > h*2;
}
if (b) {
lineValues(h);
QWidget::update();
} else {
if (updateState > 0) paintTextLines(oldXPos, oldYPos);
lineValues(h);
if (dx || dy) {
scroll(dx,dy);
// kapp->syncX();
// scroll2(dx - dx/2,dy - dy/2);
// } else {
}
if (cursorOn) paintCursor();
if (bm.eXPos > bm.sXPos) paintBracketMark();
}
}
exposeCursor = false;
// updateState = 0;
}
/*
void KWriteView::scroll2( int dx, int dy ) {
int w, h, x, y;
Display *dpy;
int winid;
if ( dx == 0 && dy == 0 ) return;
dpy = qt_xdisplay();
winid = winId();
w = width();
h = height();
XCopyArea( dpy, winid, winid, qt_xget_readonly_gc(),-dx,-dy,w,h,0,0);
//XSync(qt_xdisplay(),false);
usleep(100000);
*/
/*
if ( dx ) {
x = (dx < 0) ? w + dx : 0;
dx = QABS(dx);
XClearArea( dpy, winid,x,0,dx/2,h, TRUE);
XClearArea( dpy, winid,x + dx/2,0,dx - dx/2,h, TRUE);
}
if ( dy ) {
y = (dy < 0) ? h + dy : 0;
XClearArea( dpy, winid,0,y,w,QABS(dy), TRUE);
}
*/
//}
/*
void KWriteView::tagLines(int start, int end) {
int line, z;
if (updateState < MAX_UPDATE_LINES) {
if (start < startLine) start = startLine;
if (end > endLine) end = endLine;
if (end - start > MAX_UPDATE_LINES - 2) {
updateState = MAX_UPDATE_LINES;
} else {
for (line = start; line <= end; line++) {
for (z = 0; z < updateState && updateLines[z] != line; z++);
if (z == updateState) {
updateState++;
if (updateState >= MAX_UPDATE_LINES) break;
updateLines[z] = line;
}
}
}
}
}
void KWriteView::tagAll() {
updateState = MAX_UPDATE_LINES;
}
*/
kdevelop'KWriteView::paintTextLines() (./kdevelop/kdevelop/kwrite/kwview.cpp:1033)
void KWriteView::paintTextLines(int xPos, int yPos) {
// int xStart, xEnd;
int line;//, z;
int h;
LineRange *r;
QPainter paint;
paint.begin(drawBuffer);
h = kWriteDoc->fontHeight;
r = lineRanges;
for (line = startLine; line <= endLine; line++) {
if (r->start < r->end) {
//debug("painttextline %d %d %d", line, r->start, r->end);
kWriteDoc->paintTextLine(paint, line, r->start, r->end);
bitBlt(this, r->start - (xPos-2), line*h - yPos, drawBuffer, 0, 0,
r->end - r->start, h);
}
r++;
}
/*
xStart = xPos-2;
xEnd = xStart + width();
h = kWriteDoc->fontHeight;
for (z = 0; z < updateState; z++) {
line = updateLines[z];
kWriteDoc->paintTextLine(paint,line,xStart,xEnd);
bitBlt(this,0,line*h - yPos,drawBuffer,0,0,width(),h);
}*/
paint.end();
}
kdevelop'KWriteView::paintCursor() (./kdevelop/kdevelop/kwrite/kwview.cpp:1065)
void KWriteView::paintCursor() {
int h, y, x;
h = kWriteDoc->fontHeight;
y = h*cursor.y - yPos;
x = cXPos - (xPos-2);
QPainter paint;
if (cursorOn) {
paint.begin(this);
paint.setPen(kWriteDoc->cursorCol(cursor.x,cursor.y));
h += y - 1;
paint.drawLine(x,y,x,h);
paint.drawLine(x-2,y,x+2,y);
paint.drawLine(x-2,h,x+2,h);
} else {
paint.begin(drawBuffer);
kWriteDoc->paintTextLine(paint,cursor.y,cXPos - 2,cXPos + 3);
bitBlt(this,x - 2,y,drawBuffer,0,0,5,h);
}
paint.end();
}
kdevelop'KWriteView::paintBracketMark() (./kdevelop/kdevelop/kwrite/kwview.cpp:1089)
void KWriteView::paintBracketMark() {
int y;
y = kWriteDoc->fontHeight*(bm.cursor.y +1) - yPos -1;
QPainter paint;
paint.begin(this);
paint.setPen(kWriteDoc->cursorCol(bm.cursor.x, bm.cursor.y));
paint.drawLine(bm.sXPos - (xPos-2), y, bm.eXPos - (xPos-2) -1, y);
paint.end();
}
kdevelop'KWriteView::placeCursor() (./kdevelop/kdevelop/kwrite/kwview.cpp:1102)
void KWriteView::placeCursor(int x, int y, int flags) {
VConfig c;
getVConfig(c);
c.flags |= flags;
cursor.y = (yPos + y)/kWriteDoc->fontHeight;
cXPos = cOldXPos = kWriteDoc->textWidth(c.flags & cfWrapCursor, cursor,xPos-2 + x);
update(c);
}
// convert the given physical coordinates to logical (line/column within the document)
/*
void KWriteView::calcLogicalPosition(int &x, int &y) {
TextLine line;
y = (yPos + y)/kWriteDoc->fontHeight;
line = kWriteDoc->textLine(y);
x = kWriteDoc->textPos(kWriteDoc->textLine(y), x);
}
*/
// given physical coordinates, report whether the text there is selected
kdevelop'KWriteView::isTargetSelected() (./kdevelop/kdevelop/kwrite/kwview.cpp:1126)
bool KWriteView::isTargetSelected(int x, int y) {
TextLine *line;
y = (yPos + y) / kWriteDoc->fontHeight;
line = kWriteDoc->textLine(y);
if (! line)
return false;
x = kWriteDoc->textPos(line, x);
return line->isSelected(x);
}
kdevelop'KWriteView::focusInEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1141)
void KWriteView::focusInEvent(QFocusEvent *) {
// debug("got focus %d",cursorTimer);
if (!cursorTimer) {
cursorTimer = startTimer(KApplication::cursorFlashTime() / 2);
cursorOn = true;
paintCursor();
}
}
kdevelop'KWriteView::focusOutEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1151)
void KWriteView::focusOutEvent(QFocusEvent *) {
// debug("lost focus %d", cursorTimer);
if (cursorTimer) {
killTimer(cursorTimer);
cursorTimer = 0;
}
if (cursorOn) {
cursorOn = false;
paintCursor();
}
}
kdevelop'KWriteView::keyPressEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1165)
void KWriteView::keyPressEvent(QKeyEvent *e) {
VConfig c;
// int ascii;
/* if (e->state() & AltButton) {
e->ignore();
return;
}*/
// debug("ascii %i, key %i, state %i",e->ascii(), e->key(), e->state());
getVConfig(c);
// ascii = e->ascii();
if (!kWrite->isReadOnly()) {
if (c.flags & cfTabIndents && kWriteDoc->hasMarkedText()) {
if (e->key() == Qt::Key_Tab) {
kWriteDoc->indent(c);
kWriteDoc->updateViews();
return;
}
if (e->key() == Qt::Key_Backtab) {
kWriteDoc->unIndent(c);
kWriteDoc->updateViews();
return;
}
}
if (kWriteDoc->insertChars(c, e->text())) {
kWriteDoc->updateViews();
e->accept();
return;
}
}
e->ignore();
}
kdevelop'KWriteView::mousePressEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1200)
void KWriteView::mousePressEvent(QMouseEvent *e) {
if (e->button() == LeftButton) {
if (isTargetSelected(e->x(), e->y())) {
// we have a mousedown on selected text
// we initialize the drag info thingy as pending from this position
dragInfo.state = diPending;
dragInfo.start.x = e->x();
dragInfo.start.y = e->y();
} else {
// we have no reason to ever start a drag from here
dragInfo.state = diNone;
int flags;
flags = 0;
if (e->state() & ShiftButton) {
flags |= cfMark;
if (e->state() & ControlButton) flags |= cfMark | cfKeepSelection;
}
placeCursor(e->x(), e->y(), flags);
scrollX = 0;
scrollY = 0;
if (!scrollTimer) scrollTimer = startTimer(50);
kWriteDoc->updateViews();
}
}
if (e->button() == MidButton) {
placeCursor(e->x(), e->y());
if (! kWrite->isReadOnly())
kWrite->paste();
}
if (kWrite->popup && e->button() == RightButton) {
kWrite->popup->popup(mapToGlobal(e->pos()));
}
kWrite->mousePressEvent(e); // this doesn't do anything, does it?
}
kdevelop'KWriteView::mouseDoubleClickEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1240)
void KWriteView::mouseDoubleClickEvent(QMouseEvent *e) {
if (e->button() == LeftButton) {
VConfig c;
getVConfig(c);
kWriteDoc->selectWord(c.cursor, c.flags);
kWriteDoc->updateViews();
}
}
kdevelop'KWriteView::mouseReleaseEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1250)
void KWriteView::mouseReleaseEvent(QMouseEvent *e) {
if (e->button() == LeftButton) {
if (dragInfo.state == diPending) {
// we had a mouse down in selected area, but never started a drag
// so now we kill the selection
placeCursor(e->x(), e->y(), 0);
kWriteDoc->updateViews();
} else if (dragInfo.state == diNone) {
if (kWrite->config() & cfMouseAutoCopy) kWrite->copy();
killTimer(scrollTimer);
scrollTimer = 0;
}
dragInfo.state = diNone;
}
}
kdevelop'KWriteView::mouseMoveEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1267)
void KWriteView::mouseMoveEvent(QMouseEvent *e) {
if (e->state() & LeftButton) {
int flags;
int d;
int x = e->x(),
y = e->y();
if (dragInfo.state == diPending) {
// we had a mouse down, but haven't confirmed a drag yet
// if the mouse has moved sufficiently, we will confirm
if (x > dragInfo.start.x + 4 || x < dragInfo.start.x - 4 ||
y > dragInfo.start.y + 4 || y < dragInfo.start.y - 4) {
// we've left the drag square, we can start a real drag operation now
doDrag();
}
return;
} else if (dragInfo.state == diDragging) {
// this isn't technically needed because mouseMoveEvent is suppressed during
// Qt drag operations, replaced by dragMoveEvent
return;
}
mouseX = e->x();
mouseY = e->y();
scrollX = 0;
scrollY = 0;
d = kWriteDoc->fontHeight;
if (mouseX < 0) {
mouseX = 0;
scrollX = -d;
}
if (mouseX > width()) {
mouseX = width();
scrollX = d;
}
if (mouseY < 0) {
mouseY = 0;
scrollY = -d;
}
if (mouseY > height()) {
mouseY = height();
scrollY = d;
}
//debug("modifiers %d", ((KGuiCmdApp *) kapp)->getModifiers());
flags = cfMark;
if (e->state() & ControlButton) flags |= cfKeepSelection;
placeCursor(mouseX, mouseY, flags);
kWriteDoc->updateViews(/*ufNoScroll*/);
}
}
kdevelop'KWriteView::paintEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1320)
void KWriteView::paintEvent(QPaintEvent *e) {
int xStart, xEnd;
int h;
int line, y, yEnd;
QRect updateR = e->rect();
// debug("update rect = ( %i, %i, %i, %i )",
// updateR.x(),updateR.y(), updateR.width(), updateR.height() );
QPainter paint;
paint.begin(drawBuffer);
xStart = xPos-2 + updateR.x();
xEnd = xStart + updateR.width();
h = kWriteDoc->fontHeight;
line = (yPos + updateR.y()) / h;
y = line*h - yPos;
yEnd = updateR.y() + updateR.height();
while (y < yEnd) {
kWriteDoc->paintTextLine(paint,line,xStart,xEnd);
// if (cursorOn && line == cursor.y) paintCursor(paint,cXPos - xStart,h);
bitBlt(this,updateR.x(),y,drawBuffer,0,0,updateR.width(),h);
line++;
y += h;
}
paint.end();
if (cursorOn) paintCursor();
if (bm.eXPos > bm.sXPos) paintBracketMark();
}
kdevelop'KWriteView::resizeEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1353)
void KWriteView::resizeEvent(QResizeEvent *) {
// debug("KWriteView::resize");
resizeBuffer(this, width(), kWriteDoc->fontHeight);
// QWidget::update();
}
kdevelop'KWriteView::timerEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1360)
void KWriteView::timerEvent(QTimerEvent *e) {
if (e->timerId() == cursorTimer) {
cursorOn = !cursorOn;
paintCursor();
}
if (e->timerId() == scrollTimer && (scrollX | scrollY)) {
xScroll->setValue(xPos + scrollX);
yScroll->setValue(yPos + scrollY);
placeCursor(mouseX, mouseY, cfMark);
kWriteDoc->updateViews(/*ufNoScroll*/);
}
}
/////////////////////////////////////
// Drag and drop handlers
//
// call this to start a drag from this view
kdevelop'KWriteView::doDrag() (./kdevelop/kdevelop/kwrite/kwview.cpp:1379)
void KWriteView::doDrag()
{
dragInfo.state = diDragging;
dragInfo.dragObject = new QTextDrag(kWriteDoc->markedText(0), this);
if (kWrite->isReadOnly()) {
dragInfo.dragObject->dragCopy();
} else {
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
drag() is broken for move operations in Qt - dragCopy() is the only safe way
to go right now
if (dragInfo.dragObject->drag()) {
// the drag has completed and it turned out to be a move operation
if (! kWriteDoc->ownedView((KWriteView*)(QDragObject::target()))) {
// the target is not me - we need to delete our selection
VConfig c;
getVConfig(c);
kWriteDoc->delMarkedText(c);
kWriteDoc->updateViews();
}
}
*/
dragInfo.dragObject->dragCopy();
}
}
kdevelop'KWriteView::dragEnterEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1407)
void KWriteView::dragEnterEvent( QDragEnterEvent *event )
{
event->accept( (QTextDrag::canDecode(event) && ! kWrite->isReadOnly()) || QUriDrag::canDecode(event) );
}
/*
void KWriteView::dragMoveEvent( QDragMoveEvent * )
{
}
void KWriteView::dragLeaveEvent( QDragLeaveEvent * )
{
// we should implement a shadow cursor here
}
*/
kdevelop'KWriteView::dropEvent() (./kdevelop/kdevelop/kwrite/kwview.cpp:1422)
void KWriteView::dropEvent( QDropEvent *event )
{
if ( QUriDrag::canDecode(event) ) {
QStrList urls;
if (! HandleURIDrops) {
// the container should handle this one for us...
emit dropEventPass(event);
} else {
// we can only load one url
// this is why a smarter container should do this if possible
if (QUriDrag::decode(event, urls)) {
char *s;
s = urls.first();
if (s) {
// Load the first file in this window
if (s == urls.getFirst()) {
if (kWrite->canDiscard()) kWrite->loadURL(s);
}
}
}
}
} else if ( QTextDrag::canDecode(event) && ! kWrite->isReadOnly() ) {
QString text;
if (QTextDrag::decode(event, text)) {
bool priv, selected;
// is the source our own document?
priv = kWriteDoc->ownedView((KWriteView*)(event->source()));
// dropped on a text selection area?
selected = isTargetSelected(event->pos().x(), event->pos().y());
if (priv && selected) {
// this is a drag that we started and dropped on our selection
// ignore this case
return;
}
VConfig c;
PointStruc cursor;
getVConfig(c);
cursor = c.cursor;
if (priv) {
// this is one of mine (this document), not dropped on the selection
if (event->action() == QDropEvent::Move) {
kWriteDoc->delMarkedText(c);
getVConfig(c);
cursor = c.cursor;
} else {
}
placeCursor(event->pos().x(), event->pos().y());
getVConfig(c);
cursor = c.cursor;
} else {
// this did not come from this document
if (! selected) {
placeCursor(event->pos().x(), event->pos().y());
getVConfig(c);
cursor = c.cursor;
}
}
kWriteDoc->insert(c, text);
cursor = c.cursor;
updateCursor(cursor);
kWriteDoc->updateViews();
}
}
}