Subversion Repositories Kolibri OS

use32

        db      'MENUET01'

        dd      1

        dd      start

        dd      i_end

memsize dd      mem

        dd      stacktop

        dd      0, app_path

version equ '0.42'

version_dword equ 0*10000h + 42

include 'lang.inc'

include 'font.inc'

include 'sort.inc'

include 'kglobals.inc'

include 'dialogs.inc'

include 'viewer.inc'

include 'tools.inc'

include 'filetool.inc'

start:

        mov     edi, tolower_table

        push    'A'

        pop     ecx

        xor     eax, eax

@@:

        stosb

        inc     eax

        loop    @b

        add     al, 0x20

        mov     cl, 'Z'-'A'+1

@@:

        stosb

        inc     eax

        loop    @b

        sub     al, 0x20

        mov     cl, '�'-'Z'-1

@@:

        stosb

        inc     eax

        loop    @b

        add     al, 0x20

        mov     cl, '�'-'�'

@@:

        stosb

        inc     eax

        loop    @b

        add     al, 0x30

        mov     cl, '�'-'�'+1

@@:

        stosb

        inc     eax

        loop    @b

        sub     al, 0x50

        mov     cl, 256-'�'-1

@@:

        stosb

        inc     eax

        loop    @b

        mov     byte [edi-256+'�'], '�'

        push    68

        pop     eax

        push    11

        pop     ebx

        int     0x40

        call    init_console

        call    draw_window

        push    66

        pop     eax

        push    1

        pop     ebx

        mov     ecx, ebx

        int     40h     ; set keyboard mode to scancodes

        mov     eax, 200

        mov     [panel1_nfa], eax

        mov     [panel2_nfa], eax

        mov     ecx, 200*4 + 32 + 200*304

        call    pgalloc

        mov     [panel1_files], eax

        call    pgalloc

        mov     [panel2_files], eax

        test    eax, eax

        jz      exit

        cmp     [panel1_files], 0

        jz      exit

        xor     eax, eax

        mov     [panel1_hPlugin], eax

        mov     [panel1_parents], eax

        mov     [panel1_parents_sz], eax

        mov     [panel1_parents_alloc], eax

        mov     [panel2_hPlugin], eax

        mov     [panel2_parents], eax

        mov     [panel2_parents_sz], eax

        mov     [panel2_parents_alloc], eax

        mov     [panel1_sortmode], al   ; sort by name

        mov     [panel2_sortmode], al

        mov     al, 2                   ; "�।���" �ଠ�

        mov     [panel1_colmode], eax

        mov     [panel2_colmode], eax

        mov     [num_screens], 1

        mov     ecx, 0x1000

        call    pgalloc

        mov     [screens], eax

        test    eax, eax

        jz      exit

        mov     ecx, panels_vtable

        mov     [eax], ecx

        mov     [active_screen_vtable], ecx

; load libini.obj and kfar.ini

        mov     eax, libini_name

        mov     esi, ini_import

        push    3

        pop     ebp     ; we use version 3 of libini

        call    load_dll_and_import

        test    eax, eax

        jnz     .noini

        mov     edi, app_path

        or      ecx, -1

        repnz   scasb

        mov     dword [edi-1], '.ini'

        mov     byte [edi+3], 0

        push    1

        push    dword aConfirmDelete

        push    dword aConfirmations

        push    dword app_path

        call    [ini.get_int]

        mov     [bConfirmDelete], al

        push    0

        push    dword aConfirmDeleteIncomplete

        push    dword aConfirmations

        push    dword app_path

        call    [ini.get_int]

        mov     [bConfirmDeleteIncomplete], al

        push    2

        push    aLeftViewMode

        push    aPanels

        push    app_path

        call    [ini.get_int]

        cmp     eax, 1

        jb      @f

        cmp     eax, 4

        ja      @f

        mov     [panel1_colmode], eax

@@:

        push    2

        push    aRightViewMode

        push    aPanels

        push    app_path

        call    [ini.get_int]

        cmp     eax, 1

        jb      @f

        cmp     eax, 4

        ja      @f

        mov     [panel2_colmode], eax

