What is the correct way to update window after changing extent?

Hello. I do the following.
When i need to show more data in window
1. I calc new height
2. Update the sprite which i show on redraw events
3. Set new extent
4. scroll to bottom
In case my scroll position stay somewhere in middle everything perfect, but when my old scroll position is already at bottom after all of this i see blank space between old and new data partially hide a new data. But if i do scroll to top and back it shows fine.
I was trying to call force_redraw and update_window at step 5 but nothing happens. I think i do something wrong.
What is the correct way to update window with new data?
Thanks

Without seeing the code that you’re using to do the redraw and set the extent, it’s quite hard to say.

so the pseudo code looks like this

calcNewHeight();

updateContent(); // this create a new image updated with new data

set_new_extent();

scroll_bottom();

here are the details of functions

 void set_window_new_extent_height(toolbox_o window_handler, int height) {

     os_box extent;

     window_get_extent(0,window_handler,&extent);

     if (extent.ymax – extent.ymin != height) {

         extent.ymin = -height;

         extent.ymax = 0;

         window_set_extent(0,window_handler,&extent);

     }

 }

void set_yscroll_to_bottom(toolbox_o window_handler)
{
os_box extent;
window_get_extent(0,window_handler,&extent);
wimp_w w = window_get_wimp_handle(0, window_handler);
wimp_window_state state;
state.w = w;
wimp_get_window_state(&state);

state.yscroll = extent.ymin;

wimp_open open_block;
open_block.w = w;
open_block.visible = state.visible;
open_block.next = state.next;
open_block.xscroll = state.xscroll;
open_block.yscroll = state.yscroll;
wimp_open_window(&open_block);
}

The code that i was trying to update the window after all of this

         wimp_w w = window_get_wimp_handle(0, toolbox_window_id);

         wimp_window_state state;

         state.w = w;

         wimp_get_window_state(&state);

wimp_draw wd;
wd.w = w;
wd.box = state.visible;
wd.xscroll = state.xscroll;
wd.yscroll = state.yscroll;
wd.clip = state.visible;
wimp_update_window(&wd);

A few thoughts… This area is a minefield, and since none of the following is tested, it could be complete rubbish.

First, there’s a gotcha with Wimp_SetExtent, which might (or might not) apply to the Toolbox’s window_set_extent() call: you can’t set an extent that results in a visible bit of a window disappearing. This is fine

void set_window_new_extent_height(toolbox_o window_handler, int height) {
    os_box extent;

    window_get_extent(0,window_handler,&extent);

    if (extent.ymax – extent.ymin != height) {
        extent.ymin = -height;
        extent.ymax = 0;

        window_set_extent(0,window_handler,&extent);
    }
}

except for the situation where you’re reducing the extent. In that case, you have to make sure that you call Wimp_OpenWindow first with the yoffset such that the area to be lost is out of view, then change the extent. If the new extent is smaller than the visible area, you have to increase the extent that you ask for to match the visible area, or use Wimp_OpenWindow to reduce the size of the visible area first. Otherwise, the Wimp will resist you.

I’d expect to see something like this:

void set_window_new_extent_height(toolbox_o window_handler, int height) {
    os_box extent;
    wimp_window_state state;
    int visible_height, new_scroll;
 
    window_get_extent(0,window_handler,&extent);

    if (extent.ymax – extent.ymin != height) {
        state.w = w;
        wimp_get_window_state(&state);

        visible_height = state.yscroll + (state.visible.y0 - state.visible.y1);

        if (new_height > visible_extent) {
            /* Calculate the required new scroll offset.  If this is greater than zero,
             * the current window is too big and will need shrinking down.  Otherwise,
             * just set the new scroll offset.
             */

            new_scroll = height - (state.visible.y0 - state.visible.y1);

            if (new_scroll > 0) {
                state.visible.y0 += new_scroll;
                state.yscroll = 0;
            } else {
                state.yscroll = new_scroll;
            }
 
            wimp_open_window((wimp_open *) &state);
        }

        extent.ymin = -height;
        extent.ymax = 0;

        window_set_extent(0,window_handler,&extent);
    }
}

The scroll to bottom call seems to be calculating the scroll offset wrong, too. You’re not taking into account the height of the visible area: the extent is the bottom of the area, while the scroll offset points to the top.

void set_yscroll_to_bottom(toolbox_o window_handler)
{
    os_box extent;

    window_get_extent(0,window_handler,&extent);

    wimp_w w = window_get_wimp_handle(0, window_handler);
    wimp_window_state state;
    state.w = w;
    wimp_get_window_state(&state);

    state.yscroll = extent.ymin - (state.visible.y1 - state.visible.y0);

    wimp_open open_block;
    open_block.w = w;
    open_block.visible = state.visible;
    open_block.next = state.next;
    open_block.xscroll = state.xscroll;
    open_block.yscroll = state.yscroll;
    wimp_open_window(&open_block);
}

