; ***************************************************************************
; copyright   : (C) 2026 by Martin Preuss
; email       : martin@libchipcard.de
;
; ***************************************************************************
; * This file is part of the project "AqHome".                              *
; * Please see toplevel file COPYING of that project for license details.   *
; ***************************************************************************

#ifndef AQH_AVR_GUI2_MLAYOUT2_ASM
#define AQH_AVR_GUI2_MLAYOUT2_ASM

; TODO:
; - use this class also for HLayout and VLayout, those are just special
;  cases with only one row (HLayout) or column (VLayout)
; - add TMP2, use TMP1 for X, TMP2 for Y, position cells    ??
; - set X=left pos of space allocated to object, Y=top pos??
; - use that to position cells in the end??



; ***************************************************************************
; defines


.equ MLAYOUT_OFFS_BEGIN      =  WIDGET_SIZE
.equ MLAYOUT_OFFS_MODE       =  MLAYOUT_OFFS_BEGIN+0
.equ MLAYOUT_OFFS_COLSORROWS =  MLAYOUT_OFFS_BEGIN+1
.equ MLAYOUT_SIZE            =  MLAYOUT_OFFS_BEGIN+2


; values for MLAYOUT_OFFS_MODE
.equ HLAYOUT_MODE_COLUMNS   = 0
.equ HLAYOUT_MODE_ROWS      = 1





; ***************************************************************************
; code

.cseg



; ---------------------------------------------------------------------------
; @routine MLayout_new @global
;
; @return CFLAG set of okay, cleared otherwise
; @return Y address of newly created object
; @param X parent widget
; @param r16 value for OBJECT_OFFS_OPTS
; @param r17 value for WIDGET_OFFS_PACK
; @param r20 layout mode (MLAYOUT_MODE_COLUMNS, MLAYOUT_MODE_ROWS)
; @param r21 number of columns or rows (depending on mode in r20)
; @clobbers any

MLayout_new:
  push r20
    push r21
      ldi r24, LOW(MLAYOUT_SIZE)
      ldi r25, HIGH(MLAYOUT_SIZE)
      bigcall Object_Alloc         ; (!r16, !r17, !X)
    pop r21
  pop r20
  brcc MLayout_new_ret
  rcall MLayout_Init               ; (r16, r17, X)
  sec
MLayout_new_ret:
  ret
; @end



; ---------------------------------------------------------------------------
; @routine MLayout_Init @global
;
; @param Y address of widget
; @param X parent widget (if any)
; @param r16 value for OBJECT_OFFS_OPTS
; @param r17 value for WIDGET_OFFS_PACK
; @param r20 layout mode (MLAYOUT_MODE_COLUMN, MLAYOUT_MODE_ROW)
; @param r21 number of columns or rows (depending on mode in r20)
; @clobbers r16, r17, X

MLayout_Init:
  push r20
    push r21
      ; call base class
      bigcall Widget_Init             ; (r16, r17, X)
    pop r21
  pop r20

  ; set widget-specific data
  std Y+MLAYOUT_OFFS_MODE, r20
  std Y+MLAYOUT_OFFS_COLSORROWS, r21

  ; set default signal map
  ldi r16, LOW(MLayout_DefaultSignalmap*2)
  std Y+OBJECT_OFFS_SIGNALMAP_LO, r16
  ldi r16, HIGH(MLayout_DefaultSignalmap*2)
  std Y+OBJECT_OFFS_SIGNALMAP_HI, r16

  ret
; @end




MLayout_OnLayout:
  bigcall OBJ_GetFirstChild             ; test for children
  brcc MLayout_OnLayout_ret   ; none, done here
  ; TODO
MLayout_OnLayout_ret:
  sec
  ret


MLayout_OnGetDefaultWidth:
MLayout_OnGetDefaultHeight:
  ret









mLayoutColumnLayoutHorizontally:
  ; prepare
  rcall mLayoutSetDefaultWidthToTmp       ; (any, !Y)
  rcall mLayoutCopyTmpToWidth             ; (r18, r19, r25, Z)
  rcall mLayoutGetBorders                 ; r22=spacing, r23=border

  ; prepare first row
  rcall mLayoutSetupFirstContiguous       ; set max column widths to first row (r18, r19, r25, Z)

  ; possibly distribute free space to expandable columns
  push r22                                ; spacing
    push r23                              ; border
      rcall mLayoutColumnExpandColumns    ; (r16-r23, r25)
    pop r23
  pop r22

  rcall mLayoutColumnCopyTmpFromFirstRow  ; copy TMP of every column from first row to following (r18-r21, r25, Z)
  
  rcall mLayoutColumnPositionX            ; (r12, r13, r16-r21, r25, X)
  ret
; @end