@@:

        mov     ecx, 0x1000

        call    xpgalloc

        test    eax, eax

        jz      .skip_assoc

        mov     [associations], eax

        push    enum_associations_callback

        push    aAssociations

        push    app_path

        call    [ini.enum_keys]

.skip_assoc:

        xor     ebp, ebp

        xor     esi, esi

.shortcut_loop:

        mov     edi, saved_file_name

        push    dword nullstr

        push    512

        push    edi

        push    dword aShortcut

        push    dword aFolderShortcuts

        push    dword app_path

        call    [ini.get_str]

        cmp     byte [edi], 0

        jz      .shortcut_cont

        or      ecx, -1

        xor     eax, eax

        repnz   scasb

        not     ecx

        cmp     ecx, 2

        jz      @f

        cmp     byte [edi-2], '/'

        jnz     @f

        mov     byte [edi-2], 0

        dec     ecx

@@:

        mov     al, [aShortcut.d]

        push    esi

        inc     esi

        mov     [FolderShortcuts+(eax-'0')*4], esi

        lea     esi, [esi+ecx-1]

        push    esi

        and     esi, 0xFFF

        cmp     esi, ecx

        pop     esi

        ja      .norealloc

        mov     edx, ebp

        mov     ecx, esi

        call    xpgrealloc

        test    eax, eax

        jnz     @f

        pop     esi

        mov     edi, FolderShortcuts

        mov     ecx, 10

        rep     stosd

        jmp     .skip_shortcuts

@@:

        mov     ebp, eax

.norealloc:

        pop     edi

        add     edi, ebp

        mov     ecx, saved_file_name

@@:

        mov     al, [ecx]

        inc     ecx

        stosb

        test    al, al

        jnz     @b

.shortcut_cont:

        inc     [aShortcut.d]

        cmp     [aShortcut.d], '9'

        jbe     .shortcut_loop

        mov     esi, FolderShortcuts

        mov     ecx, 10

        dec     ebp

.l3:

        lodsd

        test    eax, eax

        jz      @f

        add     [esi-4], ebp

@@:

        loop    .l3

.skip_shortcuts:

; load plugins

        push    enum_plugins_callback

        push    aPlugins

        push    app_path

        call    [ini.enum_keys]

.noini:

        mov     esi, def_left_dir

        mov     edi, panel1_dir

@@:

        lodsb

        stosb

        test    al, al

        jnz     @b

        mov     esi, def_right_dir

        mov     edi, panel2_dir

@@:

        lodsb

        stosb

        test    al, al

        jnz     @b

        call    draw_keybar

        call    draw_cmdbar

        mov     [prev_dir], 0

        mov     ebp, panel1_data

        call    calc_colwidths

        call    read_folder

        call    draw_panel

        mov     [bSilentFolderMode], 1

        mov     ebp, panel2_data

        call    calc_colwidths

        call    read_folder

        call    draw_panel

event:

        push    10

        pop     eax

        int     40h

        dec     eax

        jz      redraw

        dec     eax

        jz      key

; button - we have only one button, close

exit:

; close all screens

@@:

        mov     ecx, [num_screens]

        mov     eax, [screens]

        mov     ebp, [eax+ecx*8-4]

        mov     eax, [eax+ecx*8-8]

        push    ebp

        call    [eax+screen_vtable.OnExit]

        pop     ecx

        call    pgfree

        dec     [num_screens]

        jnz     @b

; unload all plugins

        mov     ecx, [num_plugins]

        imul    esi, ecx, PluginInfo.size

        add     esi, [plugins]

.unload:

        dec     ecx

        js      .unload_done

        sub     esi, PluginInfo.size

        push    ecx esi

        call    [esi+PluginInfo.unload]

        pop     esi ecx

        jmp     .unload

.unload_done:

