PMsrHighlighter.cpp

Go to the documentation of this file.

 
/***************************************************************************
 *   Copyright (C) 2007-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#include <utility>
 
#include <QGuiApplication>
#include <QStyleHints>
#include <QMessageBox> //as35
 
#include "PMsrHighlighter.h"

PMsrHighlighter::PMsrHighlighter(QTextDocument *parent)
    : QSyntaxHighlighter(parent) {
 
  // =========================================================================
  // TABLEAU COLOURS
  // =========================================================================
 
  // Individual QColor definitions grouped by color pairs (Dark / Light)
  const QColor tabBlue("#1F77B4");
  const QColor tabBlueLight("#AEC7E8");
 
  const QColor tabOrange("#FF7F0E");
  const QColor tabOrangeLight("#FFBB78");
 
  const QColor tabGreen("#2CA02C");
  const QColor tabGreenLight("#98DF8A");
 
  const QColor tabRed("#D62728");
  const QColor tabRedLight("#FF9896");
 
  const QColor tabPurple("#9467BD");
  const QColor tabPurpleLight("#C5B0D5");
 
  const QColor tabBrown("#8C564B");
  const QColor tabBrownLight("#C49C94");
 
  const QColor tabPink("#E377C2");
  const QColor tabPinkLight("#F7B6D2");
 
  const QColor tabGray("#7F7F7F");
  const QColor tabGrayLight("#C7C7C7");
 
  const QColor tabOlive("#BCBD22");
  const QColor tabOliveLight("#DBDB8D");
 
  const QColor tabCyan("#17BECF");
  const QColor tabCyanLight("#9EDAE5");
 
  // =========================================================================
  // KEYWORD STYLING
  // =========================================================================
 
  // Define the colour/styling for each keyword type.
  Qt::ColorScheme scheme = QGuiApplication::styleHints()->colorScheme();
  
  if (scheme == Qt::ColorScheme::Light) {
    fBlockFormat.setForeground(tabOlive);    // BLOCK keywords
    fTheoryFormat.setForeground(tabGreen);   // THEORY keywords
    fFunctionsFormat.setForeground(tabRed);  // FUNCTION keywords
    fParFormat.setForeground(tabPink);       // parX keywords
    fMapFormat.setForeground(tabOrange);     // mapX keywords
    fFunFormat.setForeground(tabPurple);     // funX keywords
    fRunFormat.setForeground(tabGreen);      // RUN/GLOBAL keywords
    fCommandsFormat.setForeground(tabGreen); // COMMANDS keywords
    fFourierFormat.setForeground(tabGreen);  // FOURIER keywords
    fPlotFormat.setForeground(tabGreen);     // PLOT keywords
    fOptionsFormat.setForeground(tabRed);    // keywords input options
    fInfoFormat.setForeground(tabGray);      // auto-printed information
    fBoolFormat.setForeground(tabRed);       // boolean strings
    fNullFormat.setForeground(tabRed);       // null strings
    fDateFormat.setForeground(tabPink);      // date & time strings
    fNumberFormat.setForeground(tabBlue);    // integer & float strings
    fCommentFormat.setForeground(tabGray);   // comments
    fCommentFormat.setFontItalic(true);
    fTitleFormat.setForeground(Qt::black); // title
  } else if (scheme == Qt::ColorScheme::Dark) {
    fBlockFormat.setForeground(tabOlive);    // BLOCK keywords
    fTheoryFormat.setForeground(tabGreen);   // THEORY keywords
    fFunctionsFormat.setForeground(tabRed);  // FUNCTION keywords
    fParFormat.setForeground(tabPink);       // parX keywords
    fMapFormat.setForeground(tabOrange);     // mapX keywords
    fFunFormat.setForeground(tabPurple);     // funX keywords
    fRunFormat.setForeground(tabGreen);      // RUN/GLOBAL keywords
    fCommandsFormat.setForeground(tabGreen); // COMMANDS keywords
    fFourierFormat.setForeground(tabGreen);  // FOURIER keywords
    fPlotFormat.setForeground(tabGreen);     // PLOT keywords
    fOptionsFormat.setForeground(tabRed);    // keywords input options
    fInfoFormat.setForeground(tabGray);      // auto-printed information
    fBoolFormat.setForeground(tabRed);       // boolean strings
    fNullFormat.setForeground(tabRed);       // null strings
    fDateFormat.setForeground(tabPink);      // date & time strings
    fNumberFormat.setForeground(tabBlueLight);  // integer & float strings
    fCommentFormat.setForeground(tabGray);   // comments
    fCommentFormat.setFontItalic(true);
    fTitleFormat.setForeground(Qt::white); // title
  } else { // set it to Light for now
    fBlockFormat.setForeground(tabOlive);    // BLOCK keywords
    fTheoryFormat.setForeground(tabGreen);   // THEORY keywords
    fFunctionsFormat.setForeground(tabRed);  // FUNCTION keywords
    fParFormat.setForeground(tabPink);       // parX keywords
    fMapFormat.setForeground(tabOrange);     // mapX keywords
    fFunFormat.setForeground(tabPurple);     // funX keywords
    fRunFormat.setForeground(tabGreen);      // RUN/GLOBAL keywords
    fCommandsFormat.setForeground(tabGreen); // COMMANDS keywords
    fFourierFormat.setForeground(tabGreen);  // FOURIER keywords
    fPlotFormat.setForeground(tabGreen);     // PLOT keywords
    fOptionsFormat.setForeground(tabRed);    // keywords input options
    fInfoFormat.setForeground(tabGray);      // auto-printed information
    fBoolFormat.setForeground(tabRed);       // boolean strings
    fNullFormat.setForeground(tabRed);       // null strings
    fDateFormat.setForeground(tabPink);      // date & time strings
    fNumberFormat.setForeground(tabBlue);    // integer & float strings
    fCommentFormat.setForeground(tabGray);   // comments
    fCommentFormat.setFontItalic(true);
    fTitleFormat.setForeground(Qt::black); // title
  }
 
  // =========================================================================
  // BLOCK HEADERS
  // =========================================================================
  QStringList block_keywords = {"FITPARAMETER", "THEORY", "FUNCTIONS",
                                "GLOBAL",       "RUN",    "COMMANDS",
                                "FOURIER",      "PLOT",   "STATISTIC"};
  AddRule(block_keywords, fBlockFormat);
 
  // =========================================================================
  // THEORY KEYWORDS
  // =========================================================================
  QStringList theory_keywords_long = {
      "const",        "asymmetry",   "simplExpo",   "generExpo",
      "simpleGss",    "statGssKT",   "statGssKTLF", "dynGssKTLF",
      "statExpKT",    "statExpKTLF", "dynExpKTLF",  "dynGLKT_F_ZF",
      "dynGLKT_F_LF", "dynGLKT_LF",  "combiLGKT",   "strKT",
      "spinGlass",    "rdAnisoHf",   "TFieldCos",   "internFld",
      "Bessel",       "internbsl",   "internFldGK", "internFldLL",
      "F_mu_F",       "abragam",     "skewedGss",   "staticNKZF",
      "staticNKTF",   "dynamicNKZF", "dynamicNKTF", "muMinusExpTF",
      "polynom",      "userFcn"};
 
  QStringList theory_keywords_short = {"c",
                                       "a",
                                       "se",
                                       "ge",
                                       "sg",
                                       "stg",
                                       "sgktlf",
                                       "dgktlf",
                                       "sekt",
                                       "sektlf",
                                       "dektlf",
                                       "dglktfzf",
                                       "dglktflf",
                                       "dglktlf",
                                       "lgkt",
                                       "skt",
                                       "spg",
                                       "rahf",
                                       "tf",
                                       "ifld",
                                       "b",
                                       "ib",
                                       "ifgk",
                                       "ifll",
                                       "fmuf",
                                       "ab",
                                       "skg",
                                       "snkzf",
                                       "snktf",
                                       "dnkzf",
                                       "dnktf",
                                       "mmsetf",
                                       "p",
                                       "u"};
 
  // combine both theory keyword lists
  QStringList theory_keywords = theory_keywords_long + theory_keywords_short;
 
  AddRule(theory_keywords, fTheoryFormat);
 
  // =========================================================================
  // FUNCTIONS KEYWORDS
  // =========================================================================
  QStringList functions_keywords = {
      "gamma_mu", "pi", "B", "b", "En", "en", "T\\d+",
      /* "+", "-",  "*",  "/", */
  };
  AddRule(functions_keywords, fFunctionsFormat);
 
  // =========================================================================
  // funX KEYWORDS
  // =========================================================================
  QStringList fun_keywords = {"fun\\d+"};
  AddRule(fun_keywords, fFunFormat);
 
  // =========================================================================
  // parX KEYWORDS
  // =========================================================================
  QStringList par_keywords = {"par\\d+"};
  AddRule(par_keywords, fParFormat);
 
  // =========================================================================
  // mapX KEYWORDS
  // =========================================================================
  QStringList map_keywords = {"map\\d+"};
  AddRule(map_keywords, fMapFormat);
 
  // =========================================================================
  // RUN KEYWORDS
  // =========================================================================
  QStringList run_keywords = {
      "fittype",      "data",       "t0",       "addt0",
      "deadtime-cor", "fit",        "packing",  "rrf_freq",
      "rrf_packing",  "rrf_phase",  "alpha",    "beta",
      "norm",         "backgr.fit", "lifetime", "lifetimecorrection",
      "map",          "forward",    "backward", "backgr.fix",
      "background",   "xy-data"};
  AddRule(run_keywords, fRunFormat);
 
  // =========================================================================
  // FOURIER KEYWORDS
  // =========================================================================
  QStringList fourier_keywords = {"units",
                                  "fourier_power",
                                  "dc-corrected",
                                  "apodization",
                                  "plot",
                                  "phase",
                                  "range_for_phase_correction",
                                  "range"};
  AddRule(fourier_keywords, fFourierFormat);
 
  // =========================================================================
  // PLOT KEYWORDS
  // =========================================================================
  QStringList plot_keywords = {"lifetimecorrection",
                               "runs",
                               "range",
                               "sub_ranges",
                               "use_fit_ranges",
                               "view_packing",
                               "logx",
                               "logy",
                               "rrf_packing value",
                               "rrf_freq value unit",
                               "rrf_phase value"};
  AddRule(plot_keywords, fPlotFormat);
 
  // =========================================================================
  // UNITS OPTIONS
  // =========================================================================
  QStringList units_options = {"Gauss", "Tesla", "MHz", "Mc/s"};
 
  // =========================================================================
  // APODIZATION OPTIONS
  // =========================================================================
  QStringList apodization_options = {"NONE", "WEAK", "MEDIUM", "STRONG"};
 
  // =========================================================================
  // RRF OPTIONS
  // =========================================================================
  QStringList rrf_options = {"MHz", "Mc", "T"};
 
  // =========================================================================
  // FOURIER OPTIONS
  // =========================================================================
  QStringList fourier_options = {"REAL",  "IMAG",  "REAL_AND_IMAG",
                                 "POWER", "PHASE", "PHASE_OPT_REAL"};
 
  // =========================================================================
  // COMMANDS OPTIONS
  // =========================================================================
  QStringList commands_options = {"RESET"};
 
  // =========================================================================
  // ALL OPTIONS
  // =========================================================================
  QStringList all_options = units_options + apodization_options + rrf_options +
                            fourier_options + commands_options;
 
  AddRule(all_options, fOptionsFormat);
 
  // =========================================================================
  // FIT INFO
  // =========================================================================
  QStringList fit_info = {
      "(single histogram fit)", "(single histogram RRF fit)",
      "(asymmetry fit)",        "(asymmetry RRF fit)",
      "(mu minus fit)",         "(beta-NMR fit)",
      "(non muSR fit)"};
 
  // =========================================================================
  // PLOT INFO
  // =========================================================================
  QStringList plot_info = {"(single histo plot)", "(single histo RRF plot)",
                           "(asymmetry plot)",    "(asymmetry RRF plot)",
                           "(mu minus plot)",     "(beta-NMR asymmetry plot)",
                           "(non muSR plot)"};
 
  // =========================================================================
  // RUN INFO
  // =========================================================================
  QStringList run_info = {"(name beamline institute data-file-format)"};
 
  // =========================================================================
  // THEORY INFO
  // =========================================================================
  QStringList theory_info = {"(N0 tau A lambda phase nu tshift)",
                             "(N0 tau A lambda phase nu)",
                             "(damping hopping-rate tshift)",
                             "(damping hopping-rate)",
                             "(damping_D0 R_b nu_c tshift)",
                             "(damping_D0 R_b nu_c)",
                             "(damping_D0 R_b tshift)",
                             "(damping_D0 R_b)",
                             "(fraction frequency sigma lambda beta tshift)",
                             "(fraction frequency sigma lambda beta)",
                             "(fraction phase frequency Trate Lrate tshift)",
                             "(fraction phase frequency Trate Lrate)",
                             "(frequency damping hopping-rate tshift)",
                             "(frequency damping hopping-rate)",
                             "(frequency damping tshift)",
                             "(frequency damping)",
                             "(frequency rate tshift)",
                             "(frequency rate)",
                             "(frequency tshift)",
                             "(frequency)",
                             "(lorentzRate gaussRate tshift)",
                             "(lorentzRate gaussRate)",
                             "(phase frequency damping_D0 R_b nu_c tshift)",
                             "(phase frequency damping_D0 R_b nu_c)",
                             "(phase frequency damping_D0 R_b tshift)",
                             "(phase frequency damping_D0 R_b)",
                             "(phase frequency rate_m rate_p tshift)",
                             "(phase frequency rate_m rate_p)",
                             "(phase frequency tshift)",
                             "(phase frequency)",
                             "(rate beta tshift)",
                             "(rate beta)",
                             "(rate exponent tshift)",
                             "(rate exponent)",
                             "(rate hopprate order tshift)",
                             "(rate hopprate order)",
                             "(rate hopprate tshift)",
                             "(rate hopprate)",
                             "(rate tshift)",
                             "(rate)",
                             "(tshift p0 p1 ... pn)"};
 
  // =========================================================================
  // ALL INFO
  // =========================================================================
  QStringList all_info = fit_info + run_info + plot_info + theory_info;
 
  AddRule(all_info, fInfoFormat);
 
  // =========================================================================
  // COMMANDS BLOCK KEYWORDS
  // =========================================================================
  QStringList commands_keywords = {
      "STRATEGY",   "MIGRAD",         "SIMPLEX",     "MINIMIZE",
      "MINOS",      "HESSE",          "SAVE",        "SET BATCH",
      "END RETURN", "MAX_LIKELIHOOD", "PRINT_LEVEL", "SCAN",
      "CONTOURS",   "MNPLOT",         "FIX",         "RELEASE",
      "FIT_RANGE",  "SCALE_N0_BKG",   "SECTOR",      "OpenMP",
      "CUDA",       "OpenCL-CPU",     "OpenCL-GPU"};
 
  AddRule(commands_keywords, fCommandsFormat);
 
  // =========================================================================
  // BOOLEANS
  // =========================================================================
  QStringList bool_keywords = {"true", "false"};
  AddRule(bool_keywords, fBoolFormat);
 
  // =========================================================================
  // NULLS
  // =========================================================================
  QStringList null_keywords = {"none"};
  AddRule(null_keywords, fNullFormat);
 
  // =========================================================================
  // NUMBERS
  // =========================================================================
  // Distinguish integer/decimal numbers from raw text.
  PHighlightingRule number_rule;
  QRegularExpression number_regex("\\b-?\\d*\\.?\\d+\\b");
  number_rule.fPattern = number_regex;
  number_rule.fFormat = fNumberFormat;
  fHighlightingRules.append(number_rule);
 
  // =========================================================================
  // DATES
  // =========================================================================
  // Distinguish date/time strings from raw text.
  PHighlightingRule date_rule;
  // date regex (for dates of the form: YYYY-MM-DD HH:mm:ss)
  QRegularExpression date_regex("\\b\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3["
                                "01]) (0\\d|1\\d|2[0-3]):[0-5]\\d:[0-5]\\d\\b");
  date_rule.fPattern = date_regex;
  date_rule.fFormat = fDateFormat;
  fHighlightingRules.append(date_rule);
 
  // =========================================================================
  // INLINE AND LINE COMMENTS
  // =========================================================================
  // Musrfit treats lines beginning with '#' as ignored comments.
  // This matches a literal '#' symbol and captures everything remaining on that
  // line. Styled gray and italicized to quickly indicate non-executable text
  // annotations.
  PHighlightingRule comment_rule;
  QRegularExpression comment_regex("#.*");
  comment_rule.fPattern = comment_regex;
  comment_rule.fFormat = fCommentFormat;
  fHighlightingRules.append(comment_rule);
}

