| /* 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(); |
| } |