if 0    ; commented due to bug in libini

        cmp     [ini.set_int], aIniSetInt

        jz      .nosave

        push    [panel1_colmode]

        push    aLeftViewMode

        push    aPanels

        push    app_path

        call    [ini.set_int]

        push    [panel2_colmode]

        push    aRightViewMode

        push    aPanels

        push    app_path

        call    [ini.set_int]

.nosave:

end if

if CHECK_FOR_LEAKS

        mov     ecx, [panel1_files]

        call    pgfree

        mov     ecx, [panel2_files]

        call    pgfree

        mov     ecx, [screens]

        call    pgfree

        mov     ecx, [associations]

        call    pgfree

        mov     ecx, [console_data_ptr]

        call    pgfree

        mov     ecx, [MemForImage]

        call    pgfree

        mov     esi, FolderShortcuts

        push    10

        pop     ecx

@@:

        lodsd

        test    eax, eax

        jnz     @f

        loop    @b

        jmp     .nofreefs

@@:

        mov     ecx, eax

        call    pgfree

        mov     ecx, [plugins]

        call    pgfree

        mov     ecx, [panel1_parents]

        call    pgfree

        mov     ecx, [panel2_parents]

        call    pgfree

.nofreefs:

        mov     eax, [numallocatedregions]

        test    eax, eax

        jz      @f

        mov     edi, allocatedregions

        int3

        jmp     $

@@:

end if

        or      eax, -1

        int     40h

redraw:

; query kbd state from OS

        mov     al, 66

        push    3

        pop     ebx

        int     0x40

        and     eax, 0x3F

        cmp     al, [ctrlstate]

        mov     [ctrlstate], al

        jz      @f

        call    draw_keybar

@@:

        mov     al, 9

        mov     ebx, procinfo

        or      ecx, -1

        int     40h

; test if rolled up

; height of rolled up window is [skinh]+3

        mov     eax, [ebx+46]

        sub     eax, [skinh]

        cmp     eax, 5

        ja      @f

        mov     al, 12

        push    1

        pop     ebx

        int     0x40

        xor     eax, eax

; ebx, ecx, edi are ignored by function 0 after first redraw

        mov     edx, 0x53000000

        int     0x40

        mov     al, 12

        inc     ebx

        int     0x40

        jmp     event

@@:

        xor     ecx, ecx

        mov     eax, [ebx+42]

        mov     [wnd_width], eax

        sub     eax, 5*2-1

        jae     @f

        xor     eax, eax

@@:

        cdq

        mov     esi, font_width

        div     esi

        cmp     eax, 54

        jae     @f

        mov     al, 54

        mov     ch, 1

@@:

        cmp     eax, 255

        jbe     @f

        mov     eax, 255

        mov     ch, 1

@@:

        cmp     eax, [cur_width]

        mov     [cur_width], eax

        setnz   cl

        or      cl, ch

        test    edx, edx

        mov     [fill_width], edx

        setnz   ch

        mov     eax, [ebx+46]

        mov     [wnd_height], eax

        sub     eax, [skinh]

        sub     eax, 5-1

        jns     @f

        xor     eax, eax

@@:

        cdq

        mov     esi, font_height

        div     esi

        cmp     eax, 8

        jae     @f

        mov     al, 8

        mov     cl, 1

@@:

        cmp     eax, 255

        jbe     @f

        mov     eax, 255

        mov     cl, 1

@@:

        mov     [fill_height], edx

        cmp     eax, [cur_height]

        mov     [cur_height], eax

        jnz     .resize

        test    cl, cl

        jnz     .resize

        test    edx, edx

        setnz   cl

        or      cl, ch

        jz      @f

        test    byte [ebx+70], 1

        jnz     @f

.resize:

        push    67

        pop     eax

        or      ebx, -1

        or      ecx, -1

        mov     edx, [cur_width]

        imul    edx, font_width

        add     edx, 5*2-1

        mov     esi, [cur_height]

        imul    esi, font_height

        add     esi, [skinh]

        add     esi, 5-1

        int     40h

.resize_draw:

        mov     ecx, [MemForImage]

        call    pgfree

        and     [MemForImage], 0

        call    init_console

