Esempio n. 1
0
/* Calculates the ideal size of the toolbar */
static void _etk_toolbar_size_request(Etk_Widget *widget, Etk_Size *size)
{
   Etk_Toolbar *toolbar;

   if (!(toolbar = ETK_TOOLBAR(widget)) || !size)
      return;
   etk_widget_size_request(ETK_WIDGET(toolbar->box), size);
}
Esempio n. 2
0
/* Recursively requests the size of all the widgets */
static void _etk_main_size_request_recursive(Etk_Widget *widget)
{
   Eina_List *l;
   Etk_Size unused_size;

   if (!widget)
      return;

   etk_widget_size_request(widget, &unused_size);
   for (l = widget->children; l; l = l->next)
      _etk_main_size_request_recursive(ETK_WIDGET(l->data));
}
Esempio n. 3
0
/* Resizes the toolbar to the allocated size */
static void _etk_toolbar_size_allocate(Etk_Widget *widget, Etk_Geometry geometry)
{
   Etk_Toolbar *toolbar;
   Etk_Size size;

   if (!(toolbar = ETK_TOOLBAR(widget)))
      return;

   etk_widget_size_request(toolbar->box, &size);
   geometry.w = ETK_MAX(geometry.w, size.w);
   etk_widget_size_allocate(ETK_WIDGET(toolbar->box), geometry);
}
Esempio n. 4
0
/* Calculates the ideal size of the vbox */
static void _etk_vbox_size_request(Etk_Widget *widget, Etk_Size *size)
{
   Etk_VBox *vbox;
   Etk_Box *box;
   Etk_Container *container;
   Etk_Box_Cell *cell;
   Etk_Widget *child;
   Etk_Size child_size;
   int num_visible_children;
   int i, j;

   if (!(vbox = ETK_VBOX(widget)) || !size)
      return;

   box = ETK_BOX(vbox);
   container = ETK_CONTAINER(vbox);
   size->w = 0;
   size->h = 0;
   num_visible_children = 0;

   for (i = 0; i < 2; i++)
   {
      box->request_sizes[i] = realloc(box->request_sizes[i], box->cells_count[i] * sizeof(int));
      for (cell = box->first_cell[i], j = 0; cell; cell = cell->next, j++)
      {
         child = cell->child;
         box->request_sizes[i][j] = 0;

         if (!etk_widget_is_visible(child))
            continue;

         etk_widget_size_request(child, &child_size);

         if (box->homogeneous)
         {
            if (size->h < child_size.h + 2 * cell->padding)
               size->h = child_size.h + 2 * cell->padding;
         }
         else
         {
            box->request_sizes[i][j] = child_size.h + 2 * cell->padding;
            size->h += box->request_sizes[i][j];
         }

         if (size->w < child_size.w)
            size->w = child_size.w;

         num_visible_children++;
      }
   }
   if (box->homogeneous)
   {
      for (i = 0; i < 2; i++)
      {
         for (j = 0; j < box->cells_count[i]; j++)
            box->request_sizes[i][j] = size->h;
      }
      size->h *= num_visible_children;
   }
   if (num_visible_children > 1)
      size->h += (num_visible_children - 1) * box->spacing;

   size->w += 2 * container->border_width;
   size->h += 2 * container->border_width;
}
Esempio n. 5
0
/* Calculates the ideal size of the table */
static void _etk_table_size_request(Etk_Widget *widget, Etk_Size *size_requisition)
{
   Etk_Table *table;
   Etk_Widget *child;
   Etk_Table_Cell *cell;
   Etk_Size child_size;
   Etk_Bool hexpand = ETK_FALSE, vexpand = ETK_FALSE;
   Eina_List *l;
   int i;

   if (!(table = ETK_TABLE(widget)) || !size_requisition)
      return;

   if (!table->cells)
   {
      size_requisition->w = 0;
      size_requisition->h = 0;
   }
   else
   {
      /*********************************************
       * Phase 1: We calculate the width of the cols of the table
       *********************************************/

      /* Horizontally-homogeneous table */
      if (table->homogeneous & ETK_TABLE_HHOMOGENEOUS)
      {
         int max_col_width = CELL_MIN_SIZE;
         int cell_size;

         /* We calculate the maximum size of a cell */
         for (l = table->cells_list; l; l = l->next)
         {
            cell = l->data;
            child = cell->child;
            etk_widget_size_request(child, &child_size);

            cell_size = (2 * cell->x_padding + child_size.w) / (cell->right_attach - cell->left_attach + 1);
            if (max_col_width < cell_size)
               max_col_width = cell_size;
            hexpand |= (cell->fill_policy & ETK_TABLE_HEXPAND);
         }

         for (i = 0; i < table->num_cols; i++)
         {
            table->cols[i].requested_size = max_col_width;
            table->cols[i].expand = !!hexpand;
         }

         size_requisition->w = table->num_cols * max_col_width;
      }
      /* Non horizontally-homogeneous table */
      else
      {
         for (i = 0; i < table->num_cols; i++)
         {
            table->cols[i].requested_size = CELL_MIN_SIZE;
            table->cols[i].expand = ETK_FALSE;
         }

         /* We first treat the children that span only one column */
         for (l = table->cells_list; l; l = l->next)
         {
            cell = l->data;
            child = cell->child;

            if (cell->left_attach == cell->right_attach)
            {
               etk_widget_size_request(child, &child_size);
               if (table->cols[cell->left_attach].requested_size < child_size.w + 2 * cell->x_padding)
                  table->cols[cell->left_attach].requested_size = child_size.w + 2 * cell->x_padding;
               table->cols[cell->left_attach].expand |= ((cell->fill_policy & ETK_TABLE_HEXPAND) != 0);
               hexpand |= (cell->fill_policy & ETK_TABLE_HEXPAND);
            }
         }
         /* Then, we treat the children that span several columns */
         for (l = table->cells_list; l; l = l->next)
         {
            int cells_size;
            int num_expandable_cells;
            int free_space;
            float delta;

            cell = l->data;
            child = cell->child;

            if (cell->left_attach < cell->right_attach)
            {
               cells_size = 0;
               num_expandable_cells = 0;

               etk_widget_size_request(child, &child_size);
               for (i = cell->left_attach; i <= cell->right_attach; i++)
               {
                  cells_size += table->cols[i].requested_size;
                  if (!hexpand && (cell->fill_policy & ETK_TABLE_HEXPAND))
                     table->cols[i].expand = ETK_TRUE;
                  if (table->cols[i].expand)
                     num_expandable_cells++;
               }

               free_space = child_size.w - cells_size;
               if (free_space > 0)
               {
                  if (num_expandable_cells <= 0)
                  {
                     delta = (float)free_space / (cell->right_attach - cell->left_attach + 1);
                     for (i = cell->left_attach; i <= cell->right_attach; i++)
                        table->cols[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
                  }
                  else
                  {
                     delta = (float)free_space / num_expandable_cells;
                     for (i = cell->left_attach; i <= cell->right_attach; i++)
                     {
                        if (table->cols[i].expand)
                           table->cols[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
                     }
                  }
               }
            }
         }

         size_requisition->w = 0;
         for (i = 0; i < table->num_cols; i++)
            size_requisition->w += table->cols[i].requested_size;
      }


      /*********************************************
       * Phase 2: We calculate the height of the rows of the table
       *********************************************/

      /* Vertically-homogeneous table */
      if (table->homogeneous & ETK_TABLE_VHOMOGENEOUS)
      {
         int max_row_height = CELL_MIN_SIZE;
         int cell_size;

         /* We calculate the maximum size of a cell */
         for (l = table->cells_list; l; l = l->next)
         {
            cell = l->data;
            child = cell->child;
            etk_widget_size_request(child, &child_size);

            cell_size = (2 * cell->y_padding + child_size.h) / (cell->bottom_attach - cell->top_attach + 1);
            if (max_row_height < cell_size)
               max_row_height = cell_size;
            vexpand |= (cell->fill_policy & ETK_TABLE_VEXPAND);
         }

         for (i = 0; i < table->num_rows; i++)
         {
            table->rows[i].requested_size = max_row_height;
            table->rows[i].expand = !!vexpand;
         }

         size_requisition->h = table->num_rows * max_row_height;
      }
      /* Non vertically-homogeneous table */
      else
      {
         for (i = 0; i < table->num_rows; i++)
         {
            table->rows[i].requested_size = CELL_MIN_SIZE;
            table->rows[i].expand = ETK_FALSE;
         }

         /* We first treat the children that span only one row */
         for (l = table->cells_list; l; l = l->next)
         {
            cell = l->data;
            child = cell->child;

            if (cell->top_attach == cell->bottom_attach)
            {
               etk_widget_size_request(child, &child_size);
               if (table->rows[cell->top_attach].requested_size < child_size.h + 2 * cell->y_padding)
                  table->rows[cell->top_attach].requested_size = child_size.h + 2 * cell->y_padding;
               table->rows[cell->top_attach].expand |= ((cell->fill_policy & ETK_TABLE_VEXPAND) != 0);
               vexpand |= (cell->fill_policy & ETK_TABLE_VEXPAND);
            }
         }
         /* Then, we treat the children that span several rows */
         for (l = table->cells_list; l; l = l->next)
         {
            int cells_size;
            int num_expandable_cells;
            int free_space;
            float delta;

            cell = l->data;
            child = cell->child;

            if (cell->top_attach < cell->bottom_attach)
            {
               cells_size = 0;
               num_expandable_cells = 0;

               etk_widget_size_request(child, &child_size);
               for (i = cell->top_attach; i <= cell->bottom_attach; i++)
               {
                  cells_size += table->rows[i].requested_size;
                  if (!vexpand && (cell->fill_policy & ETK_TABLE_VEXPAND))
                     table->rows[i].expand = ETK_TRUE;
                  if (table->rows[i].expand)
                     num_expandable_cells++;
               }

               free_space = child_size.h - cells_size;
               if (free_space > 0)
               {
                  if (num_expandable_cells <= 0)
                  {
                     delta = (float)free_space / (cell->bottom_attach - cell->top_attach + 1);
                     for (i = cell->top_attach; i <= cell->bottom_attach; i++)
                        table->rows[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
                  }
                  else
                  {
                     delta = (float)free_space / num_expandable_cells;
                     for (i = cell->top_attach; i <= cell->bottom_attach; i++)
                     {
                        if (table->rows[i].expand)
                           table->rows[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
                     }
                  }
               }
            }
         }

         size_requisition->h = 0;
         for (i = 0; i < table->num_rows; i++)
            size_requisition->h += table->rows[i].requested_size;
      }
   }

   size_requisition->w += 2 * ETK_CONTAINER(table)->border_width;
   size_requisition->h += 2 * ETK_CONTAINER(table)->border_width;
}