KexiComboBoxDropDownButton::KexiComboBoxDropDownButton(QWidget *parent)
: QToolButton(parent)
, d(new Private)
{
setAutoRaise(true);
setArrowType(Qt::DownArrow);
styleChanged();
}
std::shared_ptr<ScrollBar> SimpleScrollableAreaSkin::createScrollBar(
const std::shared_ptr<FloatValue>& controlledValue,
Direction::Enum direction) const
{
if (!m_scrollBarEnabled[direction])
return nullptr;
auto skin = std::make_shared<CommonScrollBarSkin>(
createScrollBarBox(direction, m_scrollBarWidth),
createDragBarBox(direction, m_scrollBarWidth),
direction);
skin->setAlwaysShow(false);
skin->setStep(m_scrollStep);
auto scrollBarBackground = std::make_shared<StaticFilledRect>(
std::make_shared<RelativeBox>(RelativeValue(), RelativeValue()));
scrollBarBackground->setColor(m_backgroundColor);
skin->addElement(scrollBarBackground);
auto decButtonSkin = std::make_shared<ArrowButtonSkin>(std::make_shared<SquareBox>());
fillSkin(decButtonSkin.get());
decButtonSkin->setArrowType(direction == Direction::Horizontal
? ArrowButtonSkin::Left : ArrowButtonSkin::Down);
decButtonSkin->setArrowColor(m_arrowColor);
decButtonSkin->setArrowPadding(m_arrowPadding);
skin->setDecButtonSkin(decButtonSkin);
auto incButtonSkin = std::make_shared<ArrowButtonSkin>(std::make_shared<SquareBox>());
fillSkin(incButtonSkin.get());
incButtonSkin->setArrowType(direction == Direction::Horizontal
? ArrowButtonSkin::Right : ArrowButtonSkin::Up);
incButtonSkin->setArrowColor(m_arrowColor);
incButtonSkin->setArrowPadding(m_arrowPadding);
skin->setIncButtonSkin(incButtonSkin);
auto dragBar = std::make_shared<SimpleRectangleButtonSkin>(
std::make_shared<RelativeBox>(RelativeValue(), RelativeValue()));
fillSkin(dragBar.get());
skin->setDragBarSkin(dragBar);
auto scrollBar = std::make_shared<ScrollBar>(skin, createScrollBarOffset(direction));
scrollBar->setControlledValue(controlledValue);
return scrollBar;
}
void PaletteBoxButton::showPalette(bool visible)
{
if (visible && preferences.singlePalette) {
// close all palettes
emit closeAll();
}
palette->setVisible(visible);
setChecked(visible);
setArrowType(visible ? Qt::DownArrow : Qt::RightArrow );
}
void PaletteBoxButton::showPalette(bool visible)
{
if (visible && preferences.getBool(PREF_APP_USESINGLEPALETTE)) {
// close all palettes
emit closeAll();
}
palette->setVisible(visible);
setChecked(visible);
setArrowType(visible ? Qt::DownArrow : Qt::RightArrow );
if (visible)
TourHandler::startTour("show-palette");
}
IconButton::IconButton(QWidget *parent)
: QToolButton(parent)
{
setFocusPolicy(Qt::NoFocus);
//setToolButtonStyle(Qt::ToolButtonIconOnly);
setStyleSheet("QToolButton { background-color:transparent; border: none; padding: 0px}");
setCursor(Qt::ArrowCursor);
setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
setContextMenuPolicy(Qt::PreventContextMenu);
setAutoRaise(true);
setPopupMode (QToolButton::InstantPopup);
setArrowType( Qt::NoArrow);
}
PaletteBoxButton::PaletteBoxButton(Palette* p, QWidget* parent)
: QToolButton(parent)
{
palette = p;
editAction = 0;
setCheckable(true);
setFocusPolicy(Qt::NoFocus);
connect(this, SIGNAL(clicked(bool)), this, SLOT(showPalette(bool)));
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
setText(qApp->translate("Palette", palette->name().toUtf8()));
setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
setArrowType(Qt::RightArrow);
showPalette(false);
}
BtDropdownChooserButton::BtDropdownChooserButton(BtBibleKeyWidget* ref)
: QToolButton(),
m_ref(ref) {
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
setAutoRaise(false);
setArrowType(Qt::NoArrow);
setFixedHeight(ARROW_HEIGHT);
setFocusPolicy(Qt::NoFocus);
setPopupMode(QToolButton::InstantPopup);
setStyleSheet("QToolButton{margin:0px;}QToolButton::menu-indicator{subcontrol-position: center center;}");
BtVerseKeyMenu* m = new BtVerseKeyMenu(this);
// KAcceleratorManager::setNoAccel(m);
setMenu(m);
BT_CONNECT(m, SIGNAL(triggered(QAction *)),
this, SLOT(slotMenuTriggered(QAction *)));
}
YTabMenuButton::YTabMenuButton(QWidget *parent)
: QToolButton(parent)
{
setArrowType(Qt::DownArrow);
setPopupMode(QToolButton::InstantPopup);
}
void Arrow::readGraphicAttributes(const QXmlStreamAttributes &attributes)
{
// Check for legacy arrow type
auto legacyArrowType = attributes.value("type").toString();
// if not legacy type, read arrow tip type and return
if ("ReactionArrow" != legacyArrowType // TODO make these names constants (see MolScene::produceChild())
&& "MechanismArrow" != legacyArrowType)
{
d->arrowType = (ArrowType) (attributes.value("arrowType").toString().toInt()) ;
d->spline = ! (attributes.value("splineDisabled").toString().toInt());
return;
}
// Code for legacy version
if ("ReactionArrow" == legacyArrowType)
{
enum LegacyReactionArrowType {
SingleArrow = 0,
DoubleArrow,
Equilibrium,
EqRightShifted,
EqLeftShifted
};
// Arrow tip
auto legacyReactionArrowType = (LegacyReactionArrowType) (attributes.value("arrowType").toString().toInt());
switch(legacyReactionArrowType)
{
case SingleArrow:
setArrowType(UpperBackward | LowerBackward);
break;
case DoubleArrow:
setArrowType(LowerForward | UpperForward | LowerBackward | UpperBackward);
break;
case Equilibrium:
case EqRightShifted:
case EqLeftShifted:
setArrowType(UpperBackward);
break;
default:
setArrowType(NoArrow);
}
// Coordinates
QPointF origin(attributes.value("posx").toString().toDouble(),
attributes.value("posy").toString().toDouble());
QLineF arrowLine(origin, origin +
QPointF(attributes.value("endx").toString().toDouble(),
attributes.value("endy").toString().toDouble()));
setCoordinates(QPolygonF() << arrowLine.p1() << arrowLine.p2());
if (!scene()) return;
// Fix equilibrium arrows:
if (Equilibrium == legacyReactionArrowType
|| EqLeftShifted == legacyReactionArrowType
|| EqRightShifted == legacyReactionArrowType)
{ // shift both arrows in equilibrium
QLineF normalVector = arrowLine.normalVector().unitVector();
QLineF unitVector = arrowLine.unitVector();
QPointF normalTranslation = 2*(normalVector.p2() - normalVector.p1());
QPointF unitTranslation = 15*(unitVector.p2() - unitVector.p1());
QLineF reverseArrowLine = arrowLine;
arrowLine.translate(normalTranslation);
reverseArrowLine.translate(-normalTranslation);
if (EqRightShifted == legacyReactionArrowType)
{
reverseArrowLine.setP1(reverseArrowLine.p1() + unitTranslation);
reverseArrowLine.setP2(reverseArrowLine.p2() - unitTranslation);
}
if (EqLeftShifted == legacyReactionArrowType)
{
arrowLine.setP1(arrowLine.p1() + unitTranslation);
arrowLine.setP2(arrowLine.p2() - unitTranslation);
}
auto reverseArrow = new Arrow;
reverseArrow->setParentItem(parentItem());
scene()->addItem(reverseArrow);
reverseArrow->setCoordinates(QPolygonF() << reverseArrowLine.p1()
<< reverseArrowLine.p2());
reverseArrow->setArrowType(LowerForward);
setCoordinates(QPolygonF() << arrowLine.p1()
<< arrowLine.p2());
}
}
if ("MechanismArrow" == legacyArrowType)
{
enum LegacyMechanismArrowType {
SingleArrowRight = 0,
SingleArrowLeft,
DoubleMechanismArrow,
SingleHookRight,
SingleHookLeft,
DoubleHook
};
// Arrow tip
auto legacyMechanismArrowType = (LegacyMechanismArrowType) (attributes.value("arrowType").toString().toInt());
switch(legacyMechanismArrowType)
{
case SingleArrowRight:
setArrowType(UpperBackward | LowerBackward);
break;
case SingleArrowLeft:
setArrowType(UpperForward | LowerForward);
break;
case DoubleMechanismArrow:
setArrowType(LowerForward | UpperForward | LowerBackward | UpperBackward);
break;
case SingleHookRight:
setArrowType(UpperBackward);
break;
case SingleHookLeft:
setArrowType(UpperForward);
break;
case DoubleHook:
setArrowType(UpperForward | UpperBackward);
break;
default:
setArrowType(NoArrow);
}
// Setting coordinates
QPolygonF points;
for (int i = 0 ; i < 4 ; ++i)
points << QPointF(attributes.value("p" + QString::number(i+1) + "x").toString().toDouble(),
attributes.value("p" + QString::number(i+1) + "y").toString().toDouble());
points.translate(attributes.value("posx").toString().toDouble(),
attributes.value("posy").toString().toDouble());
setCoordinates(points);
}
}
