CLIM mail archive
[Prev][Next][Index][Thread]

Weird top-level accept symptom

    Date: Wed, 12 Feb 1992 09:05 EST
    From: Curt Eggemeyer <curt@eraserhead.jpl.nasa.gov>

    As per my earlier message. (I'm on a Sun using Clim 1.0 in Allegro CL)

    In my application frame I somethings get caught in a weird recursive
    type accept problem. It seems that somehow the top-level accept loop in
    the application frame sometimes starts in a deeper recursive call on
    accept when you enter top level commands for the application.  It shows
    up after some commands have already been entered and executed on the
    application and at some point you hit the debugger (so you can either
    pop or abort out).

    Afterwards when I try and type in another application command as you
    type in the characters (including trying to do completion via the space
    bar) the cursor all of a sudden moves to another line in my interactor
    pane and continues to echo out the characters of the command.  Only the
    accept now thinks that those characters entered on the new line are the
    beginning of a new command (from this point on the top-level accept loop
    in the application frame is screwed for keyboard input).  So, if I try
    and rubout those characters I randomly get beeped and it ignores the
    rubout.  However, if I do positioning of the cursor ala control
    characters the cursor sometimes jumps up to the original line and starts
    editing on that character string.   From that point on the cursor
    randomly jumps back and forth between the two lines and never lets me
    successfully remove all of the characters in both lines.

    If I abort out of entering the command, from that point on the top-level
    accept will continually fail to accept my commands via the keyboard.
    Menu commands are still available and will echo correctly in the
    interactor pane, but any keying in of commands will now fail as
    described above.  The only way for me to recover is to blow out the
    application frame and re-instantiate a whole new one.

    Another weird symptom is sometimes my interactor pane will lose the
    ability to echo characters out (including the command prompt) (I think
    the ink has somehow been flipped because I notice the cursor moving).

It sounds to me like you might have executed some presentation action
(not a translator, an action) that is going back to the application's
command loop.  If this is the case, the action is in error; actions
should never terminate input.

    Here's something I found.  Does anybody have the same problem if they do
    the following?

    ;--------------------------------------------------------------------------
    We'll I findly was able to find a way to reproduce the same symptom.  If
    you are in X you can have fun blowing CLIM's command accept in your
    application frame by the following method.

    From the LISP listener invoke your application from a
    process-run-function, after you have instantiated it into some global,
    lets say *my-application*.

    Now start the application like so;

    (process-run-function (list :name "My application") 'run-frame-top-level
	    *my-application*)

    Okay, your application is up on the display.  Now go to the title bar
    for that application and bring up the x-menu and select "Close" from it.
    This will now close the application display into an icon.  Go back into
    the lisp listener and reinvoke the same process-run-function form.  At
    this point any attempt at invoking application commands in the top-level
    accept will exhibit the same symptoms I have indicated above.  I think I
    only hit these problems after I hit the debugger, while I am working in
    some of my application commands.  Apparently, there is a random chance
    that when you pop or abort out of the debugger while in your application
    you can screw your application command's top-level accept.  The only
    recourse is to kill that application and resinstantiate a new one.  Gee,
    if only there was a function in which you can totally flush out the
    top-level accept in your application when it loses its input buffer
    positioning.

If you can get into a debugger, CLIM does establish a restart handler
that reinvokes the application from the top.

Also, the so-called CLIM 1.1 (which a number of companies are about to
release) will contain some improvements to the CLX port w.r.t. its
interactions with screen managers.  This should fix some other problems.
References:
Main Index | Thread Index