This repository is a mirror!

; includes OS specific utility procedures, data, etc.
include 'progutils.asm'


; OS independent template engine.
include 'ObjTemplates.asm'

; OS independent components
include 'objects.asm'

include 'TObject.asm'
include 'TWindow.asm'

include 'TApplication.asm'
include 'TForm.asm'
include 'TButton.asm'
include 'TEdit.asm'

; OS independent main procedures.
include 'Main.asm'

uglobal
  _globalevent  XEvent
endg



proc ProcessSystemEvents
begin

.event_loop:
        cinvoke XPending, [hApplicationDisplay]
        test    eax, eax
        jz      .noevents

        cinvoke  XNextEvent, [hApplicationDisplay], _globalevent
        stdcall  __ProcessOneSystemEvent, _globalevent

; check for quit
        cmp     [_globalevent.type], DestroyNotify
        jne     .event_loop

        mov     eax, [_globalevent.window]
        mov     ecx, [Application]
        cmp     [ecx+TApplication.MainWindow], eax
        jne     .event_loop

; main window destroyed, so terminate whole application.
        xor     eax, eax
        stc
        return

.noevents:
        clc
        return
endp



proc WaitForSystemEvent
.event XEvent
begin
        lea     eax, [.event]
        cinvoke XPeekEvent, [hApplicationDisplay], eax
        return
endp




ExitApplication:
        push    eax
        FinalizeAll
        pop     eax
        cinvoke exit, eax
        int3



proc __ProcessOneSystemEvent, .linux_event
.event  rb 32
begin
        push    eax ebx ecx edx esi edi

        mov     ebx, [.linux_event]

        stdcall _GetWindowStruct, [ebx+XEvent.window]
        test    eax, eax
        jz      .notprocessed

        mov     esi, eax
        lea     edi, [.event]


        cmp     [ebx+XEvent.type], MotionNotify
        je      .mousemove

        cmp     [ebx+XEvent.type], EnterNotify
        je      .mouseenter

        cmp     [ebx+XEvent.type], LeaveNotify
        je      .mouseleave

        cmp     [ebx+XEvent.type], KeyPress
        je      .mouse_btn_press
        cmp     [ebx+XEvent.type], ButtonPress
        je      .mouse_btn_press

        cmp     [ebx+XEvent.type], KeyRelease
        je      .mouse_btn_release
        cmp     [ebx+XEvent.type], ButtonRelease
        je      .mouse_btn_release

        cmp     [ebx+XEvent.type], Expose
        je      .paint_window


.notprocessed:
        pop     edi esi edx ecx ebx eax
        stc
        return

.finish:
        pop     edi esi edx ecx ebx eax
        clc
        return

.mouseleave:
        mov     [edi+TMouseEnterEvent.event], seMouseLeave
        stdcall ExecEvent, esi, edi
        jmp     .finish

.mouseenter:
        mov     [edi+TMouseEnterEvent.event], seMouseEnter
        stdcall ExecEvent, esi, edi
        jmp     .finish

.mousemove:
        mov     [edi+TMouseMoveEvent.event], seMouseMove
        mov     eax, [ebx+XMotionEvent.x]
        mov     ecx, [ebx+XMotionEvent.y]
        mov     [edi+TMouseMoveEvent.x], eax
        mov     [edi+TMouseMoveEvent.y], ecx
        stdcall ExecEvent, esi, edi
        jmp     .finish


.paint_window:
        mov     [edi+TPaintEvent.event], sePaint

        mov     eax, [esi+TWindow.handle]
        mov     [edi+TPaintEvent.raster], eax

        mov     eax, [ebx+XExposeEvent.x]
        mov     ecx, [ebx+XExposeEvent.y]

        mov     [edi+TPaintEvent.rect.left], eax
        mov     [edi+TPaintEvent.rect.top], ecx

        mov     eax, [ebx+XExposeEvent.width]
        mov     ecx, [ebx+XExposeEvent.height]

        mov     [edi+TPaintEvent.rect.right], eax
        mov     [edi+TPaintEvent.rect.bottom], ecx

        pushad
        stdcall ExecEvent, esi, edi
        popad

        jmp     .finish

.mouse_btn_press:
.mouse_btn_release:

        mov     eax, [ebx+XButtonEvent.type]
        mov     [edi+TMouseButtonEvent.event], eax      ; seMouseBtnPress=ButtonPress and seMouseBtnRelease = ButtonRelease

        mov     eax, [ebx+XButtonEvent.button]
        dec     eax
        mov     [edi+TMouseButtonEvent.Button], eax

        mov     eax, [ebx+XButtonEvent.state]
        mov     [edi+TMouseButtonEvent.kbdStatus], eax

        stdcall ExecEvent, esi, edi
        jmp     .finish

.keyboard_events:

        jmp     .finish
endp






;proc _CommonWindowEventHandler, .ptrevent
;begin
;        push    esi edi ebx eax
;
;        mov     esi, [.ptrevent]
;        mov     ecx, [esi+XEvent.type]
;        mov     eax, [esi+XEvent.window]
;
;        stdcall _GetWindowStruct, [esi+XEvent.window]
;        test    eax, eax
;        jz      .finish
;
;        mov     edi, eax
;        mov     ebx, [edi+TObject.ptrClass]
;
;        mov     eax, [ebx+TObjectClass.procSysEventHandler]
;        cmp     eax, 0
;        je      .go_further
;
;        push    [.ptrevent]
;        call    eax
;        jc      .go_further
;
;.finish:
;        pop     eax ebx edi esi
;        return
;
;.go_further:
;        mov     eax, [esi+XEvent.type]
;        cmp     eax, CreateNotify
;        je      .create
;        cmp     eax, DestroyNotify
;        je      .destroy
;
;        stc
;        pop     eax ebx edi esi
;        return
;
;.create:
;        mov     eax, [edi+TWindow.OnCreate]
;        cmp     eax, 0
;        je      @f
;        call    eax
;@@:
;        clc
;        pop     eax ebx edi esi
;        return
;
;.destroy:
;        mov     eax, [edi+TWindow.OnDestroy]
;        cmp     eax, 0
;        je      @f
;        call    eax
;@@:
;        clc
;        pop     eax ebx edi esi
;        return
;endp
;

uglobal
  hApplicationDisplay dd ?
  hRootWindow         dd ?
  wmdelete_atom       dd ?
  _SystemFont         dd ?
endg

iglobal
  _cWinDeleteName db 'WM_DELETE_WINDOW', 0
endg


win_structure_context = 1


proc TApplication.Create, .obj, .parent
begin
        cinvoke XOpenDisplay, 0
        test    eax, eax
        jz      .exit_error

        mov     [hApplicationDisplay], eax

        cinvoke XDefaultRootWindow, eax
        mov     [hRootWindow], eax

        cinvoke XInternAtom, [hApplicationDisplay], _cWinDeleteName, 0
        mov     [wmdelete_atom], eax

;cDefaultFont text 'DejaVu Sans-9:antialias=false:weight=medium'
cDefaultFont text 'Liberation sans-9'

        cinvoke XftFontOpenName, [hApplicationDisplay], 0, cDefaultFont
        mov   [_SystemFont], eax

        clc
        return

.exit_error:
        stc
        return
endp




proc TApplication.Get, .obj, .paramID
begin
        stc
        return
endp



proc TApplication.Set, .obj, .paramID, .value
begin
        stc
        return
endp



proc TApplication.SysEventHandler
begin
        clc
        return
endp

proc TWindow.Create, .obj, .parent
begin
        push    eax ecx edx esi edi

        mov     ebx, [.obj]

        mov     eax, [.parent]
        test    eax, eax
        jz      .root
        mov     eax, [eax+TWindow.handle]
        jmp     .parentok

.root:
        mov     eax, [hRootWindow]

.parentok:
        cinvoke XCreateSimpleWindow, [hApplicationDisplay], eax, 0, 0, 1, 1, 0, 0, $d4d0c8
        mov     [ebx+TWindow.handle], eax

        stdcall _SetWindowStruct, eax, ebx

        cinvoke XSetWMProtocols, [hApplicationDisplay], [ebx+TForm.handle], wmdelete_atom, 1
        cinvoke XSelectInput, [hApplicationDisplay], [ebx+TWindow.handle], ExposureMask or KeyPressMask or KeyReleaseMask or SubstructureNotifyMask or ButtonPressMask or ButtonReleaseMask or EnterWindowMask or LeaveWindowMask

        clc
        pop     edi esi edx ecx eax
        return
endp




proc TWindow.Destroy, .obj
begin
        push    eax
        stdcall IsObject, [.obj], CWindow
        jc      .exit
        mov     eax, [.obj]
        cinvoke XDestroyWindow, [hApplicationDisplay], [eax+TWindow.handle]
.exit:
        pop     eax
        return
endp



proc TWindow.Get, .obj, .paramID
.rect RECT
begin
        stdcall IsObject, [.obj], CWindow
        jc      .fault

        push    ecx edx esi ebx

        mov     esi, [.obj]
        mov     eax, [.paramID]

        test    eax, maskParameter
        jz      .field

        cmp     eax, 4 or maskParameter
        jb      .getrect

        cmp     eax, TWindow.visible
        je      .getvisible

        cmp     eax, TWindow.caption
        je      .getcaption

.fault:
        stc
.finish:
        pop     ebx esi edx ecx
        return

.field:
        mov     ebx, [.paramID]
        mov     eax, [esi+ebx]
        clc
        jmp     .finish


.getcaption:
        stdcall StrDup, [esi+TWindow.Fcaption]
        clc
        jmp     .finish


.getvisible:
        clc
        jmp     .finish


.getrect:
locals
  .attr XWindowAttributes
endl
        lea     ecx, [.attr]
        cinvoke XGetWindowAttributes, [hApplicationDisplay], [esi+TWindow.handle], ecx

        mov     eax, [.paramID]
        sub     eax, TWindow.x
        mov     eax, [.attr+4*eax]
        jmp     .finish
endp




proc TWindow.Set, .obj, .idparam, .value
  .wch XWindowChanges
begin
        stdcall IsObject, [.obj], CWindow
        jc      .fault

        push    esi eax

        mov     esi, [.obj]
        mov     eax, [.idparam]

        test    eax, maskParameter
        jz      .field

        cmp     eax, 4 or maskParameter
        jb      .configure

        cmp     eax, TWindow.visible
        je      .setvisible

        cmp     eax, TWindow.caption
        je      .setcaption

        pop     eax esi
.fault:
        stc
        return


.field:
        stc
        pop     eax esi
        return


.setcaption:
        lea     eax, [esi+TWindow.Fcaption]
        stdcall SetString, eax, [.value]
        stdcall StrPtr, [eax]

        cinvoke XStoreName, [hApplicationDisplay], [esi+TWindow.handle], eax
        clc
        pop     eax esi
        return

.setvisible:
        cmp     [.value], 0
        je      .hide

        cinvoke XMapWindow, [hApplicationDisplay], [esi+TWindow.handle]
        clc
        pop     eax esi
        return

.hide:
        cinvoke XUnmapWindow, [hApplicationDisplay], [esi+TWindow.handle]
        clc
        pop     eax esi
        return

.configure:
        mov     cl, al
        mov     edx, 1
        shl     edx, cl

        pushd   [.value]
        popd    [.wch+ 4*eax]

        lea     eax, [.wch]
        cinvoke XConfigureWindow, [hApplicationDisplay], [esi+TWindow.handle], edx, eax
        clc
        pop     eax esi
        return
endp



proc _GetWindowStruct, .hwin
  .user_data dd ?
begin
        lea     eax, [.user_data]
        cinvoke XFindContext, [hApplicationDisplay], [.hwin], win_structure_context, eax
        test    eax, eax
        jnz     .error

        mov     eax, [.user_data]
        clc
        return

.error:
        DebugMsg 'FreshLib: Error find context.'
        int3
endp




proc _SetWindowStruct, .hwin, .value
begin
        cinvoke XSaveContext, [hApplicationDisplay], [.hwin], win_structure_context, [.value]
        return
endp






proc RefreshWindow, .ptrobj
.event XExposeEvent
begin
        push    eax ebx ecx edx esi edi
        mov     ebx, [.ptrobj]

        lea     eax, [.event]
        mov     ecx, [hApplicationDisplay]
        mov     edx, [ebx+TWindow.handle]
        mov     [eax+XExposeEvent.type], Expose
        mov     [eax+XExposeEvent.display], ecx
        mov     [eax+XExposeEvent.window], edx

        cinvoke XSendEvent, ecx, edx, FALSE, ExposureMask, eax

        pop     edi esi edx ecx ebx eax eax
        return
endp


proc GetRaster, .pObj
begin
        stdcall IsObject, [.pObj], CWindow
        jc      .exit

        mov     eax, [.pObj]
        mov     eax, [eax+TWindow.handle]
        clc
