watermark.ts

Go to the documentation of this file.

 
import * as vscode from 'vscode';
import { logger } from "./logger";
import { getMessage } from "./messageProvider";
import { LazyFileLoader } from "./lazyFileLoad";
import { authorLogo } from '../constants';
 
export interface watermark {
    watermark: string[],
    fontName: string
}
 
export class Watermark {
 
    private fileInstance: LazyFileLoader = new LazyFileLoader();
 
    constructor(filePath: string | undefined = undefined, cwd: string | undefined = undefined, alternateFilePath: string | undefined = undefined) {
        logger.debug(getMessage("inFunction", "constructor", "Watermark"));
        if (filePath) {
            this.fileInstance.updateFilePath(filePath);
        }
        if (alternateFilePath) {
            this.fileInstance.updateAlternateFilePath(alternateFilePath);
        }
        if (cwd) {
            this.fileInstance.updateCurrentWorkingDirectory(cwd);
        }
    }
 
    async updateFilePath(filePath: string): Promise<boolean> {
        logger.debug(getMessage("inFunction", "updateFilePath", "Watermark"));
        return await this.fileInstance.updateFilePath(filePath);
    }
    async updateAlternateFilePath(alternateFilePath: string): Promise<boolean> {
        logger.debug(getMessage("inFunction", "updateAlternateFilePath", "Watermark"));
        return await this.fileInstance.updateAlternateFilePath(alternateFilePath);
    }
 
    async updateCurrentWorkingDirectory(cwd: string): Promise<boolean> {
        logger.debug(getMessage("inFunction", "updateCurrentWorkingDirectory", "Watermark"));
        return await this.fileInstance.updateCurrentWorkingDirectory(cwd);
    }
 
    private getRandomNumber(maxValue: number): number {
        logger.debug(getMessage("inFunction", "getRandomNumber", "Watermark"));
        return Math.floor(Math.random() * maxValue);
    }
 
    async getRandomWatermark(): Promise<watermark> {
        logger.debug(getMessage("inFunction", "getRandomWatermark", "Watermark"));
        const fileContent = await this.fileInstance.get();
        if (!Array.isArray(fileContent) || fileContent.length === 0) {
            const err: string = getMessage("watermarkJsonFileInvalid");
            logger.Gui.error(err);
            throw new Error(err);
        }
        const chosenIndex: number = this.getRandomNumber(fileContent.length);
        const raw = fileContent[chosenIndex];
        const watermark: watermark = {
            watermark: raw.Logo,
            fontName: raw.fontName
        };
        return watermark;
    }
 
    private copyButtonScript(): string {
        logger.debug(getMessage("inFunction", "copyButtonScript", "Watermark"));
        return `
<script>
    const vscode = acquireVsCodeApi();
    console.log(\`vscode = \${vscode}\`);
    document.getElementById('copyBtn').addEventListener('click', () => {
        const content = document.getElementById('ascii').innerText;
        navigator.clipboard.writeText(content).then(() => {
        vscode.postMessage({ type: 'copied' });
        });
    });
</script>
  `;
    }
 
    private zoomScript(): string {
        logger.debug(getMessage("inFunction", "zoomScript", "Watermark"));
        return `
<script>
    let currentSize = 20;
    function updateFontSize(sizeDifference) {
        console.log(\`sizeDifference = \${sizeDifference}\`);
        const asciiPre = document.getElementById('ascii');
        console.log(\`asciiPre = \${JSON.stringify(asciiPre)}\`);
        console.log(\`currentSize = \${currentSize}\`);
        if (currentSize + sizeDifference >= 2) {
            currentSize += sizeDifference;
            console.log(\`currentSize (after update) = \${currentSize}\`);
        } else {
            console.log(\`currentSize (no update) = \${currentSize}\`);
        }
        asciiPre.style.fontSize = currentSize + "px";
        asciiPre.style.lineHeight = currentSize + "px";
        console.log(\`newSize = \${asciiPre.style.fontSize}\`);
    }
 
    document.getElementById('zoomInBtn').addEventListener('click', () => {
        updateFontSize((2));
    });
 
    document.getElementById('zoomOutBtn').addEventListener('click', () => {
        updateFontSize((-2));
    });
 
    // init
    updateFontSize();
</script>
    `;
    }
 
    private pageStyle(): string {
        logger.debug(getMessage("inFunction", "pageStyle", "Watermark"));
        return `
        <style>
    body { font-family: sans-serif; padding: 20px; }
    h1 { font-size: 20px; margin-bottom: 0.2em; }
    h2 { margin-top: 1.2em; }
    pre { font-size: 10px; line-height: 10px; white-space: pre; }
    button { margin: 10px 0; padding: 5px 12px; font-size: 14px; }
    .logo { width:150px; height:150px }
  </style>
        `;
    }
 
    async displayRandomAuthorWatermarkInWindow() {
        logger.debug(getMessage("inFunction", "displayRandomAuthorWatermarkInWindow", "Watermark"));
        const randomwatermark: watermark = await this.getRandomWatermark();
 
        const panel = vscode.window.createWebviewPanel(
            getMessage("watermarkView"),
            randomwatermark.fontName,
            vscode.ViewColumn.One,
            { enableScripts: true }
        );
 
        const watermark = randomwatermark.watermark;
        logger.info(getMessage("watermarkChosen", watermark));
        let asciiArt = "";
        if (typeof watermark === "string") {
            asciiArt = watermark;
        } else if (Array.isArray(watermark)) {
            asciiArt = watermark.join("\n");
        } else if (watermark === undefined) {
            asciiArt = getMessage("watermarkNotFound");
        }
 
        const copyButton: string = this.copyButtonScript();
        const pageStyle: string = this.pageStyle();
        const zoomScript: string = this.zoomScript();
 
        panel.webview.html = `
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  ${pageStyle}
</head>
<body>
    <p>${getMessage("watermarkAuthorName")}: Henry Letellier</p>
    <img class="logo" src="${authorLogo}"/>
    <div>
        <button id="copyBtn">${getMessage('watermarkCopyAscii')}</button>
        <button id="zoomInBtn">${getMessage('watermarkZoomIn')}</button>
        <button id="zoomOutBtn">${getMessage('watermarkZoomOut')}</button>
    </div>
    <h1>${getMessage('watermarkName')}: ${randomwatermark.fontName}</h1>
    <pre id="ascii">${asciiArt}</pre>
    ${copyButton}
    ${zoomScript}
</body>
</html>
`;
 
        panel.webview.onDidReceiveMessage(message => {
            if (message.type === "copied") {
                logger.Gui.info(getMessage("watermarkCopied", randomwatermark.fontName));
            }
        });
 
        logger.Gui.info(getMessage("watermarkPersonDisplayed", randomwatermark.fontName));
    }
}