void QGraphicsEllipseItem_QtDShell::__override_keyReleaseEvent(QKeyEvent* event0, bool static_call)
{
if (static_call) {
QGraphicsItem::keyReleaseEvent((QKeyEvent* )event0);
} else {
keyReleaseEvent((QKeyEvent* )event0);
}
}
void QDateEdit_QtDShell::__override_keyReleaseEvent(QKeyEvent* event0, bool static_call)
{
if (static_call) {
QAbstractSpinBox::keyReleaseEvent((QKeyEvent* )event0);
} else {
keyReleaseEvent((QKeyEvent* )event0);
}
}
void QFontComboBox_QtDShell::__override_keyReleaseEvent(QKeyEvent* e0, bool static_call)
{
if (static_call) {
QComboBox::keyReleaseEvent((QKeyEvent* )e0);
} else {
keyReleaseEvent((QKeyEvent* )e0);
}
}
void QStatusBar_QtDShell::__override_keyReleaseEvent(QKeyEvent* arg__1, bool static_call)
{
if (static_call) {
QWidget::keyReleaseEvent((QKeyEvent* )arg__1);
} else {
keyReleaseEvent((QKeyEvent* )arg__1);
}
}
void TorrentsListWidget::torrentWidgetKeyReleased(TorrentWidget *item, QKeyEvent *event) {
switch(event->key()) {
case Qt::Key_Control:
case Qt::Key_Shift:
keyReleaseEvent(event);
break;
}
};
bool Prefs_KeyboardShortcuts::event( QEvent* ev )
{
bool ret = QWidget::event( ev );
if ( ev->type() == QEvent::KeyPress )
keyPressEvent((QKeyEvent*)ev);
if ( ev->type() == QEvent::KeyRelease )
keyReleaseEvent((QKeyEvent*)ev);
return ret;
}
void BrowserWidget::pressKey(QString key) {
int qt_key = 0;
if (key == "backspace") {
qt_key = Qt::Key_Backspace;
key = "";
}
keyPressEvent(new QKeyEvent(QEvent::KeyPress, qt_key, 0, key));
keyReleaseEvent(new QKeyEvent(QEvent::KeyRelease, qt_key, 0, key));
}
bool MainWindow::eventFilter(QObject *target, QEvent *event)
{
if (event->type() == QEvent::KeyRelease) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
keyReleaseEvent(keyEvent);
}
return QMainWindow::eventFilter(target, event);
}
int AbstractXApplication::exec() {
/* Show window */
XMapWindow(_display, _window);
while(!(_flags & Flag::Exit)) {
XEvent event;
/* Closed window */
if(XCheckTypedWindowEvent(_display, _window, ClientMessage, &event) &&
Atom(event.xclient.data.l[0]) == _deleteWindow) {
return 0;
}
while(XCheckWindowEvent(_display, _window, INPUT_MASK, &event)) {
switch(event.type) {
/* Window resizing */
case ConfigureNotify: {
Vector2i size(event.xconfigure.width, event.xconfigure.height);
if(size != _viewportSize) {
_viewportSize = size;
viewportEvent(size);
_flags |= Flag::Redraw;
}
}
break;
/* Key/mouse events */
case KeyPress:
case KeyRelease: {
KeyEvent e(static_cast<KeyEvent::Key>(XLookupKeysym(&event.xkey, 0)), static_cast<InputEvent::Modifier>(event.xkey.state), {event.xkey.x, event.xkey.y});
event.type == KeyPress ? keyPressEvent(e) : keyReleaseEvent(e);
}
break;
case ButtonPress:
case ButtonRelease: {
MouseEvent e(static_cast<MouseEvent::Button>(event.xbutton.button), static_cast<InputEvent::Modifier>(event.xkey.state), {event.xbutton.x, event.xbutton.y});
event.type == ButtonPress ? mousePressEvent(e) : mouseReleaseEvent(e);
}
break;
/* Mouse move events */
case MotionNotify: {
MouseMoveEvent e(static_cast<InputEvent::Modifier>(event.xmotion.state), {event.xmotion.x, event.xmotion.y});
mouseMoveEvent(e);
}
break;
}
}
if(_flags & Flag::Redraw) {
_flags &= ~Flag::Redraw;
drawEvent();
} else Utility::sleep(5);
}
return 0;
}
bool NaClApplication::HandleInputEvent(const pp::InputEvent& event) {
/* Don't handle anything during switch from/to fullscreen */
if(flags & Flag::FullscreenSwitchInProgress) return false;
Flags tmpFlags = flags;
switch(event.GetType()) {
case PP_INPUTEVENT_TYPE_KEYDOWN:
case PP_INPUTEVENT_TYPE_KEYUP: {
pp::KeyboardInputEvent keyEvent(event);
KeyEvent e(static_cast<KeyEvent::Key>(keyEvent.GetKeyCode()), static_cast<InputEvent::Modifier>(keyEvent.GetModifiers()));
event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
case PP_INPUTEVENT_TYPE_MOUSEUP: {
pp::MouseInputEvent mouseEvent(event);
MouseEvent e(static_cast<MouseEvent::Button>(mouseEvent.GetButton()), {mouseEvent.GetPosition().x(), mouseEvent.GetPosition().y()}, static_cast<InputEvent::Modifier>(mouseEvent.GetModifiers()));
event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN ? mousePressEvent(e) : mouseReleaseEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_WHEEL: {
pp::WheelInputEvent wheelEvent(event);
if(Math::TypeTraits<Float>::equals(wheelEvent.GetDelta().y(), 0.0f)) return false;
MouseEvent e(wheelEvent.GetDelta().y() > 0 ? MouseEvent::Button::WheelUp : MouseEvent::Button::WheelDown, {}, static_cast<InputEvent::Modifier>(wheelEvent.GetModifiers()));
mousePressEvent(e);
if(!e.isAccepted()) return false;
break;
}
case PP_INPUTEVENT_TYPE_MOUSEMOVE: {
pp::MouseInputEvent mouseEvent(event);
MouseMoveEvent e({mouseEvent.GetPosition().x(), mouseEvent.GetPosition().y()}, {mouseEvent.GetMovement().x(), mouseEvent.GetMovement().y()}, static_cast<InputEvent::Modifier>(mouseEvent.GetModifiers()));
mouseMoveEvent(e);
if(!e.isAccepted()) return false;
break;
}
default: return false;
}
/* Assume everything is properly sequential here */
CORRADE_INTERNAL_ASSERT((tmpFlags & Flag::SwapInProgress) == (flags & Flag::SwapInProgress));
/* Redraw, if it won't be handled after swap automatically */
if((flags & Flag::Redraw) && !(flags & Flag::SwapInProgress)) {
flags &= ~Flag::Redraw;
drawEvent();
}
return true;
}
bool KisToolProxy::forwardEvent(ActionState state, KisTool::ToolAction action, QEvent *event, QEvent *originalEvent, QTabletEvent *lastTabletEvent, const QPoint &canvasOriginWorkaround)
{
bool retval = true;
QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
QTouchEvent *touchEvent = dynamic_cast<QTouchEvent*>(event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (tabletEvent) {
QPointF docPoint = tabletToDocument(tabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
tabletEvent->accept();
this->tabletEvent(tabletEvent, docPoint);
forwardToTool(state, action, tabletEvent, docPoint);
retval = tabletEvent->isAccepted();
} else if (touchEvent) {
if (state == END && touchEvent->type() != QEvent::TouchEnd) {
//Fake a touch end if we are "upgrading" a single-touch gesture to a multi-touch gesture.
QTouchEvent fakeEvent(QEvent::TouchEnd, touchEvent->deviceType(), touchEvent->modifiers(), touchEvent->touchPointStates(), touchEvent->touchPoints());
this->touchEvent(&fakeEvent);
} else {
this->touchEvent(touchEvent);
}
} else if (mouseEvent) {
if (lastTabletEvent) {
QPointF docPoint = tabletToDocument(lastTabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
lastTabletEvent->accept();
this->tabletEvent(lastTabletEvent, docPoint);
forwardToTool(state, action, lastTabletEvent, docPoint);
retval = lastTabletEvent->isAccepted();
} else {
QPointF docPoint = widgetToDocument(mouseEvent->posF());
mouseEvent->accept();
if (mouseEvent->type() == QEvent::MouseButtonPress) {
mousePressEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonDblClick) {
mouseDoubleClickEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonRelease) {
mouseReleaseEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseMove) {
mouseMoveEvent(mouseEvent, docPoint);
}
forwardToTool(state, action, originalEvent, docPoint);
retval = mouseEvent->isAccepted();
}
} else if(event->type() == QEvent::KeyPress) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyPressEvent(kevent);
} else if(event->type() == QEvent::KeyRelease) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyReleaseEvent(kevent);
}
return retval;
}
void PlayerTank::processKeyEvent(QKeyEvent *event)
{
if (event->type() == QKeyEvent::KeyPress)
{
keyPressEvent(event);
}
if (event->type() == QKeyEvent::KeyRelease)
{
keyReleaseEvent(event);
}
}
bool MainWindow::event(QEvent *event) {
if (event->type() == QEvent::KeyPress) {
keyPressEvent(static_cast<QKeyEvent *>(event));
event->accept();
return true;
} else if (event->type() == QEvent::KeyRelease) {
keyReleaseEvent(static_cast<QKeyEvent *>(event));
event->accept();
return true;
} else
return QMainWindow::event(event);
}
bool QtKeypadBridge::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
if(event->type() == QEvent::KeyPress)
keyPressEvent(static_cast<QKeyEvent*>(event));
else if(event->type() == QEvent::KeyRelease)
keyReleaseEvent(static_cast<QKeyEvent*>(event));
else
return false;
return true;
}
bool TabWidget::eventFilter(QObject *obj, QEvent *ev)
{
switch(ev->type())
{
case QEvent::ChildAdded:
installEventFilterToChildren(((QChildEvent*)ev)->child());
return false;
case QEvent::ChildRemoved:
removeEventFilterFromChildren(((QChildEvent*)ev)->child());
return false;
case QEvent::KeyPress:
{
QKeyEvent *keyEv = (QKeyEvent*)ev;
m_altEventValid = (keyEv->key() == Qt::Key_Alt && keyEv->modifiers() == Qt::AltModifier);
if(!(keyEv->modifiers() & Qt::ControlModifier) || keyEv->key() != Qt::Key_Tab)
return false;
keyPressEvent(keyEv);
return true;
}
case QEvent::KeyRelease:
{
QKeyEvent *keyEv = (QKeyEvent*)ev;
if(m_altEventValid && keyEv->key() == Qt::Key_Alt && keyEv->modifiers() == Qt::NoModifier)
{
m_menuBtn->animateClick();
m_altEventValid = false;
return false;
}
if(keyEv->key() == Qt::Key_Control)
keyReleaseEvent(keyEv);
return false;
}
case QEvent::FocusIn:
{
emit changeActiveWidget(this);
return false;
}
default:break;
}
return QTabWidget::eventFilter(obj, ev);
}
bool RenderWidget::eventFilter(QObject* obj, QEvent* event)
{
// handle event in this widget, is there a better way to do this?
if (event->type() == QEvent::MouseButtonPress)
mousePressEvent(static_cast<QMouseEvent*>(event));
if (event->type() == QEvent::MouseButtonRelease)
mouseReleaseEvent(static_cast<QMouseEvent*>(event));
if (event->type() == QEvent::MouseMove)
mouseMoveEvent(static_cast<QMouseEvent*>(event));
if (event->type() == QEvent::KeyPress)
keyPressEvent(static_cast<QKeyEvent*>(event));
if (event->type() == QEvent::KeyRelease)
keyReleaseEvent(static_cast<QKeyEvent*>(event));
if (event->type() == QEvent::Wheel)
wheelEvent(static_cast<QWheelEvent *>(event));
// Always pass the event on to GLWidget, i.e. to OSG event queue
return QObject::eventFilter(obj, event);
}
bool CanvasQt::event(QEvent *e) {
switch (e->type()) {
case QEvent::KeyPress:
keyPressEvent(static_cast<QKeyEvent*>(e));
return true;
case QEvent::KeyRelease:
keyReleaseEvent(static_cast<QKeyEvent*>(e));
return true;
case QEvent::MouseButtonPress:
if(!gestureMode_)
mousePressEvent(static_cast<QMouseEvent*>(e));
return true;
case QEvent::MouseButtonRelease:
if(!gestureMode_)
mouseReleaseEvent(static_cast<QMouseEvent*>(e));
return true;
case QEvent::MouseMove:
if(!gestureMode_)
mouseMoveEvent(static_cast<QMouseEvent*>(e));
return true;
case QEvent::Wheel:
wheelEvent(static_cast<QWheelEvent*>(e));
return true;
#ifndef QT_NO_GESTURES
case QEvent::TouchBegin:
case QEvent::TouchEnd:
case QEvent::TouchUpdate:
touchEvent(static_cast<QTouchEvent*>(e));
return true;
case QEvent::Gesture:
return gestureEvent(static_cast<QGestureEvent*>(e));
#endif
#ifdef USE_QWINDOW
case QEvent::UpdateRequest:
paintGL();
return true;
#endif
default:
return QGLWindow::event(e);
}
}
bool MainView::event( QEvent *event )
{
switch (event->type())
{
case QEvent::KeyPress :
{
QKeyEvent *k = (QKeyEvent *)event;
keyPressEvent(k);
if (k->key() == Qt::Key_Backtab || k->key() == Qt::Key_Tab ) event->accept();
return true;
}
break;
case QEvent::KeyRelease :
{
QKeyEvent *k = (QKeyEvent *)event;
keyReleaseEvent(k);
if (k->key() == Qt::Key_Backtab || k->key() == Qt::Key_Tab ) event->accept();
return true;
}
break;
default: return View::event( event );
}
}
bool GLWidget::eventFilter(QObject*, QEvent* event) {
switch (event->type()) {
case QEvent::KeyPress:
case QEvent::KeyRelease:
case QEvent::ShortcutOverride:
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->key() == Qt::Key_Alt || keyEvent->key() == Qt::Key_Meta) {
if (event->type() == QEvent::KeyPress) {
keyPressEvent(keyEvent);
} else if (event->type() == QEvent::KeyRelease) {
keyReleaseEvent(keyEvent);
} else {
QGLWidget::event(event);
}
return true;
}
}
default:
break;
}
return false;
}
void DhQGLWidget::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void Sdl2Application::mainLoop() {
#ifndef CORRADE_TARGET_EMSCRIPTEN
const UnsignedInt timeBefore = _minimalLoopPeriod ? SDL_GetTicks() : 0;
#endif
SDL_Event event;
while(SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_WINDOWEVENT:
switch(event.window.event) {
case SDL_WINDOWEVENT_RESIZED: {
#ifndef CORRADE_TARGET_IOS
viewportEvent({event.window.data1, event.window.data2});
#else
/* On iOS the window event is in points and not pixels,
but we need pixels to call glViewport() properly */
Vector2i drawableSize;
SDL_GL_GetDrawableSize(_window, &drawableSize.x(), &drawableSize.y());
viewportEvent(drawableSize);
#endif
_flags |= Flag::Redraw;
} break;
case SDL_WINDOWEVENT_EXPOSED:
_flags |= Flag::Redraw;
break;
} break;
case SDL_KEYDOWN:
case SDL_KEYUP: {
KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), fixedModifiers(event.key.keysym.mod));
event.type == SDL_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
} break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP: {
MouseEvent e(static_cast<MouseEvent::Button>(event.button.button), {event.button.x, event.button.y});
event.type == SDL_MOUSEBUTTONDOWN ? mousePressEvent(e) : mouseReleaseEvent(e);
} break;
case SDL_MOUSEWHEEL:
if(event.wheel.y != 0) {
MouseEvent e(event.wheel.y > 0 ? MouseEvent::Button::WheelUp : MouseEvent::Button::WheelDown, {event.wheel.x, event.wheel.y});
mousePressEvent(e);
} break;
case SDL_MOUSEMOTION: {
MouseMoveEvent e({event.motion.x, event.motion.y}, {event.motion.xrel, event.motion.yrel}, static_cast<MouseMoveEvent::Button>(event.motion.state));
mouseMoveEvent(e);
break;
}
case SDL_QUIT:
#ifndef CORRADE_TARGET_EMSCRIPTEN
_flags |= Flag::Exit;
#else
emscripten_cancel_main_loop();
#endif
return;
}
}
/* Tick event */
if(!(_flags & Flag::NoTickEvent)) tickEvent();
/* Draw event */
if(_flags & Flag::Redraw) {
_flags &= ~Flag::Redraw;
drawEvent();
#ifndef CORRADE_TARGET_EMSCRIPTEN
/* If VSync is not enabled, delay to prevent CPU hogging (if set) */
if(!(_flags & Flag::VSyncEnabled) && _minimalLoopPeriod) {
const UnsignedInt loopTime = SDL_GetTicks() - timeBefore;
if(loopTime < _minimalLoopPeriod)
SDL_Delay(_minimalLoopPeriod - loopTime);
}
#endif
return;
}
#ifndef CORRADE_TARGET_EMSCRIPTEN
/* If not drawing anything, delay to prevent CPU hogging (if set) */
if(_minimalLoopPeriod) {
const UnsignedInt loopTime = SDL_GetTicks() - timeBefore;
if(loopTime < _minimalLoopPeriod)
SDL_Delay(_minimalLoopPeriod - loopTime);
}
/* Then, if the tick event doesn't need to be called periodically, wait
indefinitely for next input event */
if(_flags & Flag::NoTickEvent) SDL_WaitEvent(nullptr);
#endif
}
bool QDeclarativeViewInspector::eventFilter(QObject *obj, QEvent *event)
{
if (obj == data->view) {
// Event from view
if (event->type() == QEvent::ChildRemoved) {
// Might mean that viewport has changed
if (data->view->viewport() != data->viewport.data())
data->setViewport(data->view->viewport());
}
return QObject::eventFilter(obj, event);
}
// Event from viewport
switch (event->type()) {
case QEvent::Leave: {
if (leaveEvent(event))
return true;
break;
}
case QEvent::MouseButtonPress: {
if (mousePressEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
}
case QEvent::MouseMove: {
if (mouseMoveEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
}
case QEvent::MouseButtonRelease: {
if (mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
}
case QEvent::KeyPress: {
if (keyPressEvent(static_cast<QKeyEvent*>(event)))
return true;
break;
}
case QEvent::KeyRelease: {
if (keyReleaseEvent(static_cast<QKeyEvent*>(event)))
return true;
break;
}
case QEvent::MouseButtonDblClick: {
if (mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
}
case QEvent::Wheel: {
if (wheelEvent(static_cast<QWheelEvent*>(event)))
return true;
break;
}
default: {
break;
}
} //switch
// standard event processing
return QObject::eventFilter(obj, event);
}
void DhQPushButton::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void DhQGroupBox::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void DhQAbstractSpinBox::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void DhQSlider::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void DhQGraphicsItemGroup::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void WindowEventHandler::handleEvent(WindowEvent & event)
{
if (!event.window())
return;
switch (event.type())
{
case WindowEvent::Resize:
resizeEvent(static_cast<ResizeEvent&>(event));
break;
case WindowEvent::FrameBufferResize:
framebufferResizeEvent(static_cast<ResizeEvent&>(event));
break;
case WindowEvent::Move:
moveEvent(static_cast<MoveEvent&>(event));
break;
case WindowEvent::Paint:
paintEvent(static_cast<PaintEvent&>(event));
break;
case WindowEvent::KeyPress:
keyPressEvent(static_cast<KeyEvent&>(event));
break;
case WindowEvent::KeyRelease:
keyReleaseEvent(static_cast<KeyEvent&>(event));
break;
case WindowEvent::MousePress:
mousePressEvent(static_cast<MouseEvent&>(event));
break;
case WindowEvent::MouseRelease:
mouseReleaseEvent(static_cast<MouseEvent&>(event));
break;
case WindowEvent::MouseMove:
mouseMoveEvent(static_cast<MouseEvent&>(event));
break;
case WindowEvent::MouseEnter:
break;
case WindowEvent::MouseLeave:
break;
case WindowEvent::Scroll:
scrollEvent(static_cast<ScrollEvent&>(event));
break;
case WindowEvent::Focus:
focusEvent(static_cast<FocusEvent&>(event));
break;
case WindowEvent::Iconify:
iconifyEvent(static_cast<IconifyEvent&>(event));
break;
case WindowEvent::Timer:
timerEvent(static_cast<TimerEvent&>(event));
break;
default:
break;
}
}
void DhQGraphicsEllipseItem::DvhkeyReleaseEvent(QKeyEvent* x1) {
return keyReleaseEvent(x1);
}
void MyTextBrowser::moveContent(int pos)
{
if(pos >= '\t' || pos < 0)
{
activateWindow();
char text[16];
text[0] = pos & 0x0ff;
text[1] = '\0';
int modifiers = pos & 0x07fffff00;
int key = pos & 0x0ff;
if ((pos & 0x0ff) == '\t') key = Qt::Key_Tab;
else if((pos & 0x0ff) == 0x0d) key = Qt::Key_Return;
QKeyEvent pressEvent( QEvent::KeyPress, (Qt::Key) key, (Qt::KeyboardModifiers) modifiers, text);
QKeyEvent releaseEvent(QEvent::KeyRelease, (Qt::Key) key, (Qt::KeyboardModifiers) modifiers, text);
if((pos & 0x0ff) == '\t') QWidget::setFocus(Qt::TabFocusReason);
keyPressEvent(&pressEvent);
keyReleaseEvent(&releaseEvent);
return;
}
#ifdef NO_WEBKIT
char buf[MAX_PRINTF_LENGTH];
QString myurl;
if(opt.arg_debug) printf("moveContent(%d)\n", pos);
if (pos == 0 && homeIsSet)
{
myurl = home;
setSource(QUrl(home));
}
else if(pos == 1)
{
forward();
myurl = source().path();
}
else if(pos == 2)
{
backward();
myurl = source().path();
}
else if(pos == 3)
{
reload();
myurl = source().path();
}
#else
char buf[MAX_PRINTF_LENGTH];
QString myurl;
QWebHistory *hist;
if(opt.arg_debug) printf("moveContent(%d)\n", pos);
if (pos == 0 && homeIsSet)
{
myurl = home;
load(home);
}
else if(pos == 1)
{
hist = history();
if(hist != NULL && hist->canGoForward()) myurl = hist->forwardItem().url().toString();
forward();
}
else if(pos == 2)
{
hist = history();
if(hist != NULL && hist->canGoBack()) myurl = hist->backItem().url().toString();
back();
}
else if(pos == 3)
{
hist = history();
if(hist != NULL) myurl = hist->currentItem().url().toString();
reload();
}
#endif
if(myurl.isEmpty()) return;
if(opt.arg_debug) printf("moveContent(%s)\n", (const char *) myurl.toUtf8());
if(myurl.length()+40 > MAX_PRINTF_LENGTH) return;
sprintf(buf,"text(%d,\"%s\")\n", id,decode(myurl));
tcp_send(s,buf,strlen(buf));
}