.exit:
        return
endp

proc FreeRaster, .raster
begin
        return
endp

uglobal
  Application dd ?
endg


proc Run
begin

.mainloop:
        stdcall ProcessSystemEvents
        jc      .terminate

        mov     eax, [Application]
        test    eax, eax
        jz      .eventok

        cmp     [eax+TApplication.OnIdle], 0
        je      .eventok

        pushad
        stdcall [eax+TApplication.OnIdle], eax
        popad

.eventok:
        stdcall WaitForSystemEvent
        jmp     .mainloop

.terminate:
        return
endp





include '%TargetOS%/Main.asm'

tfChild  = 0
tfParent = 1
tfEnd    = 2


struct TObjTemplate
  .flags     dd  ?         ; tfParent; tfEnd
  .class     dd  ?
  .ptrVar    dd  ?         ; can be NULL
  .paramsize dd  ?
  .params:
ends


macro ObjTemplate  flags, class, name, [id, param] {
common
local ..paramsize, ..prms
      dd  flags
      dd  C#class
      dd  name
      dd  ..paramsize
..prms:
forward
local ..value
      dd  T#class#.#id
      dd  ..value
common
      dd  -1
forward
  if param eqtype 2
    ..value = param
  else
    ..value db param, 0
  end if
common
  name dd ?
  ..paramsize = $ - ..prms
}


; returns the last created window in ebx.

proc CreateFromTemplate, .ptrTemplate, .parent
begin
        push    esi

        mov     esi, [.ptrTemplate]
        stdcall _DoCreateFromTemplate, [.parent]

        pop     esi
        return
endp


proc _DoCreateFromTemplate, .parent
begin
        push    eax ecx edx

.createloop:

        stdcall Create, [esi+TObjTemplate.class], [.parent]

        lea     ecx, [esi+TObjTemplate.params]

.paramloop:
        cmp     dword [ecx], -1
        je      .paramsok

        push    ebx ecx edx esi edi
        stdcall Set, ebx, [ecx], [ecx+4]
        pop     edi esi edx ecx ebx
        add     ecx, 8
        jmp     .paramloop

.paramsok:
        mov     eax, [esi+TObjTemplate.ptrVar]
        test    eax, eax
        jz      .oncreate

        mov     [eax], ebx      ; returned pointer/handle to the object.

.oncreate:
        cmp     [ebx+TObject.OnCreate], 0
        je      .gonext

; execute user OnCreate event.
        pushad
        stdcall [ebx+TObject.OnCreate], ebx
        popad

.gonext:
        mov     edx, [esi+TObjTemplate.flags]

        mov     eax, sizeof.TObjTemplate
        add     eax, [esi+TObjTemplate.paramsize]
        add     esi, eax

        test    edx, tfParent
        jz      .childrenok

        push    ebx
        stdcall _DoCreateFromTemplate, ebx
        pop     ebx

.childrenok:
        test    edx, tfEnd
        jz      .createloop

.exit:
        pop     edx ecx eax
        return
endp

        ObjectClass Application,        \
            Object,                     \
            TApplication.Create,        \
            0,                          \
            TApplication.Get,           \
            TApplication.Set,           \
            TApplication.SysEventHandler

; The root object in the application.
; every other object will be child on the TApplication.MainWindow.
; only one instance of TApplication should be created.
;
object TApplication, TObject
  .MainWindow   dd ?
  .Accelerators dd ?    ; table of application wide hot keys.
  .OnIdle       dd ?    ; user event handler for idle state.
endobj


include '%TargetOS%/TApplication.asm'

ObjectClass Button,                     \
            Window,                     \
            0,                          \
            0,                          \
            TButton.Get,                \
            TButton.Set,                \
            TButton.SysEventHandler


; Button states for the field TButton.state
btnNormal    = 0
btnPressed   = 1
btnPointed   = 2
btnChecked   = 3



object TButton, TWindow
  .state      dd ?
  .icon       dd ?
  .Ftextalign dd ?

  .OnClick dd ?

  param .TextAlign
endobj



proc TButton.Get, .obj, .paramID
begin
        stdcall IsObject, [.obj], CButton
        jc      .exit

        cmp     [.paramID], TButton.OnClick
        je      .getonclick

        cmp     [.paramID], TButton.TextAlign
        je      .gettextalign

        stc
.exit:
        return

.gettextalign:
        mov     eax, [.obj]
        mov     eax, [eax+TButton.Ftextalign]
        clc
        return

.getonclick:
        mov     eax, [.obj]
        mov     eax, [eax+TButton.OnClick]
        clc
        return
endp




proc TButton.Set, .obj, .paramID, .value
begin
        push    eax
        cmp     [.paramID], TButton.OnClick
        je      .setonclick

        cmp     [.paramID], TButton.TextAlign
        je      .settextalign

        stc
        pop     eax
        return

.settextalign:
        mov     eax, [.obj]
        push    [.value]
        pop     [eax+TButton.Ftextalign]
        stdcall RefreshWindow, [.obj]
        clc
        pop     eax
        return

.setonclick:
        stdcall IsObject, [.obj], CButton
        jc      .exit

        mov     eax, [.obj]

        push    [.value]
        pop     [eax+TButton.OnClick]
        clc

.exit:
        pop     eax
        return
endp



proc TButton.SysEventHandler, .pObj, .pEvent
begin
        push    eax ebx ecx edx esi edi

        mov     esi, [.pObj]
        mov     ebx, [.pEvent]
        mov     eax, [ebx+TSysEvent.event]
        cmp     eax, sePaint
        je      .onpaint

        cmp     eax, seMouseEnter
        je      .enter
        cmp     eax, seMouseLeave
        je      .leave

        cmp     eax, seMouseBtnPress
        je      .pressed
        cmp     eax, seMouseBtnRelease
        je      .released

.finish:
        stc
        pop     edi esi edx ecx ebx eax
        return

.pressed:
        mov     [esi+TButton.state], btnPressed
        stdcall  RefreshWindow, esi
        jmp     .finish

.released:
        test    [ebx+TMouseButtonEvent.kbdStatus], maskBtnLeft or maskBtnMiddle or maskBtnRight
        jnz     .finish

        cmp     [esi+TButton.state], btnPressed
        jne     .finish

        mov     [esi+TButton.state], btnPointed
        stdcall RefreshWindow, esi

        cmp     [esi+TButton.OnClick], 0
        je      .finish

        pushad
        stdcall [esi+TButton.OnClick], esi, [ebx+TMouseButtonEvent.Button]
        popad
        jmp     .finish

.enter:
        mov     [esi+TButton.state], btnPointed
        stdcall  RefreshWindow, esi
        jmp     .finish

.leave:
        mov     [esi+TButton.state], btnNormal
        stdcall  RefreshWindow, esi
        jmp     .finish

.onpaint:
        stdcall Get, esi, TButton.width
        mov     ecx, eax
        stdcall Get, esi, TButton.height

        mov     edx, bxFlat
        cmp     [esi+TButton.state], btnNormal
        je      .drawit
        mov     edx, bxRaised
        cmp     [esi+TButton.state], btnPointed
        je      .drawit
        mov     edx, bxSunken
        cmp     [esi+TButton.state], btnPressed
        je      .drawit

        mov     edx, bxFlat

.drawit:
locals
 .bounds TBounds
endl
        stdcall DrawBox, [ebx+TPaintEvent.raster], 0, 0, ecx, eax, $c0c0c0, edx

        mov     [.bounds.x], 2
        mov     [.bounds.y], 2
        mov     [.bounds.width], ecx
        mov     [.bounds.height], eax
        sub     [.bounds.width], 4
        sub     [.bounds.height], 4

        stdcall Get, esi, TWindow.caption
        push    eax eax
        stdcall StrLen, eax
        mov     ecx, eax
        pop     eax
        lea     edx, [.bounds]
        stdcall DrawTextBox, [ebx+TPaintEvent.raster], eax, edx, [esi+TButton.Ftextalign], 0
        stdcall StrDel ; from the stack
        jmp     .finish
endp

; it is single line text edit widget for FreshLib

ObjectClass Edit,                       \
            Window,                     \
            TEdit.Create,               \
            TEdit.Destroy,              \
            TEdit.Get,                  \
            TEdit.Set,                  \
            TEdit.SysEventHandler


object TEdit, TWindow
  .Ftext dd ?

  param .Text
endobj


proc TEdit.Create, .obj, .parent
begin
        push    ecx eax
        stdcall StrNew
        mov     ecx, [.obj]
        mov     [ecx+TEdit.Ftext], eax

        mov     [ecx+TEdit.Fcursor], mcText
        pop     eax ecx
        clc
        return
endp


proc TEdit.Destroy, .obj
begin
        mov     eax, [.obj]
        stdcall StrDel, [eax+TEdit.Ftext]
        return
endp


proc TEdit.Get, .obj, .paramID
begin
        stdcall IsObject, [.obj], CEdit
        jc      .exit

        cmp     [.paramID], TEdit.Text
        je      .gettext

        stc
.exit:
        return

.gettext:
        mov     eax, [.obj]
        stdcall StrDup, [eax+TEdit.Ftext]
        clc
        return
endp




proc TEdit.Set, .obj, .paramID, .value
begin
        cmp     [.paramID], TEdit.Text
        je      .settext

        stc
        return

.settext:
        push    eax
        mov     eax, [.obj]
        lea     eax, [eax+TEdit.Ftext]
        stdcall SetString, eax, [.value]
        stdcall RefreshWindow, [.obj]
        pop     eax
        clc
        return
endp



proc TEdit.SysEventHandler, .pObj, .pEvent
begin
        push    eax ebx ecx edx esi edi

        mov     esi, [.pObj]
        mov     ebx, [.pEvent]
        mov     eax, [ebx+TSysEvent.event]

        cmp     eax, sePaint
        je      .onpaint

.finish:
        stc
        pop     edi esi edx ecx ebx eax
        return


.onpaint:
        stdcall Get, esi, TEdit.width
        mov     ecx, eax
        stdcall Get, esi, TEdit.height

locals
 .bounds TBounds
endl
        stdcall DrawBox, [ebx+TPaintEvent.raster], 0, 0, ecx, eax, $ffffff, bxSunken

        mov     [.bounds.x], 2
        mov     [.bounds.y], 2
        mov     [.bounds.width], ecx
        mov     [.bounds.height], eax
        sub     [.bounds.width], 4
        sub     [.bounds.height], 4

        stdcall Get, esi, TEdit.Text
        push    eax eax
        stdcall StrLen, eax
        mov     ecx, eax
        pop     eax
        lea     edx, [.bounds]
        stdcall DrawTextBox, [ebx+TPaintEvent.raster], eax, edx, dtfAlignLeft or dtfAlignTop, 0
        stdcall StrDel ; from the stack
        jmp     .finish
endp

ObjectClass Form,                       \
            Window,                     \
            0,                          \
            0,                          \
            TForm.Get,                  \
            TForm.Set,                  \
            TForm.SysEventHandler


borderNone  = 0
borderFull  = 1
borderModal = 2
borderToolbox = 3


object TForm, TWindow
  param .type
endobj



; OS independent code.

proc TForm.Get, .obj, .paramID
begin
        stc
        return
endp



proc TForm.Set, .obj, .paramID, .value
begin
        stc
        return
endp



proc TForm.SysEventHandler, .pObj, .pEvent
begin
        push    ebx esi
        mov     ebx, [.pEvent]
        cmp     [ebx+TSysEvent.event], sePaint
        je      .onpaint

.finish:
        stc
        pop     esi ebx
        return

.onpaint:
        mov     esi, [.pObj]
        stdcall Get, esi, TForm.width
        mov     ecx, eax
        stdcall Get, esi, TForm.height

        stdcall DrawFillRect, [ebx+TPaintEvent.raster], 0, 0, ecx, eax, $c0c0c0
        jmp     .finish
endp

ObjectClass TextLabel,       \
            Window,          \
            Create,          \
            0,               \
            TLabel.Get,      \
            TLabel.Set,      \
            TLabel.SysEventHandler


object TLabel, TWindow
  .border     dd  ?     ; border flags.
  .TextAline  dd  ?     ; text align flags.
  .control    dd  ?     ; pointer of some control, that to get focus if the labels hot key is pressed.
endobj

ObjectClass  Object,                    \
             Root,                      \
             0,                         \
             TObject.Destroy,           \
             0,                         \
             0,                         \
             0




object TObject
  .ptrClass     dd ?    ; pointer to the object class structure.

  .OnCreate     dd ?    ; user event handlers.
  .OnDestroy    dd ?
endobj




proc TObject.Destroy, .obj
begin
        push    eax
        mov     eax, [.obj]

        cmp     [eax+TObject.OnDestroy], 0
        je      .freeit

        pushad
        stdcall [eax+TObject.OnDestroy], eax
        popad

.freeit:
        stdcall FreeMem, eax
        pop     eax
        return
