#help_index "Windows"
#help_file "::/Doc/Windows"

CMouseStateGlobals old_mouse = {{-1000, -1000, 0}, {-1000, -1000, 0}, {-1000, -1000, 0},
        {0, 0, 0}, {1.0, 1.0, 1.0}, 0.0, TSCGet, 0.350, 0, 0,
        FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
};

public CWinMgrGlobals winmgr = {0, 0, 0, WINMGR_FPS, tS, tS, NULL, FALSE, FALSE, FALSE};
winmgr.t = CAlloc(sizeof(CWinMgrTimingGlobals));
winmgr.t->last_calc_idle_time = tS;

U0 ProgressBarsRegTf(U8 *path = NULL)
{
        F64 t, p1, p2, p3, p4;

        if (path)
        {
                t = tS;
                if (progress1_t0) p1 = t - progress1_t0; else p1 = 0;
                if (progress2_t0) p2 = t - progress2_t0; else p2 = 0;
                if (progress3_t0) p3 = t - progress3_t0; else p3 = 0;
                if (progress4_t0) p4 = t - progress4_t0; else p4 = 0;
                RegWrite(path, "progress1_tf=%0.3f;progress2_tf=%0.3f;\n"
                                           "progress3_tf=%0.3f;progress4_tf=%0.3f;\n", p1, p2, p3, p4);
        }
}

#define PROGRESS_BAR_HEIGHT             20
#define PROGRESS_BAR_WIDTH                      (3 * GR_WIDTH / 4)
U0 DrawProgressBars(CDC *dc)
{
        I64 i, j, k, n, m;
        U8 *st, *st2;

        for (i = 0; i < PROGRESS_BARS_NUM; i++)
        {
                if (m = sys_progresses[i].max)
                {
                        dc->color = BLACK;
                        GrRect(dc,      (GR_WIDTH - PROGRESS_BAR_WIDTH) / 2,
                                                (GR_HEIGHT -(PROGRESS_BARS_NUM * 2 - 1 - i * 4) * PROGRESS_BAR_HEIGHT) / 2,
                                                PROGRESS_BAR_WIDTH, PROGRESS_BAR_HEIGHT);

                        dc->color = LTGREEN;
                        n = sys_progresses[i].val;
                        if (n>m)
                                n = m;
                        GrRect(dc,      (GR_WIDTH - PROGRESS_BAR_WIDTH) / 2 + 2,
                                                (GR_HEIGHT - (PROGRESS_BARS_NUM * 2 - 1 - i * 4) * PROGRESS_BAR_HEIGHT) / 2 + 2,
                                                n * (PROGRESS_BAR_WIDTH - 4) / m,
                                                PROGRESS_BAR_HEIGHT - 4);

                        if (m>1)
                        {
                                dc->color = BLACK;
                                k = m - 1;
                                if (k > 19) k = 19;
                                for (j = 0; j <= k; j++)
                                        GrLine(dc,      (GR_WIDTH - PROGRESS_BAR_WIDTH) / 2 + 1 + j * (PROGRESS_BAR_WIDTH - 4) / ToF64(k + 1),
                                                                (GR_HEIGHT - (PROGRESS_BARS_NUM * 2 - 1 - i * 4) * PROGRESS_BAR_HEIGHT) / 2 + 4,
                                                                (GR_WIDTH - PROGRESS_BAR_WIDTH) / 2 + 1 + j * (PROGRESS_BAR_WIDTH - 4) / ToF64(k + 1),
                                                                (GR_HEIGHT - (PROGRESS_BARS_NUM * 2 - 3 - i * 4) * PROGRESS_BAR_HEIGHT) / 2 - 4);
                        }

                        dc->color = GREEN;
                        if (*sys_progresses[i].desc)
                                st = StrNew(sys_progresses[i].desc);
                        else
                                st = MStrPrint("%d/%d", n, m);
                        if (sys_progresses[i].t0)
                        {
                                st2 = MStrPrint("%s %fs", st, tS - sys_progresses[i].t0);
                                Free(st);
                        }
                        else
                                st2 = st;
                        if (sys_progresses[i].tf)
                        {
                                st = MStrPrint("%s/%fs", st2, sys_progresses[i].tf);
                                Free(st2);
                        }
                        else
                                st = st2;
                        GrPrint(dc, (GR_WIDTH - FONT_WIDTH * StrLen(st)) / 2, (GR_HEIGHT - FONT_HEIGHT -
                                                (PROGRESS_BARS_NUM * 2 - 2 - i * 4) * PROGRESS_BAR_HEIGHT) / 2, "%s", st);
                        Free(st);
                }
        }
}

