disabling mouse and keyboard input when calling the system() function

Hi,

I made a brutal solution that might work for you (it is far from perfect) : 

This will unmap/remap the windows while the command runs.

It should prevent clicking and keyboard inputs (I haven't tested it thoroughly though...)

It might be surprising for the users that might think Virtuoso has crashed!

Keeping the CIW mapped or displaying a popup while the command is running might be options to consider.

(defun blocking_subprocess ( cmd )
  "Run CMD while preventing inputs (keyboard or mouse) to be intercepted by Virtuoso."
  (let ( ( mapped_windows (setof win (hiGetWindowList) (eq 'mapped (hiGetWindowState win))) )
         ( pid            (ipcBeginProcess cmd) )
         )
    (unwindProtect
      (progn (foreach win mapped_windows (hiUnmapWindow win))
             (ipcWait pid)
             )
      (foreach win mapped_windows (hiMapWindow win))
      )
    ))

Another solution that might appear less intrusive is to unmap/remap all the mouse and keyboard shortcuts while the command is running.

This has to be made very carefully as removing all the shortcuts could be very inconvenient...

Maybe there is a native solution that I am unaware of and Andrew might know.

(I tried to ask your question to the support AI assistant but it told me to create a support case )

I'm not aware of any way of doing this. I don't think it's generally something applications can do - I believe it's X windows that takes care of handling the event interaction with applications, so unmapping the windows is probably the only option. 

Andrew

thank you, aurel and andrew.

when these codes are executed, the window disappears, which makes the usability poor.

what i'm curious about is that when hiDisplayAppDBox() runs, a modal dialog is shown
and mouse/keyboard input is blocked at that moment.

i suspect that inside hiDisplayAppDBox() there is a routine that disables input
before the modal dialog is displayed.

how does virtuoso block keyboard and mouse input when hiDisplayAppDBox() is executed?

It's funny you say that because that was my first attempt and reference.

However I could not make it work the first time : 

(defun blocking_subprocess ( cmd )
  "Run CMD while preventing inputs (keyboard or mouse) to be intercepted by Virtuoso."
  (let ( ( name (gensym 'blocking_dbox) )
         ( pid  (ipcBeginProcess cmd)   )
         )
    (setf blocking_subprocess.pid pid)
    (hiEnqueueCmd (lsprintf "{hiFlush() ipcWait(blocking_subprocess.pid) hiDBoxOK(%s)}" name))
    ;(hiRegTimer   (lsprintf "{hiFlush() ipcWait(blocking_subprocess.pid) hiDBoxOK(%s)}" name) 10)
    (hiDisplayAppDBox
      ?name        name
      ?dboxBanner  "tmp block"
      ?dboxText    "Blocking inputs why waiting for subprocess to finish..."
      ?dialogStyle 'modal
      )
    ))

It seems that even when a modal popup is displayed, when Virtuoso enters ipcWait then all the inputs are catched anyway.

Which is why I made a second attempt where instead of using ipcWait and then closing the popup. I now have a modal popup that [almost] always repop until the job finishes and kills it. I also added a safeguard so that a user can close it a few times and then regains control over Virtuoso. Which might be before the end of the job (so probably not what you want).

(defun blocking_subprocess ( cmd )
  "Run CMD while preventing inputs (keyboard or mouse) to be intercepted by Virtuoso."
  (letseq ( ( name  (gensym 'blocking_dbox) )
            ( fnil  (lambda (@rest _) nil) )
            ( pid   (ipcBeginProcess cmd "" fnil fnil
                      ;; Handler to close any remaining popup
                      (lambda (@rest _)
                        (hiEnqueueCmd (lsprintf "(errset (muffleWarnings (hiDBoxOK %s)))" name)))) )
            ( num   5 )
            )
    (ipcWaitForProcess pid)

    (while (and (ipcIsAliveProcess pid) (plusp num))
      (hiDisplayAppDBox
        ?name         name
        ?buttonLayout 'Close
        ?dialogStyle  'modal
        ?dboxBanner   "Waiting for subprocess..."
        ?dboxText     (lsprintf "This popup prevents inputs while waiting for subprocess to terminate.\n\
It will close automatically.\n\
\n\
(This popup will re-open %d times.)" num--)
        ))
    ))

Anyway, I hope this helps and at least gives you ideas about what you can do.

It's funny you say that because that was my first attempt and reference.

However I could not make it work the first time : 

(defun blocking_subprocess ( cmd )
  "Run CMD while preventing inputs (keyboard or mouse) to be intercepted by Virtuoso."
  (let ( ( name (gensym 'blocking_dbox) )
         ( pid  (ipcBeginProcess cmd)   )
         )
    (setf blocking_subprocess.pid pid)
    (hiEnqueueCmd (lsprintf "{hiFlush() ipcWait(blocking_subprocess.pid) hiDBoxOK(%s)}" name))
    ;(hiRegTimer   (lsprintf "{hiFlush() ipcWait(blocking_subprocess.pid) hiDBoxOK(%s)}" name) 10)
    (hiDisplayAppDBox
      ?name        name
      ?dboxBanner  "tmp block"
      ?dboxText    "Blocking inputs why waiting for subprocess to finish..."
      ?dialogStyle 'modal
      )
    ))

It seems that even when a modal popup is displayed, when Virtuoso enters ipcWait then all the inputs are catched anyway.

Which is why I made a second attempt where instead of using ipcWait and then closing the popup. I now have a modal popup that [almost] always repop until the job finishes and kills it. I also added a safeguard so that a user can close it a few times and then regains control over Virtuoso. Which might be before the end of the job (so probably not what you want).

(defun blocking_subprocess ( cmd )
  "Run CMD while preventing inputs (keyboard or mouse) to be intercepted by Virtuoso."
  (letseq ( ( name  (gensym 'blocking_dbox) )
            ( fnil  (lambda (@rest _) nil) )
            ( pid   (ipcBeginProcess cmd "" fnil fnil
                      ;; Handler to close any remaining popup
                      (lambda (@rest _)
                        (hiEnqueueCmd (lsprintf "(errset (muffleWarnings (hiDBoxOK %s)))" name)))) )
            ( num   5 )
            )
    (ipcWaitForProcess pid)

    (while (and (ipcIsAliveProcess pid) (plusp num))
      (hiDisplayAppDBox
        ?name         name
        ?buttonLayout 'Close
        ?dialogStyle  'modal
        ?dboxBanner   "Waiting for subprocess..."
        ?dboxText     (lsprintf "This popup prevents inputs while waiting for subprocess to terminate.\n\
It will close automatically.\n\
\n\
(This popup will re-open %d times.)" num--)
        ))
    ))

Anyway, I hope this helps and at least gives you ideas about what you can do.

thank you for your deep interest.

we coded the parts that were difficult to implement in skill to Python.
however, there's a risk that the designer's clicks will be exposed to the virtuoso GUI.
if Python execution time exceeds 10 seconds, the designer can click the GUI indiscriminately.

i believe there is an internal function in virtuoso that can disable(keyboard, mouse) a window.
but there is no way to know.

i found a way to force it.

1. process execute

ipcBeginProcess "python test.py"

2. simple message box

a window named 'a' is created, and virtuoso stably blocks keyboard and clicks.

hiDisplayAppDBox(?name 'a)

3. in test.py

a short sleep for window 'a' to be created.

subprocess this:

this command line hides the "a" window.
this makes the "a" message box in Virtuoso invisible, but still protects against keyboard and clicks.