/*
 * Divide rect into square-ish areas 
 *
 *   rect: parent rectangle (will be destroyed)
 *   areas: array of floats (must be sorted descending)
 *   area_count: number of floats
 *   cb: callback for each output rectangle ( index, rect )
 */
void squarey_layout( i32 rect[4], f32 *areas, u32 area_count,
                     void (*cb)(u32,i32[4]) )
{
   f32 area_total = 0.0f;
   for( u32 i=0; i<area_count; i ++ )
      area_total += areas[i];

   u32 i=0, row_start=0, row_count=1;
   f32 s = areas[0];

L_LOOP_ADJUST:;
   u32 short_side = rect[3] < rect[2]? 1: 0;
   f32 norm = ((f32)rect[2] * (f32)rect[3]) / area_total,
       w = rect[ 2+short_side ],
       w2n = w*w*norm;
L_LOOP:
   i ++;
   if( i == area_count )
   {
      cb( area_count-1, rect );
      return;
   }

   f32 s0 = s*norm,
       s1 = s0+areas[i]*norm,
       cur = vg_maxf( w2n*areas[row_start]/(s0*s0), (s0*s0)/(w2n*areas[i-1]) ),
       new = vg_maxf( w2n*areas[row_start]/(s1*s1), (s1*s1)/(w2n*areas[i  ]) );

   if( (new < cur) && (i != area_count-1) )
   {
      s += areas[ i ];
      row_count ++;
      goto L_LOOP;
   }

   i32 height = s0 / w,
       out_box[4] = { rect[0], rect[1] };
   out_box[ 2+short_side^0x1 ] = height;
   f32 ihn = (1.0f/(f32)height) * norm;

   f32 x = rect[ short_side ];
   i32 start = x, end;
   for( u32 j=0; j<row_count; j ++ )
   {
      if( j == row_count-1 ) 
         end = rect[short_side]+rect[2+short_side];
      else 
      {
         x += areas[ row_start + j ] * ihn;
         end = x;
      }

      out_box[ short_side ] = start;
      out_box[ 2+short_side ] = end-start;
      cb( row_start + j, out_box );
      start=end;
   }

   rect[ short_side^0x1 ] += height;
   rect[ 2+short_side^0x1 ] -= height;

   area_total -= s;
   s = areas[ i ];

   row_count = 1;
   row_start = i;
   goto L_LOOP_ADJUST;
}