summaryrefslogtreecommitdiffstats
path: root/kate/part/kateviewhelpers.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitce4a32fe52ef09d8f5ff1dd22c001110902b60a2 (patch)
tree5ac38a06f3dde268dc7927dc155896926aaf7012 /kate/part/kateviewhelpers.cpp
downloadtdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.tar.gz
tdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kate/part/kateviewhelpers.cpp')
-rw-r--r--kate/part/kateviewhelpers.cpp1205
1 files changed, 1205 insertions, 0 deletions
diff --git a/kate/part/kateviewhelpers.cpp b/kate/part/kateviewhelpers.cpp
new file mode 100644
index 000000000..4ca753486
--- /dev/null
+++ b/kate/part/kateviewhelpers.cpp
@@ -0,0 +1,1205 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
+ Copyright (C) 2001 Anders Lund <anders@alweb.dk>
+ Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kateviewhelpers.h"
+#include "kateviewhelpers.moc"
+
+#include "../interfaces/document.h"
+#include "../interfaces/katecmd.h"
+#include "kateattribute.h"
+#include "katecodefoldinghelpers.h"
+#include "kateconfig.h"
+#include "katedocument.h"
+#include "katefactory.h"
+#include "katerenderer.h"
+#include "kateview.h"
+#include "kateviewinternal.h"
+
+#include <kapplication.h>
+#include <kglobalsettings.h>
+#include <klocale.h>
+#include <knotifyclient.h>
+#include <kglobal.h>
+#include <kcharsets.h>
+#include <kpopupmenu.h>
+
+#include <qcursor.h>
+#include <qpainter.h>
+#include <qpopupmenu.h>
+#include <qstyle.h>
+#include <qtimer.h>
+#include <qwhatsthis.h>
+#include <qregexp.h>
+#include <qtextcodec.h>
+
+#include <math.h>
+
+#include <kdebug.h>
+
+//BEGIN KateScrollBar
+KateScrollBar::KateScrollBar (Orientation orientation, KateViewInternal* parent, const char* name)
+ : QScrollBar (orientation, parent->m_view, name)
+ , m_middleMouseDown (false)
+ , m_view(parent->m_view)
+ , m_doc(parent->m_doc)
+ , m_viewInternal(parent)
+ , m_topMargin(-1)
+ , m_bottomMargin(-1)
+ , m_savVisibleLines(0)
+ , m_showMarks(false)
+{
+ connect(this, SIGNAL(valueChanged(int)), SLOT(sliderMaybeMoved(int)));
+ connect(m_doc, SIGNAL(marksChanged()), this, SLOT(marksChanged()));
+
+ m_lines.setAutoDelete(true);
+}
+
+void KateScrollBar::mousePressEvent(QMouseEvent* e)
+{
+ if (e->button() == MidButton)
+ m_middleMouseDown = true;
+
+ QScrollBar::mousePressEvent(e);
+
+ redrawMarks();
+}
+
+void KateScrollBar::mouseReleaseEvent(QMouseEvent* e)
+{
+ QScrollBar::mouseReleaseEvent(e);
+
+ m_middleMouseDown = false;
+
+ redrawMarks();
+}
+
+void KateScrollBar::mouseMoveEvent(QMouseEvent* e)
+{
+ QScrollBar::mouseMoveEvent(e);
+
+ if (e->state() | LeftButton)
+ redrawMarks();
+}
+
+void KateScrollBar::paintEvent(QPaintEvent *e)
+{
+ QScrollBar::paintEvent(e);
+ redrawMarks();
+}
+
+void KateScrollBar::resizeEvent(QResizeEvent *e)
+{
+ QScrollBar::resizeEvent(e);
+ recomputeMarksPositions();
+}
+
+void KateScrollBar::styleChange(QStyle &s)
+{
+ QScrollBar::styleChange(s);
+ m_topMargin = -1;
+ recomputeMarksPositions();
+}
+
+void KateScrollBar::valueChange()
+{
+ QScrollBar::valueChange();
+ redrawMarks();
+}
+
+void KateScrollBar::rangeChange()
+{
+ QScrollBar::rangeChange();
+ recomputeMarksPositions();
+}
+
+void KateScrollBar::marksChanged()
+{
+ recomputeMarksPositions(true);
+}
+
+void KateScrollBar::redrawMarks()
+{
+ if (!m_showMarks)
+ return;
+
+ QPainter painter(this);
+ QRect rect = sliderRect();
+ for (QIntDictIterator<QColor> it(m_lines); it.current(); ++it)
+ {
+ if (it.currentKey() < rect.top() || it.currentKey() > rect.bottom())
+ {
+ painter.setPen(*it.current());
+ painter.drawLine(0, it.currentKey(), width(), it.currentKey());
+ }
+ }
+}
+
+void KateScrollBar::recomputeMarksPositions(bool forceFullUpdate)
+{
+ if (m_topMargin == -1)
+ watchScrollBarSize();
+
+ m_lines.clear();
+ m_savVisibleLines = m_doc->visibleLines();
+
+ int realHeight = frameGeometry().height() - m_topMargin - m_bottomMargin;
+
+ QPtrList<KTextEditor::Mark> marks = m_doc->marks();
+ KateCodeFoldingTree *tree = m_doc->foldingTree();
+
+ for (KTextEditor::Mark *mark = marks.first(); mark; mark = marks.next())
+ {
+ uint line = mark->line;
+
+ if (tree)
+ {
+ KateCodeFoldingNode *node = tree->findNodeForLine(line);
+
+ while (node)
+ {
+ if (!node->isVisible())
+ line = tree->getStartLine(node);
+ node = node->getParentNode();
+ }
+ }
+
+ line = m_doc->getVirtualLine(line);
+
+ double d = (double)line / (m_savVisibleLines - 1);
+ m_lines.insert(m_topMargin + (int)(d * realHeight),
+ new QColor(KateRendererConfig::global()->lineMarkerColor((KTextEditor::MarkInterface::MarkTypes)mark->type)));
+ }
+
+ if (forceFullUpdate)
+ update();
+ else
+ redrawMarks();
+}
+
+void KateScrollBar::watchScrollBarSize()
+{
+ int savMax = maxValue();
+ setMaxValue(0);
+ QRect rect = sliderRect();
+ setMaxValue(savMax);
+
+ m_topMargin = rect.top();
+ m_bottomMargin = frameGeometry().height() - rect.bottom();
+}
+
+void KateScrollBar::sliderMaybeMoved(int value)
+{
+ if (m_middleMouseDown)
+ emit sliderMMBMoved(value);
+}
+//END
+
+//BEGIN KateCmdLnWhatsThis
+class KateCmdLnWhatsThis : public QWhatsThis
+{
+ public:
+ KateCmdLnWhatsThis( KateCmdLine *parent )
+ : QWhatsThis( parent )
+ , m_parent( parent ) {;}
+
+ QString text( const QPoint & )
+ {
+ QString beg = "<qt background=\"white\"><div><table width=\"100%\"><tr><td bgcolor=\"brown\"><font color=\"white\"><b>Help: <big>";
+ QString mid = "</big></b></font></td></tr><tr><td>";
+ QString end = "</td></tr></table></div><qt>";
+
+ QString t = m_parent->text();
+ QRegExp re( "\\s*help\\s+(.*)" );
+ if ( re.search( t ) > -1 )
+ {
+ QString s;
+ // get help for command
+ QString name = re.cap( 1 );
+ if ( name == "list" )
+ {
+ return beg + i18n("Available Commands") + mid
+ + KateCmd::self()->cmds().join(" ")
+ + i18n("<p>For help on individual commands, do <code>'help &lt;command&gt;'</code></p>")
+ + end;
+ }
+ else if ( ! name.isEmpty() )
+ {
+ Kate::Command *cmd = KateCmd::self()->queryCommand( name );
+ if ( cmd )
+ {
+ if ( cmd->help( (Kate::View*)m_parent->parentWidget(), name, s ) )
+ return beg + name + mid + s + end;
+ else
+ return beg + name + mid + i18n("No help for '%1'").arg( name ) + end;
+ }
+ else
+ return beg + mid + i18n("No such command <b>%1</b>").arg(name) + end;
+ }
+ }
+
+ return beg + mid + i18n(
+ "<p>This is the Katepart <b>command line</b>.<br>"
+ "Syntax: <code><b>command [ arguments ]</b></code><br>"
+ "For a list of available commands, enter <code><b>help list</b></code><br>"
+ "For help for individual commands, enter <code><b>help &lt;command&gt;</b></code></p>")
+ + end;
+ }
+
+ private:
+ KateCmdLine *m_parent;
+};
+//END KateCmdLnWhatsThis
+
+//BEGIN KateCmdLineFlagCompletion
+/**
+ * This class provide completion of flags. It shows a short description of
+ * each flag, and flags are appended.
+ */
+class KateCmdLineFlagCompletion : public KCompletion
+{
+ public:
+ KateCmdLineFlagCompletion() {;}
+
+ QString makeCompletion( const QString & string )
+ {
+ return QString::null;
+ }
+
+};
+//END KateCmdLineFlagCompletion
+
+//BEGIN KateCmdLine
+KateCmdLine::KateCmdLine (KateView *view)
+ : KLineEdit (view)
+ , m_view (view)
+ , m_msgMode (false)
+ , m_histpos( 0 )
+ , m_cmdend( 0 )
+ , m_command( 0L )
+ , m_oldCompletionObject( 0L )
+{
+ connect (this, SIGNAL(returnPressed(const QString &)),
+ this, SLOT(slotReturnPressed(const QString &)));
+
+ completionObject()->insertItems (KateCmd::self()->cmds());
+ setAutoDeleteCompletionObject( false );
+ m_help = new KateCmdLnWhatsThis( this );
+}
+
+void KateCmdLine::slotReturnPressed ( const QString& text )
+{
+
+ // silently ignore leading space
+ uint n = 0;
+ while( text[n].isSpace() )
+ n++;
+
+ QString cmd = text.mid( n );
+
+ // Built in help: if the command starts with "help", [try to] show some help
+ if ( cmd.startsWith( "help" ) )
+ {
+ m_help->display( m_help->text( QPoint() ), mapToGlobal(QPoint(0,0)) );
+ clear();
+ KateCmd::self()->appendHistory( cmd );
+ m_histpos = KateCmd::self()->historyLength();
+ m_oldText = QString ();
+ return;
+ }
+
+ if (cmd.length () > 0)
+ {
+ Kate::Command *p = KateCmd::self()->queryCommand (cmd);
+
+ m_oldText = cmd;
+ m_msgMode = true;
+
+ if (p)
+ {
+ QString msg;
+
+ if (p->exec (m_view, cmd, msg))
+ {
+ KateCmd::self()->appendHistory( cmd );
+ m_histpos = KateCmd::self()->historyLength();
+ m_oldText = QString ();
+
+ if (msg.length() > 0)
+ setText (i18n ("Success: ") + msg);
+ else
+ setText (i18n ("Success"));
+ }
+ else
+ {
+ if (msg.length() > 0)
+ setText (i18n ("Error: ") + msg);
+ else
+ setText (i18n ("Command \"%1\" failed.").arg (cmd));
+ KNotifyClient::beep();
+ }
+ }
+ else
+ {
+ setText (i18n ("No such command: \"%1\"").arg (cmd));
+ KNotifyClient::beep();
+ }
+ }
+
+ // clean up
+ if ( m_oldCompletionObject )
+ {
+ KCompletion *c = completionObject();
+ setCompletionObject( m_oldCompletionObject );
+ m_oldCompletionObject = 0;
+ delete c;
+ c = 0;
+ }
+ m_command = 0;
+ m_cmdend = 0;
+
+ m_view->setFocus ();
+ QTimer::singleShot( 4000, this, SLOT(hideMe()) );
+}
+
+void KateCmdLine::hideMe () // unless i have focus ;)
+{
+ if ( isVisibleTo(parentWidget()) && ! hasFocus() ) {
+ m_view->toggleCmdLine ();
+ }
+}
+
+void KateCmdLine::focusInEvent ( QFocusEvent *ev )
+{
+ if (m_msgMode)
+ {
+ m_msgMode = false;
+ setText (m_oldText);
+ selectAll();
+ }
+
+ KLineEdit::focusInEvent (ev);
+}
+
+void KateCmdLine::keyPressEvent( QKeyEvent *ev )
+{
+ if (ev->key() == Key_Escape)
+ {
+ m_view->setFocus ();
+ hideMe();
+ }
+ else if ( ev->key() == Key_Up )
+ fromHistory( true );
+ else if ( ev->key() == Key_Down )
+ fromHistory( false );
+
+ uint cursorpos = cursorPosition();
+ KLineEdit::keyPressEvent (ev);
+
+ // during typing, let us see if we have a valid command
+ if ( ! m_cmdend || cursorpos <= m_cmdend )
+ {
+ QChar c;
+ if ( ! ev->text().isEmpty() )
+ c = ev->text()[0];
+
+ if ( ! m_cmdend && ! c.isNull() ) // we have no command, so lets see if we got one
+ {
+ if ( ! c.isLetterOrNumber() && c != '-' && c != '_' )
+ {
+ m_command = KateCmd::self()->queryCommand( text().stripWhiteSpace() );
+ if ( m_command )
+ {
+ //kdDebug(13025)<<"keypress in commandline: We have a command! "<<m_command<<". text is '"<<text()<<"'"<<endl;
+ // if the typed character is ":",
+ // we try if the command has flag completions
+ m_cmdend = cursorpos;
+ //kdDebug(13025)<<"keypress in commandline: Set m_cmdend to "<<m_cmdend<<endl;
+ }
+ else
+ m_cmdend = 0;
+ }
+ }
+ else // since cursor is inside the command name, we reconsider it
+ {
+ kdDebug(13025)<<"keypress in commandline: \\W -- text is "<<text()<<endl;
+ m_command = KateCmd::self()->queryCommand( text().stripWhiteSpace() );
+ if ( m_command )
+ {
+ //kdDebug(13025)<<"keypress in commandline: We have a command! "<<m_command<<endl;
+ QString t = text();
+ m_cmdend = 0;
+ bool b = false;
+ for ( ; m_cmdend < t.length(); m_cmdend++ )
+ {
+ if ( t[m_cmdend].isLetter() )
+ b = true;
+ if ( b && ( ! t[m_cmdend].isLetterOrNumber() && t[m_cmdend] != '-' && t[m_cmdend] != '_' ) )
+ break;
+ }
+
+ if ( c == ':' && cursorpos == m_cmdend )
+ {
+ // check if this command wants to complete flags
+ //kdDebug(13025)<<"keypress in commandline: Checking if flag completion is desired!"<<endl;
+ }
+ }
+ else
+ {
+ // clean up if needed
+ if ( m_oldCompletionObject )
+ {
+ KCompletion *c = completionObject();
+ setCompletionObject( m_oldCompletionObject );
+ m_oldCompletionObject = 0;
+ delete c;
+ c = 0;
+ }
+
+ m_cmdend = 0;
+ }
+ }
+
+ // if we got a command, check if it wants to do semething.
+ if ( m_command )
+ {
+ //kdDebug(13025)<<"Checking for CommandExtension.."<<endl;
+ Kate::CommandExtension *ce = dynamic_cast<Kate::CommandExtension*>(m_command);
+ if ( ce )
+ {
+ KCompletion *cmpl = ce->completionObject( text().left( m_cmdend ).stripWhiteSpace(), m_view );
+ if ( cmpl )
+ {
+ // save the old completion object and use what the command provides
+ // instead. We also need to prepend the current command name + flag string
+ // when completion is done
+ //kdDebug(13025)<<"keypress in commandline: Setting completion object!"<<endl;
+ if ( ! m_oldCompletionObject )
+ m_oldCompletionObject = completionObject();
+
+ setCompletionObject( cmpl );
+ }
+ }
+ }
+ }
+ else if ( m_command )// check if we should call the commands processText()
+ {
+ Kate::CommandExtension *ce = dynamic_cast<Kate::CommandExtension*>( m_command );
+ if ( ce && ce->wantsToProcessText( text().left( m_cmdend ).stripWhiteSpace() )
+ && ! ( ev->text().isNull() || ev->text().isEmpty() ) )
+ ce->processText( m_view, text() );
+ }
+}
+
+void KateCmdLine::fromHistory( bool up )
+{
+ if ( ! KateCmd::self()->historyLength() )
+ return;
+
+ QString s;
+
+ if ( up )
+ {
+ if ( m_histpos > 0 )
+ {
+ m_histpos--;
+ s = KateCmd::self()->fromHistory( m_histpos );
+ }
+ }
+ else
+ {
+ if ( m_histpos < ( KateCmd::self()->historyLength() - 1 ) )
+ {
+ m_histpos++;
+ s = KateCmd::self()->fromHistory( m_histpos );
+ }
+ else
+ {
+ m_histpos = KateCmd::self()->historyLength();
+ setText( m_oldText );
+ }
+ }
+ if ( ! s.isEmpty() )
+ {
+ // Select the argument part of the command, so that it is easy to overwrite
+ setText( s );
+ static QRegExp reCmd = QRegExp(".*[\\w\\-]+(?:[^a-zA-Z0-9_-]|:\\w+)(.*)");
+ if ( reCmd.search( text() ) == 0 )
+ setSelection( text().length() - reCmd.cap(1).length(), reCmd.cap(1).length() );
+ }
+}
+//END KateCmdLine
+
+//BEGIN KateIconBorder
+using namespace KTextEditor;
+
+static const char* const plus_xpm[] = {
+"11 11 3 1",
+" c None",
+". c #000000",
+"+ c #FFFFFF",
+"...........",
+".+++++++++.",
+".+++++++++.",
+".++++.++++.",
+".++++.++++.",
+".++.....++.",
+".++++.++++.",
+".++++.++++.",
+".+++++++++.",
+".+++++++++.",
+"..........."};
+
+static const char* const minus_xpm[] = {
+"11 11 3 1",
+" c None",
+". c #000000",
+"+ c #FFFFFF",
+"...........",
+".+++++++++.",
+".+++++++++.",
+".+++++++++.",
+".+++++++++.",
+".++.....++.",
+".+++++++++.",
+".+++++++++.",
+".+++++++++.",
+".+++++++++.",
+"..........."};
+
+static const char * const bookmark_xpm[] = {
+"14 13 82 1",
+" c None",
+". c #F27D01",
+"+ c #EF7901",
+"@ c #F3940F",
+"# c #EE8F12",
+"$ c #F9C834",
+"% c #F5C33A",
+"& c #F09110",
+"* c #FCEE3E",
+"= c #FBEB3F",
+"- c #E68614",
+"; c #FA8700",
+"> c #F78703",
+", c #F4920E",
+"' c #F19113",
+") c #F6C434",
+"! c #FDF938",
+"~ c #FDF839",
+"{ c #F1BC3A",
+"] c #E18017",
+"^ c #DA7210",
+"/ c #D5680B",
+"( c #CA5404",
+"_ c #FD8F06",
+": c #FCB62D",
+"< c #FDE049",
+"[ c #FCE340",
+"} c #FBE334",
+"| c #FDF035",
+"1 c #FEF834",
+"2 c #FCEF36",
+"3 c #F8DF32",
+"4 c #F7DC3D",
+"5 c #F5CE3E",
+"6 c #DE861B",
+"7 c #C64C03",
+"8 c #F78C07",
+"9 c #F8B019",
+"0 c #FDE12D",
+"a c #FEE528",
+"b c #FEE229",
+"c c #FBD029",
+"d c #E18814",
+"e c #CB5605",
+"f c #EF8306",
+"g c #F3A00E",
+"h c #FBC718",
+"i c #FED31C",
+"j c #FED11D",
+"k c #F8B91C",
+"l c #E07D0D",
+"m c #CB5301",
+"n c #ED8A0E",
+"o c #F7A90D",
+"p c #FEC113",
+"q c #FEC013",
+"r c #F09B0E",
+"s c #D35E03",
+"t c #EF9213",
+"u c #F9A208",
+"v c #FEAA0C",
+"w c #FCA10B",
+"x c #FCA70B",
+"y c #FEAF0B",
+"z c #F39609",
+"A c #D86203",
+"B c #F08C0D",
+"C c #FA9004",
+"D c #F17F04",
+"E c #E36D04",
+"F c #E16F03",
+"G c #EE8304",
+"H c #F88C04",
+"I c #DC6202",
+"J c #E87204",
+"K c #E66A01",
+"L c #DC6001",
+"M c #D15601",
+"N c #DA5D01",
+"O c #D25200",
+"P c #DA5F00",
+"Q c #BC3C00",
+" .+ ",
+" @# ",
+" $% ",
+" &*=- ",
+" ;>,')!~{]^/( ",
+"_:<[}|11234567",
+" 890aaaaabcde ",
+" fghiiijklm ",
+" nopqpqrs ",
+" tuvwxyzA ",
+" BCDEFGHI ",
+" JKL MNO ",
+" P Q "};
+
+const int iconPaneWidth = 16;
+const int halfIPW = 8;
+
+KateIconBorder::KateIconBorder ( KateViewInternal* internalView, QWidget *parent )
+ : QWidget(parent, "", Qt::WStaticContents | Qt::WRepaintNoErase | Qt::WResizeNoErase )
+ , m_view( internalView->m_view )
+ , m_doc( internalView->m_doc )
+ , m_viewInternal( internalView )
+ , m_iconBorderOn( false )
+ , m_lineNumbersOn( false )
+ , m_foldingMarkersOn( false )
+ , m_dynWrapIndicatorsOn( false )
+ , m_dynWrapIndicators( 0 )
+ , m_cachedLNWidth( 0 )
+ , m_maxCharWidth( 0 )
+{
+ setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Minimum ) );
+
+ setBackgroundMode( NoBackground );
+
+ m_doc->setDescription( MarkInterface::markType01, i18n("Bookmark") );
+ m_doc->setPixmap( MarkInterface::markType01, QPixmap((const char**)bookmark_xpm) );
+
+ updateFont();
+}
+
+void KateIconBorder::setIconBorderOn( bool enable )
+{
+ if( enable == m_iconBorderOn )
+ return;
+
+ m_iconBorderOn = enable;
+
+ updateGeometry();
+
+ QTimer::singleShot( 0, this, SLOT(update()) );
+}
+
+void KateIconBorder::setLineNumbersOn( bool enable )
+{
+ if( enable == m_lineNumbersOn )
+ return;
+
+ m_lineNumbersOn = enable;
+ m_dynWrapIndicatorsOn = (m_dynWrapIndicators == 1) ? enable : m_dynWrapIndicators;
+
+ updateGeometry();
+
+ QTimer::singleShot( 0, this, SLOT(update()) );
+}
+
+void KateIconBorder::setDynWrapIndicators( int state )
+{
+ if (state == m_dynWrapIndicators )
+ return;
+
+ m_dynWrapIndicators = state;
+ m_dynWrapIndicatorsOn = (state == 1) ? m_lineNumbersOn : state;
+
+ updateGeometry ();
+
+ QTimer::singleShot( 0, this, SLOT(update()) );
+}
+
+void KateIconBorder::setFoldingMarkersOn( bool enable )
+{
+ if( enable == m_foldingMarkersOn )
+ return;
+
+ m_foldingMarkersOn = enable;
+
+ updateGeometry();
+
+ QTimer::singleShot( 0, this, SLOT(update()) );
+}
+
+QSize KateIconBorder::sizeHint() const
+{
+ int w = 0;
+
+ if (m_iconBorderOn)
+ w += iconPaneWidth + 1;
+
+ if (m_lineNumbersOn || (m_view->dynWordWrap() && m_dynWrapIndicatorsOn)) {
+ w += lineNumberWidth();
+ }
+
+ if (m_foldingMarkersOn)
+ w += iconPaneWidth;
+
+ w += 4;
+
+ return QSize( w, 0 );
+}
+
+// This function (re)calculates the maximum width of any of the digit characters (0 -> 9)
+// for graceful handling of variable-width fonts as the linenumber font.
+void KateIconBorder::updateFont()
+{
+ const QFontMetrics *fm = m_view->renderer()->config()->fontMetrics();
+ m_maxCharWidth = 0;
+ // Loop to determine the widest numeric character in the current font.
+ // 48 is ascii '0'
+ for (int i = 48; i < 58; i++) {
+ int charWidth = fm->width( QChar(i) );
+ m_maxCharWidth = kMax(m_maxCharWidth, charWidth);
+ }
+}
+
+int KateIconBorder::lineNumberWidth() const
+{
+ int width = m_lineNumbersOn ? ((int)log10((double)(m_view->doc()->numLines())) + 1) * m_maxCharWidth + 4 : 0;
+
+ if (m_view->dynWordWrap() && m_dynWrapIndicatorsOn) {
+ width = kMax(style().scrollBarExtent().width() + 4, width);
+
+ if (m_cachedLNWidth != width || m_oldBackgroundColor != m_view->renderer()->config()->iconBarColor()) {
+ int w = style().scrollBarExtent().width();
+ int h = m_view->renderer()->config()->fontMetrics()->height();
+
+ QSize newSize(w, h);
+ if ((m_arrow.size() != newSize || m_oldBackgroundColor != m_view->renderer()->config()->iconBarColor()) && !newSize.isEmpty()) {
+ m_arrow.resize(newSize);
+
+ QPainter p(&m_arrow);
+ p.fillRect( 0, 0, w, h, m_view->renderer()->config()->iconBarColor() );
+
+ h = m_view->renderer()->config()->fontMetrics()->ascent();
+
+ p.setPen(m_view->renderer()->attribute(0)->textColor());
+ p.drawLine(w/2, h/2, w/2, 0);
+#if 1
+ p.lineTo(w/4, h/4);
+ p.lineTo(0, 0);
+ p.lineTo(0, h/2);
+ p.lineTo(w/2, h-1);
+ p.lineTo(w*3/4, h-1);
+ p.lineTo(w-1, h*3/4);
+ p.lineTo(w*3/4, h/2);
+ p.lineTo(0, h/2);
+#else
+ p.lineTo(w*3/4, h/4);
+ p.lineTo(w-1,0);
+ p.lineTo(w-1, h/2);
+ p.lineTo(w/2, h-1);
+ p.lineTo(w/4,h-1);
+ p.lineTo(0, h*3/4);
+ p.lineTo(w/4, h/2);
+ p.lineTo(w-1, h/2);
+#endif
+ }
+ }
+ }
+
+ return width;
+}
+
+void KateIconBorder::paintEvent(QPaintEvent* e)
+{
+ paintBorder(e->rect().x(), e->rect().y(), e->rect().width(), e->rect().height());
+}
+
+void KateIconBorder::paintBorder (int /*x*/, int y, int /*width*/, int height)
+{
+ static QPixmap minus_px ((const char**)minus_xpm);
+ static QPixmap plus_px ((const char**)plus_xpm);
+
+ uint h = m_view->renderer()->config()->fontStruct()->fontHeight;
+ uint startz = (y / h);
+ uint endz = startz + 1 + (height / h);
+ uint lineRangesSize = m_viewInternal->lineRanges.size();
+
+ // center the folding boxes
+ int m_px = (h - 11) / 2;
+ if (m_px < 0)
+ m_px = 0;
+
+ int lnWidth( 0 );
+ if ( m_lineNumbersOn || (m_view->dynWordWrap() && m_dynWrapIndicatorsOn) ) // avoid calculating unless needed ;-)
+ {
+ lnWidth = lineNumberWidth();
+ if ( lnWidth != m_cachedLNWidth || m_oldBackgroundColor != m_view->renderer()->config()->iconBarColor() )
+ {
+ // we went from n0 ->n9 lines or vice verca
+ // this causes an extra updateGeometry() first time the line numbers
+ // are displayed, but sizeHint() is supposed to be const so we can't set
+ // the cached value there.
+ m_cachedLNWidth = lnWidth;
+ m_oldBackgroundColor = m_view->renderer()->config()->iconBarColor();
+ updateGeometry();
+ update ();
+ return;
+ }
+ }
+
+ int w( this->width() ); // sane value/calc only once
+
+ QPainter p ( this );
+ p.setFont ( *m_view->renderer()->config()->font() ); // for line numbers
+ // the line number color is for the line numbers, vertical separator lines
+ // and for for the code folding lines.
+ p.setPen ( m_view->renderer()->config()->lineNumberColor() );
+
+ KateLineInfo oldInfo;
+ if (startz < lineRangesSize)
+ {
+ if ((m_viewInternal->lineRanges[startz].line-1) < 0)
+ oldInfo.topLevel = true;
+ else
+ m_doc->lineInfo(&oldInfo,m_viewInternal->lineRanges[startz].line-1);
+ }
+
+ for (uint z=startz; z <= endz; z++)
+ {
+ int y = h * z;
+ int realLine = -1;
+
+ if (z < lineRangesSize)
+ realLine = m_viewInternal->lineRanges[z].line;
+
+ int lnX ( 0 );
+
+ p.fillRect( 0, y, w-4, h, m_view->renderer()->config()->iconBarColor() );
+ p.fillRect( w-4, y, 4, h, m_view->renderer()->config()->backgroundColor() );
+
+ // icon pane
+ if( m_iconBorderOn )
+ {
+ p.drawLine(lnX+iconPaneWidth, y, lnX+iconPaneWidth, y+h);
+
+ if( (realLine > -1) && (m_viewInternal->lineRanges[z].startCol == 0) )
+ {
+ uint mrk ( m_doc->mark( realLine ) ); // call only once
+
+ if ( mrk )
+ {
+ for( uint bit = 0; bit < 32; bit++ )
+ {
+ MarkInterface::MarkTypes markType = (MarkInterface::MarkTypes)(1<<bit);
+ if( mrk & markType )
+ {
+ QPixmap *px_mark (m_doc->markPixmap( markType ));
+
+ if (px_mark)
+ {
+ // center the mark pixmap
+ int x_px = (iconPaneWidth - px_mark->width()) / 2;
+ if (x_px < 0)
+ x_px = 0;
+
+ int y_px = (h - px_mark->height()) / 2;
+ if (y_px < 0)
+ y_px = 0;
+
+ p.drawPixmap( lnX+x_px, y+y_px, *px_mark);
+ }
+ }
+ }
+ }
+ }
+
+ lnX += iconPaneWidth + 1;
+ }
+
+ // line number
+ if( m_lineNumbersOn || (m_view->dynWordWrap() && m_dynWrapIndicatorsOn) )
+ {
+ lnX +=2;
+
+ if (realLine > -1)
+ if (m_viewInternal->lineRanges[z].startCol == 0) {
+ if (m_lineNumbersOn)
+ p.drawText( lnX + 1, y, lnWidth-4, h, Qt::AlignRight|Qt::AlignVCenter, QString("%1").arg( realLine + 1 ) );
+ } else if (m_view->dynWordWrap() && m_dynWrapIndicatorsOn) {
+ p.drawPixmap(lnX + lnWidth - m_arrow.width() - 4, y, m_arrow);
+ }
+
+ lnX += lnWidth;
+ }
+
+ // folding markers
+ if( m_foldingMarkersOn )
+ {
+ if( realLine > -1 )
+ {
+ KateLineInfo info;
+ m_doc->lineInfo(&info,realLine);
+
+ if (!info.topLevel)
+ {
+ if (info.startsVisibleBlock && (m_viewInternal->lineRanges[z].startCol == 0))
+ {
+ if (oldInfo.topLevel)
+ p.drawLine(lnX+halfIPW,y+m_px,lnX+halfIPW,y+h-1);
+ else
+ p.drawLine(lnX+halfIPW,y,lnX+halfIPW,y+h-1);
+
+ p.drawPixmap(lnX+3,y+m_px,minus_px);
+ }
+ else if (info.startsInVisibleBlock)
+ {
+ if (m_viewInternal->lineRanges[z].startCol == 0)
+ {
+ if (oldInfo.topLevel)
+ p.drawLine(lnX+halfIPW,y+m_px,lnX+halfIPW,y+h-1);
+ else
+ p.drawLine(lnX+halfIPW,y,lnX+halfIPW,y+h-1);
+
+ p.drawPixmap(lnX+3,y+m_px,plus_px);
+ }
+ else
+ {
+ p.drawLine(lnX+halfIPW,y,lnX+halfIPW,y+h-1);
+ }
+
+ if (!m_viewInternal->lineRanges[z].wrap)
+ p.drawLine(lnX+halfIPW,y+h-1,lnX+iconPaneWidth-2,y+h-1);
+ }
+ else
+ {
+ p.drawLine(lnX+halfIPW,y,lnX+halfIPW,y+h-1);
+
+ if (info.endsBlock && !m_viewInternal->lineRanges[z].wrap)
+ p.drawLine(lnX+halfIPW,y+h-1,lnX+iconPaneWidth-2,y+h-1);
+ }
+ }
+
+ oldInfo = info;
+ }
+
+ lnX += iconPaneWidth;
+ }
+ }
+}
+
+KateIconBorder::BorderArea KateIconBorder::positionToArea( const QPoint& p ) const
+{
+ int x = 0;
+ if( m_iconBorderOn ) {
+ x += iconPaneWidth;
+ if( p.x() <= x )
+ return IconBorder;
+ }
+ if( m_lineNumbersOn || m_dynWrapIndicators ) {
+ x += lineNumberWidth();
+ if( p.x() <= x )
+ return LineNumbers;
+ }
+ if( m_foldingMarkersOn ) {
+ x += iconPaneWidth;
+ if( p.x() <= x )
+ return FoldingMarkers;
+ }
+ return None;
+}
+
+void KateIconBorder::mousePressEvent( QMouseEvent* e )
+{
+ m_lastClickedLine = m_viewInternal->yToKateLineRange(e->y()).line;
+
+ if ( positionToArea( e->pos() ) != IconBorder )
+ {
+ QMouseEvent forward( QEvent::MouseButtonPress,
+ QPoint( 0, e->y() ), e->button(), e->state() );
+ m_viewInternal->mousePressEvent( &forward );
+ }
+ e->accept();
+}
+
+void KateIconBorder::mouseMoveEvent( QMouseEvent* e )
+{
+ if ( positionToArea( e->pos() ) != IconBorder )
+ {
+ QMouseEvent forward( QEvent::MouseMove,
+ QPoint( 0, e->y() ), e->button(), e->state() );
+ m_viewInternal->mouseMoveEvent( &forward );
+ }
+}
+
+void KateIconBorder::mouseReleaseEvent( QMouseEvent* e )
+{
+ uint cursorOnLine = m_viewInternal->yToKateLineRange(e->y()).line;
+
+ if (cursorOnLine == m_lastClickedLine &&
+ cursorOnLine <= m_doc->lastLine() )
+ {
+ BorderArea area = positionToArea( e->pos() );
+ if( area == IconBorder) {
+ if (e->button() == LeftButton) {
+ if( m_doc->editableMarks() & KateViewConfig::global()->defaultMarkType() ) {
+ if( m_doc->mark( cursorOnLine ) & KateViewConfig::global()->defaultMarkType() )
+ m_doc->removeMark( cursorOnLine, KateViewConfig::global()->defaultMarkType() );
+ else
+ m_doc->addMark( cursorOnLine, KateViewConfig::global()->defaultMarkType() );
+ } else {
+ showMarkMenu( cursorOnLine, QCursor::pos() );
+ }
+ }
+ else
+ if (e->button() == RightButton) {
+ showMarkMenu( cursorOnLine, QCursor::pos() );
+ }
+ }
+
+ if ( area == FoldingMarkers) {
+ KateLineInfo info;
+ m_doc->lineInfo(&info,cursorOnLine);
+ if ((info.startsVisibleBlock) || (info.startsInVisibleBlock)) {
+ emit toggleRegionVisibility(cursorOnLine);
+ }
+ }
+ }
+
+ QMouseEvent forward( QEvent::MouseButtonRelease,
+ QPoint( 0, e->y() ), e->button(), e->state() );
+ m_viewInternal->mouseReleaseEvent( &forward );
+}
+
+void KateIconBorder::mouseDoubleClickEvent( QMouseEvent* e )
+{
+ QMouseEvent forward( QEvent::MouseButtonDblClick,
+ QPoint( 0, e->y() ), e->button(), e->state() );
+ m_viewInternal->mouseDoubleClickEvent( &forward );
+}
+
+void KateIconBorder::showMarkMenu( uint line, const QPoint& pos )
+{
+ QPopupMenu markMenu;
+ QPopupMenu selectDefaultMark;
+
+ typedef QValueVector<int> MarkTypeVector;
+ MarkTypeVector vec( 33 );
+ int i=1;
+
+ for( uint bit = 0; bit < 32; bit++ ) {
+ MarkInterface::MarkTypes markType = (MarkInterface::MarkTypes)(1<<bit);
+ if( !(m_doc->editableMarks() & markType) )
+ continue;
+
+ if( !m_doc->markDescription( markType ).isEmpty() ) {
+ markMenu.insertItem( m_doc->markDescription( markType ), i );
+ selectDefaultMark.insertItem( m_doc->markDescription( markType ), i+100);
+ } else {
+ markMenu.insertItem( i18n("Mark Type %1").arg( bit + 1 ), i );
+ selectDefaultMark.insertItem( i18n("Mark Type %1").arg( bit + 1 ), i+100);
+ }
+
+ if( m_doc->mark( line ) & markType )
+ markMenu.setItemChecked( i, true );
+
+ if( markType & KateViewConfig::global()->defaultMarkType() )
+ selectDefaultMark.setItemChecked( i+100, true );
+
+ vec[i++] = markType;
+ }
+
+ if( markMenu.count() == 0 )
+ return;
+
+ if( markMenu.count() > 1 )
+ markMenu.insertItem( i18n("Set Default Mark Type" ), &selectDefaultMark);
+
+ int result = markMenu.exec( pos );
+ if( result <= 0 )
+ return;
+
+ if ( result > 100)
+ {
+ KateViewConfig::global()->setDefaultMarkType (vec[result-100]);
+ // flush config, otherwise it isn't nessecarily done
+ KConfig *config = kapp->config();
+ config->setGroup("Kate View Defaults");
+ KateViewConfig::global()->writeConfig( config );
+ }
+ else
+ {
+ MarkInterface::MarkTypes markType = (MarkInterface::MarkTypes) vec[result];
+ if( m_doc->mark( line ) & markType ) {
+ m_doc->removeMark( line, markType );
+ } else {
+ m_doc->addMark( line, markType );
+ }
+ }
+}
+//END KateIconBorder
+
+KateViewEncodingAction::KateViewEncodingAction(KateDocument *_doc, KateView *_view, const QString& text, QObject* parent, const char* name)
+ : KActionMenu (text, parent, name), doc(_doc), view (_view)
+{
+ connect(popupMenu(),SIGNAL(aboutToShow()),this,SLOT(slotAboutToShow()));
+}
+
+void KateViewEncodingAction::slotAboutToShow()
+{
+ QStringList modes (KGlobal::charsets()->descriptiveEncodingNames());
+
+ popupMenu()->clear ();
+ for (uint z=0; z<modes.size(); ++z)
+ {
+ popupMenu()->insertItem ( modes[z], this, SLOT(setMode(int)), 0, z);
+
+ bool found = false;
+ QTextCodec *codecForEnc = KGlobal::charsets()->codecForName(KGlobal::charsets()->encodingForName(modes[z]), found);
+
+ if (found && codecForEnc)
+ {
+ if (codecForEnc->name() == doc->config()->codec()->name())
+ popupMenu()->setItemChecked (z, true);
+ }
+ }
+}
+
+void KateViewEncodingAction::setMode (int mode)
+{
+ QStringList modes (KGlobal::charsets()->descriptiveEncodingNames());
+ doc->config()->setEncoding( KGlobal::charsets()->encodingForName( modes[mode] ) );
+ // now we don't want the encoding changed again unless the user does so using the menu.
+ doc->setEncodingSticky( true );
+ doc->reloadFile();
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;