ocoge/main.js

const { app, BrowserWindow, Menu, session, ipcMain, dialog } = require('electron')
const path = require('path')
const fs = require('fs')

/** Force disable security warning */
process.env['ELECTRON_DISABLE_SECURITY_WARNINGS'] = 'true'

// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let win

function createWindow() {
  // Create the browser window.
  win = new BrowserWindow({
    /** Icon */
    icon: path.join(__dirname, "icon.png"),
    width: 1600,
    height: 900,
    // width: 1280,
    // height: 940,
    webPreferences: {
      // preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: true,
      contextIsolation: false,
      sandbox: false
    }
  })
  /** Maximize Window at startup */
  // win.maximize()

  // and load the index.html of the app.
  win.loadFile('index.html')

  // Open the DevTools.
  win.webContents.openDevTools()

  // Emitted when the window is closed.
  // win.on('closed', () => {
  //   // Dereference the window object, usually you would store windows
  //   // in an array if your app supports multi windows, this is the time
  //   // when you should delete the corresponding element.
  //   win = null
  // })

  /** For SkyWay */
  session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
    details.requestHeaders['Origin'] = 'electron://localhost'
    callback({
      cancel: false,
      requestHeaders: details.requestHeaders
    })
  })
}

const toggleCheck_i2c = checked_id => {
  const menus = ['i2c-1', 'i2c-5', 'i2c-6'];
  menus.forEach(id => {
    menu.getMenuItemById(id).checked = (id == checked_id);
  })

}
const toggleCheck_lang = checked_id => {
  const menus = ['js', 'py'];
  menus.forEach(id => {
    menu.getMenuItemById(id).checked = (id == checked_id);
  })

}


// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
// app.on('ready', createWindow)
app.whenReady().then(() => {
  createWindow()

  app.on('activate', function () {
    // On macOS it's common to re-create a window in the app when the
    // dock icon is clicked and there are no other windows open.
    if (BrowserWindow.getAllWindows().length === 0) createWindow()
  })

  // Menu Unvisible
  win.setMenuBarVisibility(false)
})


/** Custom Menu */
let template = [
  {
    label: 'Menu',
    submenu: [
      {
        label: 'Toggle Menu Bar',
        click: () => {
          win.setMenuBarVisibility(!win.menuBarVisible)
        },
        accelerator: "CommandOrControl+Shift+M"
      },
      {
        label: 'Reload',
        click: () => {
          win.reload()
        },
        accelerator: "F5"
      },
      {
        label: 'Mascot',
        click: (item, focusedWindow) => {
          if (focusedWindow)
            focusedWindow.webContents.executeJavaScript('ugj_selectMascot()')
        },
        accelerator: "CommandOrControl+M"
      },
      {
        label: 'Toggle Developer Tools',
        click: () => {
          win.webContents.toggleDevTools()
        },
        accelerator: "F12"
      },
      {
        label: 'About',
        click: () => {
          var os = require('os')
          const { version } = require('./package.json')
          // var detail = 'Version: ' + process.env.npm_package_version + '\n'
          var detail = 'Version: ' + version + '\n'
            + 'Node.js: ' + process.versions.node + '\n'
            + 'Chrome: ' + process.versions.chrome + '\n'
            + 'Electron: ' + process.versions.electron + '\n'
            + 'V8: ' + process.versions.v8 + '\n'
            + 'OS: ' + os.type + ' ' + os.arch + ' ' + os.version + ' ' + os.release
          var options = {
            type: 'info',
            buttons: ['OK'],
            title: 'ocoge',
            message: 'ocoge: code generator',
            detail: detail
          }
          require('electron').dialog.showMessageBox(win, options)
        },
        accelerator: "CommandOrControl+I"
      },
      {
        label: 'Quit',
        click: () => {
          app.quit()
        },
        accelerator: "CommandOrControl+Q"
      }
    ]
  },
  {
    label: "Settings",
    submenu: [
      {
        label: "Language",
        submenu: [
          {
            label: "JavaScript",
            id: "js",
            type: 'checkbox',
            checked: true,
            click: (item, focusedWindow) => {
              if (focusedWindow) {
                // menu.getMenuItemById('py').checked = false;
                toggleCheck_lang("js");
                focusedWindow.webContents.executeJavaScript('apptool.setLang("js")');
              }
            }
          },
          {
            label: "MicroPython (RP2)",
            id: "py",
            type: 'checkbox',
            click: (item, focusedWindow) => {
              if (focusedWindow) {
                // menu.getMenuItemById('js').checked = false;
                toggleCheck_lang("py");
                focusedWindow.webContents.executeJavaScript('apptool.setLang("py")');
              }
            }
          },

        ]

      },
      {
        label: "i2c bus",
        submenu: [
          {
            label: "1",
            id: "i2c-1",
            type: 'checkbox',
            checked: true,
            click: (item, focusedWindow) => {
              if (focusedWindow) {
                toggleCheck_i2c("i2c-1");
                focusedWindow.webContents.executeJavaScript('apptool.setI2cbusNo("1")');
              }
            }
          },
          {
            label: "5",
            id: "i2c-5",
            type: 'checkbox',
            click: (item, focusedWindow) => {
              if (focusedWindow) {
                toggleCheck_i2c("i2c-5");
                focusedWindow.webContents.executeJavaScript('apptool.setI2cbusNo("5")');
              }
            }
          },
          {
            label: "6",
            id: "i2c-6",
            type: 'checkbox',
            click: (item, focusedWindow) => {
              if (focusedWindow) {
                toggleCheck_i2c("i2c-6");
                focusedWindow.webContents.executeJavaScript('apptool.setI2cbusNo("6")');
              }
            }
          },

        ]
      }
    ]
  },
  {
    label: "Tools",
    submenu: [
      {
        label: "Launch PyBfm",
        click: (item, focusedWindow) => {
          focusedWindow.webContents.executeJavaScript('apptool.launchPyBfm()');
        },
      },
    ]
  }
]
const menu = Menu.buildFromTemplate(template)
Menu.setApplicationMenu(menu)