U0 DrawWinGrid(CDC *dc)
{
        F64 d;

        dc->color = BLACK;
        dc->thick = 1;
        for (d = mouse_grid.x_offset; d < GR_WIDTH; d += mouse_grid.x)
                GrLine(dc, d, 0, d, GR_HEIGHT - 1);
        for (d = mouse_grid.y_offset; d < GR_HEIGHT; d += mouse_grid.y)
                GrLine(dc, 0, d, GR_WIDTH - 1, d);
}

U0 WinGrid(Bool val)
{
        CGridGlobals last_grid;

        MemCopy(&last_grid, &mouse_grid, sizeof(CGridGlobals));
        if (!val || PopUpForm(&mouse_grid))
        {
                if (!val)
                        GridInit;
                mouse_hard.prescale.x *= last_grid.x_speed / mouse_grid.x_speed;
                mouse_hard.prescale.y *= last_grid.y_speed / mouse_grid.y_speed;
                mouse_hard.prescale.z *= last_grid.z_speed / mouse_grid.z_speed;
        }
        else
                MemCopy(&mouse_grid, &last_grid, sizeof(CGridGlobals));
}
U0 CtrlAltG(I64 sc)
{
        if (sc & SCF_SHIFT)
                PopUp("WinGrid(OFF);");
        else
                PopUp("WinGrid(ON);");
}
CtrlAltCBSet('G', &CtrlAltG, "Cmd /Grid On", "Cmd /Grid Off");

CTask *ext_ASCII_task;
U0 ExtendedASCII()
{
        I64   i;
        CDoc *doc = DocNew;

        DocPrint(doc, "Sel Char and Press <ESC>\n$LTBLUE$");
        for (i = 0; i<256; i++)
        {
                if (i >= CH_SPACE && i != 0x7F)
                {
                        if (i == '$')
                                DocPrint(doc, "$MU-UL,\"\\x24\",LE=%d$", i);
                        else if (i=='\"' || i == '\\')
                                DocPrint(doc, "$MU-UL,\"\\%c\",LE=%d$", i, i);
                        else
                                DocPrint(doc, "$MU-UL,\"%c\",LE=%d$", i, i);
                }
                else
                        DocPrint(doc, " ");
                if (i & 15 == 15)
                        DocPrint(doc, "\n");
        }
        i = PopUpMenu(doc);
        DocDel(doc);
        if (i >= 0)
                MessagePost(ext_ASCII_task, MESSAGE_KEY_DOWN_UP, i, Char2ScanCode(i));
}

U0 CtrlAltA(I64)
{
        if (ext_ASCII_task = sys_focus_task)
                Spawn(&ExtendedASCII);
}
CtrlAltCBSet('A', &CtrlAltA, "Cmd /Extended ASCII");

public U0 WinScrollNull(CTask *task, CD3I64 *s)
{//If panning a window has been done, restore to zero.
        s->x = task->scroll_x;
        s->y = task->scroll_y;
        s->z = task->scroll_z;
        task->scroll_x = 0;
        task->scroll_y = 0;
        task->scroll_z = 0;
}

public U0 WinScrollRestore(CTask *task, CD3I64 *s)
{//Set window pan value to stored value.
        task->scroll_x = s->x;
        task->scroll_y = s->y;
        task->scroll_z = s->z;
}

