void text_display::paint_selection(QPainter &painter, selection &selection_area, const QColor &color)
{
if(focusPolicy() == Qt::NoFocus){
return; //Anything which doesn't accept focus can't be highlighted
}
QPoint position1 = clip_screen(nibble_to_screen(selection_area.get_start_aligned()));
QPoint position2 = clip_screen(nibble_to_screen(selection_area.get_end_aligned()));
QRegion area = QRect(0, position1.y(), get_line_characters() * editor_font::get_width(),
position2.y() - position1.y() + editor_font::get_height());
if(position1.x()){
area -= QRect(0, position1.y(), position1.x(), editor_font::get_height());
}
if(position2.x() < width()){
area -= QRect(position2.x(), position2.y(),
get_line_characters() * editor_font::get_width() - position2.x(),
editor_font::get_height());
}
if(position2.y() >= get_rows() * editor_font::get_height()){
area -= QRect(0, get_rows() * editor_font::get_height(),
get_line_characters() * editor_font::get_width(), position2.y());
}
painter.setClipRegion(area);
painter.fillRect(0, position1.y(), get_line_characters() * editor_font::get_width(),
position2.y() - position1.y() + editor_font::get_height(), color);
}
void
ComboBox::createMenu()
{
if (!_cascading) {
_rootNode->isMenu->clear();
for (U32 i = 0; i < _rootNode->children.size(); ++i) {
_rootNode->children[i]->isLeaf->setEnabled( _enabled && !_readOnly );
_rootNode->isMenu->addAction(_rootNode->children[i]->isLeaf);
for (U32 j = 0; j < _separators.size(); ++j) {
if (_separators[j] == (int)i) {
_rootNode->isMenu->addSeparator();
break;
}
}
}
} else {
setEnabledRecursive( _enabled && !_readOnly, _rootNode.get() );
}
QAction* triggered = _rootNode->isMenu->exec( this->mapToGlobal( QPoint( 0, height() ) ) );
if (triggered) {
QVariant data = triggered->data();
if ( data.toString() != QString::fromUtf8("New") ) {
setCurrentIndex( data.toInt() );
} else {
Q_EMIT itemNewSelected();
}
}
_clicked = false;
if (focusPolicy() != Qt::NoFocus) {
setFocus();
}
update();
}
void KexiDBImageBox::setDataSource(const QString &ds)
{
KexiFormDataItemInterface::setDataSource(ds);
setData(KexiBLOBBuffer::Handle());
updateActionStrings();
KexiFrame::setFocusPolicy(focusPolicy()); //set modified policy
if (m_chooser) {
m_chooser->setEnabled(popupMenuAvailable());
if (m_dropDownButtonVisible && popupMenuAvailable()) {
m_chooser->show();
} else {
m_chooser->hide();
}
}
// update some properties not changed by user
// //! @todo get default line width from global style settings
// if (!m_lineWidthChanged) {
// KexiFrame::setLineWidth(ds.isEmpty() ? 0 : 1);
// }
if (!m_paletteBackgroundColorChanged && parentWidget()) {
KexiFrame::setPaletteBackgroundColor(
dataSource().isEmpty() ? parentWidget()->paletteBackgroundColor() : palette().active().base());
}
}
void LineEditWidget::activate(Qt::FocusReason reason)
{
if (!hasFocus() && isEnabled() && focusPolicy() != Qt::NoFocus)
{
setFocus(reason);
return;
}
if (!text().trimmed().isEmpty())
{
if (m_shouldSelectAllOnFocus && reason == Qt::MouseFocusReason)
{
m_shouldSelectAllOnRelease = true;
connect(this, SIGNAL(selectionChanged()), this, SLOT(clearSelectAllOnRelease()));
return;
}
if (m_shouldSelectAllOnFocus && (reason == Qt::ShortcutFocusReason || reason == Qt::TabFocusReason || reason == Qt::BacktabFocusReason))
{
QTimer::singleShot(0, this, SLOT(selectAll()));
}
else if (reason != Qt::PopupFocusReason)
{
deselect();
}
}
}
QT_BEGIN_NAMESPACE
HintLineEdit::HintLineEdit(QWidget *parent) :
QLineEdit(parent),
m_defaultFocusPolicy(focusPolicy()),
m_refuseFocus(false)
{
}
HintLineEdit::HintLineEdit(QWidget *parent) :
QLineEdit(parent),
m_defaultFocusPolicy(focusPolicy()),
m_hintColor(QColor(0xbbbbbb)),
m_refuseFocus(false),
m_showingHintText(false)
{
}
void KexiDBDateEdit::setInvalidState( const QString& )
{
setEnabled(false);
setReadOnly(true);
m_invalidState = true;
//! @todo move this to KexiDataItemInterface::setInvalidStateInternal() ?
if (focusPolicy() & TabFocus)
setFocusPolicy(QWidget::ClickFocus);
}
/*! \reimp
*/
void QGroupBox::focusInEvent(QFocusEvent *fe)
{ // note no call to super
Q_D(QGroupBox);
if (focusPolicy() == Qt::NoFocus) {
d->_q_fixFocus(fe->reason());
} else {
QWidget::focusInEvent(fe);
}
}
void KexiDBDateTimeEdit::setInvalidState(const QString & /*! @todo paint this text: text*/)
{
setEnabled(false);
setReadOnly(true);
m_invalidState = true;
//! @todo move this to KexiDataItemInterface::setInvalidStateInternal() ?
if (focusPolicy() & Qt::TabFocus)
setFocusPolicy(Qt::ClickFocus);
}
void KexiDBCheckBox::setInvalidState(const QString& displayText)
{
setEnabled(false);
setCheckState(Qt::PartiallyChecked);
m_invalidState = true;
//! @todo move this to KexiDataItemInterface::setInvalidStateInternal() ?
if (focusPolicy() & Qt::TabFocus)
setFocusPolicy(Qt::ClickFocus);
setText(displayText);
}
void KexiDBCheckBox::setInvalidState( const QString& displayText )
{
setEnabled(false);
setState(NoChange);
m_invalidState = true;
//! @todo move this to KexiDataItemInterface::setInvalidStateInternal() ?
if (focusPolicy() & TabFocus)
setFocusPolicy(QWidget::ClickFocus);
setText(displayText);
}
void KexiDBDatePicker::setInvalidState(const QString& displayText)
{
Q_UNUSED(displayText);
m_invalidState = true;
setEnabled(false);
setReadOnly(true);
//! @todo move this to KexiDataItemInterface::setInvalidStateInternal() ?
if (focusPolicy() & Qt::TabFocus)
setFocusPolicy(Qt::ClickFocus);
KDatePicker::setDate(QDate());
}
/*! \reimp
*/
void QGroupBox::focusInEvent(QFocusEvent *fe)
{ // note no call to super
Q_D(QGroupBox);
if (focusPolicy() == Qt::NoFocus) {
d->_q_fixFocus(fe->reason());
} else {
QStyleOptionGroupBox box;
initStyleOption(&box);
QRect rect = style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxCheckBox, this)
| style()->subControlRect(QStyle::CC_GroupBox, &box, QStyle::SC_GroupBoxLabel, this);
update(rect);
}
}
/*!
Performs an animated click: the button is pressed immediately, and
released \a msec milliseconds later (the default is 100 ms).
Calling this function again before the button was released will reset
the release timer.
All signals associated with a click are emitted as appropriate.
This function does nothing if the button is \link setEnabled()
disabled. \endlink
\sa click()
*/
void QAbstractButton::animateClick(int msec)
{
if (!isEnabled())
return;
Q_D(QAbstractButton);
if (d->checkable && focusPolicy() & Qt::ClickFocus)
setFocus();
setDown(true);
repaint(); //flush paint event before invoking potentially expensive operation
QApplication::flush();
if (!d->animateTimer.isActive())
d->emitPressed();
d->animateTimer.start(msec, this);
}
void text_display::mousePressEvent(QMouseEvent *event)
{
if(event->button() == Qt::RightButton || focusPolicy() == Qt::NoFocus){
return;
}
int nibble = screen_to_nibble(clip_mouse(event->x(), event->y()));
set_cursor_nibble(nibble);
selection selection_area = get_selection();
selection_area.set_start(nibble);
selection_area.set_active(false);
selection_area.set_dragging(false);
set_selection(selection_area);
}
boost::optional<bool>
MainWindow::filterWheelEventForStrongFocus(QObject *watched,
QEvent *event) {
if (event->type() != QEvent::Wheel)
return {};
auto widget = qobject_cast<QWidget *>(watched);
if ( !widget
|| widget->hasFocus()
|| (widget->focusPolicy() != Qt::StrongFocus))
return {};
event->ignore();
return true;
}
void FormatTextEdit::setEditable(bool editable)
{
// save default frame style
static int framed = frameStyle();
static Qt::FocusPolicy defaultFocus = focusPolicy();
if (editable) {
setFrameStyle(framed);
setFocusPolicy(defaultFocus);
} else {
setFrameStyle(QFrame::NoFrame | QFrame::Plain);
setFocusPolicy(Qt::NoFocus);
}
setReadOnly(!editable);
}
/*! \reimp */
bool QAbstractButton::event(QEvent *e)
{
// as opposed to other widgets, disabled buttons accept mouse
// events. This avoids surprising click-through scenarios
if (!isEnabled()) {
switch(e->type()) {
case QEvent::TabletPress:
case QEvent::TabletRelease:
case QEvent::TabletMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove:
case QEvent::HoverMove:
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::ContextMenu:
#ifndef QT_NO_WHEELEVENT
case QEvent::Wheel:
#endif
return true;
default:
break;
}
}
#ifndef QT_NO_SHORTCUT
if (e->type() == QEvent::Shortcut) {
Q_D(QAbstractButton);
QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
if (d->shortcutId != se->shortcutId())
return false;
if (!se->isAmbiguous()) {
if (!d->animateTimer.isActive())
animateClick();
} else {
if (focusPolicy() != Qt::NoFocus)
setFocus(Qt::ShortcutFocusReason);
window()->setAttribute(Qt::WA_KeyboardFocusChange);
}
return true;
}
#endif
return QWidget::event(e);
}
void text_display::mouseReleaseEvent(QMouseEvent *event)
{
if(focusPolicy() == Qt::NoFocus){
return;
}
int nibble = screen_to_nibble(clip_mouse(event->x(), event->y()));
set_cursor_nibble(nibble);
selection selection_area = get_selection();
if(selection_area.is_active()){
selection_area.set_end(nibble);
selection_area.set_dragging(false);
set_selection(selection_area);
}
if(scroll_timer_id){
killTimer(scroll_timer_id);
scroll_timer_id = 0;
}
}
void text_display::mouseMoveEvent(QMouseEvent *event)
{
if(focusPolicy() == Qt::NoFocus){
return;
}
int nibble = screen_to_nibble(clip_mouse(event->x(), event->y()));
set_cursor_nibble(nibble);
selection selection_area = get_selection();
if(!scroll_timer_id){
selection_area.set_end(nibble);
}
selection_area.set_dragging(true);
set_selection(selection_area);
if((event->y() > height() || event->y() < 0) && !scroll_timer_id){
scroll_timer_id = startTimer(scroll_timer_speed);
scroll_direction = event->y() > 0 ? 1 : -1;
}else if(!(event->y() > height() || event->y() < 0) && scroll_timer_id){
killTimer(scroll_timer_id);
scroll_timer_id = 0;
}
}
void text_display::paintEvent(QPaintEvent *event)
{
int offset = get_offset();
int end_offset = get_rows() * get_columns() + offset;
QPainter painter(this);
QColor text = palette().color(QPalette::WindowText);
painter.setPen(text);
painter.setFont(editor_font::get_font());
painter.setClipping(true);
const bookmark_map *bookmarks = buffer->get_bookmark_map();
if(bookmarks){
for(const auto &bookmark : *bookmarks){
selection bookmark_selection = selection::create_selection(
buffer->snes_to_pc(bookmark.address), bookmark.size);
//non-sequential just skip
if(bookmark_selection.get_end_byte() < offset ||
bookmark_selection.get_start_byte() > end_offset){
continue;
}
paint_selection(painter, bookmark_selection, bookmark.color);
}
}
if(editor->is_comparing()){
auto diffs = editor->get_diff();
for(auto &diff : *diffs){
if(diff.get_end_byte() < offset){
continue;
}else if(diff.get_start_byte() > end_offset){ //sequential, break early
break;
}
paint_selection(painter, diff, diff_color);
}
}
selection selection_area = get_selection();
selection_color.setAlpha(170);
if(selection_area.is_active()){
paint_selection(painter, selection_area, selection_color);
}
painter.setClipRegion(event->region());
if(!selection_area.is_active()){
painter.setClipping(false);
QPoint cursor_position = nibble_to_screen(get_cursor_nibble());
if(cursor_state && focusPolicy() != Qt::NoFocus){
painter.fillRect(cursor_position.x(), cursor_position.y(),
cursor_width, editor_font::get_height(), text);
}
QRect active_line(0, cursor_position.y(),
get_line_characters() * editor_font::get_width(), editor_font::get_height());
painter.fillRect(active_line, selection_color);
}
for(int i = offset, row = 0; i < end_offset; i += get_columns(), row++){
int real_row = i / get_columns();
if(!row_cache.contains(real_row)){
int line_end = i + get_columns();
if(line_end > buffer->size()){
line_end = buffer->size();
}
QString line;
QTextStream string_stream(&line);
get_line(i, line_end, string_stream);
QStaticText *text = new QStaticText(line);
text->setTextFormat(Qt::PlainText);
row_cache.insert(real_row, text);
}
if(row * editor_font::get_height() >= event->rect().y()){
painter.drawStaticText(0, row * editor_font::get_height(), *row_cache.object(real_row));
}
}
}
void QWidget::reparentSys( QWidget *parent, WFlags f, const QPoint &p,
bool showIt )
{
QWidget* oldtlw = topLevelWidget();
#ifndef QT_NO_CURSOR
QCursor oldcurs;
bool setcurs=testWState(WState_OwnCursor);
if ( setcurs ) {
oldcurs = cursor();
unsetCursor();
}
#endif
WId old_winid = winid;
if ( testWFlags(WType_Desktop) )
old_winid = 0;
if ( !isTopLevel() && parentWidget() && parentWidget()->testWState(WState_Created) )
hideWindow();
setWinId( 0 );
if ( parentObj != parent ) {
QWidget *oldparent = parentWidget();
if ( oldparent ) { // remove from parent
oldparent->removeChild( this );
oldparent->setChildrenAllocatedDirty();
oldparent->paintable_region_dirty = TRUE;
}
if ( parent ) { // insert into new parent
parent->insertChild( this );
parent->setChildrenAllocatedDirty();
parent->paintable_region_dirty = TRUE;
}
}
bool enable = isEnabled(); // remember status
FocusPolicy fp = focusPolicy();
QSize s = size();
//QPixmap *bgp = (QPixmap *)backgroundPixmap();
//QColor bgc = bg_col; // save colors
#ifndef QT_NO_WIDGET_TOPEXTRA
QString capt= caption();
#endif
widget_flags = f;
clearWState( WState_Created | WState_Visible | WState_ForceHide );
create();
if ( isTopLevel() || (!parent || parent->isVisible() ) )
setWState( WState_ForceHide ); // new widgets do not show up in already visible parents
/*
if ( bgp )
XSetWindowBackgroundPixmap( dpy, winid, bgp->handle() );
else
XSetWindowBackground( dpy, winid, bgc.pixel() );
*/
setGeometry( p.x(), p.y(), s.width(), s.height() );
setEnabled( enable );
setFocusPolicy( fp );
#ifndef QT_NO_WIDGET_TOPEXTRA
if ( !capt.isNull() ) {
extra->topextra->caption = QString::null;
setCaption( capt );
}
#endif
if ( showIt )
show();
if ( (int)old_winid > 0 )
qwsDisplay()->destroyRegion( old_winid );
#ifndef QT_NO_CURSOR
if ( setcurs ) {
setCursor(oldcurs);
}
#endif
reparentFocusWidgets( oldtlw ); // fix focus chains
}
CheckBox::CheckBox(const QString& text, QWidget* parent)
: QCheckBox(text, parent),
mFocusPolicy(focusPolicy()),
mFocusWidget(0),
mReadOnly(false)
{ }
CheckBox::CheckBox(QWidget* parent)
: QCheckBox(parent),
mFocusPolicy(focusPolicy()),
mFocusWidget(0),
mReadOnly(false)
{ }
bool SelectableEntry::isEnabled() {
return focusPolicy() == Qt::TabFocus;
}
int QWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 23)
qt_static_metacall(this, _c, _id, _a);
_id -= 23;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< bool*>(_v) = isModal(); break;
case 1: *reinterpret_cast< Qt::WindowModality*>(_v) = windowModality(); break;
case 2: *reinterpret_cast< bool*>(_v) = isEnabled(); break;
case 3: *reinterpret_cast< QRect*>(_v) = geometry(); break;
case 4: *reinterpret_cast< QRect*>(_v) = frameGeometry(); break;
case 5: *reinterpret_cast< QRect*>(_v) = normalGeometry(); break;
case 6: *reinterpret_cast< int*>(_v) = x(); break;
case 7: *reinterpret_cast< int*>(_v) = y(); break;
case 8: *reinterpret_cast< QPoint*>(_v) = pos(); break;
case 9: *reinterpret_cast< QSize*>(_v) = frameSize(); break;
case 10: *reinterpret_cast< QSize*>(_v) = size(); break;
case 11: *reinterpret_cast< int*>(_v) = width(); break;
case 12: *reinterpret_cast< int*>(_v) = height(); break;
case 13: *reinterpret_cast< QRect*>(_v) = rect(); break;
case 14: *reinterpret_cast< QRect*>(_v) = childrenRect(); break;
case 15: *reinterpret_cast< QRegion*>(_v) = childrenRegion(); break;
case 16: *reinterpret_cast< QSizePolicy*>(_v) = sizePolicy(); break;
case 17: *reinterpret_cast< QSize*>(_v) = minimumSize(); break;
case 18: *reinterpret_cast< QSize*>(_v) = maximumSize(); break;
case 19: *reinterpret_cast< int*>(_v) = minimumWidth(); break;
case 20: *reinterpret_cast< int*>(_v) = minimumHeight(); break;
case 21: *reinterpret_cast< int*>(_v) = maximumWidth(); break;
case 22: *reinterpret_cast< int*>(_v) = maximumHeight(); break;
case 23: *reinterpret_cast< QSize*>(_v) = sizeIncrement(); break;
case 24: *reinterpret_cast< QSize*>(_v) = baseSize(); break;
case 25: *reinterpret_cast< QPalette*>(_v) = palette(); break;
case 26: *reinterpret_cast< QFont*>(_v) = font(); break;
case 27: *reinterpret_cast< QCursor*>(_v) = cursor(); break;
case 28: *reinterpret_cast< bool*>(_v) = hasMouseTracking(); break;
case 29: *reinterpret_cast< bool*>(_v) = isActiveWindow(); break;
case 30: *reinterpret_cast< Qt::FocusPolicy*>(_v) = focusPolicy(); break;
case 31: *reinterpret_cast< bool*>(_v) = hasFocus(); break;
case 32: *reinterpret_cast< Qt::ContextMenuPolicy*>(_v) = contextMenuPolicy(); break;
case 33: *reinterpret_cast< bool*>(_v) = updatesEnabled(); break;
case 34: *reinterpret_cast< bool*>(_v) = isVisible(); break;
case 35: *reinterpret_cast< bool*>(_v) = isMinimized(); break;
case 36: *reinterpret_cast< bool*>(_v) = isMaximized(); break;
case 37: *reinterpret_cast< bool*>(_v) = isFullScreen(); break;
case 38: *reinterpret_cast< QSize*>(_v) = sizeHint(); break;
case 39: *reinterpret_cast< QSize*>(_v) = minimumSizeHint(); break;
case 40: *reinterpret_cast< bool*>(_v) = acceptDrops(); break;
case 41: *reinterpret_cast< QString*>(_v) = windowTitle(); break;
case 42: *reinterpret_cast< QIcon*>(_v) = windowIcon(); break;
case 43: *reinterpret_cast< QString*>(_v) = windowIconText(); break;
case 44: *reinterpret_cast< double*>(_v) = windowOpacity(); break;
case 45: *reinterpret_cast< bool*>(_v) = isWindowModified(); break;
case 46: *reinterpret_cast< QString*>(_v) = toolTip(); break;
case 47: *reinterpret_cast< QString*>(_v) = statusTip(); break;
case 48: *reinterpret_cast< QString*>(_v) = whatsThis(); break;
case 49: *reinterpret_cast< QString*>(_v) = accessibleName(); break;
case 50: *reinterpret_cast< QString*>(_v) = accessibleDescription(); break;
case 51: *reinterpret_cast< Qt::LayoutDirection*>(_v) = layoutDirection(); break;
case 52: *reinterpret_cast< bool*>(_v) = autoFillBackground(); break;
case 53: *reinterpret_cast< QString*>(_v) = styleSheet(); break;
case 54: *reinterpret_cast< QLocale*>(_v) = locale(); break;
case 55: *reinterpret_cast< QString*>(_v) = windowFilePath(); break;
case 56: *reinterpret_cast< Qt::InputMethodHints*>(_v) = inputMethodHints(); break;
}
_id -= 57;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 1: setWindowModality(*reinterpret_cast< Qt::WindowModality*>(_v)); break;
case 2: setEnabled(*reinterpret_cast< bool*>(_v)); break;
case 3: setGeometry(*reinterpret_cast< QRect*>(_v)); break;
case 8: move(*reinterpret_cast< QPoint*>(_v)); break;
case 10: resize(*reinterpret_cast< QSize*>(_v)); break;
case 16: setSizePolicy(*reinterpret_cast< QSizePolicy*>(_v)); break;
case 17: setMinimumSize(*reinterpret_cast< QSize*>(_v)); break;
case 18: setMaximumSize(*reinterpret_cast< QSize*>(_v)); break;
case 19: setMinimumWidth(*reinterpret_cast< int*>(_v)); break;
case 20: setMinimumHeight(*reinterpret_cast< int*>(_v)); break;
case 21: setMaximumWidth(*reinterpret_cast< int*>(_v)); break;
case 22: setMaximumHeight(*reinterpret_cast< int*>(_v)); break;
case 23: setSizeIncrement(*reinterpret_cast< QSize*>(_v)); break;
case 24: setBaseSize(*reinterpret_cast< QSize*>(_v)); break;
case 25: setPalette(*reinterpret_cast< QPalette*>(_v)); break;
case 26: setFont(*reinterpret_cast< QFont*>(_v)); break;
case 27: setCursor(*reinterpret_cast< QCursor*>(_v)); break;
case 28: setMouseTracking(*reinterpret_cast< bool*>(_v)); break;
case 30: setFocusPolicy(*reinterpret_cast< Qt::FocusPolicy*>(_v)); break;
case 32: setContextMenuPolicy(*reinterpret_cast< Qt::ContextMenuPolicy*>(_v)); break;
case 33: setUpdatesEnabled(*reinterpret_cast< bool*>(_v)); break;
case 34: setVisible(*reinterpret_cast< bool*>(_v)); break;
case 40: setAcceptDrops(*reinterpret_cast< bool*>(_v)); break;
case 41: setWindowTitle(*reinterpret_cast< QString*>(_v)); break;
case 42: setWindowIcon(*reinterpret_cast< QIcon*>(_v)); break;
case 43: setWindowIconText(*reinterpret_cast< QString*>(_v)); break;
case 44: setWindowOpacity(*reinterpret_cast< double*>(_v)); break;
case 45: setWindowModified(*reinterpret_cast< bool*>(_v)); break;
case 46: setToolTip(*reinterpret_cast< QString*>(_v)); break;
case 47: setStatusTip(*reinterpret_cast< QString*>(_v)); break;
case 48: setWhatsThis(*reinterpret_cast< QString*>(_v)); break;
case 49: setAccessibleName(*reinterpret_cast< QString*>(_v)); break;
case 50: setAccessibleDescription(*reinterpret_cast< QString*>(_v)); break;
case 51: setLayoutDirection(*reinterpret_cast< Qt::LayoutDirection*>(_v)); break;
case 52: setAutoFillBackground(*reinterpret_cast< bool*>(_v)); break;
case 53: setStyleSheet(*reinterpret_cast< QString*>(_v)); break;
case 54: setLocale(*reinterpret_cast< QLocale*>(_v)); break;
case 55: setWindowFilePath(*reinterpret_cast< QString*>(_v)); break;
case 56: setInputMethodHints(*reinterpret_cast< Qt::InputMethodHints*>(_v)); break;
}
_id -= 57;
} else if (_c == QMetaObject::ResetProperty) {
switch (_id) {
case 27: unsetCursor(); break;
case 51: unsetLayoutDirection(); break;
case 54: unsetLocale(); break;
}
_id -= 57;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
bool *_b = reinterpret_cast<bool*>(_a[0]);
switch (_id) {
case 41: *_b = isWindow(); break;
case 42: *_b = isWindow(); break;
case 43: *_b = isWindow(); break;
case 44: *_b = isWindow(); break;
case 45: *_b = isWindow(); break;
case 55: *_b = isWindow(); break;
}
_id -= 57;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 57;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 57;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 57;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 57;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void
KexiDBAutoField::createEditor()
{
if (subwidget()) {
delete(QWidget *)subwidget();
}
QWidget *newSubwidget;
//kDebug() << "widgetType:" << d->widgetType;
switch (d->widgetType) {
case Text:
case Double: //! @todo setup validator
case Integer: //! @todo setup validator
case Date:
case Time:
case DateTime: {
KexiDBLineEdit *le = new KexiDBLineEdit(this);
newSubwidget = le;
le->setFrame(false);
break;
}
case MultiLineText:
newSubwidget = new KexiDBTextEdit(this);
break;
case Boolean:
newSubwidget = new KexiDBCheckBox(dataSource(), this);
break;
case Image:
newSubwidget = new KexiDBImageBox(designMode(), this);
break;
case ComboBox: {
KexiDBComboBox *cbox = new KexiDBComboBox(this);
newSubwidget = cbox;
cbox->setDesignMode(designMode());
break;
}
default:
newSubwidget = 0;
changeText(d->caption);
break;
}
//kDebug() << newSubwidget;
setSubwidget(newSubwidget); //this will also allow to declare subproperties, see KFormDesigner::WidgetWithSubpropertiesInterface
if (newSubwidget) {
newSubwidget->setObjectName(
QString::fromLatin1("KexiDBAutoField_") + newSubwidget->metaObject()->className());
dynamic_cast<KexiDataItemInterface*>(newSubwidget)->setParentDataItemInterface(this);
dynamic_cast<KexiFormDataItemInterface*>(newSubwidget)
->setColumnInfo(columnInfo()); //needed at least by KexiDBImageBox
dynamic_cast<KexiFormDataItemInterface*>(newSubwidget)
->setVisibleColumnInfo(visibleColumnInfo()); //needed at least by KexiDBComboBox
newSubwidget->setProperty("dataSource", dataSource()); //needed at least by KexiDBImageBox
KFormDesigner::DesignTimeDynamicChildWidgetHandler::childWidgetAdded(this);
newSubwidget->show();
d->label->setBuddy(newSubwidget);
if (d->focusPolicyChanged) {//if focusPolicy is changed at top level, editor inherits it
newSubwidget->setFocusPolicy(focusPolicy());
} else {//if focusPolicy is not changed at top level, inherit it from editor
QWidget::setFocusPolicy(newSubwidget->focusPolicy());
}
setFocusProxy(newSubwidget); //ok?
if (parentWidget())
newSubwidget->setPalette(qApp->palette());
copyPropertiesToEditor();
}
setLabelPosition(labelPosition());
}
explicit WidgetBoxFilterLineEdit(QWidget *parent = 0) : QLineEdit(parent), m_defaultFocusPolicy(focusPolicy())
{ setFocusPolicy(Qt::NoFocus); }
void KexiDBImageBox::setFocusPolicy(Qt::FocusPolicy policy)
{
m_focusPolicyInternal = policy;
KexiFrame::setFocusPolicy(focusPolicy()); //set modified policy
}
