ArtistInfoWidget::ArtistInfoWidget( const Tomahawk::artist_ptr& artist, QWidget* parent )
: QWidget( parent )
, TomahawkUtils::DpiScaler( this )
, ui( new Ui::ArtistInfoWidget )
, m_artist( artist )
{
m_widget = new QWidget;
m_headerWidget = new BasicHeader;
ui->setupUi( m_widget );
{
ui->relatedArtists->setAutoResize( true );
ui->relatedArtists->setAutoFitItems( true );
ui->relatedArtists->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->relatedArtists->setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->relatedArtists->setItemWidth( scaledX( 170 ) );
m_relatedModel = new PlayableModel( ui->relatedArtists );
ui->relatedArtists->setPlayableModel( m_relatedModel );
ui->relatedArtists->proxyModel()->sort( -1 );
ui->relatedArtists->setEmptyTip( tr( "Sorry, we could not find any related artists!" ) );
TomahawkStyle::stylePageFrame( ui->relatedArtists );
TomahawkStyle::stylePageFrame( ui->artistFrame );
TomahawkStyle::styleScrollBar( ui->relatedArtists->verticalScrollBar() );
}
{
ui->albums->setAutoResize( true );
ui->albums->setAutoFitItems( false );
ui->albums->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->albums->setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->albums->setWrapping( false );
ui->albums->setItemWidth( scaledX( 190 ) );
ui->albums->proxyModel()->setHideDupeItems( true );
ui->albums->delegate()->setWordWrapping( true );
ui->albums->setFixedHeight( ui->albums->itemSize().height() + ui->albums->spacing() * 2 );
m_albumsModel = new PlayableModel( ui->albums );
ui->albums->setPlayableModel( m_albumsModel );
ui->albums->proxyModel()->sort( -1 );
ui->albums->setEmptyTip( tr( "Sorry, we could not find any albums for this artist!" ) );
TomahawkStyle::stylePageFrame( ui->albumFrame );
TomahawkStyle::styleScrollBar( ui->albums->verticalScrollBar() );
TomahawkStyle::styleScrollBar( ui->albums->horizontalScrollBar() );
}
{
ui->topHits->setAutoResize( true );
ui->topHits->setAutoFitItems( false );
ui->topHits->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->topHits->setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->topHits->setWrapping( false );
ui->topHits->setItemWidth( scaledX( 140 ) );
ui->topHits->proxyModel()->setHideDupeItems( true );
ui->topHits->delegate()->setWordWrapping( true );
ui->topHits->delegate()->setShowBuyButtons( true );
ui->topHits->setFixedHeight( ui->topHits->itemSize().height() + ui->topHits->spacing() * 2 );
m_topHitsModel = new PlayableModel( ui->topHits );
ui->topHits->setPlayableModel( m_topHitsModel );
ui->topHits->proxyModel()->sort( -1 );
ui->topHits->setEmptyTip( tr( "Sorry, we could not find any top hits for this artist!" ) );
TomahawkStyle::stylePageFrame( ui->trackFrame );
}
{
ui->biography->setObjectName( "biography" );
ui->biography->setContentsMargins( 0, 0, 0, 0 );
ui->biography->page()->mainFrame()->setScrollBarPolicy( Qt::Horizontal, Qt::ScrollBarAlwaysOff );
ui->biography->page()->mainFrame()->setScrollBarPolicy( Qt::Vertical, Qt::ScrollBarAsNeeded );
ui->biography->page()->setLinkDelegationPolicy( QWebPage::DelegateAllLinks );
ui->biography->installEventFilter( this );
TomahawkStyle::stylePageWidget( ui->biography );
TomahawkStyle::stylePageFrame( ui->bioFrame );
connect( ui->biography, SIGNAL( linkClicked( QUrl ) ), SLOT( onBiographyLinkClicked( QUrl ) ) );
QFont f = ui->topHitsMoreLabel->font();
f.setWeight( QFont::Light );
f.setPointSize( TomahawkUtils::defaultFontSize() + 1 );
ui->topHitsMoreLabel->setFont( f );
ui->albumsMoreLabel->setFont( f );
connect( ui->albumsMoreLabel, SIGNAL( clicked() ), SLOT( onAlbumsMoreClicked() ) );
connect( ui->topHitsMoreLabel, SIGNAL( clicked() ), SLOT( onTopHitsMoreClicked() ) );
ui->cover->setFixedSize( scaled( QSize( 384, 384 ) ) );
}
{
m_headerWidget->ui->anchor1Label->setText( tr( "Music" ) );
m_headerWidget->ui->anchor2Label->setText( tr( "Biography" ) );
m_headerWidget->ui->anchor3Label->setText( tr( "Related Artists" ) );
m_headerWidget->ui->anchor1Label->show();
m_headerWidget->ui->anchor2Label->show();
m_headerWidget->ui->anchor3Label->show();
QFontMetrics fm( m_headerWidget->ui->anchor1Label->font() );
m_headerWidget->ui->anchor1Label->setFixedWidth( fm.width( m_headerWidget->ui->anchor1Label->text() ) + 16 );
m_headerWidget->ui->anchor2Label->setFixedWidth( fm.width( m_headerWidget->ui->anchor2Label->text() ) + 16 );
m_headerWidget->ui->anchor3Label->setFixedWidth( fm.width( m_headerWidget->ui->anchor3Label->text() ) + 16 );
connect( m_headerWidget->ui->anchor1Label, SIGNAL( clicked() ), SLOT( onMusicAnchorClicked() ) );
connect( m_headerWidget->ui->anchor2Label, SIGNAL( clicked() ), SLOT( onBioAnchorClicked() ) );
connect( m_headerWidget->ui->anchor3Label, SIGNAL( clicked() ), SLOT( onRelatedArtistsAnchorClicked() ) );
}
m_stackedWidget = new QStackedWidget();
{
m_area = new QScrollArea();
m_area->setWidgetResizable( true );
m_area->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOn );
m_area->setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
m_area->setWidget( m_widget );
QPalette pal = palette();
pal.setBrush( backgroundRole(), TomahawkStyle::PAGE_BACKGROUND );
m_area->setPalette( pal );
m_area->setAutoFillBackground( true );
m_area->setFrameShape( QFrame::NoFrame );
m_area->setAttribute( Qt::WA_MacShowFocusRect, 0 );
m_stackedWidget->addWidget( m_area );
connect( m_area->verticalScrollBar(), SIGNAL( valueChanged(int ) ), SLOT( onSliderValueChanged( int ) ) );
}
{
ContextView* topHitsFullView = new ContextView( m_stackedWidget );
topHitsFullView->setCaption( tr( "Songs" ) );
topHitsFullView->setShowCloseButton( true );
topHitsFullView->trackView()->setPlayableModel( m_topHitsModel );
m_stackedWidget->addWidget( topHitsFullView );
connect( topHitsFullView, SIGNAL( closeClicked() ), SLOT( onPageClosed() ) );
}
{
GridView* albumsFullView = new GridView( m_stackedWidget );
albumsFullView->delegate()->setWordWrapping( true );
// albumsFullView->setCaption( tr( "Albums" ) );
// albumsFullView->setShowCloseButton( true );
albumsFullView->setPlayableModel( m_albumsModel );
albumsFullView->proxyModel()->setHideDupeItems( true );
CaptionLabel* captionLabel = new CaptionLabel( this );
captionLabel->setText( tr( "Albums" ) );
captionLabel->setShowCloseButton( true );
QWidget* vbox = new QWidget;
QPalette pal = vbox->palette();
pal.setBrush( vbox->backgroundRole(), TomahawkStyle::PAGE_BACKGROUND );
vbox->setPalette( pal );
vbox->setAutoFillBackground( true );
QVBoxLayout* vboxl = new QVBoxLayout;
TomahawkUtils::unmarginLayout( vboxl );
vboxl->setContentsMargins( 32, 32, 32, 32 );
vboxl->setSpacing( scaledY( 8 ) );
vbox->setLayout( vboxl );
vboxl->addWidget( captionLabel );
vboxl->addWidget( albumsFullView );
vboxl->addStretch();
vboxl->setStretchFactor( albumsFullView, 1 );
m_stackedWidget->addWidget( vbox );
connect( captionLabel, SIGNAL( clicked() ), SLOT( onPageClosed() ) );
}
{
QVBoxLayout* layout = new QVBoxLayout();
layout->addWidget( m_headerWidget );
layout->addWidget( m_stackedWidget );
setLayout( layout );
TomahawkUtils::unmarginLayout( layout );
}
MetaPlaylistInterface* mpl = new MetaPlaylistInterface();
mpl->addChildInterface( ui->relatedArtists->playlistInterface() );
mpl->addChildInterface( ui->topHits->playlistInterface() );
mpl->addChildInterface( ui->albums->playlistInterface() );
m_plInterface = playlistinterface_ptr( mpl );
onSliderValueChanged( 0 );
TomahawkUtils::fixMargins( this );
m_pixmap = TomahawkUtils::defaultPixmap( TomahawkUtils::DefaultArtistImage, TomahawkUtils::Original, scaled( QSize( 48, 48 ) ) );
load( artist );
}
void WidgetMain::highlight(WidgetMain::HighlightState state)
{
static QColor defaultColor = palette().color(backgroundRole());
QWidget *w = d_widgetConfigTransmission;
switch (state)
{
case Connected:
case Normal:
{
QPalette p(w->palette());
p.setColor(w->backgroundRole(), QColor("#c5ffa0"));
w->setPalette(p);
break;
}
case Disconnected:
{
QPalette p(w->palette());
p.setColor(w->backgroundRole(), defaultColor);
w->setPalette(p);
break;
}
case Error:
{
QPalette p(w->palette());
p.setColor(w->backgroundRole(), QColor("#ff9595"));
w->setPalette(p);
break;
}
}
}
bool QChildWidget::eventFilter(QObject *o, QEvent *e)
{
if (e->type() == QEvent::Paint){
QWidget *w = static_cast<QWidget*>(o);
for (QWidget *p = parentWidget(); p; p = p->parentWidget()){
const QPixmap bg = p->palette().brush(p->backgroundRole()).texture();
if (!bg.isNull()){
QPoint pos = w->mapToGlobal(QPoint(0, 0));
pos = p->mapFromGlobal(pos);
QRect rc(pos.x(), pos.y(), w->width(), w->height());
if (rc != rcChild){
rcChild = rc;
QPixmap new_bg(w->width(), w->height());
QPainter pp(&new_bg);
pp.drawTiledPixmap(0, 0, w->width(), w->height(), bg, pos.x(), pos.y());
pp.end();
QPalette palette = w->palette();
palette.setBrush(w->backgroundRole(), QBrush(new_bg));
w->setPalette(palette);
}
if (!w->palette().brush(w->backgroundRole()).texture().isNull()){
QPainter pp(w);
pp.drawPixmap(0, 0, w->palette().brush(w->backgroundRole()).texture());
}
return true;
}
}
}
return false;
}
int QWidgetProto::backgroundRole() const
{
QWidget *item = qscriptvalue_cast<QWidget*>(thisObject());
if (item)
return item->backgroundRole();
return 0;
}
void DJToolButton::paintEvent( QPaintEvent *event )
{
QWidget *parentWidget = qobject_cast<QWidget*>(parent());
if ( parentWidget ) {
QPalette::ColorRole parentRole = parentWidget->backgroundRole();
QPalette parentPalette = parentWidget->palette();
//QRect rect = parentWidget->rect();
QBrush parentBrush = parentPalette.brush( parentRole );
//QPixmap parentPix(prect.width(),prect.height());
//QPainter p(&pix);
//p.fillRect(0,0,pix.width(),pix.height(),parentbrush);
QPalette pal = palette();
pal.setBrush(QPalette::Button,parentBrush);
setPalette(pal);
}
//QRect qrect = tbw->geometry();
// QRect prect = parent->rect();
/*
QPalette pal = palette();
//pal.setBrush(QPalette::Background,Qt::red);
pal.setBrush(QPalette::Button,Qt::green);
//pal.setBrush(QPalette::Base,Qt::blue);
setPalette(pal);
*/
QToolButton::paintEvent( event );
}
/*!
Draw the background of the canvas
\param painter Painter
*/
void QwtPlotGLCanvas::drawBackground( QPainter *painter )
{
painter->save();
QWidget *w = qwtBGWidget( this );
const QPoint off = mapTo( w, QPoint() );
painter->translate( -off );
const QRect fillRect = rect().translated( off );
if ( w->testAttribute( Qt::WA_StyledBackground ) )
{
painter->setClipRect( fillRect );
QStyleOption opt;
opt.initFrom( w );
w->style()->drawPrimitive( QStyle::PE_Widget, &opt, painter, w);
}
else
{
painter->fillRect( fillRect,
w->palette().brush( w->backgroundRole() ) );
}
painter->restore();
}
ContextView::ContextView( QWidget* parent, const QString& caption )
: QWidget( parent )
, m_trackView( new TrackView() )
, m_temporary( false )
{
TrackItemDelegate* del = new TrackItemDelegate( TrackItemDelegate::LovedTracks, m_trackView, m_trackView->proxyModel() );
m_trackView->setPlaylistItemDelegate( del );
m_trackView->proxyModel()->setStyle( PlayableProxyModel::SingleColumn );
m_trackView->setStyleSheet( QString( "QTreeView { background-color: %1; }" ).arg( TomahawkStyle::PAGE_BACKGROUND.name() ) );
#ifndef Q_OS_MAC
TomahawkStyle::styleScrollBar( m_trackView->verticalScrollBar() );
#endif
setLayout( new QVBoxLayout() );
TomahawkUtils::unmarginLayout( layout() );
m_captionLabel = new CaptionLabel( this );
setCaption( caption );
QWidget* vbox = new QWidget;
QPalette pal = vbox->palette();
pal.setBrush( vbox->backgroundRole(), TomahawkStyle::PAGE_BACKGROUND );
vbox->setPalette( pal );
vbox->setAutoFillBackground( true );
QVBoxLayout* vboxl = new QVBoxLayout();
TomahawkUtils::unmarginLayout( vboxl );
vboxl->setContentsMargins( 32, 32, 32, 32 );
vboxl->setSpacing( 32 );
vbox->setLayout( vboxl );
QWidget* hbox = new QWidget;
QHBoxLayout* hboxl = new QHBoxLayout();
TomahawkUtils::unmarginLayout( hboxl );
hboxl->setSpacing( 32 );
m_innerLayout = new QVBoxLayout();
TomahawkUtils::unmarginLayout( m_innerLayout );
m_innerLayout->addWidget( m_trackView, 1 );
m_innerLayout->addStretch();
m_detailView = new TrackDetailView;
m_detailView->setPlaylistInterface( playlistInterface() );
hboxl->addWidget( m_detailView );
hboxl->addLayout( m_innerLayout );
hbox->setLayout( hboxl );
vboxl->addWidget( m_captionLabel );
vboxl->addWidget( hbox );
layout()->addWidget( vbox );
connect( m_captionLabel, SIGNAL( clicked() ), SIGNAL( closeClicked() ) );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), SLOT( onQuerySelected( Tomahawk::query_ptr ) ) );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), m_detailView, SLOT( setQuery( Tomahawk::query_ptr ) ) );
connect( m_trackView, SIGNAL( modelChanged() ), SLOT( onModelChanged() ) );
TomahawkUtils::fixMargins( this );
}
/*
Should we require that q is a toplevel window ???
Used by QWSManager
*/
void QWidgetPrivate::blitToScreen(const QRegion &globalrgn)
{
Q_Q(QWidget);
QWidget *win = q->window();
QBrush bgBrush = win->palette().brush(win->backgroundRole());
bool opaque = bgBrush.style() == Qt::NoBrush || bgBrush.isOpaque();
QWidget::qwsDisplay()->repaintRegion(win->data->winid, win->windowFlags(), opaque, globalrgn);
}
void ServiceBlock::setCalendarColor(QCalendarWidget *calendarWidget,QColor color)
{
QWidget *calendarNavBar = calendarWidget->findChild<QWidget *>("qt_calendar_navigationbar");
if (calendarNavBar) {
QPalette pal = calendarNavBar->palette();
pal.setColor(calendarNavBar->backgroundRole(), color);
calendarNavBar->setPalette(pal);
}
}
void RKInput::updateColor () {
RK_TRACE (PLUGIN);
QWidget *widget = lineedit;
if (!widget) widget = textedit;
RK_ASSERT (widget);
QPalette palette = widget->palette ();
if (isEnabled ()) {
if (isSatisfied ()) {
palette.setColor (widget->backgroundRole (), QColor (255, 255, 255));
} else {
palette.setColor (widget->backgroundRole (), QColor (255, 0, 0));
}
} else {
palette.setColor (widget->backgroundRole (), QColor (200, 200, 200));
}
widget->setPalette (palette);
}
static void initViewPalette(QAbstractItemView* view, const QColor& fgColor)
{
QWidget* viewport = view->viewport();
QPalette palette = viewport->palette();
palette.setColor(viewport->backgroundRole(), Qt::transparent);
palette.setColor(QPalette::WindowText, fgColor);
palette.setColor(QPalette::Text, fgColor);
// QListView uses QStyledItemDelegate, which uses the view palette for
// foreground color, while KFilePlacesView uses the viewport palette.
viewport->setPalette(palette);
view->setPalette(palette);
}
CalamaresWindow::CalamaresWindow( QWidget* parent )
: QWidget( parent )
{
// Hide close button
setWindowFlags( Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint );
setMinimumSize( 1010, 560 );
QSize availableSize = qApp->desktop()->screenGeometry( this ).size();
int w = qBound( 1010, CalamaresUtils::defaultFontHeight() * 60, availableSize.width() );
int h = qBound( 560, CalamaresUtils::defaultFontHeight() * 36, availableSize.height() );
cDebug() << "Proposed window size:" << w << h;
resize( w, h );
QBoxLayout* mainLayout = new QHBoxLayout;
setLayout( mainLayout );
QWidget* sideBox = new QWidget( this );
mainLayout->addWidget( sideBox );
QBoxLayout* sideLayout = new QVBoxLayout;
sideBox->setLayout( sideLayout );
sideBox->setFixedWidth( qMax( 190, CalamaresUtils::defaultFontHeight() * 12 ) );
sideBox->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
QHBoxLayout* logoLayout = new QHBoxLayout;
sideLayout->addLayout( logoLayout );
logoLayout->addStretch();
QLabel* logoLabel = new QLabel( "branding\ngoes\nhere", sideBox );
{
QPalette plt = sideBox->palette();
sideBox->setAutoFillBackground( true );
plt.setColor( sideBox->backgroundRole(), CalamaresStyle::SIDEBAR_BACKGROUND );
plt.setColor( sideBox->foregroundRole(), CalamaresStyle::SIDEBAR_TEXT );
sideBox->setPalette( plt );
logoLabel->setPalette( plt );
}
logoLabel->setAlignment( Qt::AlignCenter );
logoLabel->setFixedSize( 80, 80 );
logoLayout->addWidget( logoLabel );
logoLayout->addStretch();
ProgressTreeView* tv = new ProgressTreeView( sideBox );
sideLayout->addWidget( tv );
CalamaresUtils::unmarginLayout( sideLayout );
CalamaresUtils::unmarginLayout( mainLayout );
Calamares::ViewManager* vm = new Calamares::ViewManager( this );
mainLayout->addWidget( vm->centralWidget() );
}
void AmbientProperties::on_buttonBackground_clicked()
{
QColor c = QColorDialog::getColor(backSample->palette().color(backSample->backgroundRole()), this);
QPalette p = backSample->palette(); p.setColor(backSample->backgroundRole(), c); backSample->setPalette(p);
p = container->palette(); p.setColor(container->backgroundRole(), c); container->setPalette(p);
if (QWorkspace *ws = qobject_cast<QWorkspace*>(container)) {
QWidgetList list( ws->windowList() );
for (int i = 0; i < list.count(); ++i) {
QWidget *widget = list.at(i);
p = widget->palette(); p.setColor(widget->backgroundRole(), c); widget->setPalette(p);
}
}
}
void QChildWidget::paintEvent(QPaintEvent*)
{
for (QWidget *p = parentWidget(); p; p = p->parentWidget()){
const QPixmap bg = p->palette().brush(p->backgroundRole()).texture();
if (!bg.isNull()){
QPoint pos = mapToGlobal(QPoint(0, 0));
pos = p->mapFromGlobal(pos);
QPainter pp(this);
pp.drawTiledPixmap(0, 0, width(), height(), bg, pos.x(), pos.y());
return;
}
if (p == topLevelWidget())
break;
}
QPainter pp(this);
pp.eraseRect(0, 0, width(), height());
}
int main(int argv, char **args)
{
QApplication app(argv, args);
//! [0]
gradient = QRadialGradient gradient(50, 50, 50, 50, 50)
gradient.setColorAt(0, QColor.fromRgbF(0, 1, 0, 1))
gradient.setColorAt(1, QColor.fromRgbF(0, 0, 0, 0))
brush = QBrush(gradient)
//! [0]
QWidget widget;
QPalette palette;
palette.setBrush(widget.backgroundRole(), brush);
widget.setPalette(palette);
widget.show();
return app.exec();
}
void QwtPlotAbstractCanvas::drawUnstyled( QPainter *painter )
{
fillBackground( painter );
QWidget *w = canvasWidget();
if ( w->autoFillBackground() )
{
const QRect canvasRect = w->rect();
painter->save();
painter->setPen( Qt::NoPen );
painter->setBrush( w->palette().brush( w->backgroundRole() ) );
const QRect frameRect = w->property( "frameRect" ).toRect();
if ( borderRadius() > 0.0 && ( canvasRect == frameRect ) )
{
const int frameWidth = w->property( "frameWidth" ).toInt();
if ( frameWidth > 0 )
{
painter->setClipPath( borderPath2( canvasRect ) );
painter->drawRect( canvasRect );
}
else
{
painter->setRenderHint( QPainter::Antialiasing, true );
painter->drawPath( borderPath2( canvasRect ) );
}
}
else
{
painter->drawRect( canvasRect );
}
painter->restore();
}
drawCanvas( painter );
}
QColor BACKGROUND(const QWidget& w) {
w.ensurePolished();
return w.palette().color(w.backgroundRole());
}
// NOTE: The X11 version of createSurface will re-create the native drawable if it's visual doesn't
// match the one for the passed in EGLConfig
EGLSurface QEgl::createSurface(QPaintDevice *device, EGLConfig config, const QEglProperties *unusedProperties)
{
Q_UNUSED(unusedProperties);
int devType = device->devType();
if (devType == QInternal::Pbuffer) {
// TODO
return EGL_NO_SURFACE;
}
QX11PixmapData *x11PixmapData = 0;
if (devType == QInternal::Pixmap) {
QPixmapData *pmd = static_cast<QPixmap*>(device)->data_ptr().data();
if (pmd->classId() == QPixmapData::X11Class)
x11PixmapData = static_cast<QX11PixmapData*>(pmd);
else {
// TODO: Replace the pixmap's data with a new QX11PixmapData
qWarning("WARNING: Creating an EGL surface on a QPixmap is only supported for QX11PixmapData");
return EGL_NO_SURFACE;
}
} else if ((devType != QInternal::Widget) && (devType != QInternal::Pbuffer)) {
qWarning("WARNING: Creating an EGLSurface for device type %d isn't supported", devType);
return EGL_NO_SURFACE;
}
VisualID visualId = QEgl::getCompatibleVisualId(config);
EGLint alphaSize;
eglGetConfigAttrib(QEgl::display(), config, EGL_ALPHA_SIZE, &alphaSize);
if (devType == QInternal::Widget) {
QWidget *widget = static_cast<QWidget*>(device);
VisualID currentVisualId = 0;
if (widget->testAttribute(Qt::WA_WState_Created))
currentVisualId = XVisualIDFromVisual((Visual*)widget->x11Info().visual());
if (currentVisualId != visualId) {
// The window is either not created or has the wrong visual. Either way, we need
// to create a window with the correct visual and call create() on the widget:
bool visible = widget->isVisible();
if (visible)
widget->hide();
XVisualInfo visualInfo;
visualInfo.visualid = visualId;
{
XVisualInfo *visualInfoPtr;
int matchingCount = 0;
visualInfoPtr = XGetVisualInfo(widget->x11Info().display(), VisualIDMask,
&visualInfo, &matchingCount);
Q_ASSERT(visualInfoPtr); // visualId really should be valid!
visualInfo = *visualInfoPtr;
XFree(visualInfoPtr);
}
Window parentWindow = RootWindow(widget->x11Info().display(), widget->x11Info().screen());
if (widget->parentWidget())
parentWindow = widget->parentWidget()->winId();
XSetWindowAttributes windowAttribs;
QColormap colmap = QColormap::instance(widget->x11Info().screen());
windowAttribs.background_pixel = colmap.pixel(widget->palette().color(widget->backgroundRole()));
windowAttribs.border_pixel = colmap.pixel(Qt::black);
unsigned int valueMask = CWBackPixel|CWBorderPixel;
if (alphaSize > 0) {
windowAttribs.colormap = XCreateColormap(widget->x11Info().display(), parentWindow,
visualInfo.visual, AllocNone);
valueMask |= CWColormap;
}
Window window = XCreateWindow(widget->x11Info().display(), parentWindow,
widget->x(), widget->y(), widget->width(), widget->height(),
0, visualInfo.depth, InputOutput, visualInfo.visual,
valueMask, &windowAttribs);
// This is a nasty hack to get round the fact that we can't be a friend of QWidget:
qt_set_winid_on_widget(widget, window);
if (visible)
widget->show();
}
// At this point, the widget's window should be created and have the correct visual. Now we
// just need to create the EGL surface for it:
EGLSurface surf = eglCreateWindowSurface(QEgl::display(), config, (EGLNativeWindowType)widget->winId(), 0);
if (surf == EGL_NO_SURFACE)
qWarning("QEglContext::createSurface(): Unable to create EGL surface, error = 0x%x", eglGetError());
return surf;
}
if (x11PixmapData) {
// X11 Pixmaps are only created with a depth, so that's all we need to check
EGLint configDepth;
eglGetConfigAttrib(QEgl::display(), config, EGL_BUFFER_SIZE , &configDepth);
if (x11PixmapData->depth() != configDepth) {
// The bit depths are wrong which means the EGLConfig isn't compatable with
// this pixmap. So we need to replace the pixmap's existing data with a new
// one which is created with the correct depth:
#ifndef QT_NO_XRENDER
if (configDepth == 32) {
qWarning("Warning: EGLConfig's depth (32) != pixmap's depth (%d), converting to ARGB32",
x11PixmapData->depth());
x11PixmapData->convertToARGB32(true);
} else
#endif
{
qWarning("Warning: EGLConfig's depth (%d) != pixmap's depth (%d)",
configDepth, x11PixmapData->depth());
}
}
QEglProperties surfaceAttribs;
// If the pixmap can't be bound to a texture, it's pretty useless
surfaceAttribs.setValue(EGL_TEXTURE_TARGET, EGL_TEXTURE_2D);
if (alphaSize > 0)
surfaceAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA);
else
surfaceAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);
EGLSurface surf = eglCreatePixmapSurface(QEgl::display(), config,
(EGLNativePixmapType) x11PixmapData->handle(),
surfaceAttribs.properties());
x11PixmapData->gl_surface = (void*)surf;
QImagePixmapCleanupHooks::enableCleanupHooks(x11PixmapData);
return surf;
}
return EGL_NO_SURFACE;
}
ContextView::ContextView( QWidget* parent, const QString& caption )
: QWidget( parent )
// , m_header( new FilterHeader( this ) )
, m_trackView( new TrackView() )
, m_model( 0 )
, m_temporary( false )
{
// qRegisterMetaType< ContextViewMode >( "ContextViewMode" );
/* m_detailedView->setColumnHidden( PlayableModel::Age, true ); // Hide age column per default
m_detailedView->setColumnHidden( PlayableModel::Filesize, true ); // Hide filesize column per default
m_detailedView->setColumnHidden( PlayableModel::Composer, true ); // Hide composer column per default*/
TrackItemDelegate* del = new TrackItemDelegate( TrackItemDelegate::LovedTracks, m_trackView, m_trackView->proxyModel() );
m_trackView->setPlaylistItemDelegate( del );
m_trackView->proxyModel()->setStyle( PlayableProxyModel::Large );
TomahawkStyle::styleScrollBar( m_trackView->verticalScrollBar() );
setLayout( new QVBoxLayout() );
TomahawkUtils::unmarginLayout( layout() );
m_trackView->setStyleSheet( QString( "QTreeView { background-color: white; }" ) );
// m_gridView->setStyleSheet( QString( "QListView { background-color: white; }" ) );
m_captionLabel = new CaptionLabel( this );
setCaption( caption );
QWidget* vbox = new QWidget;
QPalette pal = vbox->palette();
pal.setBrush( vbox->backgroundRole(), Qt::white );
vbox->setPalette( pal );
vbox->setAutoFillBackground( true );
QVBoxLayout* vboxl = new QVBoxLayout;
TomahawkUtils::unmarginLayout( vboxl );
vboxl->setContentsMargins( 32, 32, 32, 32 );
vboxl->setSpacing( 32 );
vbox->setLayout( vboxl );
QWidget* hbox = new QWidget;
QHBoxLayout* hboxl = new QHBoxLayout;
TomahawkUtils::unmarginLayout( hboxl );
hboxl->setSpacing( 32 );
QVBoxLayout* vboxInner = new QVBoxLayout;
TomahawkUtils::unmarginLayout( vboxInner );
vboxInner->addWidget( m_trackView );
vboxInner->addStretch();
vboxInner->setStretchFactor( m_trackView, 1 );
TrackDetailView* detailView = new TrackDetailView;
detailView->setPlaylistInterface( playlistInterface() );
hboxl->addWidget( detailView );
hboxl->addLayout( vboxInner );
hbox->setLayout( hboxl );
vboxl->addWidget( m_captionLabel );
vboxl->addWidget( hbox );
layout()->addWidget( vbox );
connect( m_captionLabel, SIGNAL( clicked() ), SIGNAL( closeClicked() ) );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), SLOT( onQuerySelected( Tomahawk::query_ptr ) ) );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), detailView, SLOT( setQuery( Tomahawk::query_ptr ) ) );
// connect( m_header, SIGNAL( filterTextChanged( QString ) ), SLOT( setFilter( QString ) ) );
}
// -----------------------------------------------------------
// Applies any changed settings
/// \todo simplify the conditionals involving `changed = true`
/// if user hit apply, save settings and refresh everything
void QucsSettingsDialog::slotApply()
{
bool changed = false;
bool homeDirChanged = false;
// check QucsHome is changed, will require to close all files and refresh tree
if (homeEdit->text() != QucsSettings.QucsHomeDir.path()) {
// close all open files, asking the user whether to save the modified ones
// if user aborts closing, just return
if(!App->closeAllFiles()) return;
QucsSettings.QucsHomeDir = homeEdit->text();
homeDirChanged = true;
// later below the file tree will be refreshed
}
if(QucsSettings.BGColor != BGColorButton->palette().color(BGColorButton->backgroundRole()))
{
QucsSettings.BGColor = BGColorButton->palette().color(BGColorButton->backgroundRole());
int No=0;
QWidget *w;
while((w=App->DocumentTab->widget(No++)) != 0) {
QWidget *vp;
if(QucsApp::isTextDocument(w)) {
vp = ((TextDoc*)w)->viewport();
} else {
vp = ((Schematic*)w)->viewport();
}
QPalette p = vp->palette();
p.setColor(vp->backgroundRole(), QucsSettings.BGColor);
vp->setPalette(p);
}
changed = true;
}
QucsSettings.font=Font;
QucsSettings.Language =
LanguageCombo->currentText().section('(',1,1).remove(')');
if(QucsSettings.Comment != ColorComment->palette().color(ColorComment->foregroundRole()))
{
QucsSettings.Comment = ColorComment->palette().color(ColorComment->foregroundRole());
changed = true;
}
if(QucsSettings.String != ColorString->palette().color(ColorString->foregroundRole()))
{
QucsSettings.String = ColorString->palette().color(ColorString->foregroundRole());
changed = true;
}
if(QucsSettings.Integer != ColorInteger->palette().color(ColorInteger->foregroundRole()))
{
QucsSettings.Integer = ColorInteger->palette().color(ColorInteger->foregroundRole());
changed = true;
}
if(QucsSettings.Real != ColorReal->palette().color(ColorReal->foregroundRole()))
{
QucsSettings.Real = ColorReal->palette().color(ColorReal->foregroundRole());
changed = true;
}
if(QucsSettings.Character != ColorCharacter->palette().color(ColorCharacter->foregroundRole()))
{
QucsSettings.Character = ColorCharacter->palette().color(ColorCharacter->foregroundRole());
changed = true;
}
if(QucsSettings.Type != ColorDataType->palette().color(ColorDataType->foregroundRole()))
{
QucsSettings.Type = ColorDataType->palette().color(ColorDataType->foregroundRole());
changed = true;
}
if(QucsSettings.Attribute != ColorAttribute->palette().color(ColorAttribute->foregroundRole()))
{
QucsSettings.Attribute = ColorAttribute->palette().color(ColorAttribute->foregroundRole());
changed = true;
}
if(QucsSettings.Directive != ColorDirective->palette().color(ColorDirective->foregroundRole()))
{
QucsSettings.Directive = ColorDirective->palette().color(ColorDirective->foregroundRole());
changed = true;
}
if(QucsSettings.Task != ColorTask->palette().color(ColorTask->foregroundRole()))
{
QucsSettings.Task = ColorTask->palette().color(ColorTask->foregroundRole());
changed = true;
}
bool ok;
if(QucsSettings.maxUndo != undoNumEdit->text().toUInt(&ok))
{
QucsSettings.maxUndo = undoNumEdit->text().toInt(&ok);
changed = true;
}
if(QucsSettings.Editor != editorEdit->text())
{
QucsSettings.Editor = editorEdit->text();
changed = true;
}
if(QucsSettings.NodeWiring != (unsigned)checkWiring->isChecked())
{
QucsSettings.NodeWiring = checkWiring->isChecked();
changed = true;
}
QucsSettings.FileTypes.clear();
for (int row=0; row < fileTypesTableWidget->rowCount(); row++)
{
QucsSettings.FileTypes.append(fileTypesTableWidget->item(row,0)->text()
+"/"+
fileTypesTableWidget->item(row,1)->text());
}
/*! Update QucsSettings, tool paths */
QucsSettings.AdmsXmlBinDir = admsXmlEdit->text();
QucsSettings.AscoBinDir = ascoEdit->text();
QucsSettings.OctaveExecutable = octaveEdit->text();
if (QucsSettings.IgnoreFutureVersion != checkLoadFromFutureVersions->isChecked())
{
QucsSettings.IgnoreFutureVersion = checkLoadFromFutureVersions->isChecked();
changed = true;
}
if (QucsSettings.GraphAntiAliasing != checkAntiAliasing->isChecked())
{
QucsSettings.GraphAntiAliasing = checkAntiAliasing->isChecked();
changed = true;
}
if (QucsSettings.TextAntiAliasing != checkTextAntiAliasing->isChecked())
{
QucsSettings.TextAntiAliasing = checkTextAntiAliasing->isChecked();
changed = true;
}
// use toDouble() as it can interpret the string according to the current locale
if (QucsSettings.largeFontSize != LargeFontSizeEdit->text().toDouble(&ok))
{
QucsSettings.largeFontSize = LargeFontSizeEdit->text().toDouble(&ok);
changed = true;
}
saveApplSettings(); // also sets the small and large font
// if QucsHome is changed, refresh projects tree
// do this after updating the other paths
if (homeDirChanged) {;
// files were actuallt closed above, this will refresh the projects tree
// and create an empty schematic
App->slotMenuProjClose();
changed = true;
}
if(changed)
{
App->readProjects();
App->slotUpdateTreeview();
App->repaint();
}
// update the schenatic filelist hash
QucsMain->updatePathList(currentPaths);
QucsMain->updateSchNameHash();
QucsMain->updateSpiceNameHash();
}
pFileDialog::pFileDialog( QWidget* parent, const QString& caption, const QString& directory, const QString& filter, bool textCodecEnabled, bool openReadOnlyEnabled )
: QFileDialog( parent, caption, directory, filter )
{
setFileMode( QFileDialog::AnyFile );
setOption( QFileDialog::DontUseNativeDialog );
// get grid layout
glDialog = qobject_cast<QGridLayout*>( layout() );
// assert on gridlayout
Q_ASSERT( glDialog );
// relook the dialog to be more friendly
QLabel* lLookIn = findChild<QLabel*>( "lookInLabel" );
QComboBox* cbLookIn = findChild<QComboBox*>( "lookInCombo" );
QToolButton* tbNewFolder = findChild<QToolButton*>( "newFolderButton" );
QAbstractItemView* sidebar = findChild<QAbstractItemView*>( "sidebar" );
QFrame* fFrame = findChild<QFrame*>( "frame" );
QBoxLayout* hLayout = 0;
// search layout containing tbNewFolder
foreach ( QLayout* layout, findChildren<QLayout*>() ) {
if ( layout->indexOf( tbNewFolder ) != -1 ) {
hLayout = qobject_cast<QBoxLayout*>( layout );
break;
}
}
if ( lLookIn ) {
lLookIn->setVisible( false );
}
if ( hLayout ) {
hLayout->setSpacing( 3 );
hLayout->insertStretch( hLayout->indexOf( tbNewFolder ) );
}
if ( cbLookIn && fFrame ) {
QBoxLayout* vLayout = qobject_cast<QBoxLayout*>( fFrame->layout() );
if ( vLayout ) {
vLayout->setSpacing( 3 );
vLayout->insertWidget( 0, cbLookIn );
if ( hLayout ) {
glDialog->removeItem( hLayout );
hLayout->setParent( 0 );
vLayout->insertLayout( 0, hLayout );
}
}
}
if ( sidebar ) {
QWidget* viewport = sidebar->viewport();
QPalette pal = viewport->palette();
pal.setColor( viewport->backgroundRole(), QColor( Qt::transparent ) );
viewport->setPalette( pal );
sidebar->setFrameStyle( QFrame::NoFrame | QFrame::Plain );
sidebar->setIconSize( QSize( 16, 16 ) );
}
// text codec
mTextCodecEnabled = true;
lCodec = new QLabel( tr( "Codec:" ), this );
cbCodec = new QComboBox( this );
cbCodec->addItems( pCoreUtils::textCodecs() );
setTextCodec( QTextCodec::codecForLocale()->name() );
glDialog->addWidget( lCodec, 4, 0 );
glDialog->addWidget( cbCodec, 4, 1 );
// read only
mOpenReadOnlyEnabled = true;
cbOpenReadOnly = new QCheckBox( tr( "Open in read only." ), this );
glDialog->addWidget( cbOpenReadOnly, 5, 1 );
// configuration
setTextCodecEnabled( textCodecEnabled );
setOpenReadOnlyEnabled( openReadOnlyEnabled );
}
InformationPanelContent::InformationPanelContent(QWidget* parent) :
QWidget(parent),
m_item(),
m_previewJob(0),
m_outdatedPreviewTimer(0),
m_preview(0),
m_phononWidget(0),
m_nameLabel(0),
m_metaDataWidget(0),
m_metaDataArea(0),
m_placesItemModel(0)
{
parent->installEventFilter(this);
// Initialize timer for disabling an outdated preview with a small
// delay. This prevents flickering if the new preview can be generated
// within a very small timeframe.
m_outdatedPreviewTimer = new QTimer(this);
m_outdatedPreviewTimer->setInterval(300);
m_outdatedPreviewTimer->setSingleShot(true);
connect(m_outdatedPreviewTimer, &QTimer::timeout,
this, &InformationPanelContent::markOutdatedPreview);
QVBoxLayout* layout = new QVBoxLayout(this);
// preview
const int minPreviewWidth = KIconLoader::SizeEnormous + KIconLoader::SizeMedium;
m_preview = new PixmapViewer(parent);
m_preview->setMinimumWidth(minPreviewWidth);
m_preview->setMinimumHeight(KIconLoader::SizeEnormous);
m_phononWidget = new PhononWidget(parent);
m_phononWidget->hide();
m_phononWidget->setMinimumWidth(minPreviewWidth);
connect(m_phononWidget, &PhononWidget::hasVideoChanged,
this, &InformationPanelContent::slotHasVideoChanged);
// name
m_nameLabel = new QLabel(parent);
QFont font = m_nameLabel->font();
font.setBold(true);
m_nameLabel->setFont(font);
m_nameLabel->setTextFormat(Qt::PlainText);
m_nameLabel->setAlignment(Qt::AlignHCenter);
m_nameLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
const bool previewsShown = InformationPanelSettings::previewsShown();
m_preview->setVisible(previewsShown);
#ifndef HAVE_BALOO
m_metaDataWidget = new KFileMetaDataWidget(parent);
connect(m_metaDataWidget, &KFileMetaDataWidget::urlActivated,
this, &InformationPanelContent::urlActivated);
#else
m_metaDataWidget = new Baloo::FileMetaDataWidget(parent);
connect(m_metaDataWidget, &Baloo::FileMetaDataWidget::urlActivated,
this, &InformationPanelContent::urlActivated);
#endif
m_metaDataWidget->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
m_metaDataWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
// Encapsulate the MetaDataWidget inside a container that has a dummy widget
// at the bottom. This prevents that the meta data widget gets vertically stretched
// in the case where the height of m_metaDataArea > m_metaDataWidget.
QWidget* metaDataWidgetContainer = new QWidget(parent);
QVBoxLayout* containerLayout = new QVBoxLayout(metaDataWidgetContainer);
containerLayout->setContentsMargins(0, 0, 0, 0);
containerLayout->setSpacing(0);
containerLayout->addWidget(m_metaDataWidget);
containerLayout->addStretch();
m_metaDataArea = new QScrollArea(parent);
m_metaDataArea->setWidget(metaDataWidgetContainer);
m_metaDataArea->setWidgetResizable(true);
m_metaDataArea->setFrameShape(QFrame::NoFrame);
QWidget* viewport = m_metaDataArea->viewport();
viewport->installEventFilter(this);
QPalette palette = viewport->palette();
palette.setColor(viewport->backgroundRole(), QColor(Qt::transparent));
viewport->setPalette(palette);
layout->addWidget(m_preview);
layout->addWidget(m_phononWidget);
layout->addWidget(m_nameLabel);
layout->addWidget(new KSeparator());
layout->addWidget(m_metaDataArea);
m_placesItemModel = new PlacesItemModel(this);
}
KAstTopLevel::KAstTopLevel( QWidget *parent)
: QMainWindow(parent)
{
QWidget *border = new QWidget( this );
QPalette palette;
palette.setColor(border->backgroundRole(), Qt::black);
border->setPalette(palette);
setCentralWidget( border );
QVBoxLayout *borderLayout = new QVBoxLayout( border );
borderLayout->addStretch( 1 );
QWidget *mainWin = new QWidget( border );
#if defined(Q_WS_MAEMO_5)
mainWin->setFixedSize(800, 430);
#elif defined(Q_OS_SYMBIAN)
mainWin->setFixedSize(640, 340);
#else
mainWin->setFixedSize(640, 480);
#endif
borderLayout->addWidget( mainWin, 0, Qt::AlignHCenter );
borderLayout->addStretch( 1 );
view = new KAsteroidsView( mainWin );
view->setFocusPolicy( Qt::StrongFocus );
connect( view, SIGNAL(shipKilled()), SLOT(slotShipKilled()) );
connect( view, SIGNAL(rockHit(int)), SLOT(slotRockHit(int)) );
connect( view, SIGNAL(rocksRemoved()), SLOT(slotRocksRemoved()) );
connect( view, SIGNAL(updateVitals()), SLOT(slotUpdateVitals()) );
QVBoxLayout *vb = new QVBoxLayout( mainWin );
QHBoxLayout *hb = new QHBoxLayout;
QHBoxLayout *hbd = new QHBoxLayout;
vb->addLayout( hb );
#if defined(Q_OS_SYMBIAN)
QFont labelFont( "helvetica", 8 );
#else
QFont labelFont( "helvetica", 24 );
#endif
QPalette pal(Qt::darkGreen, Qt::black, QColor( 128, 128, 128 ), QColor( 64, 64, 64 ), Qt::black, Qt::darkGreen, Qt::black);
mainWin->setPalette( pal );
hb->addSpacing( 10 );
QLabel *label;
label = new QLabel( tr("Score"), mainWin );
label->setFont( labelFont );
label->setPalette( pal );
label->setFixedWidth( label->sizeHint().width() );
hb->addWidget( label );
scoreLCD = new QLCDNumber( 6, mainWin );
scoreLCD->setFrameStyle( QFrame::NoFrame );
scoreLCD->setSegmentStyle( QLCDNumber::Flat );
scoreLCD->setFixedWidth( 150 );
scoreLCD->setPalette( pal );
hb->addWidget( scoreLCD );
hb->addStretch( 10 );
label = new QLabel( tr("Level"), mainWin );
label->setFont( labelFont );
label->setPalette( pal );
label->setFixedWidth( label->sizeHint().width() );
hb->addWidget( label );
levelLCD = new QLCDNumber( 2, mainWin );
levelLCD->setFrameStyle( QFrame::NoFrame );
levelLCD->setSegmentStyle( QLCDNumber::Flat );
levelLCD->setFixedWidth( 70 );
levelLCD->setPalette( pal );
hb->addWidget( levelLCD );
hb->addStretch( 10 );
label = new QLabel( tr("Ships"), mainWin );
label->setFont( labelFont );
label->setFixedWidth( label->sizeHint().width() );
label->setPalette( pal );
hb->addWidget( label );
shipsLCD = new QLCDNumber( 1, mainWin );
shipsLCD->setFrameStyle( QFrame::NoFrame );
shipsLCD->setSegmentStyle( QLCDNumber::Flat );
shipsLCD->setFixedWidth( 40 );
shipsLCD->setPalette( pal );
hb->addWidget( shipsLCD );
hb->addStrut( 30 );
vb->addWidget( view, 10 );
// -- bottom layout:
vb->addLayout( hbd );
#if defined(Q_OS_SYMBIAN)
QFont smallFont( "helvetica", 6 );
#else
QFont smallFont( "helvetica", 14 );
#endif
hbd->addSpacing( 10 );
QString sprites_prefix = ":/trolltech/examples/graphicsview/portedasteroids/sprites/";
/*
label = new QLabel( tr( "T" ), mainWin );
label->setFont( smallFont );
label->setFixedWidth( label->sizeHint().width() );
label->setPalette( pal );
hbd->addWidget( label );
teleportsLCD = new QLCDNumber( 1, mainWin );
teleportsLCD->setFrameStyle( QFrame::NoFrame );
teleportsLCD->setSegmentStyle( QLCDNumber::Flat );
teleportsLCD->setPalette( pal );
teleportsLCD->setFixedHeight( 20 );
hbd->addWidget( teleportsLCD );
hbd->addSpacing( 10 );
*/
QPixmap pm( sprites_prefix + "powerups/brake.png" );
label = new QLabel( mainWin );
label->setPixmap( pm );
label->setFixedWidth( label->sizeHint().width() );
label->setPalette( pal );
hbd->addWidget( label );
brakesLCD = new QLCDNumber( 1, mainWin );
brakesLCD->setFrameStyle( QFrame::NoFrame );
brakesLCD->setSegmentStyle( QLCDNumber::Flat );
brakesLCD->setPalette( pal );
brakesLCD->setFixedHeight( 20 );
hbd->addWidget( brakesLCD );
hbd->addSpacing( 10 );
pm.load( sprites_prefix + "powerups/shield.png" );
label = new QLabel( mainWin );
label->setPixmap( pm );
label->setFixedWidth( label->sizeHint().width() );
label->setPalette( pal );
hbd->addWidget( label );
shieldLCD = new QLCDNumber( 1, mainWin );
shieldLCD->setFrameStyle( QFrame::NoFrame );
shieldLCD->setSegmentStyle( QLCDNumber::Flat );
shieldLCD->setPalette( pal );
shieldLCD->setFixedHeight( 20 );
hbd->addWidget( shieldLCD );
hbd->addSpacing( 10 );
pm.load( sprites_prefix + "powerups/shoot.png" );
label = new QLabel( mainWin );
label->setPixmap( pm );
label->setFixedWidth( label->sizeHint().width() );
label->setPalette( pal );
hbd->addWidget( label );
shootLCD = new QLCDNumber( 1, mainWin );
shootLCD->setFrameStyle( QFrame::NoFrame );
shootLCD->setSegmentStyle( QLCDNumber::Flat );
shootLCD->setPalette( pal );
shootLCD->setFixedHeight( 20 );
hbd->addWidget( shootLCD );
hbd->addStretch( 1 );
label = new QLabel( tr( "Fuel" ), mainWin );
label->setFont( smallFont );
label->setFixedWidth( label->sizeHint().width() + 10 );
label->setPalette( pal );
hbd->addWidget( label );
powerMeter = new KALedMeter( mainWin );
powerMeter->setFrameStyle( QFrame::Box | QFrame::Plain );
powerMeter->setRange( MAX_POWER_LEVEL );
powerMeter->addColorRange( 10, Qt::darkRed );
powerMeter->addColorRange( 20, QColor(160, 96, 0) );
powerMeter->addColorRange( 70, Qt::darkGreen );
powerMeter->setCount( 40 );
powerMeter->setPalette( pal );
powerMeter->setFixedSize( 200, 12 );
hbd->addWidget( powerMeter );
shipsRemain = 3;
showHiscores = FALSE;
actions.insert( Qt::Key_Up, Thrust );
actions.insert( Qt::Key_Left, RotateLeft );
actions.insert( Qt::Key_Right, RotateRight );
actions.insert( Qt::Key_Space, Shoot );
actions.insert( Qt::Key_Z, Teleport );
actions.insert( Qt::Key_X, Brake );
actions.insert( Qt::Key_S, Shield );
actions.insert( Qt::Key_P, Pause );
actions.insert( Qt::Key_L, Launch );
actions.insert( Qt::Key_N, NewGame );
#if defined(Q_OS_SYMBIAN)
actions.insert( 122, Teleport );
actions.insert( 120, Brake );
actions.insert( 115, Shield );
actions.insert( 112, Pause );
actions.insert( 108, Launch );
actions.insert( 110, NewGame );
#endif
view->showText( tr( "Press N to start playing" ), Qt::yellow );
}
QArvMainWindow::QArvMainWindow(QWidget* parent, bool standalone_)
: QMainWindow(parent)
, camera(NULL)
, decoder(NULL)
, playing(false)
, recording(false)
, started(false)
, drawHistogram(false)
, standalone(standalone_)
, imageTransform()
, imageTransform_flip(0)
, imageTransform_rot(0)
, toDisableWhenPlaying()
, toDisableWhenRecording()
, futureHoldsAHistogram(false)
, recordingTimeCumulative(0)
{
setAttribute(Qt::WA_DeleteOnClose);
logMessage() << "Please ignore \"Could not resolve property\" warnings "
"unless icons look bad.";
setupUi(this);
on_statusTimeoutSpinbox_valueChanged(statusTimeoutSpinbox->value());
messageList->connect(&QArvDebug::messageSender,
SIGNAL(newDebugMessage(QString)),
SLOT(appendPlainText(QString)));
workthread = new Workthread(this);
connect(workthread, SIGNAL(frameRendered()), SLOT(frameRendered()));
connect(workthread, SIGNAL(recordingStopped()), SLOT(stopRecording()));
// Setup theme icons if available.
/*
bool usingFallbackIcons = false;
QMap<QAbstractButton*, QString> icons;
icons[unzoomButton] = "zoom-original";
icons[playButton] = "media-playback-start";
icons[refreshCamerasButton] = "view-refresh";
icons[chooseFilenameButton] = "document-open";
icons[chooseSnappathButton] = "document-open";
icons[editGainButton] = "edit-clear-locationbar-rtl";
icons[editExposureButton] = "edit-clear-locationbar-rtl";
icons[histogramLog] = "view-object-histogram-logarithmic";
icons[pickROIButton] = "edit-select";
for (auto i = icons.begin(); i != icons.end(); i++) {
if (!QIcon::hasThemeIcon(*i)) {
i.key()->setIcon(QIcon(QString(qarv_datafiles) + *i + ".svgz"));
usingFallbackIcons = true;
}
}
QMap<QAction*, QString> aicons;
aicons[showVideoAction] = "video-display";
aicons[recordAction] = "media-record";
aicons[closeFileAction] = "media-playback-stop";
aicons[showHistogramAction] = "office-chart-bar";
aicons[messageAction] = "dialog-information";
for (auto i = aicons.begin(); i != aicons.end(); i++) {
if (!QIcon::hasThemeIcon(*i)) {
i.key()->setIcon(QIcon(QString(qarv_datafiles) + *i + ".svgz"));
usingFallbackIcons = true;
}
}
if (usingFallbackIcons)
logMessage()
<< "Some icons are not available in your theme, using bundled icons.";
*/
{
auto d = QDate::currentDate();
int y = d.year(), l = d.month(), a = d.day();
int j = y % 19;
int k = y / 100;
int h = y % 100;
int m = k / 4;
int n = k % 4;
int p = (k + 8) / 25;
int q = (k - p + 1) / 3;
int r = (19 * j + k - m - q + 15) % 30;
int s = h / 4;
int u = h % 4;
int v = (32 + 2 * n + 2 * s - r - u) % 7;
int w = (j + 11 * r + 22 * v) / 451;
int x = r + v - 7 * w + 114;
int z = x % 31 + 1;
x = x / 31;
if (l == x && (z == a || z + 1 == a || z - 1 == a)) {
QWidget* wgt = new QWidget(this);
wgt->setLayout(new QHBoxLayout);
wgt->layout()->setMargin(30);
char tmp[10];
std::strcpy(tmp, "$6872F=E");
for (int i = 0; i < 8; i++)
tmp[i] = (tmp[i] + (16 ^ 63)) % (1 << 7);
auto r = new QPushButton(tmp);
wgt->layout()->addWidget(r);
connect(r, SIGNAL(clicked(bool)), SLOT(on_replayButton_clicked(bool)));
QPalette p = wgt->palette();
p.setColor(wgt->backgroundRole(), qRgb(226, 53, 48));
wgt->setPalette(p);
wgt->setAutoFillBackground(true);
}
}
// Setup the subwindows menu.
auto submenu = new QMenu;
submenu->addAction(showVideoAction);
submenu->addAction(showHistogramAction);
submenu->addAction(messageAction);
auto toolbutton = new QToolButton;
toolbutton->setMenu(submenu);
toolbutton->setPopupMode(QToolButton::InstantPopup);
toolbutton->setToolButtonStyle(Qt::ToolButtonTextOnly);
toolbutton->setText(tr("Subwindows"));
subwindowToolbar->addWidget(toolbutton);
// Setup the postproc filter menu
auto plugins = QPluginLoader::staticInstances();
auto postprocMenu = new QMenu;
foreach (auto plugin, plugins) {
auto filterPlugin = qobject_cast<ImageFilterPlugin*>(plugin);
if (filterPlugin != NULL) {
auto action = new QAction(filterPlugin->name(), this);
action->setData(QVariant::fromValue(filterPlugin));
connect(action, SIGNAL(triggered(bool)), SLOT(addPostprocFilter()));
postprocMenu->addAction(action);
}
}
FlexibleView::FlexibleView( QWidget* parent, QWidget* extraHeader )
: QWidget( parent )
, m_header( new FilterHeader( this ) )
, m_trackView( new TrackView() )
, m_detailedView( new TrackView() )
, m_gridView( new GridView() )
, m_model( 0 )
, m_temporary( false )
{
qRegisterMetaType< FlexibleViewMode >( "FlexibleViewMode" );
m_header->setBackground( ImageRegistry::instance()->pixmap( RESPATH "images/playlist_background.png", QSize( 0, 0 ) ) );
// m_trackView->setPlaylistInterface( m_playlistInterface );
m_detailedView->setPlaylistInterface( m_trackView->proxyModel()->playlistInterface() );
m_gridView->setPlaylistInterface( m_trackView->proxyModel()->playlistInterface() );
m_detailedView->setColumnHidden( PlayableModel::Age, true ); // Hide age column per default
m_detailedView->setColumnHidden( PlayableModel::Filesize, true ); // Hide filesize column per default
m_detailedView->setColumnHidden( PlayableModel::Composer, true ); // Hide composer column per default
TrackItemDelegate* del = new TrackItemDelegate( TrackItemDelegate::LovedTracks, m_trackView, m_trackView->proxyModel() );
m_trackView->setPlaylistItemDelegate( del );
m_trackView->proxyModel()->setStyle( PlayableProxyModel::Large );
m_stack = new QStackedWidget();
setLayout( new QVBoxLayout() );
TomahawkUtils::unmarginLayout( layout() );
m_trackView->setStyleSheet( QString( "QTreeView { background-color: white; }" ) );
m_gridView->setStyleSheet( QString( "QListView { background-color: white; }" ) );
TomahawkStyle::styleScrollBar( m_trackView->verticalScrollBar() );
layout()->addWidget( m_header );
if ( extraHeader )
layout()->addWidget( extraHeader );
CaptionLabel* caption = new CaptionLabel( this );
caption->setText( tr( "Playlist Details" ) );
QWidget* vbox = new QWidget;
QPalette pal = vbox->palette();
pal.setBrush( vbox->backgroundRole(), Qt::white );
vbox->setPalette( pal );
vbox->setAutoFillBackground( true );
QVBoxLayout* vboxl = new QVBoxLayout;
TomahawkUtils::unmarginLayout( vboxl );
vboxl->setContentsMargins( 32, 32, 32, 32 );
vboxl->setSpacing( 32 );
vbox->setLayout( vboxl );
QWidget* hbox = new QWidget;
QHBoxLayout* hboxl = new QHBoxLayout;
TomahawkUtils::unmarginLayout( hboxl );
hboxl->setSpacing( 32 );
m_detailView = new TrackDetailView;
m_detailView->setPlaylistInterface( playlistInterface() );
hboxl->addWidget( m_detailView );
hboxl->addWidget( m_stack );
hbox->setLayout( hboxl );
vboxl->addWidget( caption );
vboxl->addWidget( hbox );
layout()->addWidget( vbox );
m_stack->addWidget( m_trackView );
m_stack->addWidget( m_detailedView );
m_stack->addWidget( m_gridView );
setCurrentMode( Flat );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), m_detailView, SLOT( setQuery( Tomahawk::query_ptr ) ) );
connect( m_header, SIGNAL( filterTextChanged( QString ) ), SLOT( setFilter( QString ) ) );
TomahawkUtils::fixMargins( this );
}
InformationPanelContent::InformationPanelContent(QWidget* parent) :
QWidget(parent),
m_item(),
m_pendingPreview(false),
m_outdatedPreviewTimer(0),
m_preview(0),
m_phononWidget(0),
m_nameLabel(0),
m_metaDataWidget(0),
m_metaDataArea(0)
{
parent->installEventFilter(this);
// Initialize timer for disabling an outdated preview with a small
// delay. This prevents flickering if the new preview can be generated
// within a very small timeframe.
m_outdatedPreviewTimer = new QTimer(this);
m_outdatedPreviewTimer->setInterval(300);
m_outdatedPreviewTimer->setSingleShot(true);
connect(m_outdatedPreviewTimer, SIGNAL(timeout()),
this, SLOT(markOutdatedPreview()));
QVBoxLayout* layout = new QVBoxLayout(this);
layout->setSpacing(KDialog::spacingHint());
// preview
const int minPreviewWidth = KIconLoader::SizeEnormous + KIconLoader::SizeMedium;
m_preview = new PixmapViewer(parent);
m_preview->setMinimumWidth(minPreviewWidth);
m_preview->setMinimumHeight(KIconLoader::SizeEnormous);
m_phononWidget = new PhononWidget(parent);
m_phononWidget->hide();
m_phononWidget->setMinimumWidth(minPreviewWidth);
connect(m_phononWidget, SIGNAL(playingStarted()),
this, SLOT(slotPlayingStarted()));
connect(m_phononWidget, SIGNAL(playingStopped()),
this, SLOT(slotPlayingStopped()));
// name
m_nameLabel = new QLabel(parent);
QFont font = m_nameLabel->font();
font.setBold(true);
m_nameLabel->setFont(font);
m_nameLabel->setAlignment(Qt::AlignHCenter);
m_nameLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
const bool showPreview = InformationPanelSettings::showPreview();
m_preview->setVisible(showPreview);
m_metaDataWidget = new KFileMetaDataWidget(parent);
m_metaDataWidget->setFont(KGlobalSettings::smallestReadableFont());
m_metaDataWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
connect(m_metaDataWidget, SIGNAL(urlActivated(KUrl)), this, SIGNAL(urlActivated(KUrl)));
// Encapsulate the MetaDataWidget inside a container that has a dummy widget
// at the bottom. This prevents that the meta data widget gets vertically stretched
// in the case where the height of m_metaDataArea > m_metaDataWidget.
QWidget* metaDataWidgetContainer = new QWidget(parent);
QVBoxLayout* containerLayout = new QVBoxLayout(metaDataWidgetContainer);
containerLayout->setContentsMargins(0, 0, 0, 0);
containerLayout->setSpacing(0);
containerLayout->addWidget(m_metaDataWidget);
containerLayout->addStretch();
m_metaDataArea = new QScrollArea(parent);
m_metaDataArea->setWidget(metaDataWidgetContainer);
m_metaDataArea->setWidgetResizable(true);
m_metaDataArea->setFrameShape(QFrame::NoFrame);
QWidget* viewport = m_metaDataArea->viewport();
viewport->installEventFilter(this);
QPalette palette = viewport->palette();
palette.setColor(viewport->backgroundRole(), QColor(Qt::transparent));
viewport->setPalette(palette);
layout->addWidget(m_preview);
layout->addWidget(m_phononWidget);
layout->addWidget(m_nameLabel);
layout->addWidget(new KSeparator());
layout->addWidget(m_metaDataArea);
}
QColor APPBACKGROUND(const QWidget& w) {
w.ensurePolished();
return qApp->palette(&w).color(w.backgroundRole());
}
