bool QSparqlResult::previous()
{
if (hasFeature(ForwardOnly)) {
return false;
}
bool b = false;
switch (pos()) {
case QSparql::BeforeFirstRow:
return false;
case QSparql::AfterLastRow:
// Special case: empty results
if (size() == 0) {
d->idx = QSparql::BeforeFirstRow;
return false;
}
b = last();
return b;
case 0:
d->idx = QSparql::BeforeFirstRow;
return false;
default:
return setPos(pos() - 1);
}
}
QStringList SysAsus::featureArgs(const QString &id)
{
QStringList ret;
if (id == LAPSUS_FEAT_BACKLIGHT_ID)
{
if (_maxBacklight > 0)
{
ret.append(QString("0:%1").arg(QString::number(_maxBacklight)));
}
}
else if (id == LAPSUS_FEAT_LIGHT_SENSOR_LEVEL_ID)
{
if (_maxLightSensor > 0)
{
ret.append(QString("0:%1").arg(QString::number(_maxLightSensor)));
}
}
else if (hasFeature(id) || isDisplayFeature(id))
{
ret.append(LAPSUS_FEAT_ON);
ret.append(LAPSUS_FEAT_OFF);
}
return ret;
}
void QDockWidgetPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)
{
Q_Q(QDockWidget);
if (!floating && parent) {
QMainWindowLayout *mwlayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget()));
if (mwlayout && mwlayout->dockWidgetArea(q) == Qt::NoDockWidgetArea)
return; // this dockwidget can't be redocked
}
bool wasFloating = q->isFloating();
bool hidden = q->isHidden();
if (q->isVisible())
q->hide();
Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;
QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
const bool nativeDeco = dwLayout->nativeWindowDeco(floating);
if (nativeDeco) {
flags |= Qt::CustomizeWindowHint | Qt::WindowTitleHint;
if (hasFeature(this, QDockWidget::DockWidgetClosable))
flags |= Qt::WindowCloseButtonHint;
} else {
flags |= Qt::FramelessWindowHint;
}
if (unplug)
flags |= Qt::X11BypassWindowManagerHint;
q->setWindowFlags(flags);
if (!rect.isNull())
q->setGeometry(rect);
updateButtons();
if (!hidden)
q->show();
if (floating != wasFloating) {
emit q->topLevelChanged(floating);
if (!floating && parent) {
QMainWindowLayout *mwlayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget()));
if (mwlayout)
emit q->dockLocationChanged(mwlayout->dockWidgetArea(q));
}
}
if (floating && nativeDeco)
if (const QWindow *window = q->windowHandle())
if (QPlatformWindow *platformWindow = window->handle())
platformWindow->setFrameStrutEventsEnabled(true);
resizer->setActive(QWidgetResizeHandler::Resize, !unplug && floating && !nativeDeco);
}
void QDockWidgetPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)
{
Q_Q(QDockWidget);
if (!floating && parent) {
QMainWindowLayout *mwlayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget()));
if (mwlayout && mwlayout->dockWidgetArea(q) == Qt::NoDockWidgetArea)
return; // this dockwidget can't be redocked
}
bool wasFloating = q->isFloating();
bool hidden = q->isHidden();
if (q->isVisible())
q->hide();
Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;
QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
const bool nativeDeco = dwLayout->nativeWindowDeco(floating);
if (nativeDeco) {
flags |= Qt::CustomizeWindowHint | Qt::WindowTitleHint;
if (hasFeature(this, QDockWidget::DockWidgetClosable))
flags |= Qt::WindowCloseButtonHint;
} else {
flags |= Qt::FramelessWindowHint;
}
if (unplug)
flags |= Qt::X11BypassWindowManagerHint;
q->setWindowFlags(flags);
#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
if (floating && nativeDeco && (q->features() & QDockWidget::DockWidgetVerticalTitleBar)) {
ChangeWindowAttributes(HIViewGetWindow(HIViewRef(q->winId())), kWindowSideTitlebarAttribute, 0);
}
#endif
if (!rect.isNull())
q->setGeometry(rect);
updateButtons();
if (!hidden)
q->show();
if (floating != wasFloating) {
emit q->topLevelChanged(floating);
if (!floating && parent) {
QMainWindowLayout *mwlayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget()));
if (mwlayout)
emit q->dockLocationChanged(mwlayout->dockWidgetArea(q));
}
}
resizer->setActive(QWidgetResizeHandler::Resize, !unplug && floating && !nativeDeco);
}
bool DOMImplementation::hasFeatureForBindings(const String& feature, const String& version)
{
if (!hasFeature(feature, version)) {
UseCounter::count(m_document, UseCounter::DOMImplementationHasFeatureReturnFalse);
return false;
}
return true;
}
void KoDockWidgetTitleBar::paintEvent(QPaintEvent*)
{
QStylePainter p(this);
QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());
int fw = q->isFloating() ? q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q) : 0;
int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, 0, q);
QStyleOptionDockWidgetV2 titleOpt;
titleOpt.initFrom(q);
titleOpt.rect = QRect(QPoint(fw + mw + d->collapseButton->size().width(), fw),
QSize(geometry().width() - (fw * 2) - mw - d->collapseButton->size().width(), geometry().height() - (fw * 2)));
titleOpt.title = q->windowTitle();
titleOpt.closable = hasFeature(q, QDockWidget::DockWidgetClosable);
titleOpt.floatable = hasFeature(q, QDockWidget::DockWidgetFloatable);
p.drawControl(QStyle::CE_DockWidgetTitle, titleOpt);
}
/*!
\fn void QPaintEngine::drawEllipse(const QRectF &rect)
Reimplement this function to draw the largest ellipse that can be
contained within rectangle \a rect.
The default implementation calls drawPolygon().
*/
void QPaintEngine::drawEllipse(const QRectF &rect)
{
QPainterPath path;
path.addEllipse(rect);
if (hasFeature(PainterPaths)) {
drawPath(path);
} else {
QPolygonF polygon = path.toFillPolygon();
drawPolygon(polygon.data(), polygon.size(), ConvexMode);
}
}
/*!
Initialize \a option with the values from this QDockWidget. This method
is useful for subclasses when they need a QStyleOptionDockWidget, but don't want
to fill in all the information themselves.
\sa QStyleOption::initFrom()
*/
void QDockWidget::initStyleOption(QStyleOptionDockWidget *option) const
{
Q_D(const QDockWidget);
if (!option)
return;
QDockWidgetLayout *dwlayout = qobject_cast<QDockWidgetLayout*>(layout());
option->initFrom(this);
option->rect = dwlayout->titleArea();
option->title = d->fixedWindowTitle;
option->closable = hasFeature(this, QDockWidget::DockWidgetClosable);
option->movable = hasFeature(this, QDockWidget::DockWidgetMovable);
option->floatable = hasFeature(this, QDockWidget::DockWidgetFloatable);
QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout*>(layout());
QStyleOptionDockWidgetV2 *v2
= qstyleoption_cast<QStyleOptionDockWidgetV2*>(option);
if (v2 != 0)
v2->verticalTitleBar = l->verticalTitleBar;
}
bool QSparqlResult::last()
{
// With forward-only results, we don't know which row was the last before we
// have iterated to it. So, we cannot jump into the last row.
if (hasFeature(ForwardOnly)) {
return false;
}
int s = size();
if (s < 0)
return false;
return setPos(s - 1);
}
bool BaseTagHDF5::deleteFeature(const string &name_or_id) {
boost::optional<Group> g = feature_group();
bool deleted = false;
if (g && hasFeature(name_or_id)) {
shared_ptr<IFeature> feature = getFeature(name_or_id);
g->removeGroup(feature->id());
deleted = true;
}
return deleted;
}
int filter_features(struct discHdr *list, int cnt, char *feature, bool requiredOnly)
{
int i;
for (i=0; i<cnt;) {
if (!hasFeature(feature, list[i].id)) {
memcpy(list+i, list+i+1, (cnt-i-1) * sizeof(struct discHdr));
cnt--;
} else {
i++;
}
}
return cnt;
}
void QDockWidgetPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)
{
Q_Q(QDockWidget);
bool wasFloating = q->isFloating();
bool hidden = q->isHidden();
if (q->isVisible())
q->hide();
Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;
QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(q->layout());
bool nativeDeco = floating && layout->widget(QDockWidgetLayout::TitleBar) == 0;
#if defined(Q_WS_X11) || defined(Q_WS_QWS)
nativeDeco = false;
#endif
if (nativeDeco) {
flags |= Qt::CustomizeWindowHint | Qt::WindowTitleHint;
if (hasFeature(q, QDockWidget::DockWidgetClosable))
flags |= Qt::WindowSystemMenuHint;
} else {
flags |= Qt::FramelessWindowHint;
}
if (unplug)
flags |= Qt::X11BypassWindowManagerHint;
q->setWindowFlags(flags);
#ifdef Q_WS_MAC
if (floating && nativeDeco && (q->features() & QDockWidget::DockWidgetVerticalTitleBar)) {
ChangeWindowAttributes(HIViewGetWindow(HIViewRef(q->winId())), kWindowSideTitlebarAttribute, 0);
}
#endif
if (!rect.isNull())
q->setGeometry(rect);
updateButtons();
if (!hidden)
q->show();
if (floating != wasFloating)
emit q->topLevelChanged(floating);
resizer->setActive(QWidgetResizeHandler::Resize, !unplug && floating && !nativeDeco);
}
void QDockWidgetPrivate::updateButtons()
{
Q_Q(QDockWidget);
QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
QStyleOptionDockWidget opt;
q->initStyleOption(&opt);
bool customTitleBar = dwLayout->widgetForRole(QDockWidgetLayout::TitleBar) != 0;
bool nativeDeco = dwLayout->nativeWindowDeco();
bool hideButtons = nativeDeco || customTitleBar;
bool canClose = hasFeature(this, QDockWidget::DockWidgetClosable);
bool canFloat = hasFeature(this, QDockWidget::DockWidgetFloatable);
QAbstractButton *button
= qobject_cast<QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::FloatButton));
button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarNormalButton, &opt, q));
button->setVisible(canFloat && !hideButtons);
#ifndef QT_NO_ACCESSIBILITY
button->setAccessibleName(QDockWidget::tr("Float"));
button->setAccessibleDescription(QDockWidget::tr("Undocks and re-attaches the dock widget"));
#endif
button
= qobject_cast <QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::CloseButton));
button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarCloseButton, &opt, q));
button->setVisible(canClose && !hideButtons);
#ifndef QT_NO_ACCESSIBILITY
button->setAccessibleName(QDockWidget::tr("Close"));
button->setAccessibleDescription(QDockWidget::tr("Closes the dock widget"));
#endif
q->setAttribute(Qt::WA_ContentsPropagated,
(canFloat || canClose) && !hideButtons);
layout->invalidate();
}
bool QDockWidgetPrivate::mouseDoubleClickEvent(QMouseEvent *event)
{
QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
if (!dwLayout->nativeWindowDeco()) {
QRect titleArea = dwLayout->titleArea();
if (event->button() == Qt::LeftButton && titleArea.contains(event->pos()) &&
hasFeature(this, QDockWidget::DockWidgetFloatable)) {
_q_toggleTopLevel();
return true;
}
}
return false;
}
int H264Enc::GetAbility(VIDEOABILITYINFO** stAbilityInfo)
{
#if (!defined WIN32) && (!defined TARGET_OS_IPHONE)
bool hasNeon = hasFeature("neon");
int m_nCpuFreq = GetCpuFreq();
#endif
#if (defined WIN32)
(*stAbilityInfo)->nMaxWidth = 1920;
(*stAbilityInfo)->nMaxHeight = 1200;
#else
(*stAbilityInfo)->nMaxWidth = 320;
(*stAbilityInfo)->nMaxHeight = 240;
#endif //
#if defined(TARGET_OS_IPHONE)
CiOSDevInfo appleDev;
IOSDEV_DEVICE devCapa;
if (appleDev.getCurrentAbility(devCapa))
{
if(devCapa.type == iOSDev_iPhone4 )
{
(*stAbilityInfo)->nMaxFps = 10;
}
else if(devCapa.type == iOSDev_iPhone4S )
{
(*stAbilityInfo)->nMaxFps = 15;
}
else
{
(*stAbilityInfo)->nMaxFps = 15;
}
}
else
(*stAbilityInfo)->nMaxFps = 10;
#else
(*stAbilityInfo)->nMaxFps = 15;
#endif
(*stAbilityInfo)->nMaxMBPS = (*stAbilityInfo)->nMaxWidth * (*stAbilityInfo)->nMaxHeight * (*stAbilityInfo)->nMaxFps /256;
(*stAbilityInfo)->nIsEncode = 1;
(*stAbilityInfo)->nCodecType = def_CodecType_H264HighProfile;
(*stAbilityInfo)->nSupportedInputType = 1;
(*stAbilityInfo)->nInputType[0] = def_InputType_I420;
return true;
}
bool QSparqlResult::first()
{
// Already at the first result
if (pos() == 0)
return true;
if (hasFeature(ForwardOnly)) {
if (pos() == QSparql::BeforeFirstRow) {
// if the user hasn't iterated yet, calling first() is the same as
// calling next() once.
return next();
}
return false;
}
return setPos(0);
}
QString SysAsus::featureRead(const QString &id)
{
if (id == LAPSUS_FEAT_BACKLIGHT_ID)
{
return readPathString(ASUS_GET_BACKLIGHT_PATH).stripWhiteSpace();
}
else if (id == LAPSUS_FEAT_LIGHT_SENSOR_LEVEL_ID)
{
return readPathString(ASUS_LS_LEVEL_PATH).stripWhiteSpace();
}
else if (hasFeature(id))
{
uint val = readIdUInt(id);
if (val) return LAPSUS_FEAT_ON;
return LAPSUS_FEAT_OFF;
}
QString disp;
if (isDisplayFeature(id, disp))
{
uint val = readPathUInt(ASUS_DISPLAY_PATH);
uint offs = 0;
if (disp == LAPSUS_FEAT_DISPLAY_LCD) offs = 0;
else if (disp == LAPSUS_FEAT_DISPLAY_CRT) offs = 1;
else if (disp == LAPSUS_FEAT_DISPLAY_TV) offs = 2;
else if (disp == LAPSUS_FEAT_DISPLAY_DVI) offs = 3;
else return "";
if (val & (1<<offs) )
{
return LAPSUS_FEAT_ON;
}
return LAPSUS_FEAT_OFF;
}
return "";
}
bool QSparqlResult::setPos(int pos)
{
if (hasFeature(ForwardOnly)) {
// For forward-only results, the only legal way to move forward is
// next(). We cannot say that setPos(pos() + 1) is legal and the same as
// calling next(), since (it causes weird cornercases when iterating
// past the end of the result: If the last row is 2, and the user does
// setPos(3), next() is called, it sets the position to AfterLastRow
// (and not 3). Should setPos() return true or false? We cannot satisfy
// these 2 rules: 1) if setPos returns false, it hasn't changed the
// state of the Result 2) if setPos(i) returns true, pos() returns i.
return false;
}
int s = size();
if (pos < 0 || (s >= 0 && pos >= s))
return false;
d->idx = pos;
return true;
}
void QDockWidgetPrivate::endDrag(bool abort)
{
Q_Q(QDockWidget);
Q_ASSERT(state != 0);
q->releaseMouse();
if (state->dragging) {
QMainWindowLayout *mwLayout =
qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());
Q_ASSERT(mwLayout != 0);
if (abort || !mwLayout->plug(state->widgetItem)) {
if (hasFeature(this, QDockWidget::DockWidgetFloatable)) {
if (state->ownWidgetItem)
delete state->widgetItem;
mwLayout->restore();
#ifdef Q_WS_X11
// get rid of the X11BypassWindowManager window flag and activate the resizer
Qt::WindowFlags flags = q->windowFlags();
flags &= ~Qt::X11BypassWindowManagerHint;
q->setWindowFlags(flags);
resizer->setActive(QWidgetResizeHandler::Resize, true);
q->show();
#else
QDockWidgetLayout *myLayout
= qobject_cast<QDockWidgetLayout*>(layout);
resizer->setActive(QWidgetResizeHandler::Resize,
myLayout->widgetForRole(QDockWidgetLayout::TitleBar) != 0);
#endif
undockedGeometry = q->geometry();
q->activateWindow();
} else {
mwLayout->revert(state->widgetItem);
}
}
}
delete state;
state = 0;
}
void FWCamera::setFeature(CameraFeature feature, int value, bool bIgnoreOldValue)
{
#ifdef AVG_ENABLE_1394_2
if (hasFeature(feature)) {
if (bIgnoreOldValue || m_Features[feature] != value) {
m_Features[feature] = value;
if (feature == CAM_FEATURE_STROBE_DURATION) {
try {
setStrobeDuration(value);
} catch (Exception& e) {
AVG_LOG_WARNING(string("Camera: Setting strobe duration failed. ") +
e.getStr());
}
} else {
dc1394feature_t featureID = getFeatureID(feature);
setFeature(featureID, value);
// dumpCameraInfo();
}
}
}
#endif
}
void FWCamera::setWhitebalance(int u, int v, bool bIgnoreOldValue)
{
#ifdef AVG_ENABLE_1394_2
if (hasFeature(CAM_FEATURE_WHITE_BALANCE)) {
if (bIgnoreOldValue || u != m_WhitebalanceU || v != m_WhitebalanceV) {
m_WhitebalanceU = u;
m_WhitebalanceV = v;
dc1394error_t err;
if (u == -1) {
err = dc1394_feature_set_mode(m_pCamera, DC1394_FEATURE_WHITE_BALANCE,
DC1394_FEATURE_MODE_AUTO);
} else {
err = dc1394_feature_set_mode(m_pCamera, DC1394_FEATURE_WHITE_BALANCE,
DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_whitebalance_set_value(m_pCamera, u, v);
}
if (err != DC1394_SUCCESS) {
AVG_LOG_WARNING("Camera: Unable to set whitebalance. Error was " << err);
}
}
}
#endif
}
/*!
Draws the first \a rectCount rectangles in the buffer \a
rects. The default implementation of this function calls drawPath()
or drawPolygon() depending on the feature set of the paint engine.
*/
void QPaintEngine::drawRects(const QRectF *rects, int rectCount)
{
if (hasFeature(PainterPaths) &&
!state->penNeedsResolving() &&
!state->brushNeedsResolving()) {
for (int i=0; i<rectCount; ++i) {
QPainterPath path;
path.addRect(rects[i]);
if (path.isEmpty())
continue;
drawPath(path);
}
} else {
for (int i=0; i<rectCount; ++i) {
QRectF rf = rects[i];
QPointF pts[4] = { QPointF(rf.x(), rf.y()),
QPointF(rf.x() + rf.width(), rf.y()),
QPointF(rf.x() + rf.width(), rf.y() + rf.height()),
QPointF(rf.x(), rf.y() + rf.height()) };
drawPolygon(pts, 4, ConvexMode);
}
}
}
/*!
Retrieves the next row in the result, if available, and positions
the query on the retrieved row. Note that the isTable() or isGraph()
must return true before calling this function or it will do nothing
and return false.
The following rules apply:
- If the result is currently located before the first row,
e.g. immediately after a query is executed, an attempt is made to
retrieve the first row.
- If the result is currently located after the last row, there
is no change and false is returned.
- If the result is located somewhere in the middle, an attempt is
made to retrieve the next row.
If the row could not be retrieved, the result is positioned after
the last row and false is returned. If the row is successfully
retrieved, true is returned.
\sa previous() first() last() setPos() pos() isFinished() isValid()
*/
bool QSparqlResult::next()
{
// qDebug() << "QSparqlResult::next():" << pos() << " size:" << size();
// Note: Forward only results should re-implement this function, otherwise
// they cannot work.
if (hasFeature(QSparqlResult::ForwardOnly)) {
qWarning() <<
"QSparqlResult: ForwardOnly QSparqlResult doesn't override next()";
return false;
}
bool b = false;
int s = size();
if (s < 0)
return false;
switch (pos()) {
case QSparql::BeforeFirstRow:
// special case: empty results
if (s == 0) {
d->idx = QSparql::AfterLastRow;
return false;
}
b = first();
return b;
case QSparql::AfterLastRow:
return false;
default:
if (s < 0 || pos() + 1 < s) {
return setPos(pos() + 1);
} else {
d->idx = QSparql::AfterLastRow;
return false;
}
}
}
QSize KoDockWidgetTitleBar::sizeHint() const
{
if (isHidden()) {
return QSize(0, 0);
}
QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());
int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, 0, q);
int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q);
// get size of buttons...
QSize closeSize(0, 0);
if (d->closeButton && hasFeature(q, QDockWidget::DockWidgetClosable)) {
closeSize = d->closeButton->sizeHint();
}
QSize floatSize(0, 0);
if (d->floatButton && hasFeature(q, QDockWidget::DockWidgetFloatable)) {
floatSize = d->floatButton->sizeHint();
}
QSize hideSize(0, 0);
if (d->collapseButton && d->collapsable) {
hideSize = d->collapseButton->sizeHint();
}
QSize lockSize(0, 0);
if (d->lockButton && d->lockable) {
lockSize = d->lockButton->sizeHint();
}
int buttonHeight = qMax(qMax(qMax(closeSize.height(), floatSize.height()), hideSize.height()), lockSize.height()) + 2;
int buttonWidth = closeSize.width() + floatSize.width() + hideSize.width() + lockSize.width();
int height = buttonHeight;
if (d->textVisibilityMode == FullTextAlwaysVisible) {
// get font size
QFontMetrics titleFontMetrics = q->fontMetrics();
int fontHeight = titleFontMetrics.lineSpacing() + 2 * mw;
height = qMax(height, fontHeight);
}
/*
* Calculate the width of title and add to the total width of the docker window when collapsed.
*/
const int titleWidth =
(d->textVisibilityMode == FullTextAlwaysVisible) ? (q->fontMetrics().width(q->windowTitle()) + 2*mw) :
0;
if (d->preCollapsedWidth > 0) {
return QSize(d->preCollapsedWidth, height);
}
else {
if (d->textVisibilityMode == FullTextAlwaysVisible) {
return QSize(buttonWidth /*+ height*/ + 2*mw + 2*fw + titleWidth, height);
}
else {
if (q->widget()) {
return QSize(qMin(q->widget()->sizeHint().width(), buttonWidth), height);
}
else {
return QSize(buttonWidth, height);
}
}
}
}
bool SysAsus::featureWrite(const QString &id, const QString &nVal)
{
if (id == LAPSUS_FEAT_BACKLIGHT_ID)
{
bool res = false;
uint uVal = nVal.toUInt(&res);
if (!res) return false;
return setBacklight(uVal);
}
else if (id == LAPSUS_FEAT_LIGHT_SENSOR_LEVEL_ID)
{
bool res = false;
uint uVal = nVal.toUInt(&res);
if (!res) return false;
return setLightSensorLevel(uVal);
}
else if (hasFeature(id))
{
uint uVal = 0;
if (nVal == LAPSUS_FEAT_ON) uVal = 1;
else if (nVal == LAPSUS_FEAT_OFF) uVal = 0;
else return false;
uint oVal = readIdUInt(id);
if (writeIdUInt(id, uVal))
{
/*
* We perform write even if it is already set to desired value.
* Sometimes old status might not reflect real hardware state.
* This way we make sure it is set to correct state.
* But we don't want to send info if we don't think it has changed...
*/
if (oVal != uVal)
{
dbusSignalFeatureUpdate(id, nVal);
return true;
}
}
return false;
}
QString disp;
if (isDisplayFeature(id, disp))
{
uint uVal;
uint offs = 0;
if (nVal == LAPSUS_FEAT_ON) uVal = 1;
else if (nVal == LAPSUS_FEAT_ON) uVal = 0;
else return false;
if (disp == LAPSUS_FEAT_DISPLAY_LCD) offs = 0;
else if (disp == LAPSUS_FEAT_DISPLAY_CRT) offs = 1;
else if (disp == LAPSUS_FEAT_DISPLAY_TV) offs = 2;
else if (disp == LAPSUS_FEAT_DISPLAY_DVI) offs = 3;
else return false;
uint sVal, oVal = readPathUInt(ASUS_DISPLAY_PATH);
// ON - set the bit
if (uVal)
{
sVal = oVal | (1 << offs);
}
// OFF - clear the bit
else
{
sVal = oVal & ~(1 << offs);
}
if (sVal != oVal
&& writePathUInt(ASUS_DISPLAY_PATH, sVal))
{
dbusSignalFeatureUpdate(id, nVal);
return true;
}
return false;
}
return false;
}
bool QWindowSurface::hasStaticContents() const
{
return hasFeature(QWindowSurface::StaticContents) && !d_ptr->staticContents.isEmpty();
}
bool Interface::hasFeature( const QString& feature ) const
{
if ( feature == "CollectionsHaveComments" )
return hasFeature( CollectionsHaveComments );
else if ( feature == "CollectionsHaveCategory" )
return hasFeature( CollectionsHaveCategory );
else if ( feature == "CollectionsHaveCreationDate" )
return hasFeature( CollectionsHaveCreationDate );
else if ( feature == "ImagesHasComments" )
return hasFeature( ImagesHasComments );
else if ( feature == "ImagesHasTime" )
return hasFeature( ImagesHasTime );
else if ( feature == "ImagesHasTitlesWritable" )
return hasFeature( ImagesHasTitlesWritable );
else if ( feature == "HostSupportsThumbnails" )
return hasFeature( HostSupportsThumbnails );
else if ( feature == "HostSupportsReadWriteLock" )
return hasFeature( HostSupportsReadWriteLock );
else if ( feature == "HostSupportsDateRanges" )
return hasFeature( HostSupportsDateRanges );
else if ( feature == "HostAcceptNewImages" )
return hasFeature( HostAcceptNewImages );
else if ( feature == "HostSupportsProgressBar" )
return hasFeature( HostSupportsProgressBar );
else if ( feature == "HostSupportsTags" )
return hasFeature( HostSupportsTags );
else if ( feature == "HostSupportsRating" )
return hasFeature( HostSupportsRating );
else if ( feature == "HostSupportsPickLabel" )
return hasFeature( HostSupportsPickLabel );
else if ( feature == "HostSupportsColorLabel" )
return hasFeature( HostSupportsColorLabel );
else if ( feature == "HostSupportsItemReservation" )
return hasFeature( HostSupportsItemReservation );
else
{
kWarning() << "Unknown feature asked for in KIPI::Interface::hasFeature(): " << feature;
return false;
}
}
void QPaintEngine::drawPath(const QPainterPath &)
{
if (hasFeature(PainterPaths)) {
qWarning("QPaintEngine::drawPath: Must be implemented when feature PainterPaths is set");
}
}
void tst_QDockWidget::features()
{
QDockWidget dw;
QSignalSpy spy(&dw, SIGNAL(featuresChanged(QDockWidget::DockWidgetFeatures)));
// default features for dock widgets
int allDockWidgetFeatures = QDockWidget::DockWidgetClosable |
QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetFloatable;
// defaults
QCOMPARE(dw.features(), allDockWidgetFeatures);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
// test individual setting
setFeature(&dw, QDockWidget::DockWidgetClosable, false);
QCOMPARE(dw.features(), QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*(static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData())),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
setFeature(&dw, QDockWidget::DockWidgetClosable);
QCOMPARE(dw.features(), allDockWidgetFeatures);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
setFeature(&dw, QDockWidget::DockWidgetMovable, false);
QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
setFeature(&dw, QDockWidget::DockWidgetMovable);
QCOMPARE(dw.features(), allDockWidgetFeatures);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
setFeature(&dw, QDockWidget::DockWidgetFloatable, false);
QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
setFeature(&dw, QDockWidget::DockWidgetFloatable);
QCOMPARE(dw.features(), allDockWidgetFeatures);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
// set all at once
dw.setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable);
QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
dw.setFeatures(QDockWidget::DockWidgetClosable);
QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
dw.setFeatures(QDockWidget::AllDockWidgetFeatures);
QCOMPARE(dw.features(), QDockWidget::AllDockWidgetFeatures);
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable));
QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable));
QCOMPARE(spy.count(), 1);
QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()),
(int)dw.features());
spy.clear();
dw.setFeatures(dw.features());
QCOMPARE(spy.count(), 0);
spy.clear();
}
void KoDockWidgetTitleBar::resizeEvent(QResizeEvent*)
{
QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());
int fw = q->isFloating() ? q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q) : 0;
QStyleOptionDockWidgetV2 opt;
opt.initFrom(q);
opt.rect = QRect(QPoint(fw, fw), QSize(geometry().width() - (fw * 2), geometry().height() - (fw * 2)));
opt.title = q->windowTitle();
opt.closable = hasFeature(q, QDockWidget::DockWidgetClosable);
opt.floatable = hasFeature(q, QDockWidget::DockWidgetFloatable);
QRect floatRect = q->style()->subElementRect(QStyle::SE_DockWidgetFloatButton, &opt, q);
if (!floatRect.isNull())
d->floatButton->setGeometry(floatRect);
QRect closeRect = q->style()->subElementRect(QStyle::SE_DockWidgetCloseButton, &opt, q);
if (!closeRect.isNull())
d->closeButton->setGeometry(closeRect);
int top = fw;
if (!floatRect.isNull())
top = floatRect.y();
else if (!closeRect.isNull())
top = closeRect.y();
QSize size = d->collapseButton->size();
if (!closeRect.isNull()) {
size = d->closeButton->size();
} else if (!floatRect.isNull()) {
size = d->floatButton->size();
}
QRect collapseRect = QRect(QPoint(fw, top), size);
d->collapseButton->setGeometry(collapseRect);
size = d->lockButton->size();
if (!closeRect.isNull()) {
size = d->closeButton->size();
} else if (!floatRect.isNull()) {
size = d->floatButton->size();
}
int offset = 0;
if (d->collapsable) {
offset = collapseRect.width();
}
QRect lockRect = QRect(QPoint(fw + 2 + offset, top), size);
d->lockButton->setGeometry(lockRect);
if (width() < (closeRect.width() + lockRect.width()) + 50) {
d->collapsable = false;
d->collapseButton->setVisible(false);
d->lockButton->setVisible(false);
d->lockable = false;
} else {
d->collapsable = d->collapsableSet;
d->collapseButton->setVisible(d->collapsableSet);
d->lockButton->setVisible(true);
d->lockable = true;
}
}