mLayoutColumnLayoutVertically:
  ; prepare
  rcall mLayoutSetDefaultHeightToTmp       ; (any, !Y)
  rcall mLayoutCopyTmpToHeight             ; (r18, r19, r25, Z)
  rcall mLayoutGetBorders                  ; r22=spacing, r23=border

  ; prepare first row
  rcall mLayoutSetupFirstSkipped       ; set max column widths to first column (r18, r19, r25, Z)

  ; possibly distribute free space to expandable columns
  push r22                                ; spacing
    push r23                              ; border
      rcall mLayoutColumnExpandRows       ; (r16-r23, r25)
    pop r23
  pop r22

  rcall mLayoutColumnCopyTmpFromFirstColumn  ; copy TMP of every column from first row to following (r18-r21, r25, Z)
  
  rcall mLayoutColumnPositionY               ; (r12, r13, r16-r21, r25, X)
  ret
; @end






; ---------------------------------------------------------------------------
; @routine mLayoutColumnCopyTmpFromFirstRow
;
; @param  Y       widget
; @clobbers r18-r21, r25, Z

mLayoutColumnCopyTmpFromFirstRow:
  push yl
    push yh
      ldi zl, LOW(mLayoutCallbackColumnCopyRow)
      ldi zh, HIGH(mLayoutCallbackColumnCopyRow)
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutForEveryObjectContiguous     ; (r18-r21, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackColumnCopyRow
;
; @param  Y       widget
; @clobbers r18, r19, r20, r21, r25

mLayoutCallbackColumnCopyRow:
  push zl
    push zh
      rcall mLayoutColumnCopyTmpAcrossColumn ; (r18, r19, r20, r21, r25, Z)
    pop zh
  pop zl
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnCopyTmpAcrossColumn
;
; @param  Y       widget
; @clobbers r18, r19, r20, r21, r25, Z

mLayoutColumnCopyTmpAcrossColumn:
  push yl
    push yh
      ldd r20, Y+WIDGET_OFFS_TMP_LO
      ldd r21, Y+WIDGET_OFFS_TMP_HI
      ldi zl, LOW(mLayoutCallbackSetTmp)
      ldi zh, HIGH(mLayoutCallbackSetTmp)
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutForEveryObjectSkipped     ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnCopyTmpFromFirstColumn
;
; @param  Y       widget
; @clobbers r18-r21, r25, Z

mLayoutColumnCopyTmpFromFirstColumn:
  push yl
    push yh
      ldi zl, LOW(mLayoutCallbackColumnCopyColumn)
      ldi zh, HIGH(mLayoutCallbackColumnCopyColumn)
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutForEveryObjectSkipped            ; (r18-r21, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackColumnCopyColumn
;
; @param  Y       widget
; @clobbers r18, r19, r20, r21, r25

mLayoutCallbackColumnCopyColumn:
  push zl
    push zh
      rcall mLayoutColumnCopyTmpAcrossRow ; (r18, r19, r20, r21, r25, Z)
    pop zh
  pop zl
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnCopyTmpAcrossRow
;
; @param  Y       widget
; @clobbers r18, r19, r20, r21, r25, Z

mLayoutColumnCopyTmpAcrossRow:
  push yl
    push yh
      ldd r20, Y+WIDGET_OFFS_TMP_LO
      ldd r21, Y+WIDGET_OFFS_TMP_HI
      ldi zl, LOW(mLayoutCallbackSetTmp)
      ldi zh, HIGH(mLayoutCallbackSetTmp)
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutForEveryObjectContiguous    ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackSetTmp
;
; @param  Y       widget
; @param  r21:r20 TMP to set
; @clobbers none

mLayoutCallbackSetTmp:
  std Y+WIDGET_OFFS_TMP_LO, r20
  std Y+WIDGET_OFFS_TMP_HI, r21
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnPositionX
;
; Set X and width to all columns of the row
;
; @param  Y       first widget of current row
; @param  r22     spacing between widgets
; @param  r23     border at beginning and and
; @clobbers r12, r13, r16-r21, r25, X

mLayoutColumnPositionX:
  mov xl, r23             ; start at border
  clr xh
  push yl
    push yh
      ldi zl, LOW(mLayoutCallbackPositionX)
      ldi zh, HIGH(mLayoutCallbackPositionX)
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutForEveryObjectContiguous   ; (r12, r13, r16-r21, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackPositionX
;
; @param  Y       widget
; @param  r22     spacing between widgets
; @param  X       current X pos
; @clobbers r12, r13, r16-r21

mLayoutCallbackPositionX:
  ldd r16, Y+OBJECT_OFFS_FLAGS
  sbrs r16, WIDGET_FLAGS_VISIBLE_BIT
    rjmp mLayoutCallbackPositionX_ret
  ldd r18, Y+WIDGET_OFFS_TMP_LO    ; calculated cell width
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  ldd r12, Y+WIDGET_OFFS_WIDTH_LO  ; default width
  ldd r13, Y+WIDGET_OFFS_WIDTH_HI
  ldd r17, Y+WIDGET_OFFS_PACK
  andi r17, 3                      ; WIDGET_PACK_HSELF0_BIT = 0, no shift necessary
  rcall mLayoutPackCell            ; R21:R20=relative pos (r17, r18, r19)
  add r20, xl
  adc r21, xh
  std Y+WIDGET_OFFS_X_LO, r20      ; set new X
  std Y+WIDGET_OFFS_X_HI, r21
  std Y+WIDGET_OFFS_WIDTH_LO, r18  ; set new width
  std Y+WIDGET_OFFS_WIDTH_HI, r19
  add xl, r18                      ; advance X
  adc xh, r19
  add xl, r22                      ; add spacing
  adc xh, r22
  sub xh, r22
mLayoutCallbackPositionX_ret:
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnPositionY
;
; Set X and width to all columns of the row
;
; @param  Y       first widget of current row
; @param  r22     spacing between widgets
; @param  r23     border at beginning and end
; @clobbers r12, r13, r16-r21, r25, X

mLayoutColumnPositionY:
  mov xl, r23             ; start at border
  clr xh
  push yl
    push yh
      ldi zl, LOW(mLayoutCallbackPositionY)
      ldi zh, HIGH(mLayoutCallbackPositionY)
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutForEveryObjectSkipped      ; (r12, r13, r16-r21, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackPositionY
;
; @param  Y       widget
; @param  r22     spacing between widgets
; @param  X       current Y pos
; @clobbers r12, r13, r16-r21

mLayoutCallbackPositionY:
  ldd r16, Y+OBJECT_OFFS_FLAGS
  sbrs r16, WIDGET_FLAGS_VISIBLE_BIT
    rjmp mLayoutCallbackPositionY_ret
  ldd r18, Y+WIDGET_OFFS_TMP_LO    ; calculated cell width
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  ldd r12, Y+WIDGET_OFFS_HEIGHT_LO  ; default width
  ldd r13, Y+WIDGET_OFFS_HEIGHT_HI
  ldd r17, Y+WIDGET_OFFS_PACK
  lsr r17                           ; WIDGET_PACK_VSELF0_BIT = 2 -> shift 2 times right
  lsr r17
  andi r17, 3
  rcall mLayoutPackCell             ; R21:R20=relative pos (r17, r18, r19)
  add r20, xl
  adc r21, xh
  std Y+WIDGET_OFFS_Y_LO, r20       ; set new Y
  std Y+WIDGET_OFFS_Y_HI, r21
  std Y+WIDGET_OFFS_HEIGHT_LO, r18  ; set new width
  std Y+WIDGET_OFFS_HEIGHT_HI, r19
  add xl, r18                       ; advance Y
  adc xh, r19
  add xl, r22                       ; add spacing
  adc xh, r22
  sub xh, r22
mLayoutCallbackPositionY_ret:
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnExpandColumns
;
; Calculate additional space per expandable widget in a row.
;
; @param  Y       first widget of current row
; @return CFLAG   set if there is additional space to distribute
; @return r21:r20 space to add to every expandable widget
; @clobbers r16-r23, r25

mLayoutColumnExpandColumns:
  rcall mLayoutColumnCalcAddSpacePerColumn                           ; r21:r20=additional space (r16-r23, r25)
  brcc mLayoutColumnExpandColumns_ret

  ldi r22, (1<<WIDGET_PACK_HSELF1_BIT) | (1<<WIDGET_PACK_HSELF0_BIT) ; mask
  ldi r23, (WIDGET_PACK_FILLED<<WIDGET_PACK_HSELF0_BIT)              ; value
  ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
  rcall mLayoutExpandChildrenMatchingPackContiguous                  ; (r18, r19, r25)

mLayoutColumnExpandColumns_ret:
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnCalcAddSpacePerColumn
;
; Calculate additional space per expandable widget in a row.
;
; @param  Y       first widget of current row
; @return CFLAG   set if there is additional space to distribute
; @return r21:r20 space to add to every expandable widget
; @param  r22     spacing between widgets
; @param  r23     border at beginning and and
; @clobbers r16-r23, r25

mLayoutColumnCalcAddSpacePerColumn:
  ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
  rcall mLayoutSumContiguous          ; r21:r20 needed minimum row width (r18, r19, r25)
  ldd r18, Y+WIDGET_OFFS_WIDTH_LO
  ldd r19, Y+WIDGET_OFFS_WIDTH_HI
  sub r18, r20
  sbc r19, r21
  brcc mLayoutColumnCalcAddSpacePerElement_none
  breq mLayoutColumnCalcAddSpacePerElement_none
  ; r19:r18=space to distribute
  push r18
    push r19
      ldi r22, (1<<WIDGET_PACK_HSELF1_BIT) | (1<<WIDGET_PACK_HSELF0_BIT) ; mask
      ldi r23, (WIDGET_PACK_FILLED<<WIDGET_PACK_HSELF0_BIT)              ; value
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutCountChildrenMatchingPackContiguous                   ; r20=num of matching children (r18, r19, r25)
    pop r19
  pop r18
  tst r20
  breq mLayoutColumnCalcAddSpacePerElement_none    ; don't divide by zero!
  mov r22, r20
  clr r23
  mov r20, r18
  mov r21, r19
  bigcall Utils_Divu16_16_16                       ; r17:r16=space per expandable widget
  mov r20, r16
  mov r21, r17
  sec
  rjmp mLayoutColumnCalcAddSpacePerElement_ret
mLayoutColumnCalcAddSpacePerElement_none:
  clr r20
  clr r21
  clc
mLayoutColumnCalcAddSpacePerElement_ret:
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnExpandRows
;
; Calculate additional space per expandable widget in a column.
;
; @param  Y       first widget of current row
; @return CFLAG   set if there is additional space to distribute
; @return r21:r20 space to add to every expandable widget
; @clobbers r16-r23, r25

mLayoutColumnExpandRows:
  rcall mLayoutColumnCalcAddSpacePerRow                              ; r21:r20=additional space (r16-r23, r25)
  brcc mLayoutColumnExpandRows_ret

  ldi r22, (1<<WIDGET_PACK_VSELF1_BIT) | (1<<WIDGET_PACK_VSELF0_BIT) ; mask
  ldi r23, (WIDGET_PACK_FILLED<<WIDGET_PACK_VSELF0_BIT)              ; value
  ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
  rcall mLayoutExpandChildrenMatchingPackSkipped                     ; (r18, r19, r25)

mLayoutColumnExpandRows_ret:
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutColumnCalcAddSpacePerRow
;
; Calculate additional space per expandable widget in a row.
;
; @param  Y       first widget of current row
; @return CFLAG   set if there is additional space to distribute
; @return r21:r20 space to add to every expandable widget
; @param  r22     spacing between widgets
; @param  r23     border at beginning and and
; @clobbers r16-r23, r25

mLayoutColumnCalcAddSpacePerRow:
  ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
  rcall mLayoutSumSkipped                                                ; r21:r20 needed minimum row width (r18, r19, r25)
  ldd r18, Y+WIDGET_OFFS_HEIGHT_LO
  ldd r19, Y+WIDGET_OFFS_HEIGHT_HI
  sub r18, r20
  sbc r19, r21
  brcc mLayoutColumnCalcAddSpacePerRow_none
  breq mLayoutColumnCalcAddSpacePerRow_none
  ; r19:r18=space to distribute
  push r18
    push r19
      ldi r22, (1<<WIDGET_PACK_VSELF1_BIT) | (1<<WIDGET_PACK_VSELF0_BIT) ; mask
      ldi r23, (WIDGET_PACK_FILLED<<WIDGET_PACK_VSELF0_BIT)              ; value
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      rcall mLayoutCountChildrenMatchingPackSkipped                      ; r20=num of matching children (r18, r19, r25)
    pop r19
  pop r18
  tst r20
  breq mLayoutColumnCalcAddSpacePerRow_none    ; don't divide by zero!
  mov r22, r20
  clr r23
  mov r20, r18
  mov r21, r19
  bigcall Utils_Divu16_16_16                       ; r17:r16=space per expandable widget
  mov r20, r16
  mov r21, r17
  sec
  rjmp mLayoutColumnCalcAddSpacePerRow_ret
mLayoutColumnCalcAddSpacePerRow_none:
  clr r20
  clr r21
  clc
mLayoutColumnCalcAddSpacePerRow_ret:
  ret
; @end





; ---------------------------------------------------------------------------
; @routine mLayoutSetupFirstContiguous
;
; For every contiguous widget (e.g. in a row) determine the maximum TMP value
; of all widgets orthogonal to that widget, e.g. when working in column mode:
; Get the highest width for every column and store that in the first widget of
; that column (i.e. in the first row).
;
; @clobbers r18, r19, r25, Z

mLayoutSetupFirstContiguous:
  push yl
    push yh
      ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
      ldi zl, LOW(mLayoutCallbackSetupFirstContiguous)
      ldi zh, HIGH(mLayoutCallbackSetupFirstContiguous)
      rcall mLayoutForEveryObjectContiguous              ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackSetupFirstContiguous
;
; @param  Y       object to start with
; @clobbers r18, r19, r25

mLayoutCallbackSetupFirstContiguous:
  push zl
    push zh
      push yl
        push yh
          ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
          rcall mLayoutGetMaxTmpSkipped      ; (r18, r19, r25, Z)
        pop yh
      pop yl
      std Y+WIDGET_OFFS_TMP_LO, r20
      std Y+WIDGET_OFFS_TMP_LO, r21
    pop zh
  pop zl
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutSetupFirstSkipped
;
; For every skipped widget (e.g. in a column) determine the maximum TMP value
; of all widgets orthogonal to that widget.
; Same as mLayoutSetupFirstContiguous except orthograde.
;
; @param  Y       object to start with
; @clobbers r18, r19, r25, Z

mLayoutSetupFirstSkipped:
  push yl
    push yh
      ldi zl, LOW(mLayoutCallbackSetupFirstSkipped)
      ldi zh, HIGH(mLayoutCallbackSetupFirstSkipped)
      rcall mLayoutForEveryObjectSkipped              ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackSetupFirstSkipped
;
; For every skipped widget (e.g. in a column) determine the maximum TMP value
; of all widgets orthogonal to that widget.
; Same as mLayoutSetupFirstContiguous except orthograde.
;
; @param  Y       object to start with
; @clobbers r18, r19, r25

mLayoutCallbackSetupFirstSkipped:
  push zl
    push zh
      push yl
        push yh
          ldd r25, Y+MLAYOUT_OFFS_COLSORROWS
          rcall mLayoutGetMaxTmpContiguous    ; (r18, r19, r25, Z)
        pop yh
      pop yl
      std Y+WIDGET_OFFS_TMP_LO, r20
      std Y+WIDGET_OFFS_TMP_LO, r21
    pop zh
  pop zl
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutGetMaxTmpContiguous
;
; @param  Y       object to start with
; @param  r25     number of widgets to handle
; @return r21:r20 maximum TMP value encountered
; @clobbers r18, r19, r25, Z

mLayoutGetMaxTmpContiguous:
  push yl
    push yh
      clr r20
      clr r21
      ldi zl, LOW(mLayoutCallbackGetMaxTmp)
      ldi zh, HIGH(mLayoutCallbackGetMaxTmp)
      rcall mLayoutForEveryObjectContiguous   ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutGetMaxTmpSkipped
;
; @param  Y       object to start with
; @param  r25     number of widgets to skip after each widget handled
; @return r21:r20 maximum TMP value encountered
; @clobbers r18, r19, r25, Z

mLayoutGetMaxTmpSkipped:
  push yl
    push yh
      clr r20
      clr r21
      ldi zl, LOW(mLayoutCallbackGetMaxTmp)
      ldi zh, HIGH(mLayoutCallbackGetMaxTmp)
      rcall mLayoutForEveryObjectSkipped      ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end


; ---------------------------------------------------------------------------
; @routine mLayoutCallbackGetMaxTmp
;
; @param  Y       object whose TMP value is to be added
; @param  r21:r20 current maximum value
; @return CFLAG   clear (to not abort the loop function)
; @clobbers r18, r19

mLayoutCallbackGetMaxTmp:
  ldd r18, Y+WIDGET_OFFS_TMP_LO
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  cp r20, r18
  cpc r21, r19
  brcc mLayoutCallbackGetMaxTmp_ret
  mov r20, r18
  mov r21, r19
mLayoutCallbackGetMaxTmp_ret:
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCountChildrenMatchingPackContiguous
;
; @param  Y         object whose TMP value is to be added
; @param  r22 mask  for WIDGET_OFFS_PACK
; @param  r23 value for WIDGET_OFFS_PACK
; @param  r25     number of widgets to handle
; @return r20 number of matching children
; @clobbers r18, r19, r25

mLayoutCountChildrenMatchingPackContiguous:
  push yl
    push yh
      clr r20
      ldi zl, LOW(mLayoutCallbackCountChildrenMatchingPack)
      ldi zh, HIGH(mLayoutCallbackCountChildrenMatchingPack)
      rcall mLayoutForEveryObjectContiguous                  ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCountChildrenMatchingPackSkipped
;
; @param  Y         object whose TMP value is to be added
; @param  r22 mask  for WIDGET_OFFS_PACK
; @param  r23 value for WIDGET_OFFS_PACK
; @return r20 number of matching children
; @clobbers r18, r19, r25

mLayoutCountChildrenMatchingPackSkipped:
  push yl
    push yh
      clr r20
      ldi zl, LOW(mLayoutCallbackCountChildrenMatchingPack)
      ldi zh, HIGH(mLayoutCallbackCountChildrenMatchingPack)
      rcall mLayoutForEveryObjectSkipped                     ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackCountChildrenMatchingPack
;
; @param  Y         object whose TMP value is to be added
; @param  r20       number of matching children so far
; @param  r22 mask  for WIDGET_OFFS_PACK
; @param  r23 value for WIDGET_OFFS_PACK
; @return CFLAG     clear (to not abort the loop function)
; @clobbers r18

mLayoutCallbackCountChildrenMatchingPack:
  ldd r18, Y+OBJECT_OFFS_FLAGS
  sbrs r18, WIDGET_FLAGS_VISIBLE_BIT
    rjmp mLayoutCallbackCountChildrenMatchingPack_ret
  ldd r18, Y+WIDGET_OFFS_PACK
  eor r18, r23
  and r18, r22
  brne mLayoutCallbackCountChildrenMatchingPack_ret
  inc r20
mLayoutCallbackCountChildrenMatchingPack_ret:
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutExpandChildrenMatchingPackContiguous
;
; @param  Y         object whose TMP value is to be added
; @param  r21:r20   value to add to TMP
; @param  r22 mask  for WIDGET_OFFS_PACK
; @param  r23 value for WIDGET_OFFS_PACK
; @param  r25     number of widgets to handle
; @clobbers r18, r19, r25

mLayoutExpandChildrenMatchingPackContiguous:
  push yl
    push yh
      clr r20
      ldi zl, LOW(mLayoutCallbackExpandChildrenMatchingPack)
      ldi zh, HIGH(mLayoutCallbackExpandChildrenMatchingPack)
      rcall mLayoutForEveryObjectContiguous                    ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutExpandChildrenMatchingPackSkipped
;
; @param  Y         object whose TMP value is to be added
; @param  r21:r20   value to add to TMP
; @param  r22 mask  for WIDGET_OFFS_PACK
; @param  r23 value for WIDGET_OFFS_PACK
; @clobbers r18, r19, r25

mLayoutExpandChildrenMatchingPackSkipped:
  push yl
    push yh
      clr r20
      ldi zl, LOW(mLayoutCallbackExpandChildrenMatchingPack)
      ldi zh, HIGH(mLayoutCallbackExpandChildrenMatchingPack)
      rcall mLayoutForEveryObjectSkipped                       ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackExpandChildrenMatchingPack
;
; @param  Y         object whose TMP value is to be added
; @param  r21:r20   space to add to expandable widgets
; @param  r22 mask  for WIDGET_OFFS_PACK
; @param  r23 value for WIDGET_OFFS_PACK
; @return CFLAG     clear (to not abort the loop function)
; @clobbers r18, r19

mLayoutCallbackExpandChildrenMatchingPack:
  ldd r18, Y+OBJECT_OFFS_FLAGS
  sbrs r18, WIDGET_FLAGS_VISIBLE_BIT
    rjmp mLayoutCallbackExpandChildrenMatchingPack_ret
  ldd r18, Y+WIDGET_OFFS_PACK
  eor r18, r23
  and r18, r22
  brne mLayoutCallbackExpandChildrenMatchingPack_ret
  ldd r18, Y+WIDGET_OFFS_TMP_LO
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  add r18, r20
  adc r19, r21
  std Y+WIDGET_OFFS_TMP_LO, r18
  std Y+WIDGET_OFFS_TMP_HI, r19
mLayoutCallbackExpandChildrenMatchingPack_ret:
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutSetDefaultWidthToTmp
;
; @param  Y       object to start with
; @param  r25     number of widgets to handle
; @clobbers any, !Y

mLayoutSetDefaultWidthToTmp:
  push yl
    push yh
      clr r25      ; number of widgets to handle (0=all)
      ldi zl, LOW(mLayoutCallbackDefaultWidthToTmp)
      ldi zh, HIGH(mLayoutCallbackDefaultWidthToTmp)
      rcall mLayoutForEveryObjectContiguous           ; (any)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackDefaultWidthToTmp
;
; @param  Y       object whose TMP value is to be added
; @return CFLAG   clear (to not abort the loop function)
; @clobbers r18, r19 (any, !Y)

mLayoutCallbackDefaultWidthToTmp:
  push zl
    push zh
      bigcall Widget_GetDefaultWidth  ; (any, !Y)
    pop zh
  pop zl
  std Y+WIDGET_OFFS_TMP_LO, r18
  std Y+WIDGET_OFFS_TMP_HI, r19
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutSetDefaultHeightToTmp
;
; @param  Y       object to start with
; @param  r25     number of widgets to handle
; @clobbers any, !Y

mLayoutSetDefaultHeightToTmp:
  push yl
    push yh
      clr r25      ; number of widgets to handle (0=all)
      ldi zl, LOW(mLayoutCallbackDefaultHeightToTmp)
      ldi zh, HIGH(mLayoutCallbackDefaultHeightToTmp)
      rcall mLayoutForEveryObjectContiguous            ; (any)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackDefaultHeightToTmp
;
; @param  Y       object whose TMP value is to be added
; @return CFLAG   clear (to not abort the loop function)
; @clobbers r18, r19 (any, !Y)

mLayoutCallbackDefaultHeightToTmp:
  push zl
    push zh
      bigcall Widget_GetDefaultHeight  ; (any, !Y)
    pop zh
  pop zl
  std Y+WIDGET_OFFS_TMP_LO, r18
  std Y+WIDGET_OFFS_TMP_HI, r19
  clc
  ret
; @end




; ---------------------------------------------------------------------------
; @routine mLayoutCopyTmpToWidth
;
; @param  Y       object to start with
; @clobbers r18, r19, r25, Z

mLayoutCopyTmpToWidth:
  push yl
    push yh
      clr r25   ; number of widgets to handle (0=all)
      ldi zl, LOW(mLayoutCallbackCopyTmpToWidth)
      ldi zh, HIGH(mLayoutCallbackCopyTmpToWidth)
      rcall mLayoutForEveryObjectContiguous        ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end


; ---------------------------------------------------------------------------
; @routine mLayoutCallbackCopyTmpToWidth
;
; @param  Y       object to start with
; @clobbers r18, r19

mLayoutCallbackCopyTmpToWidth:
  ldd r18, Y+WIDGET_OFFS_TMP_LO
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  std Y+WIDGET_OFFS_WIDTH_LO, r18
  std Y+WIDGET_OFFS_WIDTH_HI, r19
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCopyTmpToHeight
;
; @param  Y       object to start with
; @clobbers r18, r19, r25, Z

mLayoutCopyTmpToHeight:
  push yl
    push yh
      clr r25   ; number of widgets to handle (0=all)
      ldi zl, LOW(mLayoutCallbackCopyTmpToHeight)
      ldi zh, HIGH(mLayoutCallbackCopyTmpToHeight)
      rcall mLayoutForEveryObjectContiguous        ; (r18, r19, r25, Y)
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackCopyTmpToHeight
;
; @param  Y       object to start with
; @clobbers r18, r19

mLayoutCallbackCopyTmpToHeight:
  ldd r18, Y+WIDGET_OFFS_TMP_LO
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  std Y+WIDGET_OFFS_HEIGHT_LO, r18
  std Y+WIDGET_OFFS_HEIGHT_HI, r19
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutSumContiguous
;
; @param  Y       object to start with
; @param  r25     number of widgets to handle
; @param  r22     spacing between widgets
; @param  r23     border at beginning and and
; @return r21:r20 total size in the given dimension including borders and inter-widget spacing
; @clobbers r18, r19, r25

mLayoutSumContiguous:
  push yl
    push yh
      mov r20, r23 ; start with border
      clr r21
      ldi zl, LOW(mLayoutCallbackAddToSum)
      ldi zh, HIGH(mLayoutCallbackAddToSum)
      rcall mLayoutForEveryObjectContiguous ; (r18, r19, r25, Y)
      sub r20, r22 ; undo last adding inter-widget space
      sbc r21, r22
      add r21, r22
      add r20, r23 ; end with border
      adc r21, r23
      sub r21, r23
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutSumSkipped
;
; @param  Y       object to start with
; @param  r25     number of widgets to skip after each widget handled
; @param  r22     spacing between widgets
; @param  r23     border at beginning and end
; @return r21:r20 sum of TMP values
; @clobbers r18, r19, r25

mLayoutSumSkipped:
  push yl
    push yh
      mov r20, r23 ; start with border
      clr r21
      ldi zl, LOW(mLayoutCallbackAddToSum)
      ldi zh, HIGH(mLayoutCallbackAddToSum)
      rcall mLayoutForEveryObjectSkipped    ; (r18, r19, r25, Y)
      sub r20, r22 ; undo last adding inter-widget space
      sbc r21, r22
      add r21, r22
      add r20, r23 ; end with border
      adc r21, r23
      sub r21, r23
    pop yh
  pop yl
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutCallbackAddToSum
;
; @param  Y       object whose TMP value is to be added
; @param  r25     number of widgets to handle
; @param  r21:r20 sum so far (TMP will be added to it)
; @param  r22     spacing between widgets
; @return CFLAG   clear (to not abort the loop function)
; @clobbers r18, r19

mLayoutCallbackAddToSum:
  ldd r18, Y+WIDGET_OFFS_TMP_LO
  ldd r19, Y+WIDGET_OFFS_TMP_HI
  add r20, r18                  ; add TMP
  adc r21, r19
  add r20, r22                  ; add spacing
  adc r21, r22
  sub r21, r22
  clc
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutForEveryObjectContiguous
;
; This routine itself uses R18, R19, R25 and Y. All other registers may be
; passed to the callback routine.
; However, the callback function must make sure that it doesn't modify registers
; which are to be passed to next objects later!
;
; This routine traverses the given number of contiguous objects until there is no
; next object.
;
; Y and R25 are preserved around the callback. Z MUST NOT be modified by the callback!
;
; @param  Y       object to start with
; @param  r25     number of widgets to handle (0=all)
; @param  Z       pointer to routine to call (using ICALL)
; @return CFLAG   set if the callback returned with CFLAG set on any widget
; @return Y       object on which the call returned with CFLAG set (otherwise last object handled)
; @clobbers       r18, r19, r25, Y (any)

mLayoutForEveryObjectContiguous:
mLayoutForEveryObjectContiguous_loop:
    push r25
      push yl
        push yh
          icall
        pop yh
      pop yl
    pop r25
    brcs mLayoutForEveryObjectContiguous_ret
    tst r25
    breq mLayoutForEveryObjectContiguous_next
    dec r25
    clc
    breq mLayoutForEveryObjectContiguous_ret
mLayoutForEveryObjectContiguous_next:
    bigcall OBJ_GetNext
    brcc mLayoutForEveryObjectContiguous_ret
    mov yl, r18
    mov yh, r19
  rjmp mLayoutForEveryObjectContiguous_loop
mLayoutForEveryObjectContiguous_ret:
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutForEveryObjectSkipped
;
; This routine itself uses R18, R19, R25 and Y. All other registers may be
; passed to the callback routine.
; However, the callback function must make sure that it doesn't modify registers
; which are to be passed to next objects later!
;
; This routine traverses the given objects skipping [R25] objects after each round
; until there is no next object.
;
; Y and R25 are preserved around the callback. Z MUST NOT be modified by the callback!
;
; @param  Y       object to start with
; @param  r25     number of widgets to skip per round
; @param  Z       pointer to routine to call (using ICALL)
; @return CFLAG   set if the callback returned with CFLAG set on any widget
; @return Y       object on which the call returned with CFLAG set (garbage otherwise)
; @clobbers       r18, r19, r25, Y (any)

mLayoutForEveryObjectSkipped:
mLayoutForEveryObjectSkipped_loop:
    push r25
      push yl
        push yh
          icall
        pop yh
      pop yl
    pop r25
    brcs mLayoutForEveryObjectSkipped_ret
    breq mLayoutForEveryObjectSkipped_ret
    push r16
      mov r16, r25
      bigcall OBJ_SkipObjects
    pop r16
    brcc mLayoutForEveryObjectSkipped_ret
    mov yl, r18
    mov yh, r19
  rjmp mLayoutForEveryObjectSkipped_loop
mLayoutForEveryObjectSkipped_ret:
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutGetBorders
;
; @param  Y   address of widget
; @return r22 spacing
; @return r23 outer borders
; @clobbers Z

mLayoutGetBorders:
  ldd zl, Y+WIDGET_OFFS_STYLE_LO
  ldd zh, Y+WIDGET_OFFS_STYLE_HI
  adiw zh:zl, WIDGET_STYLE_OFFS_SPACING
  lpm r22, Z
  sbiw zh:zl, WIDGET_STYLE_OFFS_SPACING
  adiw zh:zl, WIDGET_STYLE_OFFS_OUTERBORDERSIZE
  lpm r23, Z
  ret
; @end



; ---------------------------------------------------------------------------
; @routine mLayoutPackCell
;
; @param  Y       address of widget
; @param  r19:r18 size of target widget (i.e. width or height)
; @param  r17 pack mode (see @ref WIDGET_PACK_BEGIN)
; @param  R13:R12 size of object to pack (i.e. width or height)
; @param  r22     spacing (between widgets)
; @return R21:R20   pos
; @clobbers r17, r18, r19

mLayoutPackCell:
  ; subtract borders
  sub r18, r22                   ; subtract spacing
  sbc r19, r22
  add r19, r22

  andi r17, 3                    ; only 2 bits pack mode
  cpi r17, WIDGET_PACK_END
  breq mLayoutPackCell_end
  cpi r17, WIDGET_PACK_CENTER
  breq mLayoutPackCell_center
  rjmp mLayoutPackCell_ret       ; begin/filled, align at begin
mLayoutPackCell_end:
  sub r18, r12
  sbc r19, r13
  add r20, r18
  adc r21, r19
  rjmp mLayoutPackCell_ret
mLayoutPackCell_center:
  sub r18, r12
  sbc r19, r13
  lsr r19
  ror r18
  add r20, r18
  adc r21, r19
  rjmp mLayoutPackCell_ret
mLayoutPackCell_ret:
  ret
; @end








; ***************************************************************************
; data in FLASH

MLayout_DefaultSignalmap:
  ; header
  .dw Widget_DefaultSignalmap*2  ; next table to use
  ; entries
  .db 0,                           WIDGET_SIGNAL_LAYOUT,   LOW(MLayout_OnLayout),           HIGH(MLayout_OnLayout)
  .db WIDGET_VALUE_DEFAULT_WIDTH,  WIDGET_SIGNAL_GETVALUE, LOW(MLayout_OnGetDefaultWidth),  HIGH(MLayout_OnGetDefaultWidth)
  .db WIDGET_VALUE_DEFAULT_HEIGHT, WIDGET_SIGNAL_GETVALUE, LOW(MLayout_OnGetDefaultHeight), HIGH(MLayout_OnGetDefaultHeight)

  .db 0, 0, 0, 0  ; end of table




#endif