;        call    draw_window

        call    draw_keybar

        mov     ebp, [active_screen_data]

        mov     eax, [active_screen_vtable]

        call    dword [eax+screen_vtable.OnRedraw]

        jmp     event

@@:

        call    draw_window

        jmp     event

alt_f9:

        cmp     [saved_width], -1

        jz      @f

        mov     eax, [saved_width]

        mov     [cur_width], eax

        or      [saved_width], -1

        mov     eax, [saved_height]

        mov     [cur_height], eax

        or      [saved_height], -1

        jmp     redraw.resize

@@:

        push    48

        pop     eax

        push    5

        pop     ebx

        int     0x40

        push    eax

        sub     eax, [esp+2]

        inc     eax

        movzx   eax, ax

        sub     eax, 10

        xor     edx, edx

        mov     ecx, font_width

        div     ecx

        xchg    [cur_width], eax

        mov     [saved_width], eax

        mov     eax, ebx

        shr     ebx, 16

        sub     eax, ebx

        sub     eax, 5-1

        sub     eax, [skinh]

        xor     edx, edx

        mov     ecx, font_height

        div     ecx

        xchg    [cur_height], eax

        mov     [saved_height], eax

        mov     ecx, ebx

        pop     ebx

        shr     ebx, 16

        mov     edx, [cur_width]

        imul    edx, font_width

        add     edx, 5*2-1

        mov     esi, [cur_height]

        imul    esi, font_height

        add     esi, [skinh]

        add     esi, 4

        push    67

        pop     eax

        int     0x40

        jmp     redraw.resize_draw

key:

        mov     al, 2

        int     40h

        test    al, al

        jnz     event

        xchg    al, ah

        cmp     al, 0xE0

        jnz     @f

        mov     [bWasE0], 1

        jmp     event

@@:

        xchg    ah, [bWasE0]

        mov     ebp, [active_screen_data]

        mov     edx, [active_screen_vtable]

        cmp     al, 0x1D

        jz      .ctrl_down

        cmp     al, 0x9D

        jz      .ctrl_up

        cmp     al, 0x2A

        jz      .lshift_down

        cmp     al, 0xAA

        jz      .lshift_up

        cmp     al, 0x36

        jz      .rshift_down

        cmp     al, 0xB6

        jz      .rshift_up

        cmp     al, 0x38

        jz      .alt_down

        cmp     al, 0xB8

        jz      .alt_up

        call    [edx+screen_vtable.OnKey]

        jmp     event

.ctrl_down:

        test    ah, ah

        jnz     .rctrl_down

        or      [ctrlstate], 4

        jmp     .keybar

.rctrl_down:

        or      [ctrlstate], 8

        jmp     .keybar

.ctrl_up:

        test    ah, ah

        jnz     .rctrl_up

        and     [ctrlstate], not 4

        jmp     .keybar

.rctrl_up:

        and     [ctrlstate], not 8

.keybar:

        call    draw_keybar

        call    draw_image

@@:     jmp     event

.lshift_down:

; ignore E0 2A sequence

; e.g. arrow keys with NumLock on generate sequence E0 2A E0 xx / E0 xx+80 E0 AA

; where xx is scancode, so we can safely ignore E0 2A

        test    ah, ah

        jnz     @b

        or      [ctrlstate], 1

        jmp     .keybar

.lshift_up:

; ignore E0 AA sequence

        test    ah, ah

        jnz     @b

        and     [ctrlstate], not 1

        jmp     .keybar

.rshift_down:

        or      [ctrlstate], 2

        jmp     .keybar

.rshift_up:

        and     [ctrlstate], not 2

        jmp     .keybar

.alt_down:

        test    ah, ah

        jnz     .ralt_down

        or      [ctrlstate], 0x10

        jmp     .keybar

.ralt_down:

        or      [ctrlstate], 0x20

        jmp     .keybar

.alt_up:

        test    ah, ah

        jnz     .ralt_up

        and     [ctrlstate], not 0x10

        jmp     .keybar

