Add input arguments to the applications

cmd.js

@@ -65,6 +65,7 @@ const savePrompts = {
 };
 
 const isCloseAllWinBefore = process.argv.indexOf('--closeAllOpenWindows') > -1;
+const isAllowInputArgs = process.argv.indexOf('--allowInputArgs') > -1;
 const action = process.argv[2];
 let sessionName;
 if (process.argv[3] && !process.argv[3].match(/^--/)) {
@@ -81,7 +82,7 @@ function killX11() {
 if (action === 'save') {
   base.saveSession(sessionName, savePrompts).then(killX11);
 } else if (action === 'restore') {
-  base.restoreSession(sessionName, isCloseAllWinBefore).then(killX11);
+  base.restoreSession(sessionName, isCloseAllWinBefore, isAllowInputArgs).then(killX11);
 } else if (action === 'remove') {
   base.removeSession(sessionName).then(killX11);
 } else if (action === 'resetCfg') {

src/defaultConfig.ts

@@ -2,6 +2,7 @@ export const DEFAULT_CFG = {
   GIVE_X11_TIME_TIMEOUT: 80,
   POLL_ALL_APPS_STARTED_INTERVAL: 2000,
   POLL_ALL_MAX_TIMEOUT: 120000,
+  POLL_ALL_MAX_TIMEOUT_ALLOW_ARGS: 1200000,
   SAVE_SESSION_IN_PRETTY_FORMAT: true,
   WM_CLASS_AND_EXECUTABLE_FILE_MAP: {
     "gnome-terminal-server.Gnome-terminal": "gnome-terminal",

src/index.ts

@@ -173,7 +173,8 @@ function saveSessionForDisplayToDb(
 
 function restoreSession(
   sessionName: string,
-  isCloseAllOpenWindows: boolean
+  isCloseAllOpenWindows: boolean,
+  isAllowInputArgs: boolean
 ): Promise<any> {
   const sessionToHandle = sessionName || "DEFAULT";
 
@@ -213,14 +214,23 @@ function restoreSession(
           return getActiveWindowListFlow();
         })
         .then(currentWindowList => {
-          return _startSessionPrograms(savedWindowList, currentWindowList);
+          if (isAllowInputArgs) {
+            return _startAndWaitPrograms(savedWindowList);
+          } else {
+            return _startSessionPrograms(savedWindowList, currentWindowList)
+              .then(() => {
+                // gets current window list by itself and returns the updated variant
+                return _waitForAllAppsToStart(savedWindowList);
+              })
+              .then((updatedCurrentWindowList: WinObj[]) => {
+                return _updateWindowIds(
+                  savedWindowList,
+                  updatedCurrentWindowList
+                );
+              });
+          }
         })
         .then(() => {
-          // gets current window list by itself and returns the updated variant
-          return _waitForAllAppsToStart(savedWindowList);
-        })
-        .then((updatedCurrentWindowList: WinObj[]) => {
-          _updateWindowIds(savedWindowList, updatedCurrentWindowList);
           return _restoreWindowPositions(savedWindowList);
         })
         .then(() => {
@@ -461,12 +471,141 @@ async function _startSessionPrograms(
     })
     .map(win => {
       win.instancesStarted += 1;
-      return startProgram(win.executableFile, win.desktopFilePath);
+      return startProgram(
+        win.executableFile,
+        win.desktopFilePath,
+        win.executableArgs
+      );
     });
 
   await Promise.all(promises);
 }
 
+// This function is necessary to make possible sending custom arguments to applications to start,
+// making sure it will keep track of which windows correspond to which instance of the applications
+async function _startAndWaitPrograms(windowList: WinObj[]) {
+  // Clear the windowIds from the window objects
+  windowList.forEach(win => {
+    win.windowId = null;
+    win.windowIdDec = null;
+  });
+
+  // Get the windowIds of all Ids that were previously opened in order to
+  // avoid these windows from being used isntead of the newly created windows
+  // (necessary for windows with custom input arguments)
+  var activeWindows = await getActiveWindowListFlow();
+  var blackWinIdList = activeWindows.map(win => win.windowId);
+
+  // Match all the previously opened windows with the windows that do not have
+  // custom arguments (in this case, no blacklist needed)
+  await _matchWindows(windowList, false, []);
+
+  var windowsNotStarted = windowList.filter(win => win.windowId === null);
+  var windowStarted = windowList.filter(win => win.windowId !== null);
+  var windowsToStart = _getWindowsToStart(windowsNotStarted, windowStarted);
+
+  let totalTimeWaited = 0;
+  // Runs the loop until all windows have been opened or time limit is over
+  while (windowList.find(win => win.windowId === null)) {
+    totalTimeWaited += CFG.POLL_ALL_APPS_STARTED_INTERVAL;
+    if (totalTimeWaited > CFG.POLL_ALL_MAX_TIMEOUT_ALLOW_ARGS) {
+      console.error("POLL_ALL_MAX_TIMEOUT_ALLOW_ARGS reached");
+      windowList
+        .filter(win => win.windowId === null)
+        .forEach(e => {
+          console.log("Unable to start: ", e.wmClassName);
+        });
+      break;
+    }
+
+    let promises = windowsToStart.map(win => {
+      startProgram(win.executableFile, win.desktopFilePath, win.executableArgs);
+    });
+    await Promise.all(promises);
+
+    // Try to match newly started windows, the black list is needed to avoid matching
+    // windows that have custom arguments with windows oppened before running lwsm
+    await _matchWindows(windowList, true, blackWinIdList);
+    // Update the lists with the windows not to be started yet, the windows to be started next
+    // and the ones that already have the command to start sent
+    windowsNotStarted = windowsNotStarted.filter(
+      winNotStarted =>
+        !windowsToStart.find(winToStart => winToStart === winNotStarted)
+    );
+    windowStarted = windowStarted.concat(windowsToStart);
+    windowsToStart = _getWindowsToStart(windowsNotStarted, windowStarted);
+  }
+
+  windowList.forEach(win => {
+    win.windowIdDec = parseInt(win.windowId, 16);
+  });
+}
+
+// Get, from windowList, all the windows that can be started without the risk of
+// mixing same application windows with different arguments. The others will have to wait for the
+// previous windows to start, before the command can be issued
+function _getWindowsToStart(windowList: WinObj[], windowsStarted: WinObj[]) {
+  var windowsToStart = [];
+  for (var win of windowList) {
+    let shouldAdd = true;
+    // If another instance of the same application with different input arguments
+    // is in the list of windows to start, then the current one should not be added
+    windowsToStart.forEach(winToRun => {
+      if (
+        win.executableFile === winToRun.executableFile &&
+        win.executableArgs !== winToRun.executableArgs
+      ) {
+        shouldAdd = false;
+      }
+    });
+    // If another instance of the same application is in the list of windows that
+    // have been sent command to start, but still don't have a windowId, the current one should not be added
+    if (
+      windowsStarted.find(
+        winStarted =>
+          winStarted.windowId === null &&
+          winStarted.wmClassName === win.wmClassName
+      )
+    ) {
+      shouldAdd = false;
+    }
+    if (!win.windowId && shouldAdd) {
+      windowsToStart.push(win);
+    }
+  }
+  return windowsToStart;
+}
+
+// Match the windows that have been opened already to the windows on windowList
+async function _matchWindows(
+  windowList: WinObj[],
+  includeExecsWithArgs: boolean,
+  blackWinIdList: String[]
+) {
+  var activeWindows = await getActiveWindowListFlow();
+  // Remove the active windows that already have a window assigned on windowList
+  // and the ones that are on the black list
+  activeWindows = activeWindows.filter(
+    actWin => !windowList.find(win => win.windowId === actWin.windowId)
+  );
+  activeWindows = activeWindows.filter(
+    actWin => !blackWinIdList.find(windowId => windowId === actWin.windowId)
+  );
+
+  for (var win of windowList.filter(win => win.windowId === null)) {
+    let activeWindowMatch = activeWindows.find(
+      actWin => actWin.wmClassName == win.wmClassName
+    );
+    if (
+      activeWindowMatch &&
+      (!win.executableArgs || win.executableArgs === "" || includeExecsWithArgs)
+    ) {
+      win.windowId = activeWindowMatch.windowId;
+      activeWindows = activeWindows.filter(e => e !== activeWindowMatch);
+    }
+  }
+}
+
 function _getNumberOfInstancesToRun(
   windowToMatch: WinObj,
   windowList: WinObj[]
@@ -554,10 +693,10 @@ async function _restoreWindowPositions(
 ): Promise<void> {
   const promises = [];
   let last_desktop_nr = 0;
-  
+
   // Sort the window objects based on which workspace they are locate,
   // so the windows can be moved workspace by workspace
-  // This is needed because the window manager just creates an aditional workspace when 
+  // This is needed because the window manager just creates an aditional workspace when
   // the previous one has some window on it.
   savedWindowList = savedWindowList.concat().sort((a, b) => {
     return a.wmCurrentDesktopNr - b.wmCurrentDesktopNr;
@@ -566,11 +705,13 @@ async function _restoreWindowPositions(
   for (const win of savedWindowList) {
     promises.push(restoreWindowPosition(win));
     promises.push(moveToWorkspace(win.windowId, win.wmCurrentDesktopNr));
-
     // The promises are not executed until the last item is reached or 
     // the desktop_nr is different from the previous entry and which case
     // the app waits for those to finish before continuing the process
-    if ( (win.wmCurrentDesktopNr !== last_desktop_nr) || (win === savedWindowList.slice(-1)[0])) {
+    if (
+      win.wmCurrentDesktopNr != last_desktop_nr ||
+      win == savedWindowList.slice(-1)[0]
+    ) {
       for (const promise of promises) {
         try {
           await promise;
@@ -579,7 +720,7 @@ async function _restoreWindowPositions(
         }
       }
       last_desktop_nr = win.wmCurrentDesktopNr;
-      promises.length = 0
+      promises.length = 0;
     }
   }
 }

src/model.ts

@@ -16,6 +16,7 @@ export interface WinObj extends WinObjIdOnly {
   height: number;
   simpleName: string;
   executableFile: string;
+  executableArgs: string;
   desktopFilePath?: string;
   instancesStarted?: number;
 }

src/otherCmd.ts

@@ -79,7 +79,8 @@ export async function getAdditionalMetaDataForWin(
 // TODO prettify args structure
 export function startProgram(
   executableFile: string,
-  desktopFilePath: string
+  desktopFilePath: string,
+  executableArgs: string
 ): Promise<void> {
   IS_DEBUG &&
     console.log("DEBUG: startProgram():", executableFile, desktopFilePath);
@@ -88,14 +89,26 @@ export function startProgram(
   let args = [];
   if (desktopFilePath) {
     cmd = `awk`;
-    args.push(
-      '/^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); exit system($0)}'
-    );
+
+    if (executableArgs) {
+      args.push(
+        `/^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", " ${executableArgs}"); exit system($0)}`
+      );
+    } else {
+      args.push(
+        '/^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); exit system($0)}'
+      );
+    }
+
     args.push(desktopFilePath);
   } else {
     const parsedCmd = parseCmdArgs(executableFile);
     cmd = parsedCmd[0];
     args = parsedCmd[1];
+    if (executableArgs) {
+      var executableArgsArray = executableArgs.split(" ");
+      args = args.concat(executableArgsArray);
+    }
   }
 
   return new Promise(fulfill => {