thac0/vim
1
0
Fork 0
forked from aniani/vim
Code Activity
Files
86261f63f848eceb13fe23b104029bd0b5d70236
vim/src/gui_kde_wid.cc
Bram Moolenaar 06fb435a1c updated for version 7.0031
2005-01-05 22:10:30 +00:00

1645 lines
39 KiB
C++
Raw Blame History

/* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
*/
/*
* Porting to KDE(2) was done by
*
* (C) 2000 by Thomas Capricelli <orzel@freehackers.org>
*
* Please visit http://freehackers.org/kvim for other vim- or
* kde-related coding.
*
* $Id$
*
*/
#include <assert.h>
#include <qpainter.h>
#include <qevent.h>
#include <qpushbutton.h>
#include <qscrollbar.h>
#include <qlayout.h>
#include <qclipboard.h>
#include <qdragobject.h>
#include <qstrlist.h>
#include <qmenubar.h>
#include <qtextcodec.h>
#if QT_VERSION>=300
#include <qptrlist.h>
#include <ktip.h>
#endif
#include <kglobal.h>
#include <kconfig.h>
#include <kaboutapplication.h>
#include <dcopclient.h>
#include <kaboutkde.h>
#include <kbugreport.h>
#include <kurldrag.h>
#include <kmenubar.h>
#include <ktoolbar.h>
#include <kstandarddirs.h>
#include "gui_kde_wid.h"
#include <qxembed.h>
extern "C"
{
#include "version.h"
}
// Pixmap for dialog
#ifdef FEAT_GUI_DIALOG
# include "../../pixmaps/alert.xpm"
# include "../../pixmaps/error.xpm"
# include "../../pixmaps/generic.xpm"
# include "../../pixmaps/info.xpm"
# include "../../pixmaps/quest.xpm"
#endif
/**
* Keycodes recognized by vim.
*/
struct special_key {//{{{
int qtkey;
char_u code0;
char_u code1;
} special_keys[] =
{
{Qt::Key_Up, 'k', 'u'},
{Qt::Key_Down, 'k', 'd'},
{Qt::Key_Left, 'k', 'l'},
{Qt::Key_Right, 'k', 'r'},
{Qt::Key_F1, 'k', '1'},
{Qt::Key_F2, 'k', '2'},
{Qt::Key_F3, 'k', '3'},
{Qt::Key_F4, 'k', '4'},
{Qt::Key_F5, 'k', '5'},
{Qt::Key_F6, 'k', '6'},
{Qt::Key_F7, 'k', '7'},
{Qt::Key_F8, 'k', '8'},
{Qt::Key_F9, 'k', '9'},
{Qt::Key_F10, 'k', ';'},
{Qt::Key_F11, 'F', '1'},
{Qt::Key_F12, 'F', '2'},
{Qt::Key_F13, 'F', '3'},
{Qt::Key_F14, 'F', '4'},
{Qt::Key_F15, 'F', '5'},
{Qt::Key_F16, 'F', '6'},
{Qt::Key_F17, 'F', '7'},
{Qt::Key_F18, 'F', '8'},
{Qt::Key_F19, 'F', '9'},
{Qt::Key_F20, 'F', 'A'},
{Qt::Key_F21, 'F', 'B'},
{Qt::Key_F22, 'F', 'C'},
{Qt::Key_F23, 'F', 'D'},
{Qt::Key_F24, 'F', 'E'},
{Qt::Key_F25, 'F', 'F'},
{Qt::Key_F26, 'F', 'G'},
{Qt::Key_F27, 'F', 'H'},
{Qt::Key_F28, 'F', 'I'},
{Qt::Key_F29, 'F', 'J'},
{Qt::Key_F30, 'F', 'K'},
{Qt::Key_F31, 'F', 'L'},
{Qt::Key_F32, 'F', 'M'},
{Qt::Key_F33, 'F', 'N'},
{Qt::Key_F34, 'F', 'O'},
{Qt::Key_F35, 'F', 'P'},
{Qt::Key_Help, '%', '1'},
// { Qt::Key_Undo, '&', '8'}, <= hmmm ?
{Qt::Key_BackSpace, 'k', 'b'},
{Qt::Key_Insert, KS_EXTRA, KE_KINS },
{Qt::Key_Delete, KS_EXTRA, KE_KDEL },
{Qt::Key_Home, 'K', '1'},
{Qt::Key_End, 'K', '4'},
{Qt::Key_Prior, 'K', '3'},
{Qt::Key_Next, 'K', '5'},
{Qt::Key_Print, '%', '9'},
{Qt::Key_Plus, 'K', '6'},
{Qt::Key_Minus, 'K', '7'},
{Qt::Key_Slash, 'K', '8'},
{Qt::Key_multiply, 'K', '9'},
{Qt::Key_Enter, 'K', 'A'},
{Qt::Key_Period, 'K', 'B'},
{Qt::Key_0, 'K', 'C'},
{Qt::Key_1, 'K', 'D'},
{Qt::Key_2, 'K', 'E'},
{Qt::Key_3, 'K', 'F'},
{Qt::Key_4, 'K', 'G'},
{Qt::Key_5, 'K', 'H'},
{Qt::Key_6, 'K', 'I'},
{Qt::Key_7, 'K', 'J'},
{Qt::Key_8, 'K', 'K'},
{Qt::Key_9, 'K', 'L'},
/* End of list marker: */
{0, 0, 0}
};//}}}
#ifdef FEAT_CLIENTSERVER
typedef int (*QX11EventFilter)(XEvent*);
extern QX11EventFilter qt_set_x11_event_filter(QX11EventFilter filter);
static QX11EventFilter oldFilter = 0;
static int kvim_x11_event_filter(XEvent* e);
#endif
void gui_keypress(QKeyEvent *e);
/*
* Return OK if the key with the termcap name "name" is supported.
*/
int
gui_mch_haskey(char_u * name)//{{{
{
for (int i = 0; special_keys[i].qtkey != 0; i++)
if (name[0] == special_keys[i].code0
&& name[1] == special_keys[i].code1)
return OK;
return FAIL;
}//}}}
/*
* custom Frame for drawing ...
*/
void
VimWidget::paintEvent(QPaintEvent *e)//{{{
{
QRect r = e->rect();
gui_redraw(r.x(), r.y(), r.width(), r.height());
}//}}}
void
VimWidget::draw_string(int x, int y, QString s, int len, int flags)//{{{
{
gui.current_font->setBold(flags & DRAW_BOLD);
gui.current_font->setUnderline(flags & DRAW_UNDERL);
gui.current_font->setItalic(flags & DRAW_ITALIC);
painter->setBackgroundMode(flags & DRAW_TRANSP
? Qt::TransparentMode : Qt::OpaqueMode);
painter->setFont(*(gui.current_font));
painter->drawText(x, y, s, len);
}//}}}
void
VimWidget::mousePressEvent(QMouseEvent *event)//{{{
{
int button = 0;
int modifiers = 0;
ButtonState state = event->state();
ButtonState buttons = event->button();
//Look at button states
if (buttons & QMouseEvent::LeftButton)
button |= MOUSE_LEFT;
if (buttons & QMouseEvent::RightButton)
button |= MOUSE_RIGHT;
if (buttons & QMouseEvent::MidButton)
button |= MOUSE_MIDDLE;
//Look for keyboard modifiers
if (state & QMouseEvent::ShiftButton)
modifiers |= MOUSE_SHIFT;
if (state & QMouseEvent::ControlButton)
modifiers |= MOUSE_CTRL;
if (state & QMouseEvent::AltButton)
modifiers |= MOUSE_ALT;
gui_send_mouse_event(button, event->x(), event->y(), FALSE, modifiers);
#if QT_VERSION>=300
QByteArray params;
QDataStream stream(params, IO_WriteOnly);
stream << kapp->dcopClient()->appId() << button << modifiers
<< gui.row << gui.col;
kapp->dcopClient()->emitDCOPSignal(
"mousePEvent(QCString, int, int, int, int)", params);
#endif
event->accept();
}//}}}
#if defined(FEAT_SESSION)
void
VimMainWindow::saveGlobalProperties(KConfig *conf)
{
//we write a mksession file to a file written in the user's ~/.kde/share/config/
//the name of the file in saved in 'conf'
//when restoring app, we source this file
#if 0 //disabled for release
QString filename = KGlobal::dirs()->localkdedir() + KGlobal::dirs()->kde_default("config") + kapp->randomString(10);
QString cmd("mksession ");
cmd+=filename;
do_cmdline_cmd((char_u*)cmd.latin1());
conf->writePathEntry("sessionfile", filename);
conf->sync();
#endif
}
void
VimMainWindow::readGlobalProperties (KConfig *conf)
{
#if 0
QString filename = conf->readPathEntry("sessionfile");
if (filename.isNull()) return;
QString cmd("source ");
cmd+=filename;
do_cmdline_cmd((char_u*)cmd.latin1());
#endif
}
#endif
void
VimMainWindow::wheelEvent (QWheelEvent *event)//{{{
{
ButtonState state = event->state();
int button = 0;
int modifiers = 0;
if (event->delta() > 0)
button |= MOUSE_4;
else button |= MOUSE_5;
if (state & ShiftButton)
modifiers |= MOUSE_SHIFT;
if (state & ControlButton)
modifiers |= MOUSE_CTRL;
if (state & AltButton)
modifiers |= MOUSE_ALT;
gui_send_mouse_event(button, event->x(), event->y(), FALSE, modifiers);
#if QT_VERSION>=300
QByteArray params;
QDataStream stream(params, IO_WriteOnly);
stream << kapp->dcopClient()->appId() << button << modifiers
<< gui.row << gui.col;
kapp->dcopClient()->emitDCOPSignal(
"mouseWhlEvent(QCString, int, int, int, int)", params);
#endif
event->accept();
}//}}}
void
VimWidget::mouseDoubleClickEvent(QMouseEvent *event)//{{{
{
ButtonState state = event->state();
ButtonState buttons = event->button();
int modifiers = 0;
int button = 0;
//Look at button states
if (buttons & LeftButton)
button |= MOUSE_LEFT;
if (buttons & RightButton)
button |= MOUSE_RIGHT;
if (buttons & MidButton)
button |= MOUSE_MIDDLE;
//Look for keyboard modifiers
if (state & ShiftButton)
modifiers |= MOUSE_SHIFT;
if (state & ControlButton)
modifiers |= MOUSE_CTRL;
if (state & AltButton)
modifiers |= MOUSE_ALT;
gui_send_mouse_event(button, event->x(), event->y(), TRUE, modifiers);
#if QT_VERSION>=300
QByteArray params;
QDataStream stream(params, IO_WriteOnly);
stream << kapp->dcopClient()->appId() << button << modifiers
<< gui.row << gui.col;
kapp->dcopClient()->emitDCOPSignal(
"mouseDblClickEvent(QCString, int, int, int, int)", params);
#endif
event->accept();
}//}}}
void
VimWidget::mouseMoveEvent(QMouseEvent *event)//{{{
{
ButtonState state = event->state();
int modifiers = 0;
int button = 0;
gui_mch_mousehide(FALSE);
//Look at button states
//warning: we use state here, this is important !
if (state & QMouseEvent::LeftButton
|| state & QMouseEvent::RightButton
|| state & QMouseEvent::MidButton)
button |= MOUSE_DRAG;
//Look for keyboard modifiers
if (state & ShiftButton)
modifiers |= MOUSE_SHIFT;
if (state & ControlButton)
modifiers |= MOUSE_CTRL;
if (state & AltButton)
modifiers |= MOUSE_ALT;
if (button != MOUSE_DRAG)
gui_mouse_moved(event->x(), event->y());
else
gui_send_mouse_event(MOUSE_DRAG, event->x(), event->y(),
FALSE, modifiers);
}//}}}
void
VimWidget::mouseReleaseEvent(QMouseEvent *event)//{{{
{
ButtonState state = event->state();
int modifiers = 0;
//Look for keyboard modifiers
if (state & ShiftButton)
modifiers |= MOUSE_SHIFT;
if (state & ControlButton)
modifiers |= MOUSE_CTRL;
if (state & AltButton)
modifiers |= MOUSE_ALT;
gui_send_mouse_event(MOUSE_RELEASE, event->x(), event->y(),
FALSE, modifiers);
event->accept();
}//}}}
/*
* The main widget (everything but toolbar/menubar)
*/
VimWidget::VimWidget(QWidget *parent, const char *name, WFlags f)//{{{
:QWidget(parent, name, f)
, DCOPObject("KVim")
#ifdef FEAT_MZSCHEME
, mzscheme_timer_id(-1)
#endif
{
//to be able to show/hide the cursor when moving the mouse
setMouseTracking(true);
painter = new QPainter(this);
setKeyCompression(true);
setFocusPolicy(QWidget::StrongFocus);
setAcceptDrops(TRUE); // DND
blink_state = BLINK_NONE;
blink_on_time = 700;
blink_off_time = 400;
blink_wait_time = 250;
connect( &blink_timer, SIGNAL(timeout()), SLOT(blink_cursor()));
connect( &wait_timer, SIGNAL(timeout()), SLOT(wait_timeout()));
setInputMethodEnabled(true);
}//}}}
void
VimWidget::execNormal(QString command)//{{{
{
QString cmd("execute 'normal ");
cmd += command;
cmd += "'";
QCString unistring = vmw->codec->fromUnicode(cmd);
do_cmdline_cmd((char_u *)(const char*)unistring);
gui_update_screen();
}//}}}
void
VimWidget::execInsert(QString command)//{{{
{
QString cmd("execute 'normal i");
cmd += command;
cmd += "'";
QCString unistring = vmw->codec->fromUnicode(cmd);
do_cmdline_cmd((char_u *)(const char*)unistring);
gui_update_screen();
}//}}}
void
VimWidget::execRaw(QString command)//{{{
{
QString cmd("execute '");
cmd += command;
cmd += "'";
QCString unistring = vmw->codec->fromUnicode(cmd);
do_cmdline_cmd((char_u *)(const char*)unistring);
gui_update_screen();
}//}}}
void
VimWidget::execCmd(QString command)//{{{
{
QCString unistring = vmw->codec->fromUnicode(command);
do_cmdline_cmd((char_u *)(const char*)unistring);
gui_update_screen();
}//}}}
QString
VimWidget::eval(QString expr)//{{{
{
#ifdef FEAT_EVAL
QCString unistring = vmw->codec->fromUnicode(expr);
QString val((const char *)eval_to_string(
(char_u *)(const char*)unistring, NULL));
return val;
#else
return QString::null;
#endif
}//}}}
void
VimWidget::wait(long wtime)//{{{
{
if (wait_timer.isActive())
wait_timer.stop();
wait_done = false;
wait_timer.start( wtime, true);
}//}}}
void
VimWidget::wait_timeout() //{{{
{
wait_done = true;
}//}}}
void
VimWidget::dragEnterEvent (QDragEnterEvent *e)//{{{
{
#if (defined(FEAT_WINDOWS) && defined(HAVE_DROP_FILE)) || defined(PROTO)
e->accept(QUriDrag::canDecode(e));
#else
e->ignore();
#endif
}//}}}
void
VimWidget::dropEvent(QDropEvent *e) // {{{
{
#if (defined(FEAT_WINDOWS) && defined(HAVE_DROP_FILE)) || defined(PROTO)
QStrList urls;
char_u **fnames;
int redo_dirs = FALSE;
int i;
int n;
int nfiles;
int url = FALSE;
/* Count how many items there may be and normalize delimiters. */
if (QUriDrag::decode(e, urls))
{
n = urls.count();
fnames = (char_u **)lalloc((n+1) * sizeof(char_u *), TRUE);
nfiles = 0;
#if QT_VERSION>=300
QPtrListIterator<char> it(urls);
for (; it.current(); ++it)
{
KURL u(*it);
#else
for (i = 0; i < urls.count(); ++i)
{
KURL u(urls.at(i));
#endif
if (!u.isLocalFile())
url = TRUE;
else
{
fnames[nfiles] = (char_u *)strdup((const char *)u.path());
++nfiles;
}
}
/* Real files (i.e. not http and not ftp) */
if (url == FALSE)
{
if (nfiles == 1)
{
if (mch_isdir(fnames[0]))
{
/* Handle dropping a directory on Vim. */
if (mch_chdir((char *)fnames[0]) == 0)
{
free(fnames[0]);
fnames[0] = NULL;
redo_dirs = TRUE;
}
}
}
else
{
/* Ignore any directories */
for (i = 0; i < nfiles; ++i)
{
if (mch_isdir(fnames[i]))
{
vim_free(fnames[i]);
fnames[i] = NULL;
}
}
}
if (0)
{
/* Shift held down, change to first file's directory */
if (fnames[0] != NULL && vim_chdirfile(fnames[0]) == OK)
redo_dirs = TRUE;
}
else
{
char_u dirname[MAXPATHL];
char_u *s;
if (mch_dirname(dirname, MAXPATHL) == OK)
for (i = 0; i < nfiles; ++i)
if (fnames[i] != NULL)
{
s = shorten_fname(fnames[i], dirname);
if (s != NULL && (s = vim_strsave(s)) != NULL)
{
vim_free(fnames[i]);
fnames[i] = s;
}
}
}
}
/* Handle the drop, :edit or :split to get to the file */
handle_drop(nfiles, fnames, FALSE);
if (redo_dirs)
shorten_fnames(TRUE);
}
/* Update the screen display */
update_screen(NOT_VALID);
#ifdef FEAT_MENU
gui_update_menus(0);
#endif
setcursor();
out_flush();
gui_update_cursor(FALSE, FALSE);
gui_mch_flush();
#endif
} // }}}
void
VimWidget::keyPressEvent(QKeyEvent *e) // {{{
{
gui_keypress(e);
} // }}}
void
gui_keypress(QKeyEvent *e) // {{{
{
int key = (int)e->key();
int modifiers = 0, i;
uchar string[256], string2[256];
uchar *s, *d;
Qt::ButtonState state = e->state();
QCString unistring = vmw->codec->fromUnicode(e->text());
if (unistring.length() > 0)
strncpy((char*)string, (const char*)unistring, unistring.length());
string[unistring.length()] = 0;
int len = unistring.length();
// ignore certain keys
if (key == Qt::Key_Shift
|| key == Qt::Key_Alt
|| key == Qt::Key_Control
|| key == Qt::Key_Meta
|| key == Qt::Key_CapsLock
|| key == Qt::Key_NumLock
|| key == Qt::Key_ScrollLock)
{
e->ignore();
return;
}
#ifdef FEAT_MBYTE
if (input_conv.vc_type != CONV_NONE)
{
mch_memmove(string2, string, len);
len = convert_input(string2, len, sizeof(string2));
s = string2;
}
else
#endif
s = string;
d = string;
for (i = 0; i < len; ++i)
{
*d++ = s[i];
if (d[-1] == CSI && d + 2 < string + sizeof(string))
{
/* Turn CSI into K_CSI. */
*d++ = KS_EXTRA;
*d++ = (int)KE_CSI;
}
}
len = d - string;
// change shift-tab (backtab) into S_TAB
if (key == Qt::Key_BackTab && state & Qt::ShiftButton)
key = Qt::Key_Tab;
// Change C-@ and C-2 in NUL ? Gtk does this
if ((key == Qt::Key_2 || key == Qt::Key_At) && state & Qt::ControlButton)
{
string[0] = NUL;
len = 1;
}
else if (len == 0 && (key == Qt::Key_Space || key == Qt::Key_Tab))
{
/* When there are modifiers, these keys get zero length; we need the
* original key here to be able to add a modifier below. */
string[0] = (key & 0xff);
len = 1;
}
/* Check for Alt/Meta key (Mod1Mask), but not for a BS, DEL or character
* that already has the 8th bit set.
* Don't do this for <S-M-Tab>, that should become K_S_TAB with ALT. */
if (len == 1
&& (key != Qt::Key_BackSpace && key != Qt::Key_Delete)
&& (string[0] & 0x80) == 0
&& (state & Qt::AltButton)
&& !(key == Qt::Key_Tab && (state & Qt::ShiftButton)))
{
string[0] |= 0x80;
#ifdef FEAT_MBYTE
if (enc_utf8) // convert to utf-8
{
string[1] = string[0] & 0xbf;
string[0] = ((unsigned)string[0] >> 6) + 0xc0;
if (string[1] == CSI)
{
string[2] = KS_EXTRA;
string[3] = (int)KE_CSI;
len = 4;
}
else
len = 2;
}
#endif
}
/* Check for special keys, making sure BS and DEL are recognised. */
if (len == 0 || key == Qt::Key_BackSpace || key == Qt::Key_Delete)
{
while (special_keys[i].qtkey != 0 && special_keys[i].qtkey != key)
i++;
if (special_keys[i].qtkey != 0)
{
string[0] = CSI;
string[1] = special_keys[i].code0;
string[2] = special_keys[i].code1;
len = -3;
}
/*
for (i = 0; special_keys[i].qtkey != 0 ; i++)
{
if (special_keys[i].qtkey == key )
{
string[0] = CSI;
string[1] = special_keys[i].code0;
string[2] = special_keys[i].code1;
len = -3;
break;
}
}*/
}
if (len == 0)
{
//no need to dump that, that's a QT problem, we can't do anything
//dbf("Unrecognised Key : %X %s", key, e->text().latin1());
e->ignore();
return;
}
/* Special keys (and a few others) may have modifiers */
if (len == -3
|| key == Qt::Key_Space
|| key == Qt::Key_Tab
|| key == Qt::Key_Return
|| key == Qt::Key_Enter
|| key == Qt::Key_Escape)
{
modifiers = 0;
if (state & Qt::ShiftButton)
modifiers |= MOD_MASK_SHIFT;
if (state & Qt::ControlButton)
modifiers |= MOD_MASK_CTRL;
if (state & Qt::AltButton)
modifiers |= MOD_MASK_ALT;
/*
* For some keys a shift modifier is translated into another key
* code. Do we need to handle the case where len != 1 and
* string[0] != CSI?
*/
if (len == -3)
key = TO_SPECIAL(string[1], string[2]);
else
key = string[0];
key = simplify_key(key, &modifiers);
if (key == CSI)
key = K_CSI;
if (IS_SPECIAL(key))
{
string[0] = CSI;
string[1] = K_SECOND(key);
string[2] = K_THIRD(key);
len = 3;
}
else
{
string[0] = key;
len = 1;
}
if (modifiers != 0)
{
uchar string2[10];
string2[0] = CSI;
string2[1] = KS_MODIFIER;
string2[2] = modifiers;
add_to_input_buf(string2, 3);
}
} /* special keys */
if (len == 1 && ((string[0] == Ctrl_C && ctrl_c_interrupts)
|| (string[0] == intr_char && intr_char != Ctrl_C)))
{
trash_input_buf();
got_int = TRUE;
}
add_to_input_buf(string, len);
if (p_mh)
gui_mch_mousehide(TRUE);
//DCOP Embedding stuff
//if we are here then the user has type something in the window, thus we can easily imagine that :
// 1 - text has changed (emit textChanged())
// 2 - characters were interactively inserted (emit charactersInteractivelyInserted())
// 3 - cursor position has changed ( emit cursorPositionChanged() )
// 4 - selection has changed ? dunno yet //XXX
// 5 - undo changed too ? (each character typed in makes the undo changes anyway)
// conclusion : this makes a lot of things to send to the vim kpart, maybe too much
// for now i'll just send : keyboardEvent to the kpart with the event string as parameter,
// with current current position
// i'll do the same for mouseEvents
#if QT_VERSION>=300
QByteArray params;
QDataStream stream(params, IO_WriteOnly);
stream << kapp->dcopClient()->appId() << unistring << gui.row << gui.col;
kapp->dcopClient()->emitDCOPSignal(
"keyboardEvent(QCString, QCString, int, int)", params);
#endif
e->ignore();
} // }}}
#ifdef FEAT_CLIENTSERVER
void
VimWidget::serverActivate(WId id) //{{{
{
if (serverName == NULL && serverDelayedStartName != NULL)
{
commWindow = id;
(void)serverRegisterName(qt_xdisplay(), serverDelayedStartName);
}
else
serverChangeRegisteredWindow( qt_xdisplay(), id);
}//}}}
#endif
#ifdef FEAT_XIM
static int preedit_buf_len = 0;
static int im_preedit_cursor = 0;
static int im_preedit_trailing = 0;
static void
im_delete_preedit(void)
{
char_u bskey[] = {CSI, 'k', 'b'};
char_u delkey[] = {CSI, 'k', 'D'};
if (State & NORMAL)
{
im_preedit_cursor = 0;
return;
}
for (; im_preedit_cursor > 0; --im_preedit_cursor)
add_to_input_buf(bskey, (int)sizeof(bskey));
for (; im_preedit_trailing > 0; --im_preedit_trailing)
add_to_input_buf(delkey, (int)sizeof(delkey));
}
void
im_set_position(int row, int col)
{
vmw->w->setMicroFocusHint(
TEXT_X(gui.col),
TEXT_Y(gui.row), 0, 0, TRUE, &vmw->w->font());
}
int
im_is_preediting()
{
return (preedit_start_col != MAXCOL);
}
int
im_get_feedback_attr(int col)
{
if (draw_feedback != NULL && col < preedit_buf_len)
{
if (draw_feedback[col] & XIMReverse)
return HL_INVERSE;
else if (draw_feedback[col] & XIMUnderline)
return HL_UNDERLINE;
else
return hl_attr(HLF_V);
}
return -1;
}
void
VimWidget::imStartEvent(QIMEvent *e)
{
if (State & CMDLINE)
preedit_start_col = cmdline_getvcol_cursor();
else if (curwin != NULL)
getvcol(curwin, &curwin->w_cursor, &preedit_start_col, NULL, NULL);
xic = (XIC)!NULL;
e->accept();
}
void
VimWidget::imEndEvent(QIMEvent *e)
{
uchar string[256];
im_delete_preedit();
QCString unistring = vmw->codec->fromUnicode(e->text());
if (unistring.length() > 0)
strncpy((char*)string, (const char*)unistring, unistring.length());
string[unistring.length()] = 0;
int len = unistring.length();
add_to_input_buf_csi(string, len);
im_preedit_cursor = 0;
im_preedit_trailing = 0;
preedit_start_col = MAXCOL;
preedit_buf_len = 0;
if (draw_feedback)
{
free(draw_feedback);
draw_feedback = NULL;
}
xic = 0;
e->accept();
}
void
VimWidget::imComposeEvent(QIMEvent *e)
{
uchar string[256];
char_u backkey[] = {CSI, 'k', 'l'};
im_delete_preedit();
if (State & NORMAL)
{
im_preedit_cursor = 0;
return;
}
QCString unistring = vmw->codec->fromUnicode(e->text());
if (unistring.length() > 0)
strncpy((char*)string, (const char*)unistring,unistring.length());
string[unistring.length()] = 0;
int len = unistring.length();
add_to_input_buf_csi(string, len);
preedit_buf_len = e->text().length();
if (draw_feedback == NULL)
draw_feedback = (char *)alloc(preedit_buf_len);
else
draw_feedback = (char *)realloc(draw_feedback, preedit_buf_len);
preedit_end_col = preedit_start_col;
char_u *p = string;
for (int n = 0; n < preedit_buf_len; n++)
{
if (n < e->cursorPos() || n >= e->cursorPos() + e->selectionLength())
draw_feedback[n] = XIMUnderline;
else
draw_feedback[n] = XIMReverse;
preedit_end_col += (*mb_ptr2cells)(p);
p += (*mb_ptr2len_check)(p);
}
im_preedit_cursor = e->cursorPos();
im_preedit_trailing = preedit_buf_len - im_preedit_cursor;
# ifdef FEAT_RIGHTLEFT
if ((State & CMDLINE) == 0 && curwin != NULL && curwin->w_p_rl)
backkey[2] = 'r';
# endif
for (int n = 0; n < im_preedit_trailing; n++)
add_to_input_buf(backkey, (int)sizeof(backkey));
e->accept();
}
#endif
void
VimMainWindow::lock()
{
locked = true;
}
void
VimMainWindow::unlock()
{
locked = false;
}
bool
VimMainWindow::isLocked()
{
return locked;
}
// ->resize VimWidget if not locked
//
void
VimMainWindow::resizeEvent(QResizeEvent *e) //{{{
{
if (vmw->isLocked())
return;
//remove toolbar and menubar height
int height = e->size().height();
int width = e->size().width();
if (vmw->menuBar()->isVisible() && vmw->menuBar()->isEnabled()
#if QT_VERSION>=300
&& !vmw->menuBar()->isTopLevelMenu()
#endif
)
height -= vmw->menuBar()->height();
#ifdef FEAT_TOOLBAR
if (vmw->toolBar()->isVisible() && vmw->toolBar()->isEnabled()
&& (vmw->toolBar()->barPos() == KToolBar::Top
|| vmw->toolBar()->barPos() == KToolBar::Bottom))
height -= vmw->toolBar()->height();
if (vmw->toolBar()->isVisible() && vmw->toolBar()->isEnabled()
&& (vmw->toolBar()->barPos() == KToolBar::Left
|| vmw->toolBar()->barPos() == KToolBar::Right))
width -= vmw->toolBar()->width();
#endif
height = ((int)(height/gui.char_height))*gui.char_height;
if (!vmw->isLocked())
gui_resize_shell(width, height);
}//}}}
void
VimWidget::focusInEvent(QFocusEvent *fe) // {{{
{
gui_focus_change(true);
if (blink_state == BLINK_NONE)
gui_mch_start_blink();
} // }}}
void
VimWidget::focusOutEvent(QFocusEvent *fe)//{{{
{
gui_focus_change(false);
if (blink_state != BLINK_NONE)
gui_mch_stop_blink();
}//}}}
void
VimWidget::set_blink_time(long wait, long on, long off)//{{{
{
blink_wait_time = wait;
blink_on_time = on;
blink_off_time = off;
}//}}}
void
VimWidget::start_cursor_blinking()//{{{
{
if (blink_timer.isActive())
blink_timer.stop();
/* Only switch blinking on if none of the times is zero */
if (blink_wait_time && blink_on_time && blink_off_time && gui.in_focus)
{
blink_state = BLINK_ON;
gui_update_cursor(TRUE, FALSE);
// The first blink appears after wait_time
blink_timer.start( blink_wait_time, true);
}
}//}}}
void
VimWidget::blink_cursor()//{{{
{
if (blink_state == BLINK_ON)
{
// set cursor off
gui_undraw_cursor();
blink_state = BLINK_OFF;
blink_timer.start( blink_off_time, true);
}
else
{
// set cursor on
gui_update_cursor(TRUE, FALSE);
blink_state = BLINK_ON;
blink_timer.start( blink_on_time, true);
}
}//}}}
void
VimWidget::stop_cursor_blinking()//{{{
{
if (blink_timer.isActive())
blink_timer.stop();
if (blink_state == BLINK_OFF)
gui_update_cursor(TRUE, FALSE);
blink_state = BLINK_NONE;
}//}}}
#ifdef FEAT_MZSCHEME
void
VimWidget::timerEvent(QTimerEvent * evnt)//{{{
{
if (evnt->timerId() == mzscheme_timer_id)
timer_proc();
}//}}}
void
VimWidget::enable_mzscheme_threads()//{{{
{
mzscheme_timer_id = startTimer(p_mzq);
}//}}}
void
VimWidget::disable_mzscheme_threads()//{{{
{
killTimer(mzscheme_timer_id);
}//}}}
#endif
void
VimWidget::flash()//{{{
{
QPainter p(this);
p.setRasterOp(Qt::XorROP);
p.fillRect(geometry(), QColor(0xFF, 0xFF, 0xFF));
p.flush();
//FIXME: Make this a little smarter. Maybe add a timer or something
usleep(19000);
p.fillRect(geometry(), QColor(0xFF, 0xFF, 0xFF));
p.flush();
p.end();
}//}}}
/*
* The main Window
*/
VimMainWindow::VimMainWindow(const char *name , WFlags f)//{{{
:KMainWindow(0L, name, f)
{
#ifdef FEAT_CLIENTSERVER
oldFilter = qt_set_x11_event_filter(kvim_x11_event_filter);
#endif
if (echo_wid_arg == 1)
{
fprintf(stderr, "WID: %ld\n", (long)winId());
fflush(stderr);
}
w = new VimWidget(this, "main vim widget");
gui.w = w;
setFocusProxy(w);
w->setFocus();
have_tearoff = 0;
finddlg = new KEdFind(this, 0, false);
repldlg = new KEdReplace(this, 0, false);
QObject::connect(finddlg, SIGNAL(search()), this, SLOT(slotSearch()));
QObject::connect(repldlg, SIGNAL(find()), this, SLOT(slotFind()));
QObject::connect(repldlg, SIGNAL(replace()), this, SLOT(slotReplace()));
QObject::connect(repldlg, SIGNAL(replaceAll()), this,
SLOT(slotReplaceAll()));
#ifdef FEAT_TOOLBAR
connect(toolBar(), SIGNAL(clicked(int)), this, SLOT(menu_activated(int)));
#endif
#ifdef FEAT_CLIENTSERVER
w->serverActivate(winId());
if (serverName != NULL)
kapp->dcopClient()->registerAs(QCString((const char*)serverName),
false);
else if (serverDelayedStartName != NULL)
kapp->dcopClient()->registerAs(
QCString((const char*)serverDelayedStartName), false);
else if (argServerName != NULL)
kapp->dcopClient()->registerAs(argServerName->utf8(), false);
#else
if (argServerName != NULL)
kapp->dcopClient()->registerAs(argServerName->utf8(), false);
#endif
QXEmbed::initialize();
}//{{{
bool
VimMainWindow::queryClose()//{{{
{
gui_shell_closed();
return true;
}//}}}
bool
VimMainWindow::queryExit()//{{{
{
return true;
}//}}}
void
VimMainWindow::menu_activated(int dx)//{{{
{
#ifdef FEAT_MENU
if (!dx) // tearoff
return;
gui_mch_set_foreground();
gui_menu_cb((VimMenu *)dx);
#endif
}//}}}
void
VimMainWindow::clipboard_selection_update()//{{{
{
if (kapp->clipboard()->ownsSelection())
clip_own_selection(&clip_star);
else
clip_lose_selection(&clip_star);
}//}}}
void
VimMainWindow::clipboard_data_update()//{{{
{
#if QT_VERSION>=300
if (kapp->clipboard()->ownsClipboard())
clip_own_selection(&clip_plus);
else
clip_lose_selection(&clip_plus);
#else
if (kapp->clipboard()->ownsSelection())
clip_own_selection(&clip_star);
else
clip_lose_selection(&clip_star);
#endif
}//}}}
void
VimMainWindow::slotSearch()//{{{
{
QString find_text;
bool direction_down = TRUE;
bool casesensitive = TRUE;
int flags = FRD_FINDNEXT;
find_text = finddlg->getText();
direction_down = !(finddlg->get_direction());
casesensitive = finddlg->case_sensitive();
// if (casesensitive) find_text = "\\C" + find_text;
// else find_text = "\\c" + find_text;
if (casesensitive)
flags |= FRD_MATCH_CASE;
QCString unistring = vmw->codec->fromUnicode(find_text);
gui_do_findrepl(flags, (char_u *)(const char *)unistring, NULL,
(int)direction_down);
}//}}}
void
VimMainWindow::slotFind()//{{{
{
QString find_text;
bool direction_down = TRUE;
bool casesensitive = TRUE;
int flags = FRD_R_FINDNEXT;
find_text = repldlg->getText();
direction_down = !(repldlg->get_direction());
casesensitive = repldlg->case_sensitive();
// if (casesensitive) find_text = "\\C" + find_text;
// else find_text = "\\c" + find_text;
if (casesensitive) flags |= FRD_MATCH_CASE;
QCString unistring = vmw->codec->fromUnicode(find_text);
gui_do_findrepl(flags, (char_u *)(const char *)unistring, NULL,
(int)direction_down);
}//}}}
void
VimMainWindow::slotReplace()//{{{
{
QString find_text;
QString repl_text;
bool direction_down = TRUE;
bool casesensitive = TRUE;
int flags = FRD_REPLACE;
find_text = repldlg->getText();
repl_text = repldlg->getReplaceText();
direction_down = !(repldlg->get_direction());
//if (casesensitive) find_text = "\\C" + find_text;
//else find_text = "\\c" + find_text;
if (casesensitive) flags |= FRD_MATCH_CASE;
QCString unistring = vmw->codec->fromUnicode(find_text);
QCString unistring2 = vmw->codec->fromUnicode(repl_text);
gui_do_findrepl(flags, (char_u *)(const char *)unistring,
(char_u *)(const char*)unistring2, (int)direction_down);
}//}}}
void
VimMainWindow::slotReplaceAll()//{{{
{
QString find_text;
QString repl_text;
bool direction_down = TRUE;
bool casesensitive = TRUE;
int flags = FRD_REPLACEALL;
find_text = repldlg->getText();
repl_text = repldlg->getReplaceText();
direction_down = !(repldlg->get_direction());
casesensitive = repldlg->case_sensitive();
// if (casesensitive) find_text = "\\C" + find_text;
// else find_text = "\\c" + find_text;
if (casesensitive)
flags |= FRD_MATCH_CASE;
QCString unistring = vmw->codec->fromUnicode(find_text);
QCString unistring2 = vmw->codec->fromUnicode(repl_text);
gui_do_findrepl(flags, (char_u *)(const char *)unistring,
(char_u *)(const char*)unistring2, (int)direction_down);
}//}}}
void
VimMainWindow::showAboutKDE()
{
KAboutKDE *kde = new KAboutKDE(this);
kde->show();
}
void
VimMainWindow::showAboutApplication()//{{{
{
KAboutData *aboutData = new KAboutData(
"kvim"
, I18N_NOOP("KVim")
, VIM_VERSION_SHORT
, I18N_NOOP("Vim in a KDE interface")
, 0
, "(c) Vim Team, \":help credits\" for more infos.\nType \":help iccf\" to see how you can help the children in Uganda"
, 0l
, "http://freehackers.org/kvim"
, "kvim-dev@freenux.org"
);
aboutData->addAuthor("Bram Moolenaar",
I18N_NOOP("Main vim author"),
"Bram@vim.org",
"http://www.vim.org/");
aboutData->addAuthor("Thomas Capricelli",
I18N_NOOP("KDE porting"),
"orzel@freehackers.org",
"http://orzel.freehackers.org");
aboutData->addAuthor("Philippe Fremy",
I18N_NOOP("KDE porting"),
"pfremy@chez.com",
"http://www.freehackers.org/kvim");
aboutData->addAuthor("Mark Westcott",
I18N_NOOP("Qtopia porting, maintainer of the Qtopia part"),
"mark@houseoffish.org",
"http://houseoffish.org");
aboutData->addAuthor("Mickael Marchand",
I18N_NOOP("KDE porting, maintainer"),
"marchand@kde.org",
"http://freenux.org");
aboutData->addAuthor("Many other people",
I18N_NOOP("type :help credits for more infos")
);
aboutData->addCredit("Vince Negri",
I18N_NOOP("Antialiasing support, Color fixes"),
"vnegri@asl-electronics.co.uk");
aboutData->addCredit("Malte Starostik",
I18N_NOOP("Patch for performance improvement"),
"malte@kde.org");
aboutData->addCredit("Mark Stosberg",
I18N_NOOP("Provided a FreeBSD box to debug KVim on BSD"),
"mark@summersault.com"
);
aboutData->addCredit("Henrik Skott",
I18N_NOOP("Font patch when KDE not configured"),
"henrik.skott@hem.utfors.se"
);
aboutData->addCredit("Kailash Sethuraman",
I18N_NOOP("NetBSD configure/compilation fixes")
);
aboutData->setLicenseText(
"KVim as an extension of Vim follows Vim license.\n\
You can read it with \":help license\"\n\
Or read the file $VIMRUNTIME/doc/uganda.txt.");
KAboutApplication *about = new KAboutApplication(aboutData);
about->show();
}//}}}
void
VimMainWindow::showTipOfTheDay()
{
#if QT_VERSION>=300
KTipDialog::showTip(vmw, QString::null, true);
#endif
}
void
VimMainWindow::buffersToolbar()
{
}
void
VimMainWindow::showBugReport()
{
KBugReport *bug= new KBugReport(this, true);
bug->show();
}
/*
* Vim Dialog
*
* Returns:
* 0: Cancel
* 1- : nb of the pressed button
*/
VimDialog::VimDialog(int type, /* type of dialog *///{{{
char_u * title, /* title of dialog */
char_u * message, /* message text */
char_u * buttons, /* names of buttons */
int def_but, /* default button */
char_u *textfield) /* input field */
:QDialog(vmw, "vim generic dialog", true), // true is for "modal"
mapper(this, "dialog signal mapper")
{
/*
* Create Icon
*/
char ** icon_data;
switch (type)
{
case VIM_GENERIC:
icon_data = generic_xpm;
break;
case VIM_ERROR:
icon_data = error_xpm;
break;
case VIM_WARNING:
icon_data = alert_xpm;
break;
case VIM_INFO:
icon_data = info_xpm;
break;
case VIM_QUESTION:
icon_data = quest_xpm;
break;
default:
icon_data = generic_xpm;
};
QLabel * icon = new QLabel(this);
icon->setPixmap(QPixmap((const char **) icon_data));
icon->setFixedSize(icon->sizeHint());
QLabel * text = new QLabel(QSTR(message), this);
text->setAlignment(AlignHCenter | AlignVCenter | ExpandTabs);
QStringList buttonText = QStringList::split(DLG_BUTTON_SEP, QSTR(buttons));
int butNb = buttonText.count();
/*
* Layout
*/
QVBoxLayout * vly = new QVBoxLayout(this, 5, 5);
QHBoxLayout * hly1 = new QHBoxLayout(vly, 5);
hly1->addWidget(icon);
hly1->addWidget(text);
QHBoxLayout * hly3 = new QHBoxLayout(vly , 5);
if (textfield != NULL)
{
entry = new QLineEdit(QSTR(textfield), this);
entry->setText(QSTR(textfield));
hly3->addWidget(entry);
ret = textfield;
}
else
entry = NULL;
QHBoxLayout * hly2 = new QHBoxLayout(vly, 15);
QString s;
QPushButton * pushButton = 0L;
for (int i = 0; i<butNb; i++)
{
s = buttonText[i];
pushButton = new QPushButton(s, this);
if (s.find('&') != -1)
pushButton->setAccel(s.at(s.find('&') + 1).latin1());
hly2->addWidget(pushButton);
if (i == def_but - 1)
{
pushButton->setDefault(true);
pushButton->setAutoDefault(true);
setResult(i + 1);
}
connect(pushButton, SIGNAL(clicked()), &mapper, SLOT(map()));
mapper.setMapping(pushButton, i + 1);
}
connect(&mapper, SIGNAL(mapped(int)), this, SLOT(done(int)));
setCaption(QSTR(title));
vly->activate();
}//}}}
void
VimDialog::done(int r)
{
if (entry != NULL)
{
if (r)
{
QCString unistring = vmw->codec->fromUnicode(entry->text());
STRCPY(ret, (const char*)unistring);
}
else
*ret = NUL;
}
QDialog::done(r);
}
/*
* ScrollBar pool handling
*/
SBPool::SBPool(void)//{{{
:mapper(this, "SBPool signal mapper")
{
connect(&mapper, SIGNAL(mapped(int)), this, SLOT(sbUsed(int)));
}//}}}
void
SBPool::create(GuiScrollbar * sb, int orient)//{{{
{
switch(orient)
{
case SBAR_HORIZ:
sb->w = new QScrollBar(QScrollBar::Horizontal, vmw);
break;
case SBAR_VERT:
sb->w = new QScrollBar(QScrollBar::Vertical, vmw);
break;
default:
sb->w = 0;
return;
}
connect(sb->w, SIGNAL(valueChanged(int)), &mapper, SLOT(map()));
mapper.setMapping(sb->w, (long)sb);
}//}}}
void
SBPool::sbUsed(int who)//{{{
{
GuiScrollbar *sb = (GuiScrollbar*)who;
gui_drag_scrollbar(sb, sb->w->value(), FALSE);
}//}}}
void
SBPool::destroy(GuiScrollbar *sb)//{{{
{
if (!sb->w)
return;
delete sb->w;
sb->w = 0;
}//}}}
#ifdef FEAT_CLIENTSERVER
static int
kvim_x11_event_filter(XEvent* e)//{{{
{
if (e->xproperty.type == PropertyNotify
&& e->xproperty.atom == commProperty
&& e->xproperty.window == commWindow
&& e->xproperty.state == PropertyNewValue)
serverEventProc(qt_xdisplay(), e);
if (oldFilter)
return oldFilter( e );
return FALSE;
}//}}}
#endif
//add some QT 3 fonts usefull functions
#if QT_VERSION<300
QString
KVimUtils::toString(QFont *f)
{
QStringList l;
l.append(f->family());
l.append(QString::number(f->pointSize()));
l.append(QString::number(f->pixelSize()));
l.append(QString::number((int)f->styleHint()));
l.append(QString::number(f->weight()));
l.append(QString::number((int)f->italic()));
l.append(QString::number((int)f->underline()));
l.append(QString::number((int)f->strikeOut()));
l.append(QString::number((int)f->fixedPitch()));
l.append(QString::number((int)f->rawMode()));
return l.join(",");
}
bool
KVimUtils::fromString(QFont *f, QString descrip)
{
QStringList l(QStringList::split(',', descrip));
int count = l.count();
if (count != 10 && count != 9)
return FALSE;
f->setFamily(l[0]);
f->setPointSize(l[1].toInt());
if (count == 9)
{
f->setStyleHint((QFont::StyleHint) l[2].toInt());
f->setWeight(l[3].toInt());
f->setItalic(l[4].toInt());
f->setUnderline(l[5].toInt());
f->setStrikeOut(l[6].toInt());
f->setFixedPitch(l[7].toInt());
f->setRawMode(l[8].toInt());
}
else
{
f->setPixelSize(l[2].toInt());
f->setStyleHint((QFont::StyleHint) l[3].toInt());
f->setWeight(l[4].toInt());
f->setItalic(l[5].toInt());
f->setUnderline(l[6].toInt());
f->setStrikeOut(l[7].toInt());
f->setFixedPitch(l[8].toInt());
f->setRawMode(l[9].toInt());
}
return TRUE;
}
#endif
QString
KVimUtils::convertEncodingName(QString name)
{
if (name.startsWith("ucs") || name.startsWith("utf-16"))
return QString("utf16");
if (name == "cp950")
return QString("Big5");
return QString();
}
View Git Blame Copy Permalink