.ralt_up:

        and     [ctrlstate], not 0x20

        jmp     .keybar

process_ctrl_keys:

        cmp     byte [esi], 0

        jz      .done

        push    ecx

        cmp     al, [esi]

        jz      .check

.cont:

        pop     ecx

        add     esi, 8

        jmp     process_ctrl_keys

.done:

        stc

        ret

.check:

        mov     cl, 0

        call    .check_ctrlkey

        jc      .cont

        mov     cl, 2

        call    .check_ctrlkey

        jc      .cont

        mov     cl, 4

        call    .check_ctrlkey

        jc      .cont

        pop     ecx

        call    dword [esi+4]

        clc

        ret

.check_ctrlkey:

        push    eax edx

        movzx   edx, [ctrlstate]

        shr     edx, cl

        add     cl, cl

        movzx   eax, word [esi+2]

        shr     eax, cl

        and     eax, 15

        cmp     al, ctrlkey_tests_num

        jae     .fail

        xchg    eax, edx

        and     al, 3

        call    [ctrlkey_tests + edx*4]

        cmp     al, 1

        pop     edx eax

        ret

.fail:

        stc

        pop     edx eax

        ret

ctrlkey_test0:

        test    al, al

        setz    al

        ret

ctrlkey_test1:

        test    al, al

        setnp   al

        ret

ctrlkey_test2:

        cmp     al, 3

        setz    al

        ret

ctrlkey_test3:

        cmp     al, 1

        setz    al

        ret

ctrlkey_test4:

        cmp     al, 2

        setz    al

        ret

enum_associations_callback:

; LongBool __stdcall callback(f_name,sec_name,key_name);

; [esp+4] = f_name, [esp+8] = sec_name, [esp+12] = key_name

        mov     esi, [esp+12]

        mov     edi, esi

@@:

        lodsb

        test    al, al

        jnz     @b

        sub     esi, edi        ; esi = size of key name

        push    nullstr

        push    1024

        push    saved_file_name

        push    edi

        push    dword [esp+16+8]

        push    dword [esp+20+4]

        call    [ini.get_str]

        test    eax, eax

        jnz     .ret

        mov     eax, saved_file_name

@@:

        inc     esi

        inc     eax

        cmp     byte [eax-1], 0

        jnz     @b

; esi = total size of entry

        push    esi

        add     esi, [associations_size]

        mov     ecx, [associations_allocated]

@@:

        cmp     esi, ecx

        jbe     @f

        add     ecx, ecx

        jmp     @b

@@:

        pop     esi

        cmp     [associations_allocated], ecx

        jz      @f

        mov     [associations_allocated], ecx

        mov     edx, [associations]

        call    xpgrealloc

        mov     [associations], eax

        test    eax, eax

        jz      .err

@@:

        mov     eax, esi

        mov     esi, edi

        mov     edi, [associations]

        add     edi, [associations_size]

        dec     edi

        add     [associations_size], eax

@@:

        lodsb

        stosb

        test    al, al

        jnz     @b

        mov     esi, saved_file_name

@@:

        lodsb

        stosb

        test    al, al

        jnz     @b

.ret:

        mov     al, 1

        ret     12

.err:

        mov     ecx, edx

        call    pgfree

        xor     eax, eax

        ret     12

enum_plugins_callback:

; LongBool __stdcall callback(f_name,sec_name,key_name);

; [esp+4] = f_name, [esp+8] = sec_name, [esp+12] = key_name

        push    nullstr

        push    1024

        push    saved_file_name

        push    dword [esp+12+12]

        push    dword [esp+16+8]

        push    dword [esp+20+4]

        call    [ini.get_str]

        test    eax, eax

        jnz     .ret

        mov     esi, saved_file_name

        cmp     byte [esi], '/'

        jz      .absolute

; convert path to absolute

        mov     edi, execdata

        push    esi

@@:

        lodsb

        stosb

        test    al, al

        jnz     @b

        pop     edi

        mov     esi, app_path

        push    esi

        xor     ecx, ecx