// Quit when all windows are closed.
app.on('window-all-closed', () => {
  // On macOS it is common for applications and their menu bar
  // to stay active until the user quits explicitly with Cmd + Q
  if (process.platform !== 'darwin') {
    app.quit()
  }
})

// app.on('activate', () => {
//   // On macOS it's common to re-create a window in the app when the
//   // dock icon is clicked and there are no other windows open.
//   if (win === null) {
//     createWindow()
//   }
// })

// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.

// IPC
ipcMain.on('set_title', (ev, title) => {
  win.setTitle(title)
})
ipcMain.on('i2c_check_menu', (ev, menuid) => {
  toggleCheck_i2c(menuid);
})
ipcMain.on('lang_check_menu', (ev, menuid) => {
  toggleCheck_lang(menuid);
})
ipcMain.handle('open_dialog', (ev, title, dpath, filter) => {
  let filepaths = dialog.showOpenDialogSync(win, {
    properties: ['openFile'],
    title: title,
    defaultPath: dpath,
    filters: [
      filter
    ]
  })
  return filepaths
})
ipcMain.handle('save_dialog', async (ev, title, defName, filter) => {
  let save_file = await dialog.showSaveDialog(win, {
    title: title,
    defaultPath: defName,
    filters: [filter]
  })
  return save_file.filePath
})
ipcMain.handle('get_app_path', (ev) => {
  return app.getAppPath()
})

// Draw text on node-canvas : Returns PNG buffer data
const { createCanvas, registerFont } = require('canvas')
const PNG = require('pngjs').PNG
registerFont(path.join(__dirname, 'fonts', 'PixelMplus12-Regular.ttf'), { family: '' })
registerFont(path.join(__dirname, 'fonts', 'PixelMplus10-Regular.ttf'), { family: '' })
registerFont(path.join(__dirname, 'fonts', 'misaki_gothic.ttf'), { family: '' })
ipcMain.handle('text_to_rgba', (ev, text, font, color, start_x, start_y) => {
  const canvas = createCanvas(128, 64)
  const ctx = canvas.getContext('2d')
  ctx.antialias = 'none'
  ctx.font = font
  ctx.fillStyle = color;
  ctx.textBaseline = "top";
  ctx.fillText(text, start_x, start_y);
  return PNG.sync.read(canvas.toBuffer());
})
// Read PNG File : Returns PNG buffer data
ipcMain.handle('read_png_file', (ev, fname) => {
  const data = fs.readFileSync(fname);
  return PNG.sync.read(data);
})