endp

ObjectClass Window,             \
            Object,             \
            TWindow.Create,     \
            TWindow.Destroy,    \
            TWindow.Get,        \
            TWindow.Set,        \
            TWindow.SysEventHandler


object TWindow, TObject

  .handle        dd ?   ; it is handle to the system provided window.
  .ChildIndex    dd ?   ; index of the one children. Used for reading particular children from Child parameter.

  .Fcaption     dd ?    ; string handle with window caption.
  .Fcursor      dd ?    ; it is a handle to the mouse cursor.

; parameters
  param .x
  param .y
  param .width
  param .height
  param .visible
  param .caption
  param .parent
  param .cursor
  param .ChildrenCount  ; read only. Returns the count of the children windows.
  param .SelectedChild  ; read only. Returns pointer to the TObject that is selected in .ChildIndex

endobj


; OS dependend code
include '%TargetOS%/TWindow.asm'



; OS independent code.

proc TWindow.SysEventHandler, .pObj, .pEvent
begin
        push    eax ebx ecx edx esi edi

        mov     esi, [.pObj]
        mov     ebx, [.pEvent]
        mov     eax, [ebx+TSysEvent.event]

        cmp     eax, seMouseEnter
        je      .mouseenter


.finish:
        stc
        pop     edi esi edx ecx ebx eax
        return

.mouseenter:
        mov     eax, [esi+TWindow.Fcursor]
        test    eax, $ffffff00
        jnz     .customcursor

        stdcall GetStockCursor, eax

.customcursor:
        stdcall SetMouseCursor, eax
        jmp     .finish
endp

proc ProcessSystemEvents
.msg MSG
begin
        push    eax ecx edx esi

.msgloop:
        lea     esi, [.msg]
        xor     eax, eax

        invoke  PeekMessage, esi, eax, eax, eax, PM_REMOVE
        test    eax, eax
        jz      .exitok

        cmp     [.msg.message], WM_QUIT
        je      .terminate

        stdcall __ProcessOneSystemEvent, [esi+MSG.hwnd], [esi+MSG.message], [esi+MSG.wParam], [esi+MSG.lParam]
        jnc     .msgloop                ; the message is translated to system event and the event is executed by the object SysEvent handler.

; the message is for window that is not an FreshLib object, so process with standard windows behaviour.
        invoke  TranslateMessage, esi
        invoke  DispatchMessage, esi
        jmp     .msgloop


.exitok:
        clc
        pop     esi edx ecx eax
        return


.terminate:
        mov     eax, [.msg.wParam]
        stc
        pop     esi edx ecx eax
        return
endp



proc WaitForSystemEvent
begin
        push    eax ecx edx
        invoke  WaitMessage
        pop     edx ecx eax
        return
endp



ExitApplication:
        push    eax
        FinalizeAll
        invoke  ExitProcess     ; from the stack.
        int3




;----------------------------------------------------------------------------------------------------------
; This procedure makes following:
;   1. Takes as arguments one windows message
;   2. Converts this message to FreshLib system event (or not, depending on the message)
;   3. Calls SysEventHandler procedures for the given object (if any) with the created event structure.
;   4. returns CF=0 if the event was properly processed.
;   5. returns CF=1 if the event was not processed.
;
; The event can be not processed in the following cases:
;   1. The window that receives the message is not FreshLib object.
;   2. TObjectClass.procSysEventHandler = 0 for the given class and all parents.
;   3. All procSysEventHandler procedures refuse to process the event (CF=1)
;----------------------------------------------------------------------------------------------------------
uglobal
  __LatestPointedObj dd ?
endg


winproc __ProcessOneSystemEvent
.event  rb 32
begin
        push    eax ebx ecx esi edi

        stdcall _GetWindowStruct, [.hwnd]
        test    eax, eax
        jz      .ondefault

        mov     esi, eax
        mov     ebx, [.wmsg]
        lea     edi, [.event]

ondefault
        pop     edi esi ecx ebx eax
        stc
        return

.finish:
        pop     edi esi ecx ebx eax
        clc
        return

onmessage WM_SETCURSOR

        movzx   eax, word [.lparam]
        cmp     eax, HTCLIENT
        jne     .ondefault

        mov     eax, [esi+TWindow.Fcursor]
        test    eax, $ffffff00
        jnz     .customcursor

        stdcall GetStockCursor, eax

.customcursor:
        stdcall SetMouseCursor, eax
        jmp     .finish


onmessage WM_MOUSEMOVE
        cmp     esi, [__LatestPointedObj]
        je      .normal_mouse_move

        mov     [edi+TMouseEnterEvent.event], seMouseLeave
        xchg    esi, [__LatestPointedObj]
        test    esi, esi
        jz      .leaveok
        stdcall ExecEvent, esi, edi

.leaveok:
        mov     esi, [__LatestPointedObj]
        mov     [edi+TMouseEnterEvent.event], seMouseEnter
        stdcall ExecEvent, esi, edi

.normal_mouse_move:
        mov     [edi+TMouseMoveEvent.event], seMouseMove
        movsx   eax, word [.lparam]
        movsx   ecx, word [.lparam+2]
        mov     [edi+TMouseMoveEvent.x], eax
        mov     [edi+TMouseMoveEvent.y], ecx
        stdcall ExecEvent, esi, edi
        jmp     .finish


onmessage WM_PAINT
locals
  .ps PAINTSTRUCT
endl
        lea     eax, [.ps]
        invoke  BeginPaint, [.hwnd], eax

        mov     [edi+TPaintEvent.event], sePaint
        push    [.ps.hdc]
        pop     [edi+TPaintEvent.raster]
        push    [.ps.rcPaint.left] [.ps.rcPaint.top]
        pop     [edi+TPaintEvent.rect.top] [edi+TPaintEvent.rect.left]
        push    [.ps.rcPaint.right] [.ps.rcPaint.bottom]
        pop     [edi+TPaintEvent.rect.bottom] [edi+TPaintEvent.rect.right]

        stdcall ExecEvent, esi, edi

        lea     eax, [.ps]
        invoke  EndPaint, [.hwnd], eax
        pop     edi esi ecx ebx eax
        clc
        return

onmessage WM_LBUTTONUP
onmessage WM_RBUTTONUP
onmessage WM_MBUTTONUP
onmessage WM_LBUTTONDOWN
onmessage WM_RBUTTONDOWN
onmessage WM_MBUTTONDOWN
onmessage WM_LBUTTONDBLCLK
onmessage WM_RBUTTONDBLCLK
onmessage WM_MBUTTONDBLCLK

        stdcall __MouseButton, [.wmsg]
        mov     [edi+TMouseButtonEvent.event], ecx
        mov     [edi+TMouseButtonEvent.Button], eax
        stdcall __KeyStatus, [.wparam]
        mov     [edi+TMouseButtonEvent.kbdStatus], eax

        stdcall ExecEvent, esi, edi
        jmp     .finish

onmessage WM_CHAR
onmessage WM_SYSCHAR

        jmp     .finish
endwp


proc __MouseButton, .msg
begin
        mov     eax, [.msg]
        sub     eax, WM_LBUTTONDOWN
        movzx   ecx, byte [__mouse_event_table+eax]
        movzx   eax, byte [__mouse_button_table+eax]
        return
endp


iglobal
  __mouse_button_table db mbLeft,        mbLeft,       mbLeft
                       db mbRight,       mbRight,      mbRight
                       db mbMiddle,      mbMiddle,     mbMiddle

  __mouse_event_table  db seMouseBtnPress, seMouseBtnRelease, seMouseBtnDblClick
                       db seMouseBtnPress, seMouseBtnRelease, seMouseBtnDblClick
                       db seMouseBtnPress, seMouseBtnRelease, seMouseBtnDblClick
endg

proc __KeyStatus, .status
begin
        xor     eax, eax
        test    [.status], MK_LBUTTON
        jz      @f
        or      eax, maskBtnLeft
@@:
        test    [.status], MK_RBUTTON
        jz      @f
        or      eax, maskBtnRight
@@:
        test    [.status], MK_MBUTTON
        jz      @f
        or      eax, maskBtnMiddle
@@:
        test    [.status], MK_SHIFT
        jz      @f
        or      eax, maskCtrl
@@:
        test    [.status], MK_CONTROL
        jz      @f
        or      eax, maskCtrl
@@:
        return
endp

uglobal
  hInstance dd ?
endg

initialize InitApplication
begin
        invoke  GetModuleHandle, 0
        mov     [hInstance], eax
        return
endp


proc TApplication.Create, .obj, .parent
begin
        clc
        return
endp


proc TApplication.Get, .obj, .paramID
begin
        clc
        return
endp


proc TApplication.Set, .obj, .paramID, .value
begin
        clc
        return
endp



proc TApplication.SysEventHandler, .obj, .event
begin
        clc
        return
endp

cWindowClassName text 'FreshWin'

nWindowExtraBytes = 32
ofsWindowStruct = nWindowExtraBytes - 4

;*********************************************************************************************
; Registers common window class
; Call only once
;*********************************************************************************************
initialize RegisterWindowClass

.wc WNDCLASS

begin
        xor     eax, eax
        lea     edi, [.wc]
        mov     ecx, sizeof.WNDCLASS / 4
        rep stosd

        mov     [.wc.style], CS_OWNDC or CS_DBLCLKS; or CS_VREDRAW or CS_HREDRAW
        mov     [.wc.lpfnWndProc], CommonWindowProc
        mov     [.wc.cbWndExtra], nWindowExtraBytes

        mov     eax,[hInstance]
        mov     [.wc.hInstance],eax
        mov     [.wc.lpszClassName], cWindowClassName

        lea     eax, [.wc]
        invoke  RegisterClass, eax

        return
endp




proc TWindow.Create, .obj, .parent
begin
        push    eax ebx
        mov     ebx, [.obj]
        mov     eax, [.parent]
        test    eax, eax
        jz      .parentok

        mov     eax, [eax+TWindow.handle]

.parentok:
        mov     ecx, WS_OVERLAPPEDWINDOW or WS_CLIPSIBLINGS or WS_CLIPCHILDREN
        test    eax, eax
        jz      .createit
        mov     ecx, WS_CHILDWINDOW or WS_CLIPSIBLINGS or WS_CLIPCHILDREN
.createit:
        invoke  CreateWindowEx, 0, cWindowClassName, 0, ecx, 0, 0, 0, 0, eax, 0, 0, 0
        mov     [ebx+TForm.handle], eax

        stdcall _SetWindowStruct, eax, ebx

        pop     ebx eax
        clc
        return
endp





proc TWindow.Destroy, .obj
begin
        push    eax
        stdcall IsObject, [.obj], CWindow
        jc      .exit
        mov     eax, [.obj]
        invoke  DestroyWindow, [eax+TWindow.handle]
.exit:
        pop     eax
        return
endp



proc TWindow.Get, .obj, .paramID
.rect RECT
begin
        stdcall IsObject, [.obj], CWindow
        jc      .fault

        push    ecx edx esi ebx

        mov     esi, [.obj]
        mov     eax, [.paramID]

        test    eax, maskParameter
        jz      .field

        cmp     eax, TWindow.x
        je      .getrect
        cmp     eax, TWindow.y
        je      .getrect
        cmp     eax, TWindow.width
        je      .getrect
        cmp     eax, TWindow.height
        je      .getrect

        cmp     eax, TWindow.visible
        je      .getvisible

        cmp     eax, TWindow.caption
        je      .getcaption

        cmp     eax, TWindow.ChildrenCount
        je      .childrencount

        cmp     eax, TWindow.SelectedChild
        je      .getchild

.fault:
        stc
        return

.field:
        mov     ebx, [.paramID]
        mov     eax, [esi+ebx]

.finish:
        clc
        pop     ebx esi edx ecx
        return


.childrencount:
        push    ecx edx
        xor     ebx, ebx
        invoke  GetWindow, [esi+TWindow.handle], GW_CHILD

.loopchild:
        test    eax, eax
        jz      .endchild

        inc     ebx

        invoke  GetWindow, eax, GW_HWNDNEXT
        jmp     .loopchild

.endchild:
        mov     eax, ebx
        jmp     .finish

.getchild:
        mov     ebx, [esi+TWindow.ChildIndex]

        invoke  GetWindow, [esi+TWindow.handle], GW_CHILD

.loopchild2:
        test    eax, eax
        jz      .endchild2
        dec     ebx
        jz      .endchild2

        invoke  GetWindow, eax, GW_HWNDNEXT
        jmp     .loopchild2

.endchild2:
        stdcall _GetWindowStruct, eax
        jmp     .finish


.getcaption:
        stdcall StrDup, [esi+TWindow.Fcaption]
        jmp     .finish

.getvisible:
        invoke  IsWindowVisible, [esi+TWindow.handle]
        jmp     .finish


