void KHistoryComboBox::slotSimulateActivated( const QString& text )
{
/* With the insertion policy NoInsert, which we use by default,
Qt doesn't emit activated on typed text if the item is not already there,
which is perhaps reasonable. Generate the signal ourselves if that's the case.
*/
if ((insertPolicy() == NoInsert && findText(text, Qt::MatchFixedString|Qt::MatchCaseSensitive) == -1)) {
emit activated(text);
}
/*
Qt also doesn't emit it if the box is full, and policy is not
InsertAtCurrent
*/
else if (insertPolicy() != InsertAtCurrent && count() >= maxCount()) {
emit activated(text);
}
}
Allocator::Allocator(const SpillPolicy::RegisterId regs, const policy_t spillPolicies)
{
setRegisters(regs);
assertM(spillPolicies != 0, "No spill policy");
for(SpillType i = SpillType::LRU; i <= spillPolicies;
i = (SpillType) ((unsigned) (i) * 2))
{
if(spillPolicies & i)
{
insertPolicy(i, 1);
}
}
}
void LibraryHeader::paintEvent(QPaintEvent *)
{
QStyleOptionButton option;
option.initFrom(this);
QStylePainter p(this);
QColor base = QApplication::palette().base().color();
// Gradient
QLinearGradient g(rect().topLeft(), rect().bottomLeft());
g.setColorAt(0, base);
g.setColorAt(1, QApplication::palette().window().color());
p.fillRect(rect(), g);
// Text
QString header;
auto settings = SettingsPrivate::instance();
switch (settings->insertPolicy()) {
case SettingsPrivate::IP_Albums:
header = tr("Album");
break;
case SettingsPrivate::IP_ArtistsAlbums:
header = tr("Artist – Album");
break;
case SettingsPrivate::IP_Years:
header = tr("Year");
break;
case SettingsPrivate::IP_Artists:
default:
header = tr("Artist \\ Album");
break;
}
QFont f = settings->font(SettingsPrivate::FF_Library);
p.setFont(f);
QFontMetrics fm(f);
this->setMinimumHeight(fm.height());
// Check if label should be elided (in case of large font and small area on screen)
QString elided = fm.elidedText(header, Qt::ElideRight, parentWidget()->width());
p.setPen(QApplication::palette().windowText().color());
p.drawText(rect().adjusted(10, 0, 0, 0), Qt::AlignVCenter | Qt::AlignLeft, elided);
// Draw a thin line before the treeview
p.save();
p.setPen(base.darker(115));
p.drawLine(rect().bottomLeft(), rect().bottomRight());
p.restore();
// Draw sort indicator
static const QPointF sortIndicatorDown[3] = {
QPointF(0.0, 0.0),
QPointF(2.0, 0.0),
QPointF(1.0, 1.0)
};
static const QPointF sortIndicatorUp[3] = {
QPointF(0.0, 1.0),
QPointF(1.0, 0.0),
QPointF(2.0, 1.0)
};
int minX = rect().center().x() - (rect().height() / 2);
if (fm.width(elided) > minX - 20) {
/// XXX: improve this
minX = fm.width(header) + 20;
}
p.save();
p.translate(minX, rect().height() / 2.5);
// Highlight the sort indicator if needed
if (option.state.testFlag(QStyle::State_MouseOver)) {
p.setPen(QApplication::palette().highlight().color());
p.setBrush(QApplication::palette().highlight().color().lighter());
} else {
p.setPen(QApplication::palette().mid().color());
p.setBrush(Qt::NoBrush);
}
QTransform t;
float ratio = (float) rect().height() / 6.0;
t.scale(ratio, ratio);
QPolygonF sortIndicator;
if (Qt::DescendingOrder == _order) {
sortIndicator.append(t.map(sortIndicatorDown[0]));
sortIndicator.append(t.map(sortIndicatorDown[1]));
sortIndicator.append(t.map(sortIndicatorDown[2]));
} else {
sortIndicator.append(t.map(sortIndicatorUp[0]));
sortIndicator.append(t.map(sortIndicatorUp[1]));
sortIndicator.append(t.map(sortIndicatorUp[2]));
}
p.drawPolygon(sortIndicator);
p.restore();
}
/** Read all tracks entries in the database and send them to connected views. */
void LibraryItemModel::load(const QString &)
{
this->reset();
SqlDatabase db;
QSqlQuery q("SELECT uri, trackNumber, trackTitle, artist, artistNormalized, album, albumNormalized, artistAlbum, " \
"albumYear, trackLength, rating, disc, internalCover, cover, host, icon FROM cache ORDER BY uri, internalCover", db);
q.setForwardOnly(true);
if (!q.exec()) {
return;
}
const int uri = 0, trackNumber = 1, trackTitle = 2, artist = 3, artistNorm = 4, album = 5, albumNorm = 6, artistAlbum = 7,
year = 8, trackLength = 9, rating = 10, disc = 11, internalCover = 12, cover = 13, host = 14, icon = 15;
// Lambda function to reduce duplicate code which is relevant in this method only
auto loadTrack = [=] (QSqlRecord& r) -> TrackItem* {
TrackItem *trackItem = new TrackItem;
trackItem->setText(r.value(trackTitle).toString());
trackItem->setData(r.value(uri).toString(), Miam::DF_URI);
trackItem->setData(r.value(trackNumber).toString(), Miam::DF_TrackNumber);
trackItem->setData(r.value(disc).toString(), Miam::DF_DiscNumber);
trackItem->setData(r.value(trackLength).toUInt(), Miam::DF_TrackLength);
if (r.value(rating).toInt() != -1) {
trackItem->setData(r.value(rating).toInt(), Miam::DF_Rating);
}
trackItem->setData(r.value(artist).toString(), Miam::DF_Artist);
trackItem->setData(r.value(album).toString(), Miam::DF_Album);
trackItem->setData(!r.value(host).toString().isEmpty(), Miam::DF_IsRemote);
return trackItem;
};
auto s = SettingsPrivate::instance();
switch (s->insertPolicy()) {
case SettingsPrivate::IP_Artists: {
QStringList filters;
if (s->isLibraryFilteredByArticles() && !s->libraryFilteredByArticles().isEmpty()) {
filters = s->libraryFilteredByArticles();
}
QHash<uint, ArtistItem*> _artists;
QHash<uint, AlbumItem*> _albums;
while (q.next()) {
QSqlRecord r = q.record();
ArtistItem *artistItem = new ArtistItem;
QString artistNormalized = r.value(artistNorm).toString();
QString albumNormalized = r.value(albumNorm).toString();
QString artist = r.value(3).toString();
QString aa = r.value(artistAlbum).toString();
artistItem->setText(aa);
for (QString filter : filters) {
if (artist.startsWith(filter + " ", Qt::CaseInsensitive)) {
artist = artist.mid(filter.length() + 1);
artistItem->setData(artist + ", " + filter, Miam::DF_CustomDisplayText);
break;
}
}
if (artistNormalized.isEmpty() || !artistNormalized.contains(QRegularExpression("[\\w]"))) {
artistItem->setData("0", Miam::DF_NormalizedString);
} else {
artistItem->setData(artistNormalized, Miam::DF_NormalizedString);
}
// Add artist
if (_artists.contains(artistItem->hash())) {
auto it = _artists.find(artistItem->hash());
delete artistItem;
artistItem = (*it);
} else {
_artists.insert(artistItem->hash(), artistItem);
invisibleRootItem()->appendRow(artistItem);
// Also check if newly inserted artist needs to insert a separator
if (SeparatorItem *separator = this->insertSeparator(artistItem)) {
_topLevelItems.insert(separator, artistItem->index());
}
}
AlbumItem *albumItem = new AlbumItem;
if (r.value(albumNorm).toString().isEmpty() || !r.value(albumNorm).toString().contains(QRegularExpression("[\\w]"))) {
albumItem->setData("0", Miam::DF_NormalizedString);
} else {
albumItem->setData(r.value(albumNorm).toString(), Miam::DF_NormalizedString);
}
albumItem->setData(artistNormalized, Miam::DF_NormArtist);
albumItem->setData(albumNormalized, Miam::DF_NormAlbum);
albumItem->setData(r.value(year).toString(), Miam::DF_Year);
QString internalCoverPath = r.value(internalCover).toString();
QString coverPath = r.value(cover).toString();
// Add album
if (_albums.contains(albumItem->hash())) {
auto it = _albums.find(albumItem->hash());
delete albumItem;
albumItem = *it;
if (albumItem->data(Miam::DF_InternalCover).toString().isEmpty() && !internalCoverPath.isEmpty()) {
albumItem->setData(internalCoverPath, Miam::DF_InternalCover);
}
if (albumItem->data(Miam::DF_CoverPath).toString().isEmpty() && !coverPath.isEmpty()) {
albumItem->setData(coverPath, Miam::DF_CoverPath);
}
} else {
albumItem->setText(r.value(album).toString());
albumItem->setData(internalCoverPath, Miam::DF_InternalCover);
albumItem->setData(coverPath, Miam::DF_CoverPath);
albumItem->setData(r.value(icon).toString(), Miam::DF_IconPath);
albumItem->setData(!r.value(host).toString().isEmpty(), Miam::DF_IsRemote);
_albums.insert(albumItem->hash(), albumItem);
artistItem->appendRow(albumItem);
}
// Add tracks
albumItem->appendRow(loadTrack(r));
}
break;
}
case SettingsPrivate::IP_Albums: {
QHash<uint, AlbumItem*> _albums;
while (q.next()) {
QSqlRecord r = q.record();
QString artistNormalized = r.value(artistNorm).toString();
QString albumNormalized = r.value(albumNorm).toString();
AlbumItem *albumItem = new AlbumItem;
albumItem->setText(r.value(album).toString());
if (r.value(albumNorm).toString().isEmpty() || !r.value(albumNorm).toString().contains(QRegularExpression("[\\w]"))) {
albumItem->setData("0", Miam::DF_NormalizedString);
} else {
albumItem->setData(r.value(albumNorm).toString(), Miam::DF_NormalizedString);
}
albumItem->setData(artistNormalized, Miam::DF_NormArtist);
albumItem->setData(albumNormalized, Miam::DF_NormAlbum);
albumItem->setData(r.value(year).toString(), Miam::DF_Year);
if (!r.value(internalCover).toString().isEmpty()) {
albumItem->setData(r.value(internalCover).toString(), Miam::DF_InternalCover);
}
albumItem->setData(r.value(cover).toString(), Miam::DF_CoverPath);
albumItem->setData(r.value(icon).toString(), Miam::DF_IconPath);
albumItem->setData(!r.value(host).toString().isEmpty(), Miam::DF_IsRemote);
// Add album
if (_albums.contains(albumItem->hash())) {
auto it = _albums.find(albumItem->hash());
delete albumItem;
albumItem = (*it);
} else {
_albums.insert(albumItem->hash(), albumItem);
invisibleRootItem()->appendRow(albumItem);
// Also check if newly inserted artist needs to insert a separator
if (SeparatorItem *separator = this->insertSeparator(albumItem)) {
_topLevelItems.insert(separator, albumItem->index());
}
}
// Add tracks
albumItem->appendRow(loadTrack(r));
}
break;
}
case SettingsPrivate::IP_ArtistsAlbums: {
QHash<uint, AlbumItem*> _albums;
while (q.next()) {
QSqlRecord r = q.record();
QString artistNormalized = r.value(artistNorm).toString();
QString albumNormalized = r.value(albumNorm).toString();
AlbumItem *albumItem = new AlbumItem;
albumItem->setText(r.value(artist).toString() + " – " + r.value(album).toString());
albumItem->setData(artistNormalized + "|" + albumNormalized, Miam::DF_NormalizedString);
albumItem->setData(artistNormalized, Miam::DF_NormArtist);
albumItem->setData(albumNormalized, Miam::DF_NormAlbum);
albumItem->setData(r.value(year).toString(), Miam::DF_Year);
albumItem->setData(r.value(cover).toString(), Miam::DF_CoverPath);
albumItem->setData(r.value(icon).toString(), Miam::DF_IconPath);
albumItem->setData(!r.value(host).toString().isEmpty(), Miam::DF_IsRemote);
// Add album
if (_albums.contains(albumItem->hash())) {
auto it = _albums.find(albumItem->hash());
delete albumItem;
albumItem = *it;
} else {
_albums.insert(albumItem->hash(), albumItem);
invisibleRootItem()->appendRow(albumItem);
// Also check if newly inserted artist needs to insert a separator
if (SeparatorItem *separator = this->insertSeparator(albumItem)) {
_topLevelItems.insert(separator, albumItem->index());
}
}
// Add tracks
albumItem->appendRow(loadTrack(r));
}
break;
}
case SettingsPrivate::IP_Years: {
QHash<uint, YearItem*> _years;
QHash<uint, AlbumItem*> _artistAlbums;
while (q.next()) {
QSqlRecord r = q.record();
YearItem *yearItem = new YearItem(r.value(year).toString());
// Add year
if (_years.contains(yearItem->hash())) {
auto it = _years.find(yearItem->hash());
delete yearItem;
yearItem = (*it);
} else {
_years.insert(yearItem->hash(), yearItem);
invisibleRootItem()->appendRow(yearItem);
// Also check if newly inserted artist needs to insert a separator
if (SeparatorItem *separator = this->insertSeparator(yearItem)) {
_topLevelItems.insert(separator, yearItem->index());
}
}
// Add Artist - Album
AlbumItem *artistAlbumItem = new AlbumItem;
artistAlbumItem->setText(r.value(3).toString() + " – " + r.value(album).toString());
artistAlbumItem->setData(r.value(artistNorm).toString() + "|" + r.value(albumNorm).toString(), Miam::DF_NormalizedString);
artistAlbumItem->setData(r.value(artistNorm).toString(), Miam::DF_NormArtist);
artistAlbumItem->setData(r.value(albumNorm).toString(), Miam::DF_NormAlbum);
artistAlbumItem->setData(r.value(year).toString(), Miam::DF_Year);
artistAlbumItem->setData(r.value(cover).toString(), Miam::DF_CoverPath);
artistAlbumItem->setData(r.value(icon).toString(), Miam::DF_IconPath);
artistAlbumItem->setData(!r.value(14).toString().isEmpty(), Miam::DF_IsRemote);
if (_artistAlbums.contains(artistAlbumItem->hash())) {
auto it = _artistAlbums.find(artistAlbumItem->hash());
delete artistAlbumItem;
artistAlbumItem = *it;
} else {
_artistAlbums.insert(artistAlbumItem->hash(), artistAlbumItem);
yearItem->appendRow(artistAlbumItem);
}
// Add tracks
artistAlbumItem->appendRow(loadTrack(r));
}
break;
}
}
this->sort(0);
}
int QComboBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 24)
qt_static_metacall(this, _c, _id, _a);
_id -= 24;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< bool*>(_v) = isEditable(); break;
case 1: *reinterpret_cast< int*>(_v) = count(); break;
case 2: *reinterpret_cast< QString*>(_v) = currentText(); break;
case 3: *reinterpret_cast< int*>(_v) = currentIndex(); break;
case 4: *reinterpret_cast< int*>(_v) = maxVisibleItems(); break;
case 5: *reinterpret_cast< int*>(_v) = maxCount(); break;
case 6: *reinterpret_cast< InsertPolicy*>(_v) = insertPolicy(); break;
case 7: *reinterpret_cast< SizeAdjustPolicy*>(_v) = sizeAdjustPolicy(); break;
case 8: *reinterpret_cast< int*>(_v) = minimumContentsLength(); break;
case 9: *reinterpret_cast< QSize*>(_v) = iconSize(); break;
case 10: *reinterpret_cast< bool*>(_v) = autoCompletion(); break;
case 11: *reinterpret_cast< Qt::CaseSensitivity*>(_v) = autoCompletionCaseSensitivity(); break;
case 12: *reinterpret_cast< bool*>(_v) = duplicatesEnabled(); break;
case 13: *reinterpret_cast< bool*>(_v) = hasFrame(); break;
case 14: *reinterpret_cast< int*>(_v) = modelColumn(); break;
}
_id -= 15;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setEditable(*reinterpret_cast< bool*>(_v)); break;
case 3: setCurrentIndex(*reinterpret_cast< int*>(_v)); break;
case 4: setMaxVisibleItems(*reinterpret_cast< int*>(_v)); break;
case 5: setMaxCount(*reinterpret_cast< int*>(_v)); break;
case 6: setInsertPolicy(*reinterpret_cast< InsertPolicy*>(_v)); break;
case 7: setSizeAdjustPolicy(*reinterpret_cast< SizeAdjustPolicy*>(_v)); break;
case 8: setMinimumContentsLength(*reinterpret_cast< int*>(_v)); break;
case 9: setIconSize(*reinterpret_cast< QSize*>(_v)); break;
case 10: setAutoCompletion(*reinterpret_cast< bool*>(_v)); break;
case 11: setAutoCompletionCaseSensitivity(*reinterpret_cast< Qt::CaseSensitivity*>(_v)); break;
case 12: setDuplicatesEnabled(*reinterpret_cast< bool*>(_v)); break;
case 13: setFrame(*reinterpret_cast< bool*>(_v)); break;
case 14: setModelColumn(*reinterpret_cast< int*>(_v)); break;
}
_id -= 15;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 15;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 15;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 15;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 15;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 15;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 15;
}
#endif // QT_NO_PROPERTIES
return _id;
}
