Jump to content

MediaWiki:Gadget-TciTest.js: Difference between revisions

Find traditional instrumental music
← Older editNewer edit →
WikiSysop (talk | contribs)
autoreview, Bots, Bureaucrats, contributor, darkmatter, editor, gardener, Interface administrators, lookupuser, reviewer, Administrators (Semantic MediaWiki), Curators (Semantic MediaWiki), Administrators, Widget editors
119,561 edits
No edit summary
Tag: Reverted
WikiSysop (talk | contribs)
autoreview, Bots, Bureaucrats, contributor, darkmatter, editor, gardener, Interface administrators, lookupuser, reviewer, Administrators (Semantic MediaWiki), Curators (Semantic MediaWiki), Administrators, Widget editors
119,561 edits
No edit summary
Tag: Reverted
Line 1: Line 1:
// Gadget-TciTest.js — TCI Calculator (LIVE DEBUG — logging ABC matches)
// Gadget-TciTest.js — TCI Calculator (VISIBLE version fix)
(function ($, mw, OO) {
(function ($, mw, OO) {
   "use strict";
   "use strict";
Line 16: Line 16:
     ];
     ];


     const majorScales = {
     TCICalculatorTestDialog.prototype.initialize = function () {
       C: ['C', 'D', 'E', 'F', 'G', 'A', 'B'],
       TCICalculatorTestDialog.super.prototype.initialize.call(this);
      G: ['G', 'A', 'B', 'C', 'D', 'E', 'F#'],
      D: ['D', 'E', 'F#', 'G', 'A', 'B', 'C#'],
      A: ['A', 'B', 'C#', 'D', 'E', 'F#', 'G#'],
      E: ['E', 'F#', 'G#', 'A', 'B', 'C#', 'D#'],
      B: ['B', 'C#', 'D#', 'E', 'F#', 'G#', 'A#'],
      F: ['F', 'G', 'A', 'Bb', 'C', 'D', 'E']
    };


    const minorScales = {
      this.content = new OO.ui.PanelLayout({
      Am: ['A', 'B', 'C', 'D', 'E', 'F', 'G'],
        padded: true,
      Em: ['E', 'F#', 'G', 'A', 'B', 'C', 'D'],
        expanded: true,
      Dm: ['D', 'E', 'F', 'G', 'A', 'Bb', 'C'],
        scrollable: true
       Bm: ['B', 'C#', 'D', 'E', 'F#', 'G', 'A'],
       });
       Gm: ['G', 'A', 'Bb', 'C', 'D', 'Eb', 'F'],
       this.$body.append(this.content.$element);
      Fsm: ['F#', 'G#', 'A', 'B', 'C#', 'D', 'E']
    };


    const parallelMajors = {
      this.abcInput = new OO.ui.MultilineTextInputWidget({
      Em: 'E', Am: 'A', Dm: 'D', Bm: 'B', Gm: 'G', Fsm: 'F#'
        placeholder: 'Paste ABC notation here...',
    };
        autosize: true,
        rows: 10,
        classes: ['tci-abc-input']
      });


    function normalizeKey(key) {
      this.octaveChoice = new OO.ui.DropdownInputWidget({
      return key.replace(/[^a-zA-Z#bm]/g, '').trim();
        options: [
    }
          { data: 'standard', label: 'Standard fiddle range (default)' },
          { data: 'visual', label: 'Based on ABC visual octave' },
          { data: 'shiftUp', label: 'Force high octave (+1)' },
          { data: 'shiftDown', label: 'Force low octave (-1)' }
        ]
      });


    function getScaleForKey(keyRaw) {
      this.resultOutput = new OO.ui.MultilineTextInputWidget({
      const key = normalizeKey(keyRaw);
        readOnly: true,
      return majorScales[key] || minorScales[key] || majorScales['D'];
        autosize: true,
    }
        rows: 6,
        classes: ['tci-output']
      });


    function getComparativeMajorScale(keyRaw) {
      this.content.$element.append(
      const key = normalizeKey(keyRaw);
        new OO.ui.FieldsetLayout({
      return majorScales[parallelMajors[key]] || majorScales['D'];
          label: 'TCI Calculator Options',
    }
          items: [
 
            new OO.ui.FieldLayout(this.abcInput, { label: 'ABC Notation', align: 'top' }),
    function normalizeNote(note) {
            new OO.ui.FieldLayout(this.octaveChoice, { label: 'Octave Interpretation', align: 'top' }),
      return note.replace(/=/g, '').replace(/\^/g, '#').replace(/_/g, 'b');
            new OO.ui.FieldLayout(this.resultOutput, { label: 'Theme Code Index (TCI)', align: 'top' })
    }
          ]
 
        }).$element
    function parseABC(abcText, octaveMode) {
       );
       console.log("📄 TEXT RECEIVED BY PARSER:\n", abcText);
    };


      const lines = abcText.split(/\r?\n/);
    // CSS fix
      const keyLine = lines.find(line => line.startsWith('K:')) || 'K:D';
    mw.util.addCSS(`
       const lengthLine = lines.find(line => line.startsWith('L:')) || 'L:1/8';
       .tci-abc-input textarea {
 
         min-height: 150px;
      const key = keyLine.split(':')[1].trim();
      const [lNum, lDen] = lengthLine.split(':')[1].split('/').map(Number);
      const beatDuration = lNum / lDen;
 
      const scale = getScaleForKey(key);
      const refScale = getComparativeMajorScale(key) || scale;
      const beats4 = [], beats2 = [], debug4 = [], debug2 = [];
 
      const tokenRegex = /((=|\^|_)?[a-gA-GzZ][',/]*)(\d*\/?\d*)/g;
      const allMatches = [...abcText.matchAll(tokenRegex)];
      console.log("🔍 Raw matches from ABC:", allMatches.map(m => m[0]));
 
      let match;
      let beatAcc = 0, beatAlt = 0;
 
      function parseDuration(str) {
         if (!str) return beatDuration;
        if (str.includes('/')) {
          const [n, d] = str.split('/').map(Number);
          return n / d;
        }
        return parseFloat(str);
       }
       }
 
       .tci-output textarea {
       function code(note) {
         min-height: 100px;
        const baseRaw = normalizeNote(note.replace(/[',0-9\/]/g, ''));
         background: #f5f5f5;
        const base = baseRaw.toUpperCase();
        const refIdx = refScale.findIndex(n => n.replace(/[#b]/g, '') === base);
        const idxInMinor = scale.findIndex(n => n.replace(/[#b]/g, '') === base);
 
        let c = refIdx !== -1 ? (refIdx + 1).toString() : '?';
        if (refIdx !== -1 && (idxInMinor === -1 || scale[idxInMinor] !== refScale[refIdx])) {
          if (refScale[refIdx].includes('#') && (!scale[idxInMinor] || !scale[idxInMinor].includes('#'))) c += 'b';
          else if (refScale[refIdx].includes('b') && (!scale[idxInMinor] || !scale[idxInMinor].includes('b'))) c += '#';
        }
 
         const isHigh = /[a-g]/.test(note);
        const isLow = /,/.test(note);
        if (octaveMode === 'shiftUp') return c + 'H';
        if (octaveMode === 'shiftDown') return c + 'L';
        if (octaveMode === 'visual') return isHigh ? c + 'H' : isLow ? c + 'L' : c;
         if (octaveMode === 'standard') return isHigh ? c + 'H' : c;
        return c;
       }
       }
 
       .oo-ui-window-body {
       while ((match = tokenRegex.exec(abcText)) !== null && (beatAcc < 8 || beatAlt < 4)) {
         max-height: 90vh !important;
         const [full, note, , durStr] = match;
         overflow-y: auto;
        const dur = parseDuration(durStr || `${lNum}/${lDen}`);
        const val = /z/i.test(note) ? '0' : code(note);
         const plain = note.replace(/\d.*$/, '');
 
        console.log(`NOTE: ${plain}, duration: ${dur}`);
 
        if (beatAcc < 8) {
          beats4.push(val);
          debug4.push(`B${beatAcc + 1}: ${plain} → ${val}`);
          beatAcc++;
        }
        if (beatAlt < 4) {
          beats2.push(val);
          debug2.push(`B${beatAlt + 1}: ${plain} → ${val}`);
          beatAlt++;
        }
       }
       }
    `);


      return {
     // ... (rest of script unchanged, parser + logs)
        normal: beats4.join(' '),
        dual: beats2.join(' '),
        debug: '4-beat mode:\n' + debug4.join('\n') + '\n\n2-beat mode:\n' + debug2.join('\n')
      };
    }
 
     TCICalculatorTestDialog.prototype.getActionProcess = function (action) {
      if (action === 'calculate') {
        return new OO.ui.Process(() => {
          const abc = this.abcInput.getValue();
          const mode = this.octaveChoice.getValue();
 
          console.log('📥 ABC from textarea:\n', abc);
 
          const result = parseABC(abc, mode);
          this.resultOutput.setValue(
            'Standard (4 beats): ' + result.normal +
            '\nAlternate (2 beats): ' + result.dual +
            '\n\n' + result.debug
          );
        });
      } else if (action === 'cancel') {
        return new OO.ui.Process(() => this.close({ action: action }));
      }
      return TCICalculatorTestDialog.super.prototype.getActionProcess.call(this, action);
    };


     function openTCICalculatorTestDialog() {
     function openTCICalculatorTestDialog() {

Revision as of 18:19, 10 April 2025

// Gadget-TciTest.js — TCI Calculator (VISIBLE version fix)
(function ($, mw, OO) {
  "use strict";

  mw.loader.using(["oojs-ui-core", "oojs-ui-widgets", "oojs-ui-windows"]).done(function () {
    function TCICalculatorTestDialog(config) {
      TCICalculatorTestDialog.super.call(this, config);
    }
    OO.inheritClass(TCICalculatorTestDialog, OO.ui.ProcessDialog);

    TCICalculatorTestDialog.static.name = 'tciCalculatorTestDialog';
    TCICalculatorTestDialog.static.title = 'Theme Code Index Calculator — LIVE VERSION';
    TCICalculatorTestDialog.static.actions = [
      { action: 'cancel', label: 'Cancel', flags: 'safe' },
      { action: 'calculate', label: 'Calculate TCI', flags: ['primary', 'progressive'] }
    ];

    TCICalculatorTestDialog.prototype.initialize = function () {
      TCICalculatorTestDialog.super.prototype.initialize.call(this);

      this.content = new OO.ui.PanelLayout({
        padded: true,
        expanded: true,
        scrollable: true
      });
      this.$body.append(this.content.$element);

      this.abcInput = new OO.ui.MultilineTextInputWidget({
        placeholder: 'Paste ABC notation here...',
        autosize: true,
        rows: 10,
        classes: ['tci-abc-input']
      });

      this.octaveChoice = new OO.ui.DropdownInputWidget({
        options: [
          { data: 'standard', label: 'Standard fiddle range (default)' },
          { data: 'visual', label: 'Based on ABC visual octave' },
          { data: 'shiftUp', label: 'Force high octave (+1)' },
          { data: 'shiftDown', label: 'Force low octave (-1)' }
        ]
      });

      this.resultOutput = new OO.ui.MultilineTextInputWidget({
        readOnly: true,
        autosize: true,
        rows: 6,
        classes: ['tci-output']
      });

      this.content.$element.append(
        new OO.ui.FieldsetLayout({
          label: 'TCI Calculator Options',
          items: [
            new OO.ui.FieldLayout(this.abcInput, { label: 'ABC Notation', align: 'top' }),
            new OO.ui.FieldLayout(this.octaveChoice, { label: 'Octave Interpretation', align: 'top' }),
            new OO.ui.FieldLayout(this.resultOutput, { label: 'Theme Code Index (TCI)', align: 'top' })
          ]
        }).$element
      );
    };

    // CSS fix
    mw.util.addCSS(`
      .tci-abc-input textarea {
        min-height: 150px;
      }
      .tci-output textarea {
        min-height: 100px;
        background: #f5f5f5;
      }
      .oo-ui-window-body {
        max-height: 90vh !important;
        overflow-y: auto;
      }
    `);

    // ... (rest of script unchanged, parser + logs)

    function openTCICalculatorTestDialog() {
      const windowManager = new OO.ui.WindowManager();
      $(document.body).append(windowManager.$element);
      const dialog = new TCICalculatorTestDialog();
      windowManager.addWindows([dialog]);
      windowManager.openWindow(dialog);
    }

    mw.util.addPortletLink('p-cactions', '#', '🎼 TCI Test', 'ca-tcitest', 'Open TCI test');
    $(document).on('click', '#ca-tcitest', function (e) {
      e.preventDefault();
      openTCICalculatorTestDialog();
    });
  });
})(jQuery, mediaWiki, OO);
Retrieved from "https://ttadev.org/w/index.php?title=MediaWiki:Gadget-TciTest.js&oldid=544998"
Cookies help us deliver our services. By using The Traditional Tune Archive services, you agree to our use of cookies.
More information