.getrect:
        lea     ebx, [.rect]
        invoke  GetWindowRect, [esi+TWindow.handle], ebx
        invoke  GetParent, [esi+TWindow.handle]
        invoke  MapWindowPoints, NULL, eax, ebx, 2

        mov     eax, [.rect.right]
        mov     ebx, [.rect.bottom]
        sub     eax, [.rect.left]
        sub     ebx, [.rect.top]
        mov     [.rect.right],eax
        mov     [.rect.bottom], ebx

        mov     eax, [.paramID]
        sub     eax, TWindow.x
        mov     eax, [.rect+4*eax]

        jmp     .finish
endp



proc TWindow.Set, .obj, .paramID, .value
  .rect RECT
begin
        stdcall IsObject, [.obj], CWindow
        jc      .fault

        mov     esi, [.obj]
        mov     eax, [.paramID]

        test    eax, maskParameter
        jz      .field

        cmp     eax, TWindow.x
        je      .setrect
        cmp     eax, TWindow.y
        je      .setrect
        cmp     eax, TWindow.width
        je      .setrect
        cmp     eax, TWindow.height
        je      .setrect

        cmp     eax, TWindow.visible
        je      .setvisible

        cmp     eax, TWindow.caption
        je      .setcaption

.fault:
        stc
        return

.field:
        pushd   [.value]
        popd    [esi+eax]
        clc
        return


.setcaption:
        lea     eax, [esi+TWindow.Fcaption]
        stdcall SetString, eax, [.value]
        stdcall StrPtr, [eax]

        invoke  SendMessage, [esi+TWindow.handle], WM_SETTEXT, 0, [.value]
        clc
        return

.setvisible:
        invoke  ShowWindow, [esi+TWindow.handle], [.value]
        clc
        return

.setrect:
        push    ebx

        lea     ebx, [.rect]
        invoke  GetClientRect, [esi+TWindow.handle], ebx

        invoke  GetParent, [esi+TWindow.handle]
        invoke  MapWindowPoints, [esi+TWindow.handle], eax, ebx, 2

        invoke  GetWindowLong, [esi+TWindow.handle], GWL_EXSTYLE
        push    eax
        push    FALSE
        invoke  GetWindowLong, [esi+TWindow.handle], GWL_STYLE
        push    eax

        mov     eax, [.rect.right]
        mov     ecx, [.rect.bottom]
        sub     eax, [.rect.left]
        sub     ecx, [.rect.top]
        mov     [.rect.right], eax
        mov     [.rect.bottom], ecx

        mov     eax, [.paramID]
        sub     eax, TWindow.x
        push    [.value]
        popd    [.rect+4*eax]

        mov     eax, [.rect.left]
        mov     ecx, [.rect.top]
        add     [.rect.right], eax
        add     [.rect.bottom], ecx

        invoke  AdjustWindowRectEx, ebx ; and from the stack

        mov     eax, [.rect.right]
        mov     ecx, [.rect.bottom]
        sub     eax, [.rect.left]
        sub     ecx, [.rect.top]

        invoke  MoveWindow, [esi+TWindow.handle], [.rect.left], [.rect.top], eax, ecx, TRUE

        pop     ebx
        clc
        return
endp









; Common utility procedures.


;---------------------------------------------------------------
; Returns the window TObject structure, from the window handle.
;---------------------------------------------------------------
proc _GetWindowStruct, .hwin
begin
        push    ecx edx
        invoke  GetWindowLong, [.hwin], ofsWindowStruct
        pop     edx ecx
        return
endp




proc _SetWindowStruct, .hwin, .value
begin
        push    eax ecx edx
        invoke  SetWindowLong, [.hwin], ofsWindowStruct, [.value]
        pop     edx ecx eax
        return
endp





proc CommonWindowProc, .hwnd, .wmsg, .wparam, .lparam
begin
        stdcall __ProcessOneSystemEvent, [.hwnd], [.wmsg], [.wparam], [.lparam]         ; sometimes windows calls winproc directly instead of using postmessage.
        jnc     .finish

        invoke  DefWindowProc, [.hwnd], [.wmsg], [.wparam], [.lparam]

.finish:
        return
endp




proc RefreshWindow, .ptrobj
begin
        push    eax
        mov     eax, [.ptrobj]

        invoke  RedrawWindow, [eax+TWindow.handle], 0, 0, RDW_INVALIDATE

        pop     eax
        return
endp



proc GetRaster, .pObj
begin
        push    ecx edx
        stdcall IsObject, [.pObj], CWindow
        jc      .exit

        mov     eax, [.pObj]
        invoke  GetDC, [eax+TWindow.handle]
        clc
.exit:
        pop     edx ecx
        return
endp

proc FreeRaster, .raster
begin
        push    eax ecx edx
        invoke  ReleaseDC, [.raster]
        pop     edx ecx eax
        return
endp

struct TObjectClass
  .ptrParent        dd 0   ; pointer to the parent TObjectClass
  .dataSize         dd 0   ; size of TObject structure.
  .procCreate       dd 0
  .procDestroy      dd 0
  .procGetParam     dd 0
  .procSetParam     dd 0
  .procSysEventHandler dd 0
ends



macro ObjectClass name*, parent*, procCreate*, procDestroy*, procGetParam*, procSetParam*,  procSysEvents* {
  if used C#name
    C#name TObjectClass
    store dword C#parent at C#name#.ptrParent
    store dword sizeof.T#name at C#name#.dataSize
    store dword procCreate at C#name#.procCreate
    store dword procDestroy at C#name#.procDestroy
    store dword procGetParam at C#name#.procGetParam
    store dword procSetParam at C#name#.procSetParam
    store dword procSysEvents at C#name#.procSysEventHandler
  end if
}



CRoot = 0

maskParameter = $80000000
Sequence param, maskParameter