U0 DrawMouse(CDC *dc)
{
        I64 x, y;

        PUSHFD
        CLI
        x = mouse.pos.x;
        y = mouse.pos.y;
        POPFD
        if (mouse.show && mouse_hard.installed)
        {
                if (gr.fp_draw_mouse)
                {
                        if (winmgr.grab_scroll && gr.fp_draw_grab_mouse)
                                (*gr.fp_draw_grab_mouse)(dc, x, y, winmgr.grab_scroll_closed);
                        else
                                (*gr.fp_draw_mouse)(dc, x, y);
                }
        }
}

U0 WinFinalUpdate(CDC *dc)
{
        if (mouse_grid.show)
                DrawWinGrid(dc);
        if (mouse_grid.coord)
                GrPrint(dc, GR_WIDTH - FONT_WIDTH * 10, FONT_HEIGHT * 3, "(%03d,%03d)", mouse.pos.x, mouse.pos.y);
        DrawProgressBars(dc);
        if (winmgr.show_menu)
                DrawMenu(dc);
        else
                sys_cur_submenu_entry = NULL;
        DrawMouse(dc);
}

gr.fp_final_screen_update = &WinFinalUpdate;

U0 WinMouseUpdate()
{
        I64  dd;
        Bool set = FALSE;

        if (mouse_hard.installed)
        {
                mouse.has_wheel = mouse_hard.has_wheel;
                if (mouse_hard.event)
                {
                        MouseUpdate(mouse_hard.pos.x, mouse_hard.pos.y, mouse_hard.pos.z, mouse_hard.bttns[0], mouse_hard.bttns[1]);
                        mouse_hard.event = FALSE;
                        set = TRUE;
                }
        }

        if (set)
        {
                if (mouse_hard.installed)
                {
                        mouse.speed = mouse_hard.speed;
                        mouse.timestamp = mouse_hard.timestamp;
                }
        }
        else
                mouse.speed *= 0.95;
        if (gr.screen_zoom != 1)
        {
                if (gr.continuous_scroll)
                        GrScaleZoom(1.0);
                else
                {
                        dd = (mouse.pos.x - gr.sx) * gr.screen_zoom;
                        if (!(8 <= dd < GR_WIDTH - 8))
                                GrScaleZoom(1.0);
                        else
                        {
                                dd = (mouse.pos.y - gr.sy) * gr.screen_zoom;
                                if (!(8 <= dd < GR_HEIGHT - 8))
                                        GrScaleZoom(1.0);
                        }
                }
        }
}