void PMsrHighlighter::AddRule(const QStringList &keywords,
                              const QTextCharFormat &formatting) {
  // Instantiate the PHighlightingRule struct.
  PHighlightingRule rule;
 
  // loop through every keyword
  for (const QString &keyword : keywords) {
    // Wrap each keyword string into a strict word-boundary (\b) regular
    // expression. This ensures keywords matching inside longer variable titles
    // do not falsely trigger formatting.
    QRegularExpression regex(QString("\\b%1\\b").arg(keyword));
 
    // apply the formatting to the rule struct
    rule.fPattern = regex;
    rule.fFormat = formatting;
 
    // add the rule to the main list
    this->fHighlightingRules.append(rule);
  }
}

void PMsrHighlighter::highlightBlock(const QString &text) {
 
  // Sequentially process each entry stored inside the rules vector array.
  for (const PHighlightingRule &rule : std::as_const(fHighlightingRules)) {
    // Execute a global search through the single block string provided.
    QRegularExpressionMatchIterator matchIterator =
        rule.fPattern.globalMatch(text);
 
    // Loop over every match location instance discovered within this single
    // text string.
    while (matchIterator.hasNext()) {
      QRegularExpressionMatch match = matchIterator.next();
 
      // Extract the position details of the substring match sequence.
      int index = match.capturedStart();
      int length = match.capturedLength();
 
      // Core Qt framework utility method which maps styles directly onto
      // coordinates of the running open source buffer segment.
      setFormat(index, length, rule.fFormat);
    }
  }
 
  // Treat highlighting of the TITLE block separately so that it take precedence
  // over all other rules.
  if (currentBlock().blockNumber() == 0) {
    // applies the title formatting for the entirety of the first line
    setFormat(0, text.length(), fTitleFormat);
  }
}