Common::String ThemeEngine::genCacheFilename(const Common::String &filename) const {
Common::String cacheName(filename);
for (int i = cacheName.size() - 1; i >= 0; --i) {
if (cacheName[i] == '.') {
while ((uint)i < cacheName.size() - 1) {
cacheName.deleteLastChar();
}
cacheName += "fcc";
return cacheName;
}
}
return Common::String();
}
QPixmap markerPixmap(const QColor& color, const QColor& bgColor) {
// create unique string-name for color combinations
QString cacheName(color.name()+bgColor.name());
QPixmap px(16, 16);
// The method signature was changed: it's
// bool QPixmapCache::find ( const QString & key, QPixmap & pm ) in Qt <= 4.5
// and
// bool QPixmapCache::find ( const QString & key, QPixmap * pm ) in Qt >= 4.6
#if QT_VERSION >= 0x040600
if ( QPixmapCache::find(cacheName, &px) ) {
#else
if ( QPixmapCache::find(cacheName, px) ) {
#endif
return px;
}
px.fill(bgColor);
QPainter p(&px);
// As we are using pixmap cache for most pixmap access
// we can use more resource and time consuming rendering
// to get better results (smooth rounded bullet in this case).
// Remember: painting is performed only once per running juffed
// in the ideal case.
p.setRenderHint(QPainter::Antialiasing);
int red = color.red();
int green = color.green();
int blue = color.blue();
QColor light(red + (255 - red) / 2, green + (255 - green) / 2, blue + (255 - blue) / 2);
QColor dark(red / 2, green / 2, blue / 2);
QRadialGradient gr(0.4, 0.4, 0.5, 0.4, 0.4);
gr.setCoordinateMode(QGradient::ObjectBoundingMode);
gr.setColorAt(0, light);
gr.setColorAt(1, dark);
p.setPen(dark);
p.setBrush(gr);
p.drawEllipse(1, 1, 14, 14);
p.end();
QPixmapCache::insert(cacheName, px);
return px;
}
class SciDoc::Interior {
public:
Interior(QWidget* w) {
// LOGGER;
curEdit_ = NULL;
spl_ = new QSplitter(Qt::Vertical);
QVBoxLayout* vBox = new QVBoxLayout();
vBox->setContentsMargins(0, 0, 0, 0);
vBox->addWidget(spl_);
w->setLayout(vBox);
edit1_ = createEdit();
edit2_ = createEdit();
spl_->addWidget(edit1_);
spl_->addWidget(edit2_);
edit1_->setDocument(edit2_->document());
w->setFocusProxy(spl_);
spl_->setSizes(QList<int>() << 0 << spl_->height());
hlTimer_ = new QTimer( w );
hlTimer_->setSingleShot( true );
connect(hlTimer_, SIGNAL(timeout()), w, SLOT(highlightWord()));
}
JuffScintilla* createEdit() {
// LOGGER;
JuffScintilla* edit = new JuffScintilla();
edit->setFocusPolicy(Qt::ClickFocus);
edit->setUtf8(true);
edit->setFolding(QsciScintilla::BoxedTreeFoldStyle);
edit->setAutoIndent(true);
edit->setBraceMatching(QsciScintilla::SloppyBraceMatch);
// margins
edit->setMarginLineNumbers(0, false);
edit->setMarginLineNumbers(1, true);
edit->setMarginSensitivity(0, true);
edit->setMarginWidth(0, 20);
edit->setMarginWidth(2, 12);
// markers
edit->markerDefine(QsciScintilla::Background, 2);
// Set the 0th margin accept markers numbered 1 and 2
// Binary mask for markers 1 and 2 is 00000110 ( == 6 )
edit->setMarginMarkerMask(0, 6);
edit->setMarginMarkerMask(1, 0);
return edit;
}
void setCurrentEdit(JuffScintilla* edit) {
// LOGGER;
curEdit_ = edit;
spl_->setFocusProxy(edit);
}
JuffScintilla* edit1_;
JuffScintilla* edit2_;
JuffScintilla* curEdit_;
QString syntax_;
QSplitter* spl_;
QTimer* hlTimer_;
};
SciDoc::SciDoc(const QString& fileName) : Juff::Document(fileName) {
// LOGGER;
int_ = new Interior(this);
JuffScintilla* edits[] = { int_->edit1_, int_->edit2_ };
for ( int i = 0; i < 2; ++i) {
JuffScintilla* edit = edits[i];
connect(edit, SIGNAL(cursorPositionChanged(int, int)), this, SLOT(onCursorMoved(int, int)));
// connect(int_->edit1_, SIGNAL(contextMenuCalled(int, int)), this, SIGNAL(contextMenuCalled(int, int)));
connect(edit, SIGNAL(marginClicked(int, int, Qt::KeyboardModifiers)), SLOT(onMarginClicked(int, int, Qt::KeyboardModifiers)));
connect(edit, SIGNAL(focusReceived()), SLOT(onEditFocused()));
connect(edit, SIGNAL(markersMenuRequested(const QPoint&)), SIGNAL(markersMenuRequested(const QPoint&)));
connect(edit, SIGNAL(escapePressed()), SIGNAL(escapePressed()));
}
connect(int_->edit1_, SIGNAL(modificationChanged(bool)), this, SIGNAL(modified(bool)));
connect(int_->edit1_, SIGNAL(linesChanged()), SLOT(onLineCountChanged()));
connect(int_->edit1_, SIGNAL(textChanged()), this, SIGNAL(textChanged()));
QString lexName = "none";
SciDoc::Eol eol = guessEol(fileName);
std::pair<bool,int> indentation = guessIndentation(fileName);
if ( !fileName.isEmpty() && !isNoname() ) {
QString codecName = Document::guessCharset(fileName);
if ( !codecName.isEmpty() )
setCharset(codecName);
readFile();
setEol(eol);
setIndentationsUseTabs(indentation.first);
setTabWidth(indentation.second);
int_->edit1_->setModified(false);
// syntax highlighting
lexName = LexerStorage::instance()->lexerName(fileName);
}
else {
setEol(eol);
setIndentationsUseTabs(indentation.first);
setTabWidth(indentation.second);
}
setLexer(lexName);
applySettings();
QAction* hlWordAct = new QAction("", this);
hlWordAct->setShortcut(QKeySequence("Ctrl+H"));
connect(hlWordAct, SIGNAL(triggered()), SLOT(highlightWord()));
addAction(hlWordAct);
}
/*SciDoc::SciDoc(Juff::Document* doc) : Juff::Document(doc) {
SciDoc* d = qobject_cast<SciDoc*>(doc);
if ( d != 0 ) {
int_->edit1_->setDocument(d->int_->edit1_->document());
int_->edit2_->setDocument(d->int_->edit2_->document());
}
}*/
SciDoc::~SciDoc() {
delete int_;
}
QString SciDoc::type() const {
return "QSci";
}
bool SciDoc::supportsAction(Juff::ActionID id) const {
switch (id) {
case Juff::FileClone : return true;
default : return Juff::Document::supportsAction(id);
}
}
/*Juff::Document* SciDoc::createClone() {
if ( hasClone() )
return NULL;
else
return new SciDoc(this);
}
void SciDoc::updateClone() {
LOGGER;
// SciDoc* cln = qobject_cast<SciDoc*>(clone());
// if ( cln != 0 ) {
// if ( cln->int_->syntax_ != int_->syntax_ ) {
// cln->int_->syntax_ = int_->syntax_;
// QsciLexer* lexer = LexerStorage::instance()->lexer(int_->syntax_);
// cln->int_->edit1_->setLexer(lexer);
// cln->int_->edit2_->setLexer(lexer);
// }
// }
Juff::Document::updateClone();
}*/
void SciDoc::init() {
int_->setCurrentEdit(int_->edit2_);
}
bool KGameRendererPrivate::setTheme(const KgTheme* theme)
{
QLoggingCategory::setFilterRules(QStringLiteral("games.lib.debug = true"));
if (!theme)
{
return false;
}
//open cache (and SVG file, if necessary)
if (m_strategies & KGameRenderer::UseDiskCache)
{
QScopedPointer<KImageCache> oldCache(m_imageCache);
const QString imageCacheName = cacheName(theme->identifier());
m_imageCache = new KImageCache(imageCacheName, m_cacheSize);
m_imageCache->setPixmapCaching(false); //see big comment in KGRPrivate class declaration
//check timestamp of cache vs. last write access to theme/SVG
const uint svgTimestamp = qMax(
QFileInfo(theme->graphicsPath()).lastModified().toTime_t(),
theme->property("_k_themeDescTimestamp").value<uint>()
);
QByteArray buffer;
if (!m_imageCache->find(QStringLiteral("kgr_timestamp"), &buffer))
buffer = "0";
const uint cacheTimestamp = buffer.toInt();
//try to instantiate renderer immediately if the cache does not exist or is outdated
//FIXME: This logic breaks if the cache evicts the "kgr_timestamp" key. We need additional API in KSharedDataCache to make sure that this key does not get evicted.
if (cacheTimestamp < svgTimestamp)
{
qCDebug(GAMES_LIB) << "Theme newer than cache, checking SVG";
QScopedPointer<QSvgRenderer> renderer(new QSvgRenderer(theme->graphicsPath()));
if (renderer->isValid())
{
m_rendererPool.setPath(theme->graphicsPath(), renderer.take());
m_imageCache->clear();
m_imageCache->insert(QStringLiteral("kgr_timestamp"), QByteArray::number(svgTimestamp));
}
else
{
//The SVG file is broken, so we deny to change the theme without
//breaking the previous theme.
delete m_imageCache;
KSharedDataCache::deleteCache(imageCacheName);
m_imageCache = oldCache.take();
qCDebug(GAMES_LIB) << "Theme change failed: SVG file broken";
return false;
}
}
//theme is cached - just delete the old renderer after making sure that no worker threads are using it anymore
else if (m_currentTheme != theme)
m_rendererPool.setPath(theme->graphicsPath());
}
else // !(m_strategies & KGameRenderer::UseDiskCache) -> no cache is used
{
//load SVG file
QScopedPointer<QSvgRenderer> renderer(new QSvgRenderer(theme->graphicsPath()));
if (renderer->isValid())
{
m_rendererPool.setPath(theme->graphicsPath(), renderer.take());
}
else
{
qCDebug(GAMES_LIB) << "Theme change failed: SVG file broken";
return false;
}
//disconnect from disk cache (only needed if changing strategy)
delete m_imageCache;
m_imageCache = 0;
}
//clear in-process caches
m_pixmapCache.clear();
m_frameCountCache.clear();
m_boundsCache.clear();
//done
m_currentTheme = theme;
return true;
}
bool csShaderGLCGCommon::WriteToCacheWorker (iHierarchicalCache* cache,
const ProfileLimits& limits, const ProfileLimitsPair& limitsPair,
const char* tag, const ProgramObject& program,
csString& failReason)
{
if (!cache) return false;
csMemFile cacheFile;
uint32 diskMagic = csLittleEndian::UInt32 (cacheFileMagic);
if (cacheFile.Write ((char*)&diskMagic, sizeof (diskMagic))
!= sizeof (diskMagic))
{
failReason = "write error (magic)";
return false;
}
csRef<iDataBuffer> programBuffer = GetProgramData();
CS::Utility::Checksum::MD5::Digest progHash = CS::Utility::Checksum::MD5::Encode (
programBuffer->GetData(), programBuffer->GetSize());
if (cacheFile.Write ((char*)&progHash, sizeof (progHash))
!= sizeof (progHash))
{
failReason = "write error (hash)";
return false;
}
if (!program.IsValid())
{
uint32 diskState = csLittleEndian::UInt32 (cpsInvalid);
if (cacheFile.Write ((char*)&diskState, sizeof (diskState))
!= sizeof (diskState))
{
failReason = "write error (state-invalid)";
return false;
}
}
else
{
{
uint32 diskState = csLittleEndian::UInt32 (cpsValid);
if (cacheFile.Write ((char*)&diskState, sizeof (diskState))
!= sizeof (diskState))
{
failReason = "write error (state-valid)";
return false;
}
}
CS::PluginCommon::ShaderCacheHelper::WriteString (&cacheFile, description);
CS_ASSERT(!program.GetID().archive.IsEmpty());
CS::PluginCommon::ShaderCacheHelper::WriteString (&cacheFile,
program.GetID().archive);
CS_ASSERT(!program.GetID().item.IsEmpty());
CS::PluginCommon::ShaderCacheHelper::WriteString (&cacheFile,
program.GetID().item);
}
csString cacheName ("/");
cacheName += tag;
if (!cache->CacheData (cacheFile.GetData(), cacheFile.GetSize(),
cacheName))
{
failReason = "failed writing to cache";
return false;
}
return true;
}