Finally, and this may well be the significant one, I don’t think Wimp_UpdateWindow does what you think it does. Unless there’s some code missing (the redraw loop and calls to Wimp_GetRectangle which must follow Wimp_UpdateWindow), then you don’t want to be using Wimp_UpdateWindow. It is actually an alternative to Wimp_RedrawWindow, which can trigger a set of redraw events immediately (compared to Wimp_RedrawWindow, which is called in response to the Wimp raising a Window_Redraw_Request event).

If you just wish to trigger a redraw to happen at some point in the future via your window’s normal redraw code, then you need Wimp_ForceRedraw. Something like this:

wimp_w w = window_get_wimp_handle(0, toolbox_window_id);

wimp_window_state state;
state.w = w;
wimp_get_window_state(&state);

wimp_force_redraw(w, state.visible.x0, state.visible.y0, state.visible.x1, state.visible.y1);

This will then trigger a Window_Redraw_Request event to your normal redraw code when the Wimp finds it convenient to do it.

Thanks to your answer. as my visible area does not changed yet it seems your code did not change anything.
i tried wimp_force_redraw as you said and it does not work. i dont know why but it does not call redraw event at all. this event called after extent changed. produced that blank gap lines and did not update anymore until i start to scroll window. Do you have any idea why it could not be called by force redraw?

I made it work. for those who interested, i call wimp_force_redraw not with state.visible params but put there extent values. and it worked.
Hmm i made another test. second case to make it work to use wimp_force_redraw((wimp_w)-1, state.visible.×0, state.visible.y0, state.visible.×1, state.visible.y1);
Thanks to Steve to give me the correct way to start of.

Adjusting window sizes always makes my head hurt. I can never remember which bits need extent and which visible area. Fortunately I now have a BASIC library function which scans through the icons, find the highest and lowest coordinates in each direction, then resizes the window 32 units bigger all round and opens it full screen.

DEF PROCopenwindowmax(handle%)
REM resize window to fit
LOCAL I%,icount%,minY%,minX%,maxY%,maxX%,ptr%
!wimpblock%=handle%
SYS "Wimp_GetWindowInfo",,wimpblock%
icount%=wimpblock%!88
minX%=9999:minY%=9999:maxX%=-9999:maxY%=-9999
FOR I%=0 TOicount%-1
  ptr%=wimpblock%+92+I%*32
  IF (ptr%!0) < minX% THEN minX%=ptr%!0
  IF (ptr%!4) < minY% THEN minY%=ptr%!4
  IF (ptr%!8) > maxX% THEN maxX%=ptr%!8
  IF (ptr%!12) > maxY% THEN maxY%=ptr%!12
NEXT
minX% -= 32
minY% -= 32
maxX% += 32
maxY% += 32
wimpblock%!0=minX%
wimpblock%!4=minY%
wimpblock%!8=maxX%
wimpblock%!12=maxY%
SYS "Wimp_SetExtent",handle%,wimpblock%
!wimpblock%=handle%
SYS "Wimp_GetWindowState",,wimpblock%
wimpblock%!12=wimpblock%!4+maxX%+32
wimpblock%!8=wimpblock%!16+minY%-32
wimpblock%!28=-1
wimpblock%!32=(wimpblock%!32) OR (1<<13) OR (1<<18): REM set keep on screen, FULL SIZE
SYS "Wimp_OpenWindow",,wimpblock%
PROCredrawwindow(handle%)
ENDPROC
================
DEF PROCredrawwindow(handle%)
LOCAL X%,Y%
!wimpblock%=handle%
SYS "Wimp_GetWindowState",,wimpblock%
X%=wimpblock%!12 - wimpblock%!4
Y%=wimpblock%!8 - wimpblock%!16
SYS "Wimp_ForceRedraw",handle%,0,Y%,X%,0
ENDPROC

Steve claimed

First, there’s a gotcha with Wimp_SetExtent…you can’t set an extent that results in a visible bit of a window disappearing.

This is not correct. You absolutely can make an open window smaller than its currently displayed size (subject to the window’s defined minimum size) but Wimp_SetExtend alone does not cause the window to change on-screen – you must call OpenWindow at some point (but it does not have to be before).

Aleksey realised

i call wimp_force_redraw not with state.visible params but put there extent values

Yes, there are two important bounding boxes exposed¹ in the window API – the visible coordinates on the screen, and the extent of the work-area inside the window. OpenWindow deals in screen coordinates, GetRectangle returns both the screen coordinates and the work-area coordinates, and ForceRedraw uses only work-area coordinates.

¹ Three, if you include the GetWindowOutline bounding box. There’s a lot more than that internally though, as this frightening image may indicate (the bit below the line is the external definition of a window, the rest is the Wimp’s internal model):