macro object name*, parent {
  macro name@object \{ name name \}
  macro size@object \{ sizeof.#name = $ \}
  struc name \{
    param.current = maskParameter
    if ~parent eq
      . parent
    end if
}


endobj fix } obj_helper

macro obj_helper {
  virtual at 0
    name@object
    size@object
  end virtual
  purge name@object
  purge size@object
}


; common object procedures
; These procedures work with every TObject descendent object type.

;-----------------------------------------------------------------------
; proc Get, .obj, .paramID - returns the value of given parameter
;
; Arguments:
;   .obj - pointer to TObject descendent object.
;   .paramID - ID number of the parameter being read.
; Returns:
;   CF=0; eax = parameter value.
;   CF=1; the parameter is unknown and can not be retrived.
;
; This procedure calls procGet for the given object class and
; if the procedure returns CF=1; tries to call the parents procedure
; procGet, until the value is retrived, or the root level of inheritance
; is reached.
;-----------------------------------------------------------------------

proc Get, .obj, .paramID
begin
        push    ebx

        mov     ebx, [.obj]
        test    ebx, ebx
        jz      .error

        mov     ebx, [ebx+TObject.ptrClass]

.loop:
        cmp     [ebx+TObjectClass.procGetParam], 0    ; get GetParam procedure pointer
        je      .parent

        push    ebx
        stdcall [ebx+TObjectClass.procGetParam], [.obj], [.paramID]
        pop     ebx
        jnc     .exit

.parent:
        mov     ebx, [ebx+TObjectClass.ptrParent]
        test    ebx, ebx
        jnz     .loop

.error:
        stc
.exit:
        pop     ebx
        return
endp




;-----------------------------------------------------------------------
; proc Set, .obj, .paramID - sets the value of given parameter
;
; Arguments:
;   .obj - pointer to TObject descendent object.
;   .paramID - ID number of the parameter being read.
;   .value   - value of the parameter that should be set.
; Returns:
;   CF=0 - the value is successfully set.
;   CF=1; the value is not set, because the parameter is unknown.
;
; This procedure calls procSet for the given object class and
; if the procedure returns CF=1; tries to call the parents procedures
; procSet, until the value is set, or the root level of inheritance
; is reached.
;-----------------------------------------------------------------------
proc Set, .obj, .paramID, .value
begin
        push    ebx

        mov     ebx, [.obj]
        test    ebx, ebx
        jz      .error

        mov     ebx, [ebx+TObject.ptrClass]

.loop:
        cmp     [ebx+TObjectClass.procSetParam], 0    ; get SetParam procedure pointer
        je      .parent

        push    ebx
        stdcall [ebx+TObjectClass.procSetParam], [.obj], [.paramID], [.value]
        pop     ebx
        jnc     .exit

.parent:
        mov     ebx, [ebx+TObjectClass.ptrParent]
        test    ebx, ebx
        jnz     .loop

.error:
        stc
.exit:
        pop     ebx
        return
endp


;-----------------------------------------------------------------------
; proc Destroy, .obj - destroys the object instance.
;
; Arguments:
;   .obj - pointer to TObject descendent object.
;
; Returns:
;   nothing.
;
; This procedure calls procDestroy for the given object class and all
; parent classes. Note that the memory is freed only by the last
; destroy handled from CObject class.
;-----------------------------------------------------------------------
proc Destroy, .obj
begin
        push    ebx

        mov     ebx, [.obj]
        test    ebx, ebx
        jz      .error

        mov     ebx, [ebx+TObject.ptrClass]

.loop:
        cmp     [ebx+TObjectClass.procDestroy], 0
        je      .parent

        push    ebx
        stdcall [ebx+TObjectClass.procDestroy], [.obj]
        pop     ebx

.parent:
        mov     ebx, [ebx+TObjectClass.ptrParent]
        test    ebx, ebx
        jnz     .loop

        clc
        pop     ebx
        return

.error:
        stc
        pop     ebx
        return
endp



;-----------------------------------------------------------------------
; proc Create, .class, .lparam - creates an instance from the given class.
;
; Arguments:
;   .class - pointer to TObjectClass structure for needed object.
;   .lparam - additional parameter. For the object created from templates
;             it is the parent object from the template tree.
;
; Returns:
;   ebx = pointer to the instance of the object.
;
; This procedure calls procCreate for the given object class and all
; parent classes in reverce order.
;-----------------------------------------------------------------------
proc Create, .class, .lparam
begin
        push    eax ecx

        mov     ecx, [.class]
        stdcall GetMem, [ecx+TObjectClass.dataSize]
        mov     ebx, eax
        mov     [eax+TObject.ptrClass], ecx

        push    0

.loop:
        cmp     [ecx+TObjectClass.procCreate], 0
        je      .parent

        push    [ecx+TObjectClass.procCreate]

.parent:
        mov     ecx, [ecx+TObjectClass.ptrParent]
        test    ecx, ecx
        jnz     .loop

.loop2:
        pop     ecx
        jecxz   .endcreate

        push    ebx
        stdcall ecx, ebx, [.lparam]
        pop     ebx
        jmp     .loop2

.endcreate:
        pop     ecx eax
        return
endp




;-----------------------------------------------------------------------
; proc ExecEvent, .obj, .event, .inherited
; Arguments:
;   .obj - pointer to the TObject descendent object.
;   .class - pointer to TObjectClass structure that to be used for
;            event handler. if NULL, the native class of .obj is used.
;            this argument is used when there is a need to be called
;            some of the inherited event handlers.
;   .event - pointer to TSysEvent descendent structure.
;-----------------------------------------------------------------------
proc ExecEvent, .obj, .event
begin
        push    ebx

        mov     ebx, [.obj]
        test    ebx, ebx
        jz      .error

        mov     ebx, [ebx+TObject.ptrClass]

.loop:
        cmp     [ebx+TObjectClass.procSysEventHandler], 0    ; get SetParam procedure pointer
        je      .parent

        push    ebx
        stdcall [ebx+TObjectClass.procSysEventHandler], [.obj], [.event]
        pop     ebx
        jnc     .exit

.parent:
        mov     ebx, [ebx+TObjectClass.ptrParent]
        test    ebx, ebx
        jnz     .loop

.error:
        stc

.exit:
        pop     ebx
        return
endp




;-----------------------------------------------------------------------
; proc IsObject, .class - returns TRUE if the given object belongs to
;                         the given class.
;-----------------------------------------------------------------------
proc IsObject, .obj, .class
begin
        push    edx

        mov     edx, [.obj]
        test    ebx, ebx
        jz      .error

        mov     edx, [edx+TObject.ptrClass]

.loop:
        cmp     edx, [.class]
        je      .found

        mov     edx, [edx+TObjectClass.ptrParent]
        test    edx, edx
        jnz     .loop

.error:
        stc
        pop     edx
        return

.found:
        clc
        pop     edx
        return
endp

macro JumpList [id, target] {
  forward
        dw id, target - $ - 2
  common
        dd 0
}

macro JumpTable [id, target] {
if ~ msg eq
      call JumpTo
      JumpList msg, target
end if
}


;------------------------------------------------------
; proc JumpTo
; Searches for the message in the message table.
; Arguments:
;   ebx - message number to search in the table.
; Returns:
;   This procedure doesn't returns. It simply
;   jumps to the address from table or imediately
;   after the table if the message is not found.
;   in both cases esi = eip
; Changes:
;   eax, ecx
;------------------------------------------------------
proc JumpTo
begin
        pop     ecx             ; get table address, remove return address from the stack and save the value of esi.
.loop:
        mov     eax, [ecx]
        lea     ecx, [ecx+4]
        test    eax,eax
        jz      .exit

        cmp     bx, ax
        jne     .loop

        sar     eax, 16
        add     ecx, eax
.exit:
        jmp     ecx
endp

seMouseMove        = $0001
seMouseEnter       = $0002
seMouseLeave       = $0003
seMouseBtnPress    = $0004
seMouseBtnRelease  = $0005
seMouseBtnClick    = $0006
seMouseBtnDblClick = $0007
seTimer            = $0008
seKbdKeyPress      = $0009
seKbdKeyRelease    = $000a
seKbdStatusChanged = $000b
seKbdChar          = $000c
sePaint            = $0100


struct TSysEvent
  .event  dd  ?
ends


struct TMouseMoveEvent
  . TSysEvent
  .x         dd ?
  .y         dd ?
ends

mbLeft   = 0
mbMiddle = 1
mbRight  = 2

maskBtnLeft   = $01
maskBtnMiddle = $02
maskBtnRight  = $04
maskCtrl      = $08
maskShift     = $10


struct TMouseButtonEvent
  . TSysEvent
  .Button    dd ?
  .kbdStatus dd ?
ends


struct TMouseEnterEvent
  . TSysEvent
ends


struct TKeyboardEvent
  . TSysEvent
  .key       dd  ?
  .kbdStatus dd  ?
ends


struct TTimerEvent
  . TSysEvent
ends


struct TPaintEvent
  . TSysEvent

  .raster dd ?  ; ID of the raster where you should paint.
  .rect   RECT
ends

FreshLib library project is (c) 2003..2013, John Found, Fresh development team;
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright notice, this
    list of conditions and the following disclaimer in the documentation and/or
    other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.

include 'compiler/executable.inc'

include 'macros/allmacros.inc'
include 'equates/allequates.inc'


_BinaryType GUI


_CodeSection


include  'simpledebug/debug.asm'

include 'GUI/SysEvents.asm'

include 'system/memory.asm'
include 'system/files.asm'
include 'data/arrays.asm'
include 'data/strlib.asm'

include 'graphics/text.asm'
include 'graphics/draw.asm'
include 'graphics/images.asm'
include 'graphics/giflib.asm'
include 'mouse/mouse.asm'

include 'GUI/GUI.asm'


options.FastEnter         = 0
options.ShowSkipped       = 0
options.CheckArguments    = 0
options.ShowSizes         = 1


iglobal

; This is a form template.
; It will be created by the visual editor.
; This template engine can contains any count of properties for every
; component of the template. Also it can contains non visual components
; such as action lists, image lists, etc.

frmMainForm:
        ObjTemplate  tfParent or tfEnd, Form, frmMain, \
                     visible, TRUE, \
                     x, 100,        \
                     y, 50,         \
                     width, 640,    \
                     height, 480,   \
                     caption, 'Fresh portable Win32/Linux application test.'

          ObjTemplate  tfChild, Button, btnChild1,          \
                     visible, TRUE, \
                     x, 64,         \
                     y, 48,         \
                     width, 64,     \
                     height, 24,    \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle or dtfCRLF or dtfWordWrap,\
                     caption, 'Button1',        \
                     OnClick, Button1Click

          ObjTemplate  tfChild, Button, btnChild3,          \
                     visible, TRUE, \
                     x, 64,         \
                     y, 80,         \
                     width, 64,     \
                     height, 48,    \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle or dtfWordWrap,\
                     caption, 'Destroy the edit',        \
                     OnClick, Button3Click

          ObjTemplate  tfChild, Edit, editChild1,          \
                     visible, TRUE, \
                     x, 32,         \
                     y, 8,         \
                     width, 220,     \
                     height, 19,    \
                     caption, 'Edit1',        \
                     Text, 'This is example edit'

         ObjTemplate  tfChild or tfEnd, Button, btnChild2,          \
                     x, 136,         \
                     y, 48,         \
                     width, 202,     \
                     height, 202,        \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle or dtfCRLF or dtfWordWrap,\
                     caption, <'Facer percipit eam at, quod deterruisset mel te! Integre complectitur concludaturque an pri, te congue',        \
                               ' albucius dissentias ius, mel erat exerci contentiones ut. Congue aeterno aliquando mea ea. Brute tritani an',  \
                               ' eos, ea cum urbanitas adolescens! Ei pro fuisset accusamus, ad ludus tractatos erroribus per, esse exerci',    \
                               ' persecuti eos et. Ea eam tempor intellegebat, vitae semper pri no! Eam ea iisque eruditi detracto, velit',     \
                               ' commodo similique pri cu. Eam wisi augue dolore no, cum ut habemus voluptua abhorreant, vis feugiat saperet ex.',\
                               ' Cum ne modo dicunt, quo ad malis pericula urbanitas. Et eum saperet accusata, pro simul tamquam salutandi ea'>,\
                     visible, TRUE,  \
                     OnClick, Button2Click
endg



; Sample event handlers. They work with other objects on the form.


proc Button3Click, .self, .button
begin
        DebugMsg 'Button3 clicked'
        stdcall Destroy, [editChild1]   ; it is safe to call it with [.obj]=0
        mov     [editChild1], 0
        return
endp




proc Button1Click, .self, .button
begin
        DebugMsg 'Button1 clicked'

;        stdcall Get, [btnChild2], TButton.TextAlign
;        mov     ecx, eax
;        and     ecx, not $03
;        inc     eax
;        and     eax, 3
;        or      eax, ecx
;        stdcall Set, [btnChild2], TButton.TextAlign, eax
;
;        stdcall Get, [btnChild1], TButton.caption
;        stdcall Set, [editChild1], TEdit.Text, eax
;        stdcall StrDel, eax

iglobal
  cGifFile file '_test_images/test.gif'
  sizeof.cGifFile = $ - cGifFile
endg

        stdcall CreateImageGIF, cGifFile, sizeof.cGifFile
        mov     esi, eax

        stdcall OutputRegister, regEAX, 16

        stdcall GetRaster, [btnChild2]
        push    eax

        stdcall DrawImage, eax, esi, 1, 1

        stdcall FreeRaster ; from the stack
        stdcall DestroyImage, esi
        return
endp



proc Button2Click, .self, .button
begin
        DebugMsg 'Button2 clicked'

        stdcall Get, [btnChild1], TButton.TextAlign
        mov     ecx, eax
        and     ecx, not $0c
        add     eax, 4
        and     eax, $0c
        or      eax, ecx

        stdcall Set, [btnChild1], TButton.TextAlign, eax

        stdcall Get, [btnChild2], TButton.caption
        stdcall Set, [editChild1], TEdit.Text, eax
        stdcall StrDel, eax

        return
endp






; Main Program
start:
        InitializeAll

        stdcall Create, CApplication, 0
        jc      .start_error

        mov     [Application], ebx

        stdcall CreateFromTemplate, frmMainForm, 0
        mov     ecx, [Application]
        mov     [ecx+TApplication.MainWindow], ebx


DebugMsg 'After initializing.'

        stdcall Run
DebugMsg 'Just before end.'
        jmp     ExitApplication

.start_error:
        mov     eax, 1
        jmp     ExitApplication
; end of main program


_ImportSection

GlobalAPI equ ascii
include 'imports/allimports.asm'

_DataSection
IncludeAllGlobals

Legend:

[+] - Fully implemented (more or less).
[?] - Partially implemented/work in progress.
[ ] - Not even started.

Needed GUI controls in order to start work on Fresh IDE 3.0:

  [+]   TForm
  [+]   TSplitGrid
  [+]   TAction (and Action lists)
  [+]   TButton
  [+]   TCheckbox
  [?]   TTreeView
  [ ]   TabControl
  [?]   TSourceEditor
  [ ]   TToolbar
  [?]   TMenu
  [ ]   TMenuBar
  [ ]   TStatusbar
  [+]   TProgressbar
  [ ]   TListView, TListbox or other kind of table/grid control with columns.
  [+]   TEdit - line editor
  [ ]   THint

  [+]   General message dialog.
  [ ]   Open/Save dialogs.
  [ ]   Color selection dialog. (not so important).
  [ ]   Font select dialog. (not so important).

<table class="index" align="right">
<tr><td class="index">
<b>Index</b><br>
[http://fresh.flatassembler.net | Fresh home]<br>
[FreshLib reference | FreshLib reference]<br>
[Fresh user guide | Fresh tips&tricks]<br>
</td></tr>
</table>

Fresh is a visual assembly language IDE with built-in FASM assembler.

The main goal of Fresh is to make programming in assembly as fast and
efficient as in other visual languages, without sacrificing the small
application size and the raw power of assembly language.

Because Fresh is the logical continuation of the FASM project in the
area of visual programming, it is perfectly compatible with FASM and you
can use all your knowledge about FASM to program in Fresh.

Of course, you can use Fresh not only for Windows programming, but also
to create programs for any OS that FASM supports - DOS, Linux, FreeBSD,
BeOS, MenuetOS - the same way as you do this in FASM.

Now, the main direction of Fresh development is towards creating FreshLib - freely portable library, that to
provide portability for Fresh and programs created with Fresh to number of different OSes. 
Initially for Win32 and Linux.

This site is [http://www.fossil-scm.org|fossil] repository of Fresh sources.
You can clone the repository with following fossil command:
<pre><b>fossil clone http://chiselapp.com/user/johnfound/repository/FreshIDE/ Fresh.fossil</b></pre>

In order to use more functionality in this site, please [/login|login] as "anonimous" user.
Particularly you will be able to follow the links in the source tree, to download code and to fill bug reports and feature requests.

If you want to contribute to the project, please contact me (johnfound) on [http://board.flatassembler.net|FASM message board]

In order to download compiled FreshIDE, visit [http://fresh.flatassembler.net|Fresh IDE home page.]

You can report bugs, or make some feature requests here, in the [/reportlist|Tickets system]

<h4>Running and debugging Linux applications in Windows with Fresh IDE</h4>

Fresh can compile applications for Linux. But how to run and debug these applications? 

There are different approaches, including virtual machines, second computer, running Linux, or rebooting every time you want to test compiled project.

Fresh provides one very simple way of testing Linux applications. This method is to use [http://andlinux.org|andLinux]. andLinux is complete Ubuntu distribution, that uses coLinux kernel in order to allow running of Linux inside Windows OS.

How to setup andLinux to work with Fresh?

  <b>Step 1.</b> Download andLinux package from [http://andlinux.org/downloads.php|andLinux download page].

  There are two packages: "KDE version" and "minimal/XFCE version" available. For using with Fresh IDE, it is not important what version you will choose.

  KDE package is very big and very slow distribution that contains many bundled programs and tools, but in general you will not need them. The size of KDE package is 500MB download and 5GB installed.

  The XFCE package is relatively smaller and faster. Relatively means 200MB downloaded file and 2GB installed on the disk.

  It is obvious that the right choice is to use XFCE package.

  <b>Step 2.</b> Run the downloaded setup file and answer to the different questions of the setup wizard.

  The important features that we need are:

  *  coLinux version - choose the stable version (0.7.4 in my case) instead of latest (0.8.0) - we shall work with andLinux, not to play.

  *  Memory size - 256MB RAM (or maybe more - if you can afford it).

  *  Install XMing server on your primary screen.

  *  Sound - you can enable or disable sound in Linux option - it is harmless although it is one more running server.

  *  Startup type + Panel - select "run andLinux automatically as a NT service + use Windows shortcuts"; It is not very important, but can save you a little manual work and troubles later.

  *  andLinux login - just select your user name and password for Linux root.

  *  Windows File Access - it is important! - select "using CoFS", no matter it is not recommended.

  * File Access Using CoFS - important! - create one new directory somewhere and select it to be mount via CoFS. This will be the shared directory, visible from Windows and from Linux in the same time.

  All other features you can choose freely or simply leave them to default state.

  When you start installation, the installer will try to install network driver. It is possible Windows will protest and will atempt to mislead you by asking to not install not certified driver. You must ignore these attempts and firmly click "install".

  After installation of andLinux you have to restart Windows and probably andLinux will not run. :D It is because of the Windows firewall. All new network adapters are firewalled by default. As long as installed adapter (named TAP-Colinux) is virtual and local, you will not need any firewall so, go to control panel/Windows firewall/Advanced and uncheck "TAP-Colinux" adapter from the list of adapters.

  Then you can run some Linux program - in the Windows tray, there is a andLinux menu icon that have shortcuts to several Linux programs.

  <b>Step 3.</b> Install several additional Linux tools. You will need additionally debugger and come decent terminal emulator. I choose xterm for terminal, because it is small and white by default. ;) You can choose to use the built-in terminal named in the simple Linux manner: "xfce4-terminal" and console debugger "gdb". In this case you have skip this step.

  Start "Synaptic" - package manager for Ubuntu from the tray menu. You have to enter root password you choose on install.

  When Synaptic is started, click "Reload" to refresh the package list from the network and then use search to locate needed programs. I personally recommend "xterm" as terminal and "ddd" as a GUI front end to "gdb". 

  Well, I recommend "ddd" only because it is only Linux debugger that I was able to run under andLinux and able to show disassembled code of the program.
  
  Mark selected programs for install, click on Apply button and wait until downloading and installation. 

  Here you can encounter only one problem - your computer is behind a proxy server. 
  
  If the proxy is normal proxy, you simply have to set its address and port in the Synaptic preferences and it should work. 

  Completely another story is when the proxy is MS ISA server configured with NTLM user authorization. 

  Most Linux programs can't work with such authorization and Synaptic is not an exception.

  Fortunately, there is a workaround of this situation. You need [http://ntlmaps.sourceforge.net/|ntlmaps] authorization proxy server. 
  
  Setting up of this server is out of the scope of this article. On the ntlmaps home page you can read complete documentation and explanations.

  OK, we are ready with andLinux. Now you have working copy of Ubuntu inside your Windows box.

  It's time to configure Fresh to run Linux applications inside andLinux. Continue with:

  <b>Step 4.</b> Fresh IDE configuration.

  Run Fresh and open "Options|IDE options" dialog. Select "Debuggers and Emulators" page.

  Then select following directories and commands: 
  
  *  "andLinux directory" - the directory where you installed andLinux.

  *  "andLinux shared directory" - shared directory you selected during andLinux installation.

  *  "Linux debugger" - Enter "ddd" (or whatever debugger you choose).

  *  "Linux terminal" - Enter "xterm -hold +mesg -e" - note the options. 

  <h4>And voila! You finished the configuration!</h4>

  Now you can load the source of some Linux program (look at Fresh examples) and run it with shift+F9 or load it in the debugger with shift+F8. 
  
  Fresh will detect when you compiled ELF executable and will run it in andLinux instead of Windows.

<nowiki>

<a name="GUI"><h1>FreshLib directory: GUI</h1></a>

<p>GUI library defines many data structures and procedures that together form
something that conditionally can be called "OOP". It is object oriented, as
long as it deals with GUI "objects" - forms, controls, menus etc.
All these objects are in fact structures of data. For every created object,
the library allocates some memory and fills this memory with object parameters
data.</p>

<p>There are two types of data structures that describe GUI objects - classes
and instances.</p>

<p>The class is a structure that contains data commonly used by all objects of given type - for example all buttons use one class structure CButton.</p>

<p>The instance is data structure that describes the properties and behavior of particular GUI object - for example button with icon "open file" that opens a file when the user click on it.</p>

<a name="Classes"><h2>Classes</h2></a>

<p>"Class" in FreshLib is a data structure, that have the following definition:</p>

<pre class="fasm-code">
struct TObjectClass
  .ptrParent           dd 0   
  .dataSize            dd 0   
  .procCreate          dd 0
  .procDestroy         dd 0
  .procGetParam        dd 0
  .procSetParam        dd 0
  .procExecCmd         dd 0
  .procSysEventHandler dd 0
ends
</pre>

<p><span class="variable">.ptrParent</span> is a pointer to other TObjectClass structure, that appears as a parent class for the given class.</p>
<p><span class="variable">.dataSize</span> contains the size of the object instance structure.</p>

<p>The following fields are the pointers to procedures that provides the "work" of the object. All of these pointers as a rule can be <span class="constant">NULL</span>, if there is no need for such processing.</p>

<a name="Create"><h4>Create</h4></a>
<p><span class="variable">.procCreate</span> is a procedure that creates instance object of the given class. This 
field can be <span class="constant">NULL</span>. It has the following definition:</p>
<pre class="fasm-code">
proc Create, .obj
</pre>
<p>This procedure sets needed values in the object instance data structure.</p>

<a name="Destroy"><h4>Destroy</h4></a>
<p><span class="variable">.procDestroy</span> is a procedure that destroys an instance of the given class.</p>
<pre class="fasm-code">
proc Destroy, .obj
</pre>
<p>Destroys the object passed in <span class="variable">[.obj]</span> and frees all memory allocated for this object.</p>

<a name="GetParam"><h4>GetParam</h4></a>
<p><span class="variable">.procGetParam</span> is a pointer to the procedure that retrieves and returns the properties of the object.</p>
<pre class="fasm-code">
proc GetParam, .obj, .paramID
</pre>
<p>Returns the value of the object <span class="variable">[.obj]</span> parameter with ID=<span class="variable">[.paramID]</span></p>

<a name="Set"><h4>Set</h4></a>
<p><span class="variable">.procSetParam</span> is a pointer to the procedure that set the properties of the object.</p>
<pre class="fasm-code">
proc Set, .obj, .paramID, .value
</pre>
<p>For object <span class="variable">[.obj]</span>, set the value of the parameter with ID=<span class="variable">[.paramID]</span></p>

<h4>ExecCmd</h4>
<p><span class="variable">.procExecCmd</span> is a pointer to the procedure that executes object method.</p>
<pre class="fasm-code">
proc ExecCmd, .obj, .method
</pre>
<p>For the object [.obj] this procedure executes the method with method ID in [.method].</p>
<p>The methods can have arbitrary number of arguments, that are defined in the "object" definition (see below). 
When the method is executed, the procedure <span class="procedure">[.procExecCmd]</span> accepts pointer to the arguments array in <span class="register">[ebx]</span></p>
<p>The user is supposed to call methods of the object with the macro "execute"
The macro is defined following way:</p>
<pre class="fasm-code">
macro execute obj*, meth*, [arg]
</pre>


<a name="SysEventHandler"><h4>SysEventHandler</h4></a>
<p><span class="variable">.procSysEventHandler</span> is a pointer to the procedure that process the system events that are send to the object, i.e. mouse events, keyboard events etc.</p>
<pre class="fasm-code">
proc SysEventHandler, .obj, .pEvent
</pre>
<p>Process one system event for object <span class="variable">[.obj]</span>. <span class="variable">[.pEvent]</span> contains pointer to the system event.</p>

<p>All of these procedures are called internally and should not be used by the user of the library. 
How these procedure are called will be described later.</p>

<p>TObjectClass structure is defined statically in memory in compile time, only once for every object class. Its definition is located in the library for the respective GUI element. For example CButton class structure is defined in the file TButton.asm that contains the code and data of the object class Button.</p>

<p>In order to make construction of such structures easy, macro with name ObjectClass is defined in objects.asm</p>

<a name="ObjectClass"><h3>ObjectClass Macro</h3></a>
<pre class="fasm-code">
macro ObjectClass name*, parent*, procCreate*, procDestroy*, procGetParam*, procSetParam*, procExecCmd*, procSysEvents*
</pre>

<p>Every defined ObjectClass have a label that points to the begin of the structure. The name of this label is the name of the class, prefixed with "C".</p>

<p>One example of ObjectClass definition is the definition of Window object class:</p>
<pre class="fasm-code">
ObjectClass Window,             \
            Object,             \
            TWindow.Create,     \
            TWindow.Destroy,    \
            TWindow.Get,        \
            TWindow.Set,        \
            TWindow.ExecCmd,    \
            TWindow.SysEventHandler
</pre>

<p>This definition creates following data structure:</p>
<pre class="fasm-code">
CWindow:
            dd  CObject         
            dd  sizeof.TWindow             
            dd  TWindow.Create
            dd  TWindow.Destroy    
            dd  TWindow.Get      
            dd  TWindow.Set,        
            dd  TWindow.ExecCmd
            dd  TWindow.SysEventHandler
</pre>



<a name="Object structure"><h3>Object structure</h3></a>
<p>Object instance is data structure that contains different fields. By that it is very similar to the normal FASM structures. As structures, the object is only description of the data but not the data itself. </p>
<p>Objects can inherit field definitions by its parent objects.
The memory instance of the object is allocated dynamically in runtime, when the object is created by call to the respective FreshLib functions.</p>
<p>The definition of the object looks like following:</p>

<pre class="fasm-code">
object TObject
  .ptrClass     dd ? 

  .OnCreate     dd ? 
  .OnDestroy    dd ?

  method .AddChild, .objchild
endobj


object TWindow, TObject
  .handle       dd ?   
  .Fcaption     dd ?    
  .Fcursor      dd ?    

  param .x
  param .y
  param .width
  param .height
  param .visible
  param .caption
  param .parent
  param .cursor

  method .Refresh
endobj


object TButton, TWindow
  .state      dd ?
  .Ficon      dd ?
  .FiconAlign dd ?
  .Ftextalign dd ?

  .OnClick dd ?

  param .TextAlign
  param .Icon
  param .IconPosition
endobj
</pre>

<p>By convention the names of the objects begin with "T".</p>
<p>You can see that the object TWindow contains data fields, parameters and methods. 
The parameters defined by "param" macro are compile time constants which values are assigned automatically. 
There constants are local labels for the object structure. They are also inherited from the parent structure.</p>
<p>The methods are very similar to parameters, in that they are constants, defined in compile time. 
But besides the constant, the method also have list of arguments, passed to the method, when executed.</p>


<p>In the above example, <span class="variable">TButton.width</span> parameter is inherited from <span class="variable">TWindow</span> and have the same value as <span class="variable">TWindow.width</span> parameter.</p>
<p>Also, <span class="variable">TWindow</span> have all fields of TObject defined as well.</p>
<p>If we have to translate TWindow definition in plain FASM syntax it will looks like this:</p>

<pre class="fasm-code">
struc TWindow {
  .ptrClass     dd ? 

  .OnCreate     dd ? 
  .OnDestroy    dd ?

  .handle       dd ?   
  .Fcaption     dd ?    
  .Fcursor      dd ?    

  .x       = $80000000
  .y       = $80000001
  .width   = $80000002
  .height  = $80000003
  .visible = $80000004
  .caption = $80000005
  .parent  = $80000006
  .cursor  = $80000007
}
virtual at 0
  TWindow TWindow
  sizeof.TWindow = $
end virtual
</pre>

<p>This directory contains the libraries providing portable GUI for assembly programming.</p>
<p class="note">Note that this libraries are in very early stage of development, so the description in this chapter is preliminary and probably will be changed in one or another way in the near future.</p>
<p>Later in this text, the whole GUI subsystem of FreshLib will be called FreshGUI</p>

<h2>FreshGUI structure</h2>
<p>The main idea behind the FreshGUI is to make one small OS dependent layer of functions, that to serve as an interface between the OS and the OS independent layer of the library.</p> 
<p>The first will translate OS events, such as mouse, keyboard, timers etc to one common standard of OS independent event handlers of the user interface objects – windows, buttons and other widgets.</p>
<p>The biggest advantage of this approach is that the portability of the library is very easy – most of the code is OS independent and only little  part of it have to be write in order to port the whole library to a new OS.</p>
<p>The biggest drawback of this approach is the bigger size of the library, because, with this architecture, all controls in the library have to be created  from scratch. It is impossible to use graphic controls that the OS provides – particularly Win32 controls - buttons, simple text editors, labels, combo boxes list and tree view controls etc.</p>
<p>FreshGUI is not aimed to use all complex GUI system of the target OS. At first time, the goal of FreshGUI is to provide minimal but decent functionality that will do the job – writing portable applications in assembly language.</p>
<h3>Graphics library</h3>
<p>The graphics library provides procedures that draw graphics images and text on the screen. The library is OS dependent and is placed in the directory "graphics" in the root directory of FreshLib. The main conception of this library is ".raster" - represented by handle, object where the drawing happens. The exact meaning for this object is different for the different OS – in Win32 it is named "device context", in Linux it is "drawable" - window or pixmap.</p>

<h3>Event translation layer</h3>

<h4>Library "sysevents.asm"</h4>
<p>This library contains event codes and data structures for FreshGUI OS independent events. For now only several events are defined:</p>
<pre class="fasm-code">
seMouseMove        
seMouseEnter       
seMouseLeave       
seMouseBtnPress    
seMouseBtnRelease  
seMouseBtnClick    
seMouseBtnDblClick 

seTimer            

seKbdKeyPress      
seKbdKeyRelease    
seKbdStatusChanged 
seKbdChar          

sePaint 
</pre>           
<p>These events cover mouse, keyboard, timers and paint events.</p>
<p>Every event have some arguments that have to be sent to the recipient event handler. The event code and the event arguments are contained in data structure, defined for every kind of events.</p>
<p>The first dword of the event structure is the field <span class="variable">.event</span> that contains the event code.</p>
<p>Here are the structures defined in sysevents.asm</p>
<pre class="fasm-code">
struct TSysEvent
  .event  dd  ?
ends
</pre>
<p>The base event structure.</p>

<pre class="fasm-code">
struct TMouseMoveEvent
  . TSysEvent
  .x         dd ?
  .y         dd ?
ends
</pre>
<p>The event is generated when the mouse cursor moves over some window or control. <span class="variable">.x</span> and <span class="variable">.y</span> contains the coordinates of the mouse cursor relative to the control this message is sent to.</p>

<pre class="fasm-code">
 struct TMouseButtonEvent
  . TSysEvent
  .Button    dd ?
  .kbdStatus dd ?
ends
</pre>
<p>This event is generated when some of the mouse buttons changes its state. The button that changes its state is specified in the field <span class="variable">.Button</span></p>
<p>This field can accept following values:</p>
<table style="margin-left: 40px;">
	<tr><td><span class="constant">mbLeft</span>  </td> <td align="right">= 0</td></tr>
	<tr><td><span class="constant">mbMiddle</span></td> <td align="right">= 1</td></tr>
	<tr><td><span class="constant">mbRight</span> </td> <td align="right">= 2</td></tr>
</table>
<p>The field <span class="variable">.kbdStatus</span> contains the status of remaining mouse buttons and keyboard modifying buttons. These buttons are represented by bits in the field:</p> 
<table style="margin-left: 40px;">
	<tr><td><span class="constant">maskBtnLeft</span>   </td> <td align="right">= $01</td></tr>
	<tr><td><span class="constant">maskBtnMiddle</span> </td> <td align="right">= $02</td></tr>
	<tr><td><span class="constant">maskBtnRight</span>  </td> <td align="right">= $04</td></tr>
	<tr><td><span class="constant">maskCtrl</span>      </td> <td align="right">= $08</td></tr>
	<tr><td><span class="constant">maskShift</span>     </td> <td align="right">= $10</td></tr>
</table>
<pre class="fasm-code">
struct TMouseEnterEvent
  . TSysEvent
ends
</pre>
<p>This event is generated when the mouse cursor enters or leaves some control. There is no additional parameters besides the event code.</p>

<pre class="fasm-code">
struct TKeyboardEvent
  . TSysEvent
  .key       dd  ?
  .kbdStatus dd  ?
ends
</pre>
<p>This event is generated on keyboard button press/release. The field <span class="variable">.key</span> contains the code of the pressed button. <span class="variable">.kbdStatus</span> have the same meaning and the same values as in TMouseButtonEvent.</p>

<pre class="fasm-code">
struct TTimerEvent
  . TSysEvent
ends
</pre>
<p>TTimerEvent is generated on timer events. :)</p>

<pre class="fasm-code">
struct TPaintEvent
  . TSysEvent
  .raster dd ?  ; ID of the raster where you should paint.
  .rect   RECT
ends  
</pre>
<p>TPaintEvent is generated when given control have to be repainted. The field <span class="variable">.raster</span> contains the handle to the graphic surface where the program have to draw. This handle have different meanings in the different target OS, but it simply need to be understandable by the graphics procedures from the OS dependent library graphics.asm.</p>
<p>The field <span class="variable">.rect</span> is the rectangle of the control that needs to be repainted.</p>

<h3>Library "main.asm"</h3>

<a name="Run"><h4>proc Run</h4></a>
<p>This procedure is the main program loop of the GUI application.</p>
<p>The procedure Run process all pending system events, then calls once the OnIdle event handler of the application object and then sleeps until new events are sent by the OS.</p>
<p>When the OS terminates the application – the procedure returns an exit code.</p>
<p>The user uses this procedure following way:</p>
<pre class="fasm-code">
        stdcall Run
        jmp     ExitApplication
</pre>

<a name="ProcessSystemEvents"><h4>proc ProcessSystemEvents</h4></a>
<p>This procedure process the events generated by the OS. If there are waiting events in the queue, the procedure reads them, translates them to FreshGUI  event data structures and calls the event handlers of the respective controls.</p>
<p>If there is no pending events in the queue, ProcessSystemEvents ends with <span class="flag">CF=0</span></p>
<p>The second task this procedure serves is to detect the end of the application. In this case it ends with <span class="flag">CF=1</span>.</p>
<p>This procedure is call from the main event loop of the application. Also, the user can periodically call this procedure in order to not allow hanging of the user interface during long processing of some data.</p>

<a name="WaitForSystemEvent"><h4>proc WaitForSystemEvent</h4></a>
<p>This procedure waits until some system message is posted to the application event queue. Then it exits. During the wait, very low CPU power is consumed by the application.</p>

<a name="Terminate"><h4>proc Terminate</h4></a>
<p>It provides all finalization tasks and ends the application. The exit code is provided in <span class="register">EAX</span>.</p>

<a name="Template engine"><h3>Template engine</h3></a>
<p>The template engine provides creation of complex window structures with tree layout from memory data structure, called template. The templates makes creation of dialog windows  containing children windows and non visual objects.</p>
<p>Templates can be visually created and edited. The template format used by FreshLib is flexible and allows all parameters and fields of the objects to be set to needed values during creation of the window.</p>
<p>The template engine is located in the file ObjTemplates.asm</p>

<a name="Template data structure"><h4>Template data structure</h4></a>
<p>The template is consisted from one or more data structures of type TObjTemplate, defined following way:</p>
<pre class="fasm-code">
struct TObjTemplate
  .flags     dd  ?     
  .class     dd  ?
  .ptrVar    dd  ?     
  .paramsize dd  ?
  .params:
ends
</pre>
<p><span class="variable">.flags</span> – controls what is the place of the object in the whole tree structure.</p>
<p>Can accept one or both of the following values, combined with OR:</p>
<table style="margin-left: 40px;">
	<tr><td><span class="constant">tfChild</span> </td><td>=0</td> <td>means the object is child of the last object with tfParent set.</td></tr>
	<tr><td><span class="constant">tfParent</span>  </td><td>=1</td> <td>means the given object is parent and there will be next TObjTemplate structure that will be a child object.</td></tr>
	<tr style="vertical-align: top;"><td><span class="constant">tfEnd</span>   </td><td> =2</td> <td>means the given object is the last child of its parent. Note, that one object can be parent and child in the same time. If the current template is at root level – the processing of template stops, after creating the current element and all its children.</td></tr>
</table>

<p><span class="variable">.class</span> – pointer to TObjectClass data structure for the created object.</p>
<p><span class="variable">.ptrVar</span> – pointer to dword variable that to accept the pointer to the created object.</p>
<p><span class="variable">.paramsize</span> – the size of the additional data to the end of the template. Note, that TObjTemplate is variable length structure, not fixed. sizeof.TObjTemplate contains the size of the header part of the structure.</p>
<p><span class="variable">.params</span>: after the header fields there can be arbitrary count of dword pairs: (<span class="variable">paramID</span>, <span class="variable">Value</span>) that to be set the the object during creation. This sequence ends with dword <span class="constant">$FFFFFF</span> (<span class="constant">-1</span>) value for paramID. </p>

<p>Easy creation of templates is provided with macro ObjTemplate:</p>
<pre class="fasm-code">
macro ObjTemplate  flags, class, name, [id, param]
</pre>
<p>This macro allows use of string values for params and computes automatically the values for <span class="variable">TObjTemplate.paramsize</span></p>
<p><span class="variable">flags</span> – set of (<span class="constant">tfParent</span>, <span class="constant">tfEnd</span>) constants.</p>
<p><span class="variable">class</span> – the base name of the object class (without prefix C) – i.e. Form, Window, Button, etc.</p>
<p><span class="variable">name</span> – label of the variable to receive the pointer to the created object.</p>
<p><span class="variable">id</span> – parameter ID or offset in the object structure.</p>
<p><span class="variable">param</span> – value of the parameter. Can be dword number or string constant. In the case the parameter value is string, it will be automatically created in the memory and the pointer to this string will be placed as a param value.</p>
<p>One simple example of template structure:</p>
<pre class="fasm-code">
ObjTemplate  tfParent or tfEnd, Form, frmMain, \
			 visible, TRUE, \
			 x, 100,        \
			 y, 50,         \
			 width, 640,    \
			 height, 480,   \
			 caption, 'Fresh portable Win32/Linux application test.'

  ObjTemplate  tfChild, Button, btnChild1,          \
			 visible, TRUE, \
			 x, 64,         \
			 y, 48,         \
			 width, 64,     \
			 height, 24,    \
			 caption, 'Button1',        \
			 OnClick, Button1Click

  ObjTemplate  tfChild or tfEnd, Button, btnChild2,          \
			 x, 136,         \
			 y, 48,         \
			 width, 64,     \
			 height, 24,        \
			 caption, 'Button2' ,\
			 visible, TRUE
</pre>

<a name="Template engine procedures"><h4>Template engine procedures</h4></a>
<p>Actually the procedure is one:</p>
<pre class="fasm-code">
proc CreateFromTemplate, .ptrTemplate, .parent
</pre>

<p>This procedure creates all objects from the template, pointed by <span class="variable">[.ptrTemplate]</span> as a parent of <span class="variable">[.parent]</span> argument.</p>
<p><span class="variable">.ptrTemplate</span> points to TObjTemplate structure.</p>
<p><span class="variable">.parent</span> points to TObject descendant structure. In most cases it will be actually descendant of TWindow or <span class="constant">NULL</span> if the created object is not a child of any window.</p>
<p>Returns: <span class="register">EBX</span> contains a pointer to the topmost of the created object (it is first of the created objects)</p>
<p>All pointers of the objects are stored in the specified in the template variables ( i.e. <span class="variable">[TObjTemplate.ptrVar]</span>)</p>
</nowiki>

Network Working Group					      P. Deutsch
Request for Comments: 1950			     Aladdin Enterprises
Category: Informational 				     J-L. Gailly
								Info-ZIP
								May 1996


	 ZLIB Compressed Data Format Specification version 3.3

Status of This Memo

   This memo provides information for the Internet community.  This memo
   does not specify an Internet standard of any kind.  Distribution of
   this memo is unlimited.

IESG Note:

   The IESG takes no position on the validity of any Intellectual
   Property Rights statements contained in this document.

Notices

   Copyright (c) 1996 L. Peter Deutsch and Jean-Loup Gailly

   Permission is granted to copy and distribute this document for any
   purpose and without charge, including translations into other
   languages and incorporation into compilations, provided that the
   copyright notice and this notice are preserved, and that any
   substantive changes or deletions from the original are clearly
   marked.

   A pointer to the latest version of this and related documentation in
   HTML format can be found at the URL
   <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.

Abstract

   This specification defines a lossless compressed data format.  The
   data can be produced or consumed, even for an arbitrarily long
   sequentially presented input data stream, using only an a priori
   bounded amount of intermediate storage.  The format presently uses
   the DEFLATE compression method but can be easily extended to use
   other compression methods.  It can be implemented readily in a manner
   not covered by patents.  This specification also defines the ADLER-32
   checksum (an extension and improvement of the Fletcher checksum),
   used for detection of data corruption, and provides an algorithm for
   computing it.




Deutsch & Gailly	     Informational			[Page 1]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


Table of Contents

   1. Introduction ................................................... 2
      1.1. Purpose ................................................... 2
      1.2. Intended audience ......................................... 3
      1.3. Scope ..................................................... 3
      1.4. Compliance ................................................ 3
      1.5.  Definitions of terms and conventions used ................ 3
      1.6. Changes from previous versions ............................ 3
   2. Detailed specification ......................................... 3
      2.1. Overall conventions ....................................... 3
      2.2. Data format ............................................... 4
      2.3. Compliance ................................................ 7
   3. References ..................................................... 7
   4. Source code .................................................... 8
   5. Security Considerations ........................................ 8
   6. Acknowledgements ............................................... 8
   7. Authors' Addresses ............................................. 8
   8. Appendix: Rationale ............................................ 9
   9. Appendix: Sample code ..........................................10

1. Introduction

   1.1. Purpose

      The purpose of this specification is to define a lossless
      compressed data format that:

	  * Is independent of CPU type, operating system, file system,
	    and character set, and hence can be used for interchange;

	  * Can be produced or consumed, even for an arbitrarily long
	    sequentially presented input data stream, using only an a
	    priori bounded amount of intermediate storage, and hence can
	    be used in data communications or similar structures such as
	    Unix filters;

	  * Can use a number of different compression methods;

	  * Can be implemented readily in a manner not covered by
	    patents, and hence can be practiced freely.

      The data format defined by this specification does not attempt to
      allow random access to compressed data.







Deutsch & Gailly	     Informational			[Page 2]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


   1.2. Intended audience

      This specification is intended for use by implementors of software
      to compress data into zlib format and/or decompress data from zlib
      format.

      The text of the specification assumes a basic background in
      programming at the level of bits and other primitive data
      representations.

   1.3. Scope

      The specification specifies a compressed data format that can be
      used for in-memory compression of a sequence of arbitrary bytes.

   1.4. Compliance

      Unless otherwise indicated below, a compliant decompressor must be
      able to accept and decompress any data set that conforms to all
      the specifications presented here; a compliant compressor must
      produce data sets that conform to all the specifications presented
      here.

   1.5.  Definitions of terms and conventions used

      byte: 8 bits stored or transmitted as a unit (same as an octet).
      (For this specification, a byte is exactly 8 bits, even on
      machines which store a character on a number of bits different
      from 8.) See below, for the numbering of bits within a byte.

   1.6. Changes from previous versions

      Version 3.1 was the first public release of this specification.
      In version 3.2, some terminology was changed and the Adler-32
      sample code was rewritten for clarity.  In version 3.3, the
      support for a preset dictionary was introduced, and the
      specification was converted to RFC style.

2. Detailed specification

   2.1. Overall conventions

      In the diagrams below, a box like this:

	 +---+
	 |   | <-- the vertical bars might be missing
	 +---+




Deutsch & Gailly	     Informational			[Page 3]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


      represents one byte; a box like this:

	 +==============+
	 |		|
	 +==============+

      represents a variable number of bytes.

      Bytes stored within a computer do not have a "bit order", since
      they are always treated as a unit.  However, a byte considered as
      an integer between 0 and 255 does have a most- and least-
      significant bit, and since we write numbers with the most-
      significant digit on the left, we also write bytes with the most-
      significant bit on the left.  In the diagrams below, we number the
      bits of a byte so that bit 0 is the least-significant bit, i.e.,
      the bits are numbered:

	 +--------+
	 |76543210|
	 +--------+

      Within a computer, a number may occupy multiple bytes.  All
      multi-byte numbers in the format described here are stored with
      the MOST-significant byte first (at the lower memory address).
      For example, the decimal number 520 is stored as:

	     0	   1
	 +--------+--------+
	 |00000010|00001000|
	 +--------+--------+
	  ^	   ^
	  |	   |
	  |	   + less significant byte = 8
	  + more significant byte = 2 x 256

   2.2. Data format

      A zlib stream has the following structure:

	   0   1
	 +---+---+
	 |CMF|FLG|   (more-->)
	 +---+---+








Deutsch & Gailly	     Informational			[Page 4]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


      (if FLG.FDICT set)

	   0   1   2   3
	 +---+---+---+---+
	 |     DICTID	 |   (more-->)
	 +---+---+---+---+

	 +=====================+---+---+---+---+
	 |...compressed data...|    ADLER32    |
	 +=====================+---+---+---+---+

      Any data which may appear after ADLER32 are not part of the zlib
      stream.

      CMF (Compression Method and flags)
	 This byte is divided into a 4-bit compression method and a 4-
	 bit information field depending on the compression method.

	    bits 0 to 3  CM	Compression method
	    bits 4 to 7  CINFO	Compression info

      CM (Compression method)
	 This identifies the compression method used in the file. CM = 8
	 denotes the "deflate" compression method with a window size up
	 to 32K.  This is the method used by gzip and PNG (see
	 references [1] and [2] in Chapter 3, below, for the reference
	 documents).  CM = 15 is reserved.  It might be used in a future
	 version of this specification to indicate the presence of an
	 extra field before the compressed data.

      CINFO (Compression info)
	 For CM = 8, CINFO is the base-2 logarithm of the LZ77 window
	 size, minus eight (CINFO=7 indicates a 32K window size). Values
	 of CINFO above 7 are not allowed in this version of the
	 specification.  CINFO is not defined in this specification for
	 CM not equal to 8.

      FLG (FLaGs)
	 This flag byte is divided as follows:

	    bits 0 to 4  FCHECK  (check bits for CMF and FLG)
	    bit  5	 FDICT	 (preset dictionary)
	    bits 6 to 7  FLEVEL  (compression level)

	 The FCHECK value must be such that CMF and FLG, when viewed as
	 a 16-bit unsigned integer stored in MSB order (CMF*256 + FLG),
	 is a multiple of 31.




Deutsch & Gailly	     Informational			[Page 5]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


      FDICT (Preset dictionary)
	 If FDICT is set, a DICT dictionary identifier is present
	 immediately after the FLG byte. The dictionary is a sequence of
	 bytes which are initially fed to the compressor without
	 producing any compressed output. DICT is the Adler-32 checksum
	 of this sequence of bytes (see the definition of ADLER32
	 below).  The decompressor can use this identifier to determine
	 which dictionary has been used by the compressor.

      FLEVEL (Compression level)
	 These flags are available for use by specific compression
	 methods.  The "deflate" method (CM = 8) sets these flags as
	 follows:

	    0 - compressor used fastest algorithm
	    1 - compressor used fast algorithm
	    2 - compressor used default algorithm
	    3 - compressor used maximum compression, slowest algorithm

	 The information in FLEVEL is not needed for decompression; it
	 is there to indicate if recompression might be worthwhile.

      compressed data
	 For compression method 8, the compressed data is stored in the
	 deflate compressed data format as described in the document
	 "DEFLATE Compressed Data Format Specification" by L. Peter
	 Deutsch. (See reference [3] in Chapter 3, below)

	 Other compressed data formats are not specified in this version
	 of the zlib specification.

      ADLER32 (Adler-32 checksum)
	 This contains a checksum value of the uncompressed data
	 (excluding any dictionary data) computed according to Adler-32
	 algorithm. This algorithm is a 32-bit extension and improvement
	 of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
	 standard. See references [4] and [5] in Chapter 3, below)

	 Adler-32 is composed of two sums accumulated per byte: s1 is
	 the sum of all bytes, s2 is the sum of all s1 values. Both sums
	 are done modulo 65521. s1 is initialized to 1, s2 to zero.  The
	 Adler-32 checksum is stored as s2*65536 + s1 in most-
	 significant-byte first (network) order.








Deutsch & Gailly	     Informational			[Page 6]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


   2.3. Compliance

      A compliant compressor must produce streams with correct CMF, FLG
      and ADLER32, but need not support preset dictionaries.  When the
      zlib data format is used as part of another standard data format,
      the compressor may use only preset dictionaries that are specified
      by this other data format.  If this other format does not use the
      preset dictionary feature, the compressor must not set the FDICT
      flag.

      A compliant decompressor must check CMF, FLG, and ADLER32, and
      provide an error indication if any of these have incorrect values.
      A compliant decompressor must give an error indication if CM is
      not one of the values defined in this specification (only the
      value 8 is permitted in this version), since another value could
      indicate the presence of new features that would cause subsequent
      data to be interpreted incorrectly.  A compliant decompressor must
      give an error indication if FDICT is set and DICTID is not the
      identifier of a known preset dictionary.	A decompressor may
      ignore FLEVEL and still be compliant.  When the zlib data format
      is being used as a part of another standard format, a compliant
      decompressor must support all the preset dictionaries specified by
      the other format. When the other format does not use the preset
      dictionary feature, a compliant decompressor must reject any
      stream in which the FDICT flag is set.

3. References

   [1] Deutsch, L.P.,"GZIP Compressed Data Format Specification",
       available in ftp://ftp.uu.net/pub/archiving/zip/doc/

   [2] Thomas Boutell, "PNG (Portable Network Graphics) specification",
       available in ftp://ftp.uu.net/graphics/png/documents/

   [3] Deutsch, L.P.,"DEFLATE Compressed Data Format Specification",
       available in ftp://ftp.uu.net/pub/archiving/zip/doc/

   [4] Fletcher, J. G., "An Arithmetic Checksum for Serial
       Transmissions," IEEE Transactions on Communications, Vol. COM-30,
       No. 1, January 1982, pp. 247-252.

   [5] ITU-T Recommendation X.224, Annex D, "Checksum Algorithms,"
       November, 1993, pp. 144, 145. (Available from
       gopher://info.itu.ch). ITU-T X.244 is also the same as ISO 8073.







Deutsch & Gailly	     Informational			[Page 7]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


4. Source code

   Source code for a C language implementation of a "zlib" compliant
   library is available at ftp://ftp.uu.net/pub/archiving/zip/zlib/.

5. Security Considerations

   A decoder that fails to check the ADLER32 checksum value may be
   subject to undetected data corruption.

6. Acknowledgements

   Trademarks cited in this document are the property of their
   respective owners.

   Jean-Loup Gailly and Mark Adler designed the zlib format and wrote
   the related software described in this specification.  Glenn
   Randers-Pehrson converted this document to RFC and HTML format.

7. Authors' Addresses

   L. Peter Deutsch
   Aladdin Enterprises
   203 Santa Margarita Ave.
   Menlo Park, CA 94025

   Phone: (415) 322-0103 (AM only)
   FAX:   (415) 322-1734
   EMail: <ghost@aladdin.com>


   Jean-Loup Gailly

   EMail: <gzip@prep.ai.mit.edu>

   Questions about the technical content of this specification can be
   sent by email to

   Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
   Mark Adler <madler@alumni.caltech.edu>

   Editorial comments on this specification can be sent by email to

   L. Peter Deutsch <ghost@aladdin.com> and
   Glenn Randers-Pehrson <randeg@alumni.rpi.edu>






Deutsch & Gailly	     Informational			[Page 8]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


8. Appendix: Rationale

   8.1. Preset dictionaries

      A preset dictionary is specially useful to compress short input
      sequences. The compressor can take advantage of the dictionary
      context to encode the input in a more compact manner. The
      decompressor can be initialized with the appropriate context by
      virtually decompressing a compressed version of the dictionary
      without producing any output. However for certain compression
      algorithms such as the deflate algorithm this operation can be
      achieved without actually performing any decompression.

      The compressor and the decompressor must use exactly the same
      dictionary. The dictionary may be fixed or may be chosen among a
      certain number of predefined dictionaries, according to the kind
      of input data. The decompressor can determine which dictionary has
      been chosen by the compressor by checking the dictionary
      identifier. This document does not specify the contents of
      predefined dictionaries, since the optimal dictionaries are
      application specific. Standard data formats using this feature of
      the zlib specification must precisely define the allowed
      dictionaries.

   8.2. The Adler-32 algorithm

      The Adler-32 algorithm is much faster than the CRC32 algorithm yet
      still provides an extremely low probability of undetected errors.

      The modulo on unsigned long accumulators can be delayed for 5552
      bytes, so the modulo operation time is negligible.  If the bytes
      are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
      and order sensitive, unlike the first sum, which is just a
      checksum.  That 65521 is prime is important to avoid a possible
      large class of two-byte errors that leave the check unchanged.
      (The Fletcher checksum uses 255, which is not prime and which also
      makes the Fletcher check insensitive to single byte changes 0 <->
      255.)

      The sum s1 is initialized to 1 instead of zero to make the length
      of the sequence part of s2, so that the length does not have to be
      checked separately. (Any sequence of zeroes has a Fletcher
      checksum of zero.)








Deutsch & Gailly	     Informational			[Page 9]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


9. Appendix: Sample code

   The following C code computes the Adler-32 checksum of a data buffer.
   It is written for clarity, not for speed.  The sample code is in the
   ANSI C programming language. Non C users may find it easier to read
   with these hints:

      &      Bitwise AND operator.
      >>     Bitwise right shift operator. When applied to an
	     unsigned quantity, as here, right shift inserts zero bit(s)
	     at the left.
      <<     Bitwise left shift operator. Left shift inserts zero
	     bit(s) at the right.
      ++     "n++" increments the variable n.
      %      modulo operator: a % b is the remainder of a divided by b.

      #define BASE 65521 /* largest prime smaller than 65536 */

      /*
	 Update a running Adler-32 checksum with the bytes buf[0..len-1]
       and return the updated checksum. The Adler-32 checksum should be
       initialized to 1.

       Usage example:

	 unsigned long adler = 1L;

	 while (read_buffer(buffer, length) != EOF) {
	   adler = update_adler32(adler, buffer, length);
	 }
	 if (adler != original_adler) error();
      */
      unsigned long update_adler32(unsigned long adler,
	 unsigned char *buf, int len)
      {
	unsigned long s1 = adler & 0xffff;
	unsigned long s2 = (adler >> 16) & 0xffff;
	int n;

	for (n = 0; n < len; n++) {
	  s1 = (s1 + buf[n]) % BASE;
	  s2 = (s2 + s1)     % BASE;
	}
	return (s2 << 16) + s1;
      }

      /* Return the adler32 of the bytes buf[0..len-1] */




Deutsch & Gailly	     Informational		       [Page 10]

RFC 1950       ZLIB Compressed Data Format Specification	May 1996


      unsigned long adler32(unsigned char *buf, int len)
      {
	return update_adler32(1L, buf, len);
      }















































Deutsch & Gailly	     Informational		       [Page 11]