QGraphicsLayout * KWidget::parentLayout()
{
if(parent() == NULL)
return NULL;
KWidget *itemParent = qobject_cast<KWidget*>(parent());
if(itemParent == NULL)
return NULL;
return itemParent->layout();
}
KWidget::LayoutType KWidget::parentLayoutType()
{
if(parent() == NULL)
return None;
KWidget *itemParent = qobject_cast<KWidget*>(parent());
if(itemParent == NULL)
return None;
return itemParent->layoutType();
}
void KWindow::doThemeChange()
{
Q_D(KWindow);
foreach (QGraphicsItem* item, items())
{
KWidget* widget = qobject_cast<KWidget*>( item->toGraphicsObject() );
if ( widget )
{
widget->doThemeChange();
}
}
void KWidget::setByLayout( bool by )
{
KWidget *itemParent = qobject_cast<KWidget*>(parent());
if(itemParent == NULL)
return;
if(by)
{
itemParent->addLayoutItem(this);
}
else
{
itemParent->removeLayoutItem(this);
}
}
bool KWidget::bylayout()
{
KWidget *itemParent = qobject_cast<KWidget*>(parent());
if(itemParent == NULL)
return false;
QGraphicsLayoutItem *item = dynamic_cast<QGraphicsLayoutItem*>(this);
QGraphicsLayout *layout = itemParent->layout();
for(int i = 0; i < layout->count(); i++)
{
if(layout->itemAt(i) == item)
return true;
}
return false;
}
QObject *KHelperPrivate::viewObject()
{
if(objRoot == NULL)
return NULL;
if(objRoot->isWidgetType())
{
return objRoot;
}
KWidget *widget = qobject_cast<KWidget*>(objRoot);
if(widget == NULL)
return NULL;
return widget->view();
}
void KWidget::clearThemeCheckFlag()
{
Q_D(KWidget);
d->bThemeCheck = false;
QList<QGraphicsItem*> items = childItems();
for(int i = 0; i < items.count(); i++)
{
KWidget *widget = qobject_cast<KWidget*>(items.at(i)->toGraphicsObject());
if(widget == NULL)
{
continue;
}
widget->clearThemeCheckFlag();
}
}
void KWidget::invalidateLayout()
{
QGraphicsLayout *layout = this->layout();
if(layout == NULL)
return;
layout->invalidate();
QList<QGraphicsItem *> childs = childItems();
for(int i = 0; i < childs.count(); i++)
{
QGraphicsItem *item = childs[i];
KWidget *widget = qobject_cast<KWidget*>(item->toGraphicsObject());
if(widget == NULL)
continue;
widget->invalidateLayout();
}
}
KKSliderVolume::KKSliderVolume( QGraphicsItem *parent /*= NULL*/ )
: KFrameItem(parent)
, m_timerid(0)
{
KWidget *itemParent = qobject_cast<KWidget*>(parent->toGraphicsObject());
QGraphicsView *itemView = itemParent->view();
m_pWindow = new KBubbleTip(itemView);
m_pWindow->setSceneMargins(QMargins(0,0,0,0));
KWidget *root = m_pWindow->rootWidget();
m_sliderPannel = new KFrameItem(root);
root->addItem(m_sliderPannel);
m_sliderPannel->setFrameType(KFrameItem::GridFour);
m_sliderPannel->setLayoutType(KWidget::VBox);
m_sliderFrame = new KSpacer(m_sliderPannel);
m_sliderFrame->setLayoutType(KWidget::VBox);
m_sliderFrame->setGrayToDisable(true);
m_slider = new KSlider(m_sliderFrame);
m_slider->setOrientation(Qt::Vertical);
m_slider->setRange(0, 1.0);
m_mute = new KFrameItem(m_sliderPannel);
m_sliderFrame->addItem(m_slider);
m_sliderPannel->addItem(m_sliderFrame);
m_sliderPannel->addItem(m_mute);
setAcceptHover(true);
m_popupSize = QSize(20,100);
m_mute->setFixHeight(20);
m_mute->setAcceptClick(true);
m_sliderPannel->setMargins(QMargins(0,0,0,0));
m_sliderPannel->setDefaultFrame(KFrameItem::RectWhite);
m_sliderPannel->setFrameType(KFrameItem::GridFour);
m_sliderPannel->setZValue(100);
m_mute->setFrameSwitch(false);
setFrameSwitch(false);
m_pWindow->setTarget(this);
m_pWindow->setDirection(KFollowWindow::TopCenter);
m_pWindow->hide();
QObject::connect(m_mute, SIGNAL(clicked()), this, SLOT(on_mute_clicked()));
QObject::connect(m_slider, SIGNAL(valueChanged(qreal)), this, SIGNAL(valueChanged(qreal)));
}
bool KWidget::hasTheme()
{
Q_D(KWidget);
if(d->themePolicy == NoTheme)
return false;
if(d->themePolicy == ThemeWithParent)
{
if(d->bThemeCheck)
{
return d->bThemeResult;
}
d->bThemeCheck = true;
QGraphicsItem *itemParent = parentItem();
while(itemParent)
{
KWidget *widgetParent = qobject_cast<KWidget*>(itemParent->toGraphicsObject());
if(widgetParent == NULL)
{
itemParent = itemParent->parentItem();
continue;
}
QString objName = widgetParent->objectName();
ThemePolicy scp = widgetParent->themePolicy();
if(scp == NoTheme)
{
d->bThemeResult = false;
return false;
}
if(scp == ThemeWithParent)
{
itemParent = itemParent->parentItem();
continue;
}
d->bThemeResult = true;
return true;
}
d->bThemeResult = false;
return false;
}
return true;
}
void KFrameWindow::init()
{
Q_D(KFrameWindow);
KWidget *root = __super::rootWidget();
KTitlebar *titlebar = new KTitlebar(root);
titlebar->setObjectName(QString("titlebar%1").arg((qlonglong)this));
KWidget *content = new KSpacer(root);
content->setObjectName(QString("content%1").arg((qlonglong)this));
content->setLayoutType(KWidget::VBox);
root->addItem(titlebar);
root->addItem(content);
d->m_titlebar = titlebar;
d->m_content = content;
QMetaObject::invokeMethod(titlebar, "updateTitelbar", Qt::QueuedConnection);
}
// --------------------------------------------------------------------------------------------------------
KSize KWidgetArray::relayout ( const KSize & newSize )
{
KSize sizeDiff = newSize - size;
if (flags[KDL_WIDGET_FLAG_FILL_X] == false && flags[KDL_WIDGET_FLAG_FILL_Y] == false ||
sizeDiff.w == 0 && sizeDiff.h == 0)
{
// nothing to resize or minimum size reached -> return
size = KSize(kMax(min_size.w, size.w), kMax(min_size.h, size.h));
return size;
}
int xFillWidgets = 0, yFillWidgets = 0;
PickableVector::iterator iter = children.begin();
while (iter != children.end())
{
KWidget * child = (KWidget*)*iter;
if (child->flags[KDL_WIDGET_FLAG_VISIBLE])
{
if (child->flags[KDL_WIDGET_FLAG_FILL_X]) xFillWidgets++;
if (child->flags[KDL_WIDGET_FLAG_FILL_Y]) yFillWidgets++;
}
iter++;
}
KSize maxSize = newSize;
if (flags[KDL_WIDGETARRAY_FLAG_HORIZONTAL])
{
maxSize.h -= (2 * frame_spacing);
if (xFillWidgets > 1)
{
sizeDiff.w /= xFillWidgets;
}
}
else // vertical layout
{
maxSize.w -= (2 * frame_spacing);
if (yFillWidgets > 1)
{
sizeDiff.h /= yFillWidgets;
}
}
size.w = frame_spacing;
size.h = frame_spacing;
iter = children.begin();
while (iter != children.end())
{
KWidget * child = (KWidget*)*iter;
if (child->flags[KDL_WIDGET_FLAG_VISIBLE])
{
child->reset();
KSize childSize = child->getSize();
// translate widgets according to layout style
if (flags[KDL_WIDGETARRAY_FLAG_HORIZONTAL])
{
maxSize.w = childSize.w + sizeDiff.w;
childSize = child->relayout(maxSize);
child->translate(size.w, -frame_spacing);
size.w += childSize.w + spacing;
size.h = kMax(size.h, childSize.h + frame_spacing);
}
else
{
maxSize.h = childSize.h + sizeDiff.h;
childSize = child->relayout(maxSize);
child->translate(frame_spacing, -size.h);
size.h += childSize.h + spacing;
size.w = kMax(size.w, childSize.w + frame_spacing);
}
}
iter++;
}
if (flags[KDL_WIDGETARRAY_FLAG_HORIZONTAL])
{
size.w += (frame_spacing - spacing);
size.h += frame_spacing;
}
else
{
size.w += frame_spacing;
size.h += (frame_spacing - spacing);
}
return size;
}
// --------------------------------------------------------------------------------------------------------
KSize KWidgetArray::layout ()
{
min_size = KSize(frame_spacing, frame_spacing);
std::vector<KWidget*> fillWidgets;
PickableVector::iterator iter = children.begin();
while (iter != children.end())
{
KWidget * child = (KWidget*)*iter;
if (child->flags[KDL_WIDGET_FLAG_VISIBLE])
{
child->reset();
KSize childSize = child->layout();
// check if array will fill available space
if (child->flags[KDL_WIDGET_FLAG_FILL_X]) flags[KDL_WIDGET_FLAG_FILL_X] = true;
if (child->flags[KDL_WIDGET_FLAG_FILL_Y]) flags[KDL_WIDGET_FLAG_FILL_Y] = true;
// translate widgets according to layout style
if (flags[KDL_WIDGETARRAY_FLAG_HORIZONTAL])
{
if (child->flags[KDL_WIDGET_FLAG_FILL_Y]) fillWidgets.push_back(child);
child->translate(min_size.w, -frame_spacing);
min_size.w += childSize.w + spacing;
min_size.h = kMax(min_size.h, childSize.h + frame_spacing);
}
else
{
if (child->flags[KDL_WIDGET_FLAG_FILL_X]) fillWidgets.push_back(child);
child->translate(frame_spacing, -min_size.h);
min_size.h += childSize.h + spacing;
min_size.w = kMax(min_size.w, childSize.w + frame_spacing);
}
}
iter++;
}
if (flags[KDL_WIDGETARRAY_FLAG_HORIZONTAL])
{
min_size.w += (frame_spacing - spacing);
min_size.h += frame_spacing;
while (fillWidgets.empty() == false)
{
fillWidgets.back()->relayout(KSize(fillWidgets.back()->getSize().w, min_size.h-2*frame_spacing));
fillWidgets.pop_back();
}
}
else
{
min_size.w += frame_spacing;
min_size.h += (frame_spacing - spacing);
while (fillWidgets.empty() == false)
{
fillWidgets.back()->relayout(KSize(min_size.w-2*frame_spacing, fillWidgets.back()->getSize().h));
fillWidgets.pop_back();
}
}
size = min_size;
return min_size;
}
void KWidget::setAnchor( const QString& a )
{
Q_D(KWidget);
//检查布局
KWidget* p = qobject_cast<KWidget*>(parent());
Q_ASSERT_X(p, __FUNCTION__, "parent is null");
Q_ASSERT_X(p->layoutType() == KWidget::Anchor, __FUNCTION__, "layout type should be anchor");
QGraphicsLayout *layout = p->layout();
QGraphicsAnchorLayout *anchorLayout = static_cast<QGraphicsAnchorLayout*>(layout);
if(anchorLayout == NULL)
{
Q_ASSERT_X(false, __FUNCTION__, "layout is not group layout");
return ;
}
if(d->bAddToAnchor)
{
p->removeLayoutItem(this);
}
//参数转换
int index = KWidget::staticMetaObject.indexOfEnumerator("AnchorPoint");
QMetaEnum enu = KWidget::staticMetaObject.enumerator(index);
QStringList list = a.split('|');
Q_ASSERT_X(list.count()==4, __FUNCTION__, QString("%1 is not valide anchor info").arg(a).toLatin1().constData());
Qt::AnchorPoint anchorPoint[4]={Qt::AnchorLeft};
int distance[4]={0};
for (int i = 0; i < list.count() && i < 4; ++i)
{
QStringList innerList = list[i].split(':');
Q_ASSERT_X(innerList.count()==2, __FUNCTION__, QString("%1 is not valide anchor info").arg(a).toLatin1().constData());
if (innerList.count() >= 2)
{
int value = enu.keyToValue(innerList[0].toLatin1().constData());
Q_ASSERT_X(value != -1, __FUNCTION__, (innerList[0] + "is not a valid enum value").toLatin1().constData());
if (value == -1)
{
value = 0;
}
anchorPoint[i] = (Qt::AnchorPoint)value;
distance[i] = innerList[1].toInt();
}
}
//AnchorLeft:
int idx = 0;
QGraphicsAnchor *anchorLeft = anchorLayout->addAnchor(anchorLayout, anchorPoint[idx], this, Qt::AnchorLeft);
if(anchorLeft)
{
anchorLeft->setSpacing(distance[idx]);
}
else if(anchorPoint[idx] >= Qt::AnchorTop)
{
Q_ASSERT_X(false, __FUNCTION__, QString("it's not the same orientation for AnchorLeft: bad string is[%1]").arg(list.at(idx)).toStdString().c_str());
}
else
{
Q_ASSERT_X(false, __FUNCTION__, QString("bad parameter.bad string:%1").arg(list.at(idx)).toStdString().c_str());
}
//AnchorTop:
idx = 1;
QGraphicsAnchor *anchorTop = anchorLayout->addAnchor(anchorLayout, anchorPoint[idx], this, Qt::AnchorTop);
if(anchorTop)
{
anchorTop->setSpacing(distance[idx]);
}
else if(anchorPoint[idx] < Qt::AnchorTop)
{
Q_ASSERT_X(false, __FUNCTION__, QString("it's not the same orientation for AnchorTop: bad string is[%1]").arg(list.at(idx)).toStdString().c_str());
}
else
{
Q_ASSERT_X(false, __FUNCTION__, QString("bad parameter.bad string:%1").arg(list.at(idx)).toStdString().c_str());
}
//AnchorRight:
idx = 2;
QGraphicsAnchor *anchorRight = anchorLayout->addAnchor(this, Qt::AnchorRight, anchorLayout, anchorPoint[idx]);
if(anchorRight)
{
anchorRight->setSpacing(distance[idx]);
}
else if(anchorPoint[idx] >= Qt::AnchorTop)
{
Q_ASSERT_X(false, __FUNCTION__, QString("it's not the same orientation for AnchorRight: bad string is[%1]").arg(list.at(idx)).toStdString().c_str());
}
else
{
Q_ASSERT_X(false, __FUNCTION__, QString("bad parameter.bad string:%1").arg(list.at(idx)).toStdString().c_str());
}
//AnchorBottom
idx = 3;
QGraphicsAnchor *anchorBottom = anchorLayout->addAnchor(this, Qt::AnchorBottom, anchorLayout, anchorPoint[idx]);
if(anchorBottom)
{
anchorBottom->setSpacing(distance[idx]);
}
else if(anchorPoint[idx] < Qt::AnchorTop)
{
Q_ASSERT_X(false, __FUNCTION__, QString("it's not the same orientation for AnchorBottom: bad string is[%1]").arg(list.at(idx)).toStdString().c_str());
}
else
{
Q_ASSERT_X(false, __FUNCTION__, QString("bad parameter.bad string:%1").arg(list.at(idx)).toStdString().c_str());
}
d->bAddToAnchor = true;
}