@@:

        lodsb

        test    al, al

        jz      @f

        cmp     al, '/'

        jnz     @b

        mov     ecx, esi

        jmp     @b

@@:

        pop     esi

        sub     ecx, esi

        rep     movsb

        mov     esi, execdata

.z:

        cmp     word [esi], '.'

        jz      .ret

        cmp     word [esi], './'

        jnz     @f

        add     esi, 2

        jmp     .z

@@:

        cmp     word [esi], '..'

        jnz     .c

        cmp     byte [esi+2], 0

        jz      .ret

        cmp     byte [esi+2], '/'

        jnz     .c

        add     esi, 3

@@:

        dec     edi

        cmp     edi, saved_file_name

        jbe     .ret

        cmp     byte [edi-1], '/'

        jnz     @b

        jmp     .z

.c:

        lodsb

        stosb

        test    al, al

        jz      @f

        cmp     edi, saved_file_name+1024

        jb      .c

        mov     esi, execdata

        call    load_dll_and_import.big

.ret:

        mov     al, 1

        ret     12

@@:

.absolute:

; allocate space for plugin info

        mov     eax, [num_plugins]

        inc     eax

        mov     [num_plugins], eax

        imul    ecx, eax, PluginInfo.size

        cmp     ecx, [alloc_plugins]

        jbe     .norealloc

        mov     edx, [plugins]

        call    xpgrealloc

        test    eax, eax

        jnz     @f

.dec_ret:

        dec     [num_plugins]

        jmp     .ret

@@:

        mov     [plugins], eax

        lea     eax, [ecx+0xFFF]

        and     eax, not 0xFFF

        mov     [alloc_plugins], eax

.norealloc:

        mov     esi, [plugins]

        lea     esi, [esi+ecx-PluginInfo.size]

; load plugin DLL

        or      ebp, -1

        mov     eax, saved_file_name

        call    load_dll_and_import.do

        test    eax, eax

        jnz     .dec_ret

; find exported functions

        mov     eax, aVersion

        call    load_dll_and_import.find_exported_function

        jnc     @f

        xor     eax, eax

@@:

MIN_INTERFACE_VER = 2

MAX_INTERFACE_VER = 2

        cmp     eax, MIN_INTERFACE_VER

        jb      @f

        cmp     eax, MAX_INTERFACE_VER

        jbe     .version_ok

@@:

        push    aIncompatibleVersion

.cantload:

        push    saved_file_name

        push    aCannotLoadPlugin

        mov     eax, esp

        push    ContinueBtn

        push    1

        push    eax

        push    3

        call    SayErr

        add     esp, 12

        jmp     .dec_ret

.version_ok:

        mov     edi, esi

        mov     esi, plugin_exported

.import:

        lodsd

        test    eax, eax

        jz      .import_done

        call    load_dll_and_import.find_exported_function

        jnc     @f

        mov     eax, [esi-4+plugin_exported_default-plugin_exported]

@@:

        stosd

        jmp     .import

.import_done:

; initialize plugin

        mov     eax, aPluginLoad

        call    load_dll_and_import.find_exported_function

        jc      .ok

        push    kfar_info

        call    eax

        cmp     eax, 1

        jb      .ok

        ja      .dec_ret

        push    aInitFailed

        jmp     .cantload

.ok:

        mov     al, 1

        ret     12

plugin_unload_default:

        ret

OpenFilePlugin_default:

        xor     eax, eax

        ret     28

GetFiles_default:

        xor     eax, eax

        ret     20

ClosePlugin_default:

        ret     4

GetOpenPluginInfo_default:

        ret     8

SetFolder_default:

open_default:

        xor     eax, eax

        ret     12

new_screen:

; in: ecx=sizeof(screen data), edx->vtable

; out: ebp=pointer or NULL, eax!=0 if successful

; destroys ebx,ecx

        call    xpgalloc

        test    eax, eax

        jnz     @f

        ret

