void LogViewer::init()
{
setAcceptDrops(true);
setReadOnly(true);
setTabWidth(4);
setLineWrapMode(QPlainTextEdit::NoWrap);
setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse);
QPalette palette;
palette.setColor(QPalette::Inactive, QPalette::Highlight, palette.color(QPalette::Active, QPalette::Highlight));
palette.setColor(QPalette::Inactive, QPalette::HighlightedText, palette.color(QPalette::Active, QPalette::HighlightedText));
setPalette(palette);
// Read settings.
setFont(INIMANAGER()->font());
setForegroundColor(INIMANAGER()->foregroundColor());
setBackgroundColor(INIMANAGER()->backgroundColor());
setCustomBackgroundColor(INIMANAGER()->customBackgroundColor());
setCurrentLineFgColor(INIMANAGER()->currentLineFgColor());
setCurrentLineBgColor(INIMANAGER()->currentLineBgColor());
connect(this, SIGNAL(cursorPositionChanged()), this, SLOT(drawCurrentLine()));
connect(this, SIGNAL(blockCountChanged(int)), this, SLOT(blockCountChanged(int)));
connect(this, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
// Line Number.
updateLineNumberAreaWidth(0);
connect(this, SIGNAL(blockCountChanged(int)), this, SLOT(updateLineNumberAreaWidth(int)));
connect(this, SIGNAL(updateRequest(QRect,int)), this, SLOT(updateLineNumberArea(QRect,int)));
// Keyword Highlighter.
connect(m_keywordHighlighter, SIGNAL(modelCreated(QStandardItemModel*)), this, SLOT(modelCreated(QStandardItemModel*)));
connect(m_keywordHighlighter, SIGNAL(chartLoaded(QPixmap*)), this, SLOT(chartLoaded(QPixmap*)));
}
ScintillaEditor::ScintillaEditor(QWidget* parent) : QsciScintilla(parent) {
/* -setup editor and configurations */
//set and display line numbers; margin '1' is the default line number maring
setMarginWidth(1, 55);
setMarginLineNumbers(1, true);
//create the lexer manager
lexerManager = new SyntaxHighlightManager(this);
//set editor properties/settings
setAutoIndent(true);
setTabWidth(4);
setMarginsBackgroundColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "margins_background") );
setMarginsForegroundColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "margins_foreground") );
setWhitespaceVisibility( LeptonConfig::mainSettings->getWhiteSpaceVisibility() );
setWhitespaceForegroundColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "whitespace_color") );
setCaretForegroundColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "caret_color") );
setCallTipsHighlightColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "highlight_color") );
setSelectionBackgroundColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "selection_background") );
setSelectionForegroundColor( LeptonConfig::mainSettings->getValueAsColor("editor_theme", "selection_foreground") );
setIndentationsUseTabs(false); //use spaces instead of tabs for indentation
//*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//$ Stub code used to test Scintilla features $$
//$ $$
//$ $$
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
}
// Parse emacs modeline
FXbool Modeline::parseEmacsModeline(const FXchar* s){
FXString key;
FXString val;
while(*s!='\0'){
while(*s==';' || *s=='\t' || *s==' ') s++;
if(*s=='\0' || (*s=='-' && *(s+1)=='*' && *(s+2)=='-')) break;
key=FXString::null;
val=FXString::null;
while(*s!='\0' && *s!=':' && *s!=';' && *s!='\t' && *s!=' '){
key+=*s++;
}
while(*s=='\t' || *s==' ') s++;
if(*s=='\0') break;
if(*s!=':') continue;
s++;
while(*s=='\t' || *s==' ') s++;
if(*s=='\0') break;
while(*s!='\0' && *s!=';' && *s!='\t' && *s!=' '){
val+=*s++;
}
if(comparecase(key,"Mode")==0){
setLanguage(val);
}
else if(key=="tab-width"){
setTabWidth(val.toInt());
}
else if(key=="indent-tabs-mode"){
setTabMode(val=="nil");
}
else if(key=="autowrap"){
setWrapMode(val!="nil");
}
}
return true;
}
/**
* Updates the editor widget to use a new set of configuration parameters.
* @param config The configuration parameters
*/
void Editor::applyConfig(const Config& config)
{
QsciLexer* lex = lexer();
if (lex)
lex->setFont(config.font_);
else
setFont(config.font_);
setIndentationsUseTabs(config.indentTabs_);
setTabWidth(config.tabWidth_);
setCaretLineVisible(config.hlCurLine_);
}
// Parse VIM modeline
FXbool Modeline::parseVimModeline(const FXchar* s){
FXbool set=false;
FXbool yes=true;
FXString key;
FXString val;
while(*s!='\0' && !(*s==':' && set)){
while(*s==':' || *s=='\t' || *s==' ') s++;
if(*s=='\0') break;
if(*s=='s' && *(s+1)=='e' && *(s+1)==' '){ s+=3; set=true; }
else if(*s=='s' && *(s+1)=='e' && *(s+2)=='t' && *(s+3)==' '){ s+=4; set=true; }
yes=true;
if(*s=='n' && *(s+1)=='o'){ s+=2; yes=false; }
key=FXString::null;
val=FXString::null;
while(*s!='\0' && *s!=':' && *s!='=' && *s!='\t' && *s!=' '){
key+=*s++;
}
if(*s=='='){
s++;
while(*s!='\0' && *s!=':' && *s!='\t' && *s!=' '){
val+=*s++;
}
}
if(key=="ft" || key=="filetype"){
setLanguage(val);
}
else if(key=="et" || key=="expandtab"){
setTabMode(yes);
}
else if(key=="wrap"){
setWrapMode(yes);
}
else if(key=="ai"){
setAutoIndent(yes);
}
else if(key=="ts" || key=="tabstop"){
setTabWidth(val.toInt());
}
else if(key=="textwidth"){
setWrapWidth(val.toInt());
}
}
return true;
}
// Parse Adie modelines
FXbool Modeline::parseAdieModeline(const FXchar* s){
FXString key;
FXString val;
while(*s!='\0' && *s!=':'){
key=FXString::null;
val=FXString::null;
while(*s=='\t' || *s==' ') s++;
if(*s=='\0') break;
while(*s!='\0' && *s!=':' && *s!='=' && *s!='\t' && *s!=' '){
key+=*s++;
}
while(*s=='\t' || *s==' ') s++;
if(*s=='\0') break;
if(*s!='=') continue;
s++;
while(*s=='\t' || *s==' ') s++;
if(*s=='\0') break;
while(*s!='\0' && *s!=':' && *s!='\t' && *s!=' '){
val+=*s++;
}
if(key=="la"){
setLanguage(val);
}
else if(key=="ts"){
setTabWidth(val.toInt());
}
else if(key=="ww"){
setWrapWidth(val.toInt());
}
else if(key=="et"){
setTabMode(val!="0");
}
else if(key=="wr"){
setWrapMode(val!="0");
}
else if(key=="ai"){
setAutoIndent(val!="0");
}
}
return true;
}
void QgsCodeEditor::setSciWidget()
{
setUtf8( true );
setCaretLineVisible( true );
setCaretLineBackgroundColor( QColor( "#fcf3ed" ) );
setBraceMatching( QsciScintilla::SloppyBraceMatch );
setMatchedBraceBackgroundColor( QColor( "#b7f907" ) );
// whether margin will be shown
setMarginVisible( mMargin );
// whether margin will be shown
setFoldingVisible( mFolding );
// indentation
setAutoIndent( true );
setIndentationWidth( 4 );
setTabIndents( true );
setBackspaceUnindents( true );
setTabWidth( 4 );
// autocomplete
setAutoCompletionThreshold( 2 );
setAutoCompletionSource( QsciScintilla::AcsAPIs );
}
/**
* Initializes the lexer.
* @param script
* The script file.
*/
void SingleDocument::initLexer(QString script)
{
(void)script;
if(lexer() == 0)
{
setLexer(new QsciLexerJavaScript(this));
QsciAPIs* apis = new QsciAPIs(lexer());
(void)apis;
setAutoCompletionSource(QsciScintilla::AcsAPIs);
setAutoCompletionCaseSensitivity(true);
setAutoCompletionThreshold(3);
setAutoIndent(true);
setIndentationWidth(4);
setTabWidth(4);
setMarginLineNumbers(0,true);
setMarginType(0, QsciScintilla::NumberMargin);
setMarginsForegroundColor(QColor(128, 128, 128));
}
}
void Buffer::loadConfiguration() {
Configuration *config = Configuration::instance();
m_trackLineWidth = config->trackLineMarginWidth();
m_braceHighlight = config->braceHighlight();
setStyleQFont(STYLE_DEFAULT, config->font());
setViewWhitespace(config->viewWhitespace());
setViewIndentationGuides(config->viewIndentationGuides());
setCaretLineVisible(config->caretLineVisible());
setLongLineIndicator(config->longLineIndicator());
setViewEOL(config->viewEndOfLine());
setShowLineNumbers(config->showLineMargin());
setShowIconMargin(config->showIconMargin());
setShowFoldMargin(config->showFoldMargin());
setTabWidth(config->tabWidth());
setIndent(config->indentationWidth());
setUseTabs(config->useTabs());
setScrollWidth(config->scrollWidth());
setScrollWidthTracking(config->scrollWidthTracking());
setFoldSymbols(config->foldSymbols());
setFoldLines(config->foldLines());
setColorScheme(ColorScheme::getColorScheme(config->colorScheme()));
}
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_);
}
QsciEditor::QsciEditor( QWidget *parent ) : QsciScintilla( parent ) {
setFocus();
/* Set tab width, and fonts */
setTabWidth( 4 );
setFont( QFont( "Envy Code R", 9 ) );
setTabIndents( true );
setIndentationsUseTabs( true );
/* Set folding style */
setFolding( QsciScintilla::BoxedTreeFoldStyle );
/* Remove Horizontal Scrollbar, put a Vertical one */
setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
setVerticalScrollBarPolicy( Qt::ScrollBarAsNeeded );
/* Whitespace, indentation markings, and eol */
setIndentationGuides( false );
setWhitespaceVisibility( WsInvisible );
setEolMode( EolUnix );
/* Create Margins */
setMarginWidth( 0, QString( " %1 " ).arg( lines() ) );
setMarginWidth( 1, " " );
setMarginWidth( 2, 10 );
setMarginsFont( QFont( "Envy Code R", 9 ) );
setWrapMode( QsciScintilla::WrapWord );
/* Current Line Visibility */
ensureCursorVisible();
setCaretLineVisible( true );
setCaretLineBackgroundColor( QColor( "#555555" ) );
setCaretForegroundColor( QColor( "#FAFFAF" ) );
setCaretWidth( 2 );
/* Selection Color */
// setSelectionBackgroundColor( "#333964" );
// setSelectionForegroundColor( "*" );
/* Margin and folding margins background colors */
setMarginsBackgroundColor( QColor( "#A0A0A0" ) );
setFoldMarginColors( QColor( "#666666" ), Qt::black );
/* Set the width of the line */
setLineWidth( 144 );
ensureLineVisible( true );
/* Set the paper and pen color - Editor BG and FG color */
setPaper( Qt::black );
setColor( Qt::white );
/* Brace coloring */
setBraceMatching( QsciScintilla::SloppyBraceMatch );
setUnmatchedBraceForegroundColor( Qt::red );
setUnmatchedBraceBackgroundColor( Qt::black );
setMatchedBraceForegroundColor( Qt::darkGreen );
setMatchedBraceBackgroundColor( Qt::black );
/* Multi-selection and typing */
SendScintilla( SCI_SETADDITIONALSELECTIONTYPING, true );
SendScintilla( SCI_SETMULTIPLESELECTION, true );
SendScintilla( SCI_SETMULTIPASTE, true );
/* Scroll beyond the last line */
SendScintilla( SCI_SETENDATLASTLINE, false );
/* Set the editor state as not modified */
setModified( false );
/* Auto Save Timer: 60 sec */
autoSaveTimer = new QBasicTimer();
/* Enable and Show Custom context Menu */
setContextMenuPolicy( Qt::CustomContextMenu );
/* Connections */
setupActions();
/* Default Lexer */
setLexer( new QLexerDefault() );
QsciScintilla::FoldStyle state = static_cast<QsciScintilla::FoldStyle>( ( !folding() ) * 5 );
if ( !state )
foldAll( false );
setFolding( state );
};
void Editor::setEditorStyle (void)
{
//QFont font ("Consolas", 14, QFont::Normal, false);
QFont font (config.editorFontName, config.editorFontSize, QFont::Normal, false);
lblCursorPosition->setFont(font);
QFontMetrics fontMetrics(font);
//QColor backColor = QColor(22, 30, 32);
TextStyle style;
config.GetThemeStyle(config.themeName, "DEFAULT", style);
QColor backColor = style.backColor;//QColor(config.editorColorName);
setColor(backColor);
QString css = "color:" + style.foreColor.name() + ";";
css += "background-color:" + style.backColor.name() + ";";
css += "border: 1px solid " + style.foreColor.name() + ";";
lblCursorPosition->setStyleSheet(css);
// margin
setMarginLineNumbers(100, true);
setMarginsFont(font);
config.GetThemeStyle(config.themeName, "MARGIN", style);
setMarginsBackgroundColor(style.backColor);//QColor(24,32,34));//QColor(20,28,30));
setMarginsForegroundColor(style.foreColor); //QColor(42,50,52));
setMarginWidth(0, fontMetrics.width("00000") + 6);
// General editor things
setTabWidth(4);
ensureCursorVisible();
setIndicatorForegroundColor (Qt::red, 1);
// compile error/warning mark
markerDefine(QsciScintilla::RightArrow, 1);
setMarkerBackgroundColor(Qt::red, 1);
markerDefine(QsciScintilla::Circle, 0);
setMarkerBackgroundColor(Qt::red, 0);
setMarkerForegroundColor(Qt::white, 0);
// caret
setCaretLineVisible(true);
setCaretWidth(2);
config.GetThemeStyle(config.themeName, "CARET", style);
setCaretForegroundColor(style.foreColor);//QColor(220, 200, 200));
caretLineBackColor = style.backColor;
setCaretLineBackgroundColor(caretLineBackColor);//QColor(24, 32, 34));
//setCaretLineBackgroundColor(QColor(255, 0, 0, 100));
//SendScintilla (SC_TECHNOLOGY_DIRECTWRITE, 1);
//SendScintilla (SCI_SETBUFFEREDDRAW, 1);
//SendScintilla (SCI_SETTWOPHASEDRAW, 1);
//SendScintilla (SCI_SETFONTQUALITY, SC_EFF_QUALITY_NON_ANTIALIASED);//SC_EFF_QUALITY_DEFAULT);
// matched and unmatched braces coloring
if (config.highlightBraces) {
setBraceMatching(QsciScintilla::SloppyBraceMatch);
} else {
setBraceMatching(QsciScintilla::NoBraceMatch);
}
setMatchedBraceBackgroundColor(backColor);
setMatchedBraceForegroundColor(QColor(220, 220, 50));
setUnmatchedBraceBackgroundColor(QColor(0,0,0));
setUnmatchedBraceForegroundColor(QColor(255, 0, 0));
// selection
config.GetThemeStyle(config.themeName, "SELECTION", style);
setSelectionForegroundColor(style.foreColor);//QColor(150, 150, 150));
setSelectionBackgroundColor(style.backColor);//QColor(52, 60, 62));
// maim cpp styles
setLexerStyle(-1, "DEFAULT");//QColor (120, 120, 120),backColor);
//setLexerStyle(-1, Qt::red, Qt::blue);
//setLexerStyle(QsciLexerCPP::Default, Qt::blue, Qt::yellow);
setLexerStyle(QsciLexerCPP::Default, "DEFAULT");
//setLexerStyle(QsciLexerCPP::callSTYLE_CALLTIP, QColor (255,0,0), QColor(255,255,255));
setLexerStyle(QsciLexerCPP::Comment, "COMMENT");
setLexerStyle(QsciLexerCPP::CommentDoc, "COMMENT DOC");
setLexerStyle(QsciLexerCPP::CommentLine, "COMMENT LIN E DOC");
setLexerStyle(QsciLexerCPP::Number, "NUMBER");
setLexerStyle(QsciLexerCPP::Keyword, "KEYWORD");
setLexerStyle(QsciLexerCPP::DoubleQuotedString, "DOUBLE QUOTED STRING");
setLexerStyle(QsciLexerCPP::SingleQuotedString, "SINGLE QUOTED STRING");
setLexerStyle(QsciLexerCPP::PreProcessor, "PREPROCESSOR");
setLexerStyle(QsciLexerCPP::Operator, "OPERATOR");
setLexerStyle(QsciLexerCPP::Identifier, "IDENTIFIER");
setLexerStyle(QsciLexerCPP::UnclosedString, "UNCLOSED STRING");
// secondary styles
setLexerStyle(QsciLexerCPP::UUID, "UUID");
setLexerStyle(QsciLexerCPP::VerbatimString, "VERBATIM STRING");
setLexerStyle(QsciLexerCPP::Regex, "REGEX");
setLexerStyle(QsciLexerCPP::CommentLineDoc, "COMMENT LINE DOC");
setLexerStyle(QsciLexerCPP::KeywordSet2, "KEYWORD SET 2");
setLexerStyle(QsciLexerCPP::CommentDocKeyword, "COMMENT DOC KEYWORD");
setLexerStyle(QsciLexerCPP::CommentDocKeywordError, "COMMENT DOC KEYWORD ERROR");
setLexerStyle(QsciLexerCPP::GlobalClass, "GLOBAL CLASS");
setLexerStyle(QsciLexerCPP::RawString, "DOUBLE QUOTED STRING");
setLexerStyle(QsciLexerCPP::TripleQuotedVerbatimString, "VERBATIM STRING");
setLexerStyle(QsciLexerCPP::HashQuotedString, "VERBATIM STRING");
setLexerStyle(QsciLexerCPP::PreProcessorComment, "PREPROCESSOR");
setLexerStyle(QsciLexerCPP::PreProcessorCommentLineDoc, "PREPROCESSOR");
}
HighlightingItemDelegate::HighlightingItemDelegate(int tabWidth, QObject *parent)
: QItemDelegate(parent)
{
setTabWidth(tabWidth);
}
void ResourceTrueTypeFont::deserialization(xml::ElementPtr _node, Version _version)
{
Base::deserialization(_node, _version);
xml::ElementEnumerator node = _node->getElementEnumerator();
while (node.next())
{
if (node->getName() == "Property")
{
const std::string& key = node->findAttribute("key");
const std::string& value = node->findAttribute("value");
if (key == "Source")
setSource(value);
else if (key == "Size")
setSize(utility::parseFloat(value));
else if (key == "Resolution")
setResolution(utility::parseUInt(value));
else if (key == "Antialias")
setAntialias(utility::parseBool(value));
else if (key == "TabWidth")
setTabWidth(utility::parseFloat(value));
else if (key == "OffsetHeight")
setOffsetHeight(utility::parseInt(value));
else if (key == "SubstituteCode")
setSubstituteCode(utility::parseInt(value));
else if (key == "Distance")
setDistance(utility::parseInt(value));
else if (key == "Hinting")
setHinting(value);
else if (key == "SpaceWidth")
{
mSpaceWidth = utility::parseFloat(value);
MYGUI_LOG(Warning, _node->findAttribute("type") << ": Property '" << key << "' in font '" << _node->findAttribute("name") << "' is deprecated; remove it to use automatic calculation.");
}
else if (key == "CursorWidth")
{
MYGUI_LOG(Warning, _node->findAttribute("type") << ": Property '" << key << "' in font '" << _node->findAttribute("name") << "' is deprecated; value ignored.");
}
}
else if (node->getName() == "Codes")
{
// Range of inclusions.
xml::ElementEnumerator range = node->getElementEnumerator();
while (range.next("Code"))
{
std::string range_value;
if (range->findAttribute("range", range_value))
{
std::vector<std::string> parse_range = utility::split(range_value);
if (!parse_range.empty())
{
Char first = utility::parseUInt(parse_range[0]);
Char last = parse_range.size() > 1 ? utility::parseUInt(parse_range[1]) : first;
addCodePointRange(first, last);
}
}
}
// If no code points have been included, include the Unicode Basic Multilingual Plane by default before processing
// any exclusions.
if (mCharMap.empty())
addCodePointRange(0, 0xFFFF);
// Range of exclusions.
range = node->getElementEnumerator();
while (range.next("Code"))
{
std::string range_value;
if (range->findAttribute("hide", range_value))
{
std::vector<std::string> parse_range = utility::split(range_value);
if (!parse_range.empty())
{
Char first = utility::parseUInt(parse_range[0]);
Char last = parse_range.size() > 1 ? utility::parseUInt(parse_range[1]) : first;
removeCodePointRange(first, last);
}
}
}
}
}
initialise();
}