PatienceView::PatienceView( QWidget * parent )
: QGraphicsView( parent ),
KGameRendererClient( Renderer::self(), QStringLiteral("background") )
{
setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
setFrameStyle( QFrame::NoFrame );
// This makes the background of the widget transparent so that Oxygen's
// (or any other style's) window gradient is visible in unpainted areas of
// the scene.
QPalette p = palette();
QColor c = p.color( QPalette::Base );
c.setAlpha( 0 );
p.setColor( QPalette::Base, c );
setPalette( p );
setBackgroundRole( QPalette::Base );
setAlignment( Qt::AlignLeft | Qt::AlignTop );
setCacheMode( QGraphicsView::CacheBackground );
}
void RTTIBuilder::push_array(llvm::Constant *CI, uint64_t dim, Type *valtype,
Dsymbol *mangle_sym) {
std::string tmpStr(valtype->arrayOf()->toChars());
tmpStr.erase(remove(tmpStr.begin(), tmpStr.end(), '['), tmpStr.end());
tmpStr.erase(remove(tmpStr.begin(), tmpStr.end(), ']'), tmpStr.end());
tmpStr.append("arr");
std::string initname(mangle_sym ? mangle(mangle_sym) : ".ldc");
initname.append(".rtti.");
initname.append(tmpStr);
initname.append(".data");
const LinkageWithCOMDAT lwc(TYPEINFO_LINKAGE_TYPE, supportsCOMDAT());
auto G = new LLGlobalVariable(gIR->module, CI->getType(), true,
lwc.first, CI, initname);
setLinkage(lwc, G);
G->setAlignment(DtoAlignment(valtype));
push_array(dim, DtoBitCast(G, DtoType(valtype->pointerTo())));
}
UINodeServerSelector::UINodeServerSelector (IFrontend *frontend, int rows) :
UINodeSelector<ServerEntry>(frontend, 1, rows)
{
_headlineFont = getFont(HUGE_FONT);
_headlineHeight = _headlineFont->getCharHeight();
setBackgroundColor(backgroundColor);
setSize(0.8f, 0.6f);
setScrollingEnabled(true);
setPageVisible(false);
setAlignment(NODE_ALIGN_CENTER | NODE_ALIGN_MIDDLE);
setId("server-selector");
setFont(HUGE_FONT);
setRowHeight(getFontHeight() / static_cast<float>(_frontend->getHeight()));
_mouseWheelScrollAmount = _rowHeight * _frontend->getHeight() * 5;
Vector4Set(colorWhite, _fontColor);
reset();
setRowSpacing(2);
_entryOffsetY = _headlineHeight;
_colWidth = _size.x;
setAutoColsRows();
}
DesktopSelectionView::DesktopSelectionView(QWidget* widget_)
: QGraphicsView(widget_)
, desktopSelectionRectangle_(0)
{
// create and set scene for the view
setScene(new QGraphicsScene());
// force scene to be anchored at top left
setAlignment(Qt::AlignLeft | Qt::AlignTop);
// set attributes of the view
setInteractive(true);
// disable scrollbars
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
// create and add the rectangle for the selection area
desktopSelectionRectangle_ = new DesktopSelectionRectangle();
scene()->addItem(desktopSelectionRectangle_);
}
VendorLineEdit::VendorLineEdit(QWidget *pParent, const char *name) :
XLineEdit(pParent, name)
{
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
setMaximumWidth(100);
setAcceptDrops(TRUE);
setAlignment(Qt::AlignVCenter | Qt::AlignRight);
_id = -1;
_valid = FALSE;
_parsed = TRUE;
_dragging = FALSE;
_type = __allVendors;
connect(this, SIGNAL(lostFocus()), this, SLOT(sParse()));
connect(this, SIGNAL(requestSearch()), this, SLOT(sSearch()));
connect(this, SIGNAL(requestList()), this, SLOT(sList()));
_mapper = new XDataWidgetMapper(this);
}
void Square::setup()
{
setAlignment(po::scene::Alignment::CENTER_CENTER);
// Create and add a shape for the active state
mActive = ShapeView::createRect(100, 100);
mActive->setFillColor(mActiveColor);
addSubview(mActive);
// Create and add a shape for the selected state
// Set the alpha to 0 so we can animate it
mSelected = ShapeView::createRect(100, 100);
mSelected->setFillColor(mSelectedColor);
addSubview(mSelected);
mSelected->setAlpha(0.f);
// Connect to mouse events
getSignal(MouseEvent::DOWN_INSIDE).connect(std::bind(&Square::onMouseEvent, this, std::placeholders::_1));
getSignal(MouseEvent::UP_INSIDE).connect(std::bind(&Square::onMouseEvent, this, std::placeholders::_1));
getSignal(MouseEvent::UP).connect(std::bind(&Square::onMouseEvent, this, std::placeholders::_1));
}
ChooseCertificateScreen::ChooseCertificateScreen()
: CursesContainer(mainScreen),
CursesKeyHandler(PRI_SCREENHANDLER),
title(this, _("Certificates")),
menu(this)
{
setRow(2);
setAlignment(Curses::PARENTCENTER);
title.setAlignment(Curses::PARENTCENTER);
menu.setRow(2);
std::map<std::string, Certificates::cert>::iterator p;
for (p=myServer::certs->certs.begin();
p != myServer::certs->certs.end(); ++p)
{
certs.push_back(cert(this, p->second.name, p->first));
menu.addPrompt(NULL, &certs.back());
}
}
//======================================================//
UpDownLineEdit::UpDownLineEdit(QWidget *parent, const char *name, QString possible_value)
: QLineEdit(parent, name), possible_val(possible_value)
{
buttonUp = new QPushButton(parent, "buttonUp");
//QPixmap pm ("./image/arrow_up.png");
QPixmap pm = QPixmap::fromMimeSource("arrow_up.png");
buttonUp->setPixmap( pm);
buttonDown = new QPushButton(parent, "buttonDown");
//pm = QPixmap("./image/arrow_down.png");
pm = QPixmap::fromMimeSource("arrow_down.png");
buttonDown->setPixmap( pm);
setPosition(0, 0);
setMaxLength(1);
setReadOnly(true);
setAlignment(Qt::AlignHCenter);
QFont f = font();
f.setPointSize(12);
f.setBold(false);
setFont(f);
buttonUp->setFocusPolicy(QWidget::NoFocus);
buttonDown->setFocusPolicy(QWidget::NoFocus);
QSizePolicy sp (QSizePolicy::Fixed, QSizePolicy::Fixed);
setSizePolicy(sp);
buttonUp->setSizePolicy(sp);
buttonDown->setSizePolicy(sp);
buttonUp->setFlat(true);
buttonDown->setFlat(true);
connect ( buttonUp, SIGNAL(clicked()), SLOT(GoUp()) );
connect ( buttonDown, SIGNAL(clicked()), SLOT(GoDown()) );
index = 0;
//puts("UpDownCreate");
}
CertificatesScreen::CertificatesScreen(CursesMainScreen *parent)
: CursesContainer(parent),
CursesKeyHandler(PRI_SCREENHANDLER),
title(this, _("Certificates")),
menu(this)
{
setRow(2);
setAlignment(Curses::PARENTCENTER);
title.setAlignment(Curses::PARENTCENTER);
menu.setRow(2);
titleBar->setTitles(_("CERTIFICATES"), "");
foundfocus=false;
std::map<std::string, Certificates::cert>::iterator p;
for (p=myServer::certs->certs.begin();
p != myServer::certs->certs.end(); ++p)
addCertificate(p->second.name, p->first);
}
CoverArtLabel::CoverArtLabel( QWidget *parent, intf_thread_t *_p_i )
: QLabel( parent ), p_intf( _p_i ), p_item( NULL )
{
setContextMenuPolicy( Qt::ActionsContextMenu );
CONNECT( THEMIM->getIM(), artChanged( input_item_t * ),
this, showArtUpdate( input_item_t * ) );
setMinimumHeight( 128 );
setMinimumWidth( 128 );
setScaledContents( false );
setAlignment( Qt::AlignCenter );
QAction *action = new QAction( qtr( "Download cover art" ), this );
CONNECT( action, triggered(), this, askForUpdate() );
addAction( action );
action = new QAction( qtr( "Add cover art from file" ), this );
CONNECT( action, triggered(), this, setArtFromFile() );
addAction( action );
showArtUpdate( "" );
}
GlassWindow::GlassWindow() : gcn::Window(), GlassWidget(this), wmhandler() {
titleBar = gcn::Image::load("/gui/standard/bar_gradient.png");
mTitleBarHeight = titleBar->getHeight()+3;
titleBarContainer._setParent(this);
setAlignment(gcn::Graphics::LEFT);
shadeState = SH_OPEN;
titleVisible = true;
mGradient = false;
frame = NULL;
mBorder = 0;
setBackgroundColor(gcn::Color(213,213,213));
wmhandler.setWindow(this);
buildTitleBar(WT_ALL);
//for GlassWidget
addActionListener(this);
addFocusListener(this);
gui->addGlobalKeyListener(this);
}
ExtenderObject(const Plasma::Svg & icon,
ExtenderButton * parent)
: BasicWidget(icon, "", "")
{
iconInSvg().setUsingRenderingCache(true);
iconInSvg().setContainsMultipleImages(true);
frameCount = 0;
while (iconInSvg().hasElement("frame" + QString::number(frameCount))) {
frameCount++;
}
frameCount--;
setParentItem(parent);
setInnerOrientation(Qt::Vertical);
setAlignment(Qt::AlignCenter);
setZValue(EXTENDER_Z_VALUE);
animate = !Global::self()->config("Animation", "disableAnimations", false)
&& Global::self()->config("Animation", "extenderActivationFeedback", true);
}
FormEditorGraphicsView::FormEditorGraphicsView(QWidget *parent) :
QGraphicsView(parent),
m_isPanning(false)
{
setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
setResizeAnchor(QGraphicsView::AnchorViewCenter);
setAlignment(Qt::AlignCenter);
setCacheMode(QGraphicsView::CacheNone);
setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);
setOptimizationFlags(QGraphicsView::DontSavePainterState);
// setViewportUpdateMode(QGraphicsView::NoViewportUpdate);
setRenderHint(QPainter::Antialiasing, false);
setFrameShape(QFrame::NoFrame);
setAutoFillBackground(true);
setBackgroundRole(QPalette::Window);
activateCheckboardBackground();
viewport()->setMouseTracking(true);
}
TimeLabel::TimeLabel( intf_thread_t *_p_intf, TimeLabel::Display _displayType )
: ClickableQLabel(), p_intf( _p_intf ), bufTimer( new QTimer(this) ),
buffering( false ), showBuffering(false), bufVal( -1 ), displayType( _displayType )
{
b_remainingTime = false;
if( _displayType != TimeLabel::Elapsed )
b_remainingTime = getSettings()->value( "MainWindow/ShowRemainingTime", false ).toBool();
switch( _displayType ) {
case TimeLabel::Elapsed:
setText( " --:-- " );
setToolTip( qtr("Elapsed time") );
break;
case TimeLabel::Remaining:
setText( " --:-- " );
setToolTip( qtr("Total/Remaining time")
+ QString("\n-")
+ qtr("Click to toggle between total and remaining time")
);
break;
case TimeLabel::Both:
setText( " --:--/--:-- " );
setToolTip( QString( "- " )
+ qtr( "Click to toggle between elapsed and remaining time" )
+ QString( "\n- " )
+ qtr( "Double click to jump to a chosen time position" ) );
break;
}
setAlignment( Qt::AlignRight | Qt::AlignVCenter );
bufTimer->setSingleShot( true );
CONNECT( THEMIM->getIM(), positionUpdated( float, int64_t, int ),
this, setDisplayPosition( float, int64_t, int ) );
CONNECT( THEMIM->getIM(), cachingChanged( float ),
this, updateBuffering( float ) );
CONNECT( bufTimer, timeout(), this, updateBuffering() );
setStyleSheet( "padding-left: 4px; padding-right: 4px;" );
}
//=========================================================================
BubbleChartView::BubbleChartView(BlastTaxDataProviders *_dataProviders, QWidget *parent, bool setRank)
: DataGraphicsView(NULL, parent)
{
flags |= DGF_BUBBLES | DGF_RANKS;
config = new BubbleChartParameters();
if ( setRank && mainWindow->getRank() == TR_NORANK )
mainWindow->setRank(TR_SPECIES);
if ( _dataProviders == NULL )
_dataProviders = new BlastTaxDataProviders();
taxDataProvider = new ChartDataProvider(_dataProviders, this);
connect((ChartDataProvider *)taxDataProvider, SIGNAL(taxVisibilityChanged(quint32)), this, SLOT(onTaxVisibilityChanged(quint32)));
connect((ChartDataProvider *)taxDataProvider, SIGNAL(cacheUpdated()), this, SLOT(onDataChanged()));
QGraphicsScene *s = new QGraphicsScene(this);
s->setItemIndexMethod(QGraphicsScene::NoIndex);
setCacheMode(CacheBackground);
setViewportUpdateMode(BoundingRectViewportUpdate);
setRenderHint(QPainter::Antialiasing);
setTransformationAnchor(AnchorUnderMouse);
setMinimumSize(400, 200);
setAlignment(Qt::AlignCenter);
setScene(s);
setChartRectSize(800, 800);
propertiesAction = popupMenu.addAction("Properties...");
connect(propertiesAction, SIGNAL(triggered(bool)), this, SLOT(showPropertiesDialog()));
if ( _dataProviders->size() > 0 )
{
prepareScene();
showChart();
}
onTaxRankChanged(mainWindow->getRank());
}
TimeLabel::TimeLabel( intf_thread_t *_p_intf, TimeLabel::Display _displayType )
: ClickableQLabel(), p_intf( _p_intf ), displayType( _displayType )
{
b_remainingTime = false;
if( _displayType != TimeLabel::Elapsed )
b_remainingTime = getSettings()->value( "MainWindow/ShowRemainingTime", false ).toBool();
switch( _displayType ) {
case TimeLabel::Elapsed:
setText( " --:-- " );
setToolTip( qtr("Elapsed time") );
break;
case TimeLabel::Remaining:
setText( " --:-- " );
setToolTip( qtr("Total/Remaining time")
+ QString("\n-")
+ qtr("Click to toggle between total and remaining time")
);
break;
case TimeLabel::Both:
setText( " --:--/--:-- " );
setToolTip( QString( "- " )
+ qtr( "Click to toggle between elapsed and remaining time" )
+ QString( "\n- " )
+ qtr( "Double click to jump to a chosen time position" ) );
break;
}
setAlignment( Qt::AlignRight | Qt::AlignVCenter );
CONNECT( THEMIM->getIM(), positionUpdated( float, int64_t, int ),
this, setDisplayPosition( float, int64_t, int ) );
connect( this, SIGNAL( broadcastRemainingTime( bool ) ),
THEMIM->getIM(), SIGNAL( remainingTimeChanged( bool ) ) );
CONNECT( THEMIM->getIM(), remainingTimeChanged( bool ),
this, setRemainingTime( bool ) );
setStyleSheet( "QLabel { padding-left: 4px; padding-right: 4px; }" );
}
DItemToolTip::DItemToolTip(QWidget* const parent)
: QLabel(parent, Qt::ToolTip),
d(new Private)
{
hide();
setBackgroundRole(QPalette::ToolTipBase);
setPalette(QToolTip::palette());
ensurePolished();
const int fwidth = qMax(d->tipBorder, 1 + style()->pixelMetric(QStyle::PM_ToolTipLabelFrameWidth, 0, this));
setContentsMargins(fwidth, fwidth, fwidth, fwidth);
setWindowOpacity(style()->styleHint(QStyle::SH_ToolTipLabel_Opacity, 0, this) / 255.0);
setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
setFrameStyle(QFrame::StyledPanel);
/*
Old-style box:
setFrameStyle(QFrame::Plain | QFrame::Box);
setLineWidth(1);
*/
renderArrows();
}
void
Amarok::OSD::show( Meta::TrackPtr track ) //slot
{
setAlignment( static_cast<OSDWidget::Alignment>( AmarokConfig::osdAlignment() ) );
setOffset( AmarokConfig::osdYOffset() );
QString text;
if( !track || track->playableUrl().isEmpty() )
text = i18n( "No track playing" );
else
{
setRating( track->rating() );
text = track->prettyName();
if( track->artist() && !track->artist()->prettyName().isEmpty() )
text = track->artist()->prettyName() + " - " + text;
if( track->album() && !track->album()->prettyName().isEmpty() )
text += "\n (" + track->album()->prettyName() + ") ";
else
text += '\n';
if( track->length() > 0 )
text += Meta::secToPrettyTime( track->length() );
}
if( text.isEmpty() )
text = track->playableUrl().fileName();
if( text.startsWith( "- " ) ) //When we only have a title tag, _something_ prepends a f*****g hyphen. Remove that.
text = text.mid( 2 );
if( text.isEmpty() ) //still
text = i18n("No information available for this track");
QImage image;
if( track && track->album() )
image = track->album()->imageWithBorder( 100, 5 ).toImage();
OSDWidget::show( text, image );
}
void UIToolsView::prepare()
{
/* Install Tools-view accessibility interface factory: */
QAccessible::installFactory(UIAccessibilityInterfaceForUIToolsView::pFactory);
/* Prepare palette: */
preparePalette();
/* Setup frame: */
setFrameShape(QFrame::NoFrame);
setFrameShadow(QFrame::Plain);
setAlignment(Qt::AlignLeft | Qt::AlignTop);
/* Setup scroll-bars policy: */
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
/* Update scene-rect: */
updateSceneRect();
/* Apply language settings: */
retranslateUi();
}
OverviewView::OverviewView(QGraphicsScene* qgs, QWidget* parent)
: QGraphicsView(qgs, parent)
, barMovement_(false)
, scene_(qgs)
, slide_(false)
, offset_(0)
{
currentFrameGraphicsItem_ = new CurrentFrameGraphicsItem(true, true);
setRenderHint(QPainter::SmoothPixmapTransform);
setCacheMode(CacheBackground);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
setAlignment(Qt::AlignLeft);
scene_->setBackgroundBrush(Qt::blue);
QLinearGradient gradient(0, 0, 0, 80);
gradient.setSpread(QGradient::PadSpread);
gradient.setColorAt(0, QColor(255,255,255,0));
gradient.setColorAt(0.5, QColor(150,150,150,200));
gradient.setColorAt(1, QColor(50,0,50,100));
scene_->setBackgroundBrush(gradient);
scene_->addItem(currentFrameGraphicsItem_);
}
CActionLabel::CActionLabel(QWidget *parent)
: QLabel(parent)
{
static const int constIconSize(48);
setMinimumSize(constIconSize, constIconSize);
setMaximumSize(constIconSize, constIconSize);
setAlignment(Qt::AlignCenter);
if(0==theUsageCount++)
{
QImage img(KIconLoader::global()->loadIcon("application-x-font-ttf", KIconLoader::NoGroup, 32).toImage());
double increment=360.0/constNumIcons;
for(int i=0; i<constNumIcons; ++i)
theIcons[i]=new QPixmap(QPixmap::fromImage(0==i ? img : img.transformed(rotateMatrix(img.width(), img.height(), increment*i))));
}
setPixmap(*theIcons[0]);
itsTimer=new QTimer(this);
connect(itsTimer, SIGNAL(timeout()), SLOT(rotateIcon()));
}
IconViewWidget::IconViewWidget(const QString & configId, RazorSettings * config)
{
setObjectName("IconView");
config->beginGroup(configId);
QString dir = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
dir = config->value("directory", dir).toString();
config->endGroup();
// Hack to ensure the fully transparent QGraphicsView background
QPalette palette;
palette.setBrush(QPalette::Base, Qt::NoBrush);
setPalette(palette);
// Required to display wallpaper
setAttribute(Qt::WA_TranslucentBackground);
// no border at all finally
setFrameShape(QFrame::NoFrame);
setAcceptDrops(true);
m_iconScene = new IconScene(dir);
setScene(m_iconScene);
setRenderHint(QPainter::Antialiasing);
setRenderHint(QPainter::TextAntialiasing);
setRenderHint(QPainter::SmoothPixmapTransform);
setRenderHint(QPainter::HighQualityAntialiasing);
setDragMode(QGraphicsView::RubberBandDrag);
setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
setCacheMode(QGraphicsView::CacheBackground);
setAlignment(Qt::AlignTop | Qt::AlignLeft);
}
FormEditorGraphicsView::FormEditorGraphicsView(QWidget *parent) :
QGraphicsView(parent)
{
setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
setResizeAnchor(QGraphicsView::AnchorViewCenter);
setAlignment(Qt::AlignCenter);
setCacheMode(QGraphicsView::CacheNone);
setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);
setOptimizationFlags(QGraphicsView::DontSavePainterState);
setRenderHint(QPainter::Antialiasing, false);
setRenderHint(QPainter::SmoothPixmapTransform, true);
setFrameShape(QFrame::NoFrame);
setAutoFillBackground(true);
setBackgroundRole(QPalette::Window);
activateCheckboardBackground();
// as mousetracking only works for mouse key it is better to handle it in the
// eventFilter method so it works also for the space scrolling case as expected
QCoreApplication::instance()->installEventFilter(this);
}
TextGraphicsItem::TextGraphicsItem(Text& text,
const IF_GraphicsLayerProvider& lp,
QGraphicsItem* parent) noexcept
: PrimitiveTextGraphicsItem(parent), mText(text), mLayerProvider(lp) {
setFont(TextGraphicsItem::Font::SansSerif);
setPosition(mText.getPosition());
setRotation(mText.getRotation());
setText(mText.getText());
setHeight(mText.getHeight());
setAlignment(mText.getAlign());
setLayer(mLayerProvider.getLayer(*mText.getLayerName()));
setFlag(QGraphicsItem::ItemIsSelectable, true);
setZValue(5);
// add origin cross
mOriginCrossGraphicsItem.reset(new OriginCrossGraphicsItem(this));
mOriginCrossGraphicsItem->setSize(UnsignedLength(1000000));
mOriginCrossGraphicsItem->setLayer(
mLayerProvider.getLayer(GraphicsLayer::sSchematicReferences)); // TODO
// register to the text to get attribute updates
mText.registerObserver(*this);
}
// модифицированное поле ввода
LineEdit::LineEdit(QWidget *parent) :
QLineEdit(parent), contextMenu(0)
{
// m_history = new History(this, tr("log"));
copyAct = new QAction(tr("Copy"), this);
copyAct->setShortcut(QKeySequence::Copy);
connect(copyAct, SIGNAL(triggered()), SLOT(copy()));
pasteAct = new QAction(tr("Paste"), this);
pasteAct->setShortcut(QKeySequence::Paste);
connect(pasteAct, SIGNAL(triggered()), SLOT(pasteSlot()));
setAlignment(Qt::AlignRight);
setReadOnly(true);
QFont f = font();
f.setPointSize(f.pointSize() + 8);
setFont(f);
m_numberMode = 10;
clearAll();
}
llvm::Constant *Generator::createString(const std::string &str) {
auto iterator = constant_pool.find(str);
if (iterator != constant_pool.end()) {
return iterator->second;
}
auto array = llvm::ConstantDataArray::getString(mod->getContext(), str);
auto global_variable = new llvm::GlobalVariable(
*mod, llvm::ArrayType::get(llvm::Type::getInt8Ty(mod->getContext()),
str.length() + 1),
true, llvm::GlobalValue::PrivateLinkage, 0, ".str");
global_variable->setAlignment(1);
global_variable->setInitializer(array);
auto zero =
llvm::ConstantInt::get(llvm::Type::getInt8Ty(mod->getContext()), 0);
std::vector<llvm::Value *> indicies;
indicies.push_back(zero);
indicies.push_back(zero);
auto result = llvm::ConstantExpr::getGetElementPtr(
global_variable->getValueType(), global_variable, indicies);
constant_pool[str] = result;
return result;
}
TimeLabel::TimeLabel( intf_thread_t *_p_intf, TimeLabel::Display _displayType )
: QLabel(), p_intf( _p_intf ), bufTimer( new QTimer(this) ),
buffering( false ), showBuffering(false), bufVal( -1 ), displayType( _displayType )
{
b_remainingTime = false;
switch( _displayType ) {
case TimeLabel::Elapsed:
setText( " --:-- " );
setToolTip( qtr("Elapsed time") );
break;
case TimeLabel::Remaining:
setText( " --:-- " );
setToolTip( qtr("Total/Remaining time")
+ QString("\n-")
+ qtr("Click to toggle between total and remaining time")
);
break;
case TimeLabel::Both:
setText( " --:--/--:-- " );
setToolTip( QString( "- " )
+ qtr( "Click to toggle between elapsed and remaining time" )
+ QString( "\n- " )
+ qtr( "Double click to jump to a chosen time position" ) );
break;
}
setAlignment( Qt::AlignRight | Qt::AlignVCenter );
bufTimer->setSingleShot( true );
CONNECT( THEMIM->getIM(), positionUpdated( float, int64_t, int ),
this, setDisplayPosition( float, int64_t, int ) );
CONNECT( THEMIM->getIM(), cachingChanged( float ),
this, updateBuffering( float ) );
CONNECT( bufTimer, timeout(), this, updateBuffering() );
this->setContentsMargins( 4, 0, 4, 0 );
}
KSystemTray::KSystemTray(QWidget *parent, const char *name) : QLabel(parent, name, WType_TopLevel)
{
#ifdef Q_WS_X11
QXEmbed::initialize();
#endif
d = new KSystemTrayPrivate;
d->actionCollection = new KActionCollection(this);
#ifdef Q_WS_X11
KWin::setSystemTrayWindowFor(winId(), parent ? parent->topLevelWidget()->winId() : qt_xrootwin());
#endif
setBackgroundMode(X11ParentRelative);
setBackgroundOrigin(WindowOrigin);
hasQuit = 0;
menu = new KPopupMenu(this);
menu->insertTitle(kapp->miniIcon(), kapp->caption());
move(-1000, -1000);
KStdAction::quit(this, SLOT(maybeQuit()), d->actionCollection);
if(parentWidget())
{
new KAction(i18n("Minimize"), KShortcut(), this, SLOT(minimizeRestoreAction()), d->actionCollection, "minimizeRestore");
#ifdef Q_WS_X11
KWin::WindowInfo info = KWin::windowInfo(parentWidget()->winId());
d->on_all_desktops = info.onAllDesktops();
#else
d->on_all_desktops = false;
#endif
}
else
{
d->on_all_desktops = false;
}
setCaption(KGlobal::instance()->aboutData()->programName());
setAlignment(alignment() | Qt::AlignVCenter | Qt::AlignHCenter);
}
TsimpleScore::TsimpleScore(int notesNumber, QWidget* parent) :
QGraphicsView(parent),
m_notesNr(notesNumber),
m_bgGlyph(0),
m_prevBGglyph(-1)
{
if (TscoreNote::touchEnabled())
viewport()->setAttribute(Qt::WA_AcceptTouchEvents, true);
else {
viewport()->setAttribute(Qt::WA_AcceptTouchEvents, false);
setMouseTracking(true);
}
m_wheelFree = true;
m_wheelLockTimer = new QTimer(this);
m_wheelLockTimer->setTimerType(Qt::PreciseTimer);
m_wheelLockTimer->setInterval(150);
m_wheelLockTimer->setSingleShot(true);
connect(m_wheelLockTimer, &QTimer::timeout, this, &TsimpleScore::wheelLockSlot);
setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_scene = new TscoreScene(this);
connect(m_scene, SIGNAL(statusTip(QString)), this, SLOT(statusTipChanged(QString)));
setScene(m_scene);
m_staff = new TscoreStaff(m_scene, m_notesNr);
m_staff->enableToAddNotes(false);
m_clefType = m_staff->scoreClef()->clef().type();
connect(m_staff, SIGNAL(noteChanged(int)), this, SLOT(noteWasClicked(int)));
connect(m_staff, SIGNAL(clefChanged(Tclef)), this, SLOT(onClefChanged(Tclef)));
setBGcolor(palette().base().color());
setEnabledDblAccid(false);
setAlignment(Qt::AlignLeft);
resizeEvent(0);
}
/* Places widgets in box accordingly with angle and order */
void placeWidgets (WTApplet *wtapplet) {
// TODO: merge all this... or not?
if (wtapplet->orient == PANEL_APPLET_ORIENT_RIGHT) {
wtapplet->angle = GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE;
} else if (wtapplet->orient == PANEL_APPLET_ORIENT_LEFT) {
wtapplet->angle = GDK_PIXBUF_ROTATE_CLOCKWISE;
} else {
wtapplet->angle = GDK_PIXBUF_ROTATE_NONE;
}
if (wtapplet->angle == GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE) {
wtapplet->packtype = GTK_PACK_END;
} else {
wtapplet->packtype = GTK_PACK_START;
}
// set box orientation
if (wtapplet->angle == GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE || wtapplet->angle == GDK_PIXBUF_ROTATE_CLOCKWISE) {
gtk_orientable_set_orientation(GTK_ORIENTABLE(wtapplet->box), GTK_ORIENTATION_VERTICAL);
} else {
gtk_orientable_set_orientation(GTK_ORIENTABLE(wtapplet->box), GTK_ORIENTATION_HORIZONTAL);
}
// set packing order
if (wtapplet->prefs->swap_order == wtapplet->packtype) {
gtk_box_pack_start(wtapplet->box, GTK_WIDGET(wtapplet->eb_icon), FALSE, TRUE, 0);
gtk_box_pack_start(wtapplet->box, GTK_WIDGET(wtapplet->eb_title), TRUE, TRUE, 0);
} else {
gtk_box_pack_start(wtapplet->box, GTK_WIDGET(wtapplet->eb_title), TRUE, TRUE, 0);
gtk_box_pack_start(wtapplet->box, GTK_WIDGET(wtapplet->eb_icon), FALSE, TRUE, 0);
}
// Set alignment/orientation
gtk_label_set_angle( wtapplet->title, wtapplet->angle );
setAlignment(wtapplet, (gfloat)wtapplet->prefs->alignment);
}