public CTask *WinRefocus(CTask *task = NULL)
{//Reset the focus task if NULL.
        PUSHFD
        CLI
        if (!task)
        {
                task = sys_winmgr_task->last_task;
                while (TaskValidate(task) && task != sys_winmgr_task)
                {
                        if (!Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                        {
                                sys_focus_task = task;
                                break;
                        }
                        task = task->last_task;
                }
        }
        POPFD
        return sys_focus_task;
}

I64 WinOnTopWindows()
{
        CTask   *task, *task1, *first_moved_fwd = NULL;
        I64              res=0;

        PUSHFD
        CLI //TODO Multiprocessor safe
        task = sys_winmgr_task->next_task;
        while (task != sys_winmgr_task && task != first_moved_fwd)
        {
                task1 = task->next_task;
                if (!TaskValidate(task))
                {
                        POPFD
                        return res;
                }
                if (Bt(&task->display_flags, DISPLAYf_WIN_ON_TOP) && task != sys_winmgr_task->last_task)
                {
                        TaskQueueRemove(task);
                        TaskQueueIns(task, sys_winmgr_task);
                        res++;
                        if (!first_moved_fwd)
                                first_moved_fwd = task;
                }
                task = task1;
        }
        POPFD
        return res;
}

public I64 WinToTop(CTask *task = NULL, Bool update_z_buf = TRUE)
{//Put task's win on top of window stack.
        CTask   *task1;
        I64              res = 0;

        if (!task)
                task = Fs;
        if (!TaskValidate(task) || task->gs->num)
                return 0;
        TaskDerivedValsUpdate(task, FALSE);
        if (!sys_winmgr_task || task==sys_winmgr_task)
                return 0;

        PUSHFD
        CLI
        if (!TaskValidate(task))
        {
                POPFD
                return 0;
        }
        if (task != sys_winmgr_task->last_task)
        {
                TaskQueueRemove(task);
                TaskQueueIns(task, sys_winmgr_task);
                res++;
        }
        if (!Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                sys_focus_task = task;
        if (res && !Bt(&task->display_flags, DISPLAYf_CHILDREN_NOT_ON_TOP))
        {
                task1 = task->next_child_task;
                while (task1 != &task->next_child_task)
                {
                        if (!TaskValidate(task1))
                                break;
                        res += WinToTop(task1, FALSE);
                        task1 = task1->next_sibling_task;
                }
                if (task->popup_task && task->popup_task->parent_task == task)
                        res += WinToTop(task->popup_task, FALSE);
        }
        POPFD

        res += WinOnTopWindows;
        if (res && update_z_buf)
                WinZBufUpdate;

        return res;
}
ext[EXT_WIN_TO_TOP] = &WinToTop;

public CTask *WinFocus(CTask *task = NULL)
{//Set task as focus task.
        if (!task)
                task = Fs;

        PUSHFD
        CLI
        if (!TaskValidate(task) || Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                task = WinRefocus(sys_focus_task);
        WinToTop(sys_focus_task = task);
        POPFD

        return sys_focus_task;
}
ext[EXT_WIN_FOCUS] = &WinFocus;

public Bool WinHorz(I64 left, I64 right, CTask *task = NULL)
{//Set task's win left and right columns.
        I64 d = right - left;

        if (!task)
                task = Fs;
        if (!TaskValidate(task))
                return FALSE;
        if (d < 0) d = 0;
        if (left >= TEXT_COLS)
        {
                left = TEXT_COLS - 1;
                right = left + d;
        }
        if (right < 0)
        {
                right = 0;
                left = right - d;
        }
        if (left > right)
        {
                if (left > 0)
                        right = left;
                else
                        left = right;
        }

        PUSHFD
        CLI //TODO Multiprocessor safe
        if (task->win_left != left || task->win_right != right)
        {
                task->win_left = left;
                task->win_right = right;
                TaskDerivedValsUpdate(task);
                POPFD
                return TRUE;
        }
        else
        {
                POPFD
                return FALSE;
        }
}

public Bool WinVert(I64 top, I64 bottom, CTask *task = NULL)
{//Set task's win top and bottom rows.
        I64 d = bottom-top;

        if (!task)
                task = Fs;
        if (!TaskValidate(task))
                return FALSE;
        if (d < 0) d = 0;
        if (top >= TEXT_ROWS)
        {
                top = TEXT_ROWS - 1;
                bottom = top + d;
        }
        if (bottom <= 0)
        {
                bottom = 1;
                top = bottom - d;
        }
        if (top > bottom)
        {
                if (top >= 0)
                        bottom = top;
                else
                        top = bottom;
        }

        PUSHFD
        CLI //TODO Multiprocessor safe
        if (task->win_top != top || task->win_bottom != bottom) {
                task->win_top = top;
                task->win_bottom = bottom;
                TaskDerivedValsUpdate(task);
                POPFD
                return TRUE;
        }
        else
        {
                POPFD
                return FALSE;
        }
}

public U0 WinTileHorz()
{//Tile windows horizontally top-to-bottom.
        CTask   *task, *last_task = Fs;
        I64              count, c, i, vert_size, no_border;

        PUSHFD
        CLI //TODO Multiprocessor safe
        task = sys_winmgr_task;
        count = 0;
        do
        {
                if (!Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                        count++;
                task = task->last_task;
        }
        while (task != sys_winmgr_task);

        task = sys_winmgr_task;
        i = 0;
        do
        {
                if (!Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                {
                        no_border = Bt(&task->display_flags, DISPLAYf_NO_BORDER);
                        c = count - i & ~3;
                        if (!c)
                                c = 1;
                        else if (c > 4)
                                c = 4;
                        vert_size = (TEXT_ROWS -1) / c;

                        WinHorz(1 - no_border, TEXT_COLS - 2 + no_border, task);
                        WinVert((i & 3) * vert_size + 2 - no_border, (i & 3 + 1) * vert_size + no_border, task);
                        last_task = task;
                        if (i & 3 == 3)
                                WinVert(task->win_top, TEXT_ROWS - 2, task);
                        i++;
                }
                task = task->last_task;
        }
        while (task != sys_winmgr_task);

        WinVert(last_task->win_top, TEXT_ROWS - 2, last_task);
        POPFD
}

public U0 WinTileVert()
{//Tile windows vertically side-by-side.
        CTask   *task, *last_task = Fs;
        I64              count, c, i, horz_size, no_border;

        PUSHFD
        CLI //TODO Multiprocessor safe
        task = sys_winmgr_task;
        count = 0;
        do
        {
                if (!Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                        count++;
                task = task->last_task;
        }
        while (task != sys_winmgr_task);

        task = sys_winmgr_task;
        i = 0;
        do
        {
                if (!Bt(&task->win_inhibit, WIf_SELF_FOCUS))
                {
                        no_border = Bt(&task->display_flags, DISPLAYf_NO_BORDER);
                        c = count - i & ~3;
                        if (!c)
                                c = 1;
                        else if (c > 4)
                                c = 4;
                        horz_size = TEXT_COLS / c;
                        WinHorz((i & 3) * horz_size + 1 - no_border, (i & 3 + 1) * horz_size - 1 + no_border, task);
                        WinVert(2 - no_border, TEXT_ROWS - 2 + no_border, task);
                        last_task = task;
                        if (i & 3 == 3)
                                WinHorz(task->win_left, TEXT_COLS - 2, task);
                        i++;
                }
                task = task->last_task;
        }
        while (task != sys_winmgr_task);

        WinHorz(last_task->win_left, TEXT_COLS - 2, last_task);
        POPFD
}

public U0 WinMax(CTask *task = NULL)
{//Maximize task's window
        I64 no_border;

        if (!task)
                task = Fs;
        if (!TaskValidate(task))
                return;

        PUSHFD
        CLI //TODO Multiprocessor safe
        no_border = Bt(&task->display_flags, DISPLAYf_NO_BORDER);
        WinHorz(1 - no_border, TEXT_COLS - 2 + no_border, task);
        WinVert(2 - no_border, TEXT_ROWS - 2 + no_border, task);
        WinToTop(task);
        POPFD
}

public Bool WinBorder(Bool val = OFF, CTask *task = NULL)
{//Turn off (or on) window border.
        Bool old_has_border;

        if (!task)
                task = Fs;
        if (!TaskValidate(task))
                return FALSE;

        PUSHFD
        CLI //TODO Multiprocessor safe
        old_has_border = !Bt(&task->display_flags, DISPLAYf_NO_BORDER);
        if (val)
        {
                if (!old_has_border)
                {
                        LBtr(&task->display_flags, DISPLAYf_NO_BORDER);
                        task->win_left++;
                        task->win_right--;
                        task->win_top++;
                        task->win_bottom--;
                        TaskDerivedValsUpdate(task, FALSE);
                }
        }
        else
        {
                if (old_has_border) {
                        LBts(&task->display_flags, DISPLAYf_NO_BORDER);
                        task->win_left--;
                        task->win_right++;
                        task->win_top--;
                        task->win_bottom++;
                        TaskDerivedValsUpdate(task, FALSE);
                }
        }
        POPFD

        return old_has_border;
}