@@:

        mov     ebp, eax

        mov     eax, [screens]

        mov     ecx, [num_screens]

        inc     ecx

        shl     ecx, 3

        test    ecx, 0xFFF

        jnz     .norealloc

        push    edx

        mov     edx, eax

        call    xpgrealloc

        pop     edx

        test    eax, eax

        jnz     @f

        mov     ecx, ebp

        call    pgfree

        xor     eax, eax

        ret

@@:

        mov     [screens], eax

.norealloc:

        inc     [num_screens]

        mov     [eax+ecx-8], edx

        mov     [eax+ecx-4], ebp

        mov     eax, [num_screens]

        dec     eax

        mov     [active_screen], eax

        mov     [active_screen_vtable], edx

        mov     [active_screen_data], ebp

        jmp     draw_keybar

next_screen:

        mov     eax, [active_screen]

        inc     eax

        cmp     eax, [num_screens]

        jnz     @f

        xor     eax, eax

@@:     mov     [active_screen], eax

        jmp     change_screen

delete_active_screen:

        mov     edi, [screens]

        mov     eax, [active_screen]

        shl     eax, 3

        add     edi, eax

        push    dword [edi+4]

        lea     esi, [edi+8]

        mov     ecx, [num_screens]

        sub     ecx, [active_screen]

        dec     ecx

        add     ecx, ecx

        rep     movsd

        dec     [num_screens]

        mov     ecx, [num_screens]

        shl     ecx, 3

        test    ecx, 0xFFF

        jnz     .norealloc

        mov     edx, [screens]

        call    pgrealloc               ; must succeed, because we decrease size

        mov     [screens], eax

.norealloc:

        pop     ecx

        call    pgfree

        and     [active_screen], 0

change_screen:

        pusha

        mov     eax, [active_screen]

        mov     esi, [screens]

        mov     ebp, [esi+eax*8+4]

        mov     eax, [esi+eax*8]

        mov     [active_screen_vtable], eax

        mov     [active_screen_data], ebp

        call    draw_keybar

        call    [eax+screen_vtable.OnRedraw]

        popa

        ret

F12:

        mov     eax, [cur_width]

        add     eax, 8

        mov     esi, eax

        mul     [num_screens]

        mov     ecx, eax

        call    xpgalloc

        test    eax, eax

        jnz     @f

        ret

@@:

        mov     ebx, eax

        mov     edi, eax

        xor     ecx, ecx

.next:

        xor     eax, eax

        stosd

        inc     ecx

        cmp     ecx, [num_screens]

        jz      @f

        lea     eax, [edi+esi-4]

        mov     dword [edi-4], eax

@@:

        xor     eax, eax

        stosd

        dec     ecx

        jz      @f

        lea     eax, [edi-8]

        sub     eax, esi

        mov     dword [edi-4], eax

@@:

        mov     al, '&'

        stosb

        cmp     ecx, 36

        jae     .noletter

        lea     eax, [ecx+'0']

        cmp     al, '9'

        jbe     @f

        add     al, 7

@@:

        stosb

        mov     al, '.'

        stosb

        jmp     .letter_done

.noletter:

        mov     al, ' '

        stosb

        stosb

.letter_done:

        mov     al, ' '

        stosb

        pushad

        mov     eax, [screens]

        mov     ebp, [eax+ecx*8+4]

        mov     eax, [eax+ecx*8]

        mov     ecx, [cur_width]

        sub     ecx, 12

        call    [eax + screen_vtable.getname]

        popad

        sub     edi, 4

        add     edi, [cur_width]

        inc     ecx

        cmp     ecx, [num_screens]

        jb      .next

        mov     eax, [active_screen]

        mul     esi

        add     eax, ebx

        push    1

        push    dword aScreens

        push    eax

        call    menu

        cmp     eax, -1

        jz      @f

        sub     eax, ebx

        div     esi

        mov     [active_screen], eax

@@:

        mov     ecx, ebx

        call    pgfree

        jmp     change_screen

panels_OnKey:

        mov     ebp, [active_panel]

        mov     ecx, [ebp + panel1_index - panel1_data]

        mov     edx, [ebp + panel1_start - panel1_data]