gtkcenterbox.c 11.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
/*
 * Copyright (c) 2017 Timm Bäder <mail@baedert.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Author: Timm Bäder <mail@baedert.org>
 */

/**
 * SECTION:gtkcenterbox
 * @Short_description: A centering container
 * @Title: GtkCenterBox
 * @See_also: #GtkBox
 *
 * The GtkCenterBox widget arranges three children in a horizontal
 * or vertical arrangement, keeping the middle child centered as well
 * as possible.
 *
 * To add children to GtkCenterBox, use gtk_center_box_set_start_widget(),
 * gtk_center_box_set_center_widget() and gtk_center_box_set_end_widget().
 *
 * # CSS nodes
 *
 * GtkCenterBox uses a single CSS node with name box.
 *
 * In horizontal orientation, the nodes of the children are always arranged
 * from left to right. So :first-child will always select the leftmost child,
 * regardless of text direction.
 *
 * In vertical orientation, the are arranged from top to bottom.
 */

#include "config.h"
#include "gtkcenterbox.h"
#include "gtkcssnodeprivate.h"
#include "gtkwidgetprivate.h"

struct _GtkCenterBox
{
  GtkWidget parent_instance;

  GtkWidget *start_widget;
  GtkWidget *center_widget;
  GtkWidget *end_widget;
};


struct _GtkCenterBoxClass
{
  GtkWidgetClass parent_class;
};
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78


G_DEFINE_TYPE (GtkCenterBox, gtk_center_box, GTK_TYPE_WIDGET);


static void
gtk_center_box_measure (GtkWidget      *widget,
                        GtkOrientation  orientation,
                        int             for_size,
                        int            *minimum,
                        int            *natural,
                        int            *minimum_baseline,
                        int            *natural_baseline)
{
  GtkCenterBox *self = GTK_CENTER_BOX (widget);
79 80 81 82 83 84 85
  int min_baseline, nat_baseline;
  int start_min = 0;
  int start_nat = 0;
  int center_min = 0;
  int center_nat = 0;
  int end_min = 0;
  int end_nat = 0;
86

87
  if (self->start_widget)
88 89 90 91 92
    gtk_widget_measure (self->start_widget,
                        orientation,
                        for_size,
                        &start_min, &start_nat,
                        &min_baseline, &nat_baseline);
93

94
  if (self->center_widget)
95 96 97 98 99
    gtk_widget_measure (self->center_widget,
                        orientation,
                        for_size,
                        &center_min, &center_nat,
                        &min_baseline, &nat_baseline);
100 101

  if (self->end_widget)
102 103 104 105 106 107 108 109 110 111 112 113
    gtk_widget_measure (self->end_widget,
                        orientation,
                        for_size,
                        &end_min, &end_nat,
                        &min_baseline, &nat_baseline);

  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      *minimum = start_min + center_min + end_min;
      *natural = center_nat + 2 * MAX (start_nat, end_nat);
    }
  else /* GTK_ORIENTATION_VERTICAL */
114
    {
115 116
      *minimum = MAX (start_min, MAX (center_min, end_min));
      *natural = MAX (start_nat, MAX (center_nat, end_nat));
117
    }
118 119 120 121 122 123 124 125 126 127
}

static void
gtk_center_box_size_allocate (GtkWidget     *widget,
                              GtkAllocation *allocation)
{
  GtkCenterBox *self = GTK_CENTER_BOX (widget);
  GtkAllocation child_allocation;
  GtkAllocation clip = *allocation;
  GtkAllocation child_clip;
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
  GtkWidget *left;
  GtkWidget *right;
  int left_size = 0;
  int left_min = 0;
  int left_nat = 0;
  int center_size = 0;
  int center_min = 0;
  int center_nat = 0;
  int right_size = 0;
  int right_min = 0;
  int right_nat = 0;
  int avail;

  if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
    {
      left = self->start_widget;
      right = self->end_widget;
    }
  else
    {
      right = self->start_widget;
      left = self->end_widget;
    }
151 152 153

  GTK_WIDGET_CLASS (gtk_center_box_parent_class)->size_allocate (widget, allocation);

154 155 156 157 158 159 160 161 162 163 164 165 166 167
  if (left)
    gtk_widget_measure (left, GTK_ORIENTATION_HORIZONTAL,
                        allocation->height,
                        &left_min, &left_nat, NULL, NULL);

  if (right)
    gtk_widget_measure (right, GTK_ORIENTATION_HORIZONTAL,
                        allocation->height,
                        &right_min, &right_nat, NULL, NULL);

  if (self->center_widget)
    gtk_widget_measure (self->center_widget, GTK_ORIENTATION_HORIZONTAL,
                        allocation->height,
                        &center_min, &center_nat, NULL, NULL);
168 169 170 171

  child_allocation.y = allocation->y;
  child_allocation.height = allocation->height;

172 173 174
  center_size = CLAMP (allocation->width - (left_min + right_min), center_min, center_nat);

  if (left)
175
    {
176 177
      avail = MIN ((allocation->width - center_size) / 2, allocation->width - (center_size + right_min));
      child_allocation.width = CLAMP (avail, left_min, left_nat);
178 179
      child_allocation.x = allocation->x;

180 181
      gtk_widget_size_allocate (left, &child_allocation);
      gtk_widget_get_clip (left, &child_clip);
182
      gdk_rectangle_union (&clip, &clip, &child_clip);
183
      left_size = child_allocation.width;
184
    }
185

186
  if (right)
187
    {
188 189 190 191 192 193
      avail = MIN ((allocation->width - center_size) / 2, allocation->width - (center_size + left_min));
      child_allocation.width = CLAMP (avail, right_min, right_nat);
      child_allocation.x = allocation->x + allocation->width - child_allocation.width;

      gtk_widget_size_allocate (right, &child_allocation);
      gtk_widget_get_clip (right, &child_clip);
194
      gdk_rectangle_union (&clip, &clip, &child_clip);
195
      right_size = child_allocation.width;
196
    }
197 198 199

  if (self->center_widget)
    {
200 201
      child_allocation.width = center_size;
      child_allocation.x = (allocation->width / 2) - (child_allocation.width / 2);
202 203

      /* Push in from start/end */
204 205 206 207
      if (left_size > child_allocation.x)
        child_allocation.x = left_size;
      else if (allocation->width - right_size < child_allocation.x + child_allocation.width)
        child_allocation.x = allocation->width - child_allocation.width - right_size;
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

      child_allocation.x += allocation->x;
      gtk_widget_size_allocate (self->center_widget, &child_allocation);
      gtk_widget_get_clip (self->center_widget, &child_clip);
      gdk_rectangle_union (&clip, &clip, &child_clip);
    }

  gtk_widget_set_clip (widget, &clip);
}

static void
gtk_center_box_snapshot (GtkWidget   *widget,
                         GtkSnapshot *snapshot)
{
  GtkCenterBox *self = GTK_CENTER_BOX (widget);

224 225
  if (self->start_widget)
    gtk_widget_snapshot_child (widget, self->start_widget, snapshot);
226 227 228 229

  if (self->center_widget)
    gtk_widget_snapshot_child (widget, self->center_widget, snapshot);

230 231
  if (self->end_widget)
    gtk_widget_snapshot_child (widget, self->end_widget, snapshot);
232 233
}

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
static void
update_css_node_order (GtkCenterBox *self)
{
  GtkCssNode *parent;
  GtkCssNode *first;
  GtkCssNode *last;

  parent = gtk_widget_get_css_node (GTK_WIDGET (self));

  if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_LTR)
    {
      first = self->start_widget ? gtk_widget_get_css_node (self->start_widget) : NULL;
      last = self->end_widget ? gtk_widget_get_css_node (self->end_widget) : NULL;
    }
  else
    {
      first = self->end_widget ? gtk_widget_get_css_node (self->end_widget) : NULL;
      last = self->start_widget ? gtk_widget_get_css_node (self->start_widget) : NULL;
    }

  if (first)
    gtk_css_node_insert_after (parent, first, NULL);
  if (last)
    gtk_css_node_insert_before (parent, last, NULL);
}

static void
gtk_center_box_direction_changed (GtkWidget        *widget,
                                  GtkTextDirection  previous_direction)
{
  update_css_node_order (GTK_CENTER_BOX (widget));
}

267 268 269 270 271 272 273 274
static void
gtk_center_box_class_init (GtkCenterBoxClass *klass)
{
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  widget_class->measure = gtk_center_box_measure;
  widget_class->size_allocate = gtk_center_box_size_allocate;
  widget_class->snapshot = gtk_center_box_snapshot;
275
  widget_class->direction_changed = gtk_center_box_direction_changed;
276 277 278

  gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_FILLER);
  gtk_widget_class_set_css_name (widget_class, "box");
279 280 281 282 283 284 285 286 287 288 289 290
}

static void
gtk_center_box_init (GtkCenterBox *self)
{
  gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);

  self->start_widget = NULL;
  self->center_widget = NULL;
  self->end_widget = NULL;
}

291 292 293 294 295 296 297 298 299
/**
 * gtk_center_box_new:
 *
 * Creates a new #GtkCenterBox.
 *
 * Returns: the new #GtkCenterBox.
 *
 * Since: 3.92
 */
300 301 302 303 304 305
GtkWidget *
gtk_center_box_new (void)
{
  return GTK_WIDGET (g_object_new (GTK_TYPE_CENTER_BOX, NULL));
}

306 307 308 309 310 311 312 313 314
/**
 * gtk_center_box_set_start_widget:
 * @self: a #GtkCenterBox
 * @child: the child
 *
 * Sets the start widget.
 *
 * Since: 3.92
 */
315 316 317 318 319 320 321 322 323 324
void
gtk_center_box_set_start_widget (GtkCenterBox *self,
                                 GtkWidget    *child)
{
  if (self->start_widget)
    gtk_widget_unparent (self->start_widget);

  self->start_widget = child;
  if (child)
    gtk_widget_set_parent (child, GTK_WIDGET (self));
325 326

  update_css_node_order (self);
327 328
}

329 330 331 332 333 334 335 336 337
/**
 * gtk_center_box_set_center_widget:
 * @self: a #GtkCenterBox
 * @child: the child
 *
 * Sets the center widget.
 *
 * Since: 3.92
 */
338 339
void
gtk_center_box_set_center_widget (GtkCenterBox *self,
340
                                 GtkWidget     *child)
341 342 343 344 345 346 347
{
  if (self->center_widget)
    gtk_widget_unparent (self->center_widget);

  self->center_widget = child;
  if (child)
    gtk_widget_set_parent (child, GTK_WIDGET (self));
348 349

  update_css_node_order (self);
350 351
}

352 353 354 355 356 357 358 359 360
/**
 * gtk_center_box_set_end_widget:
 * @self: a #GtkCenterBox
 * @child: the child
 *
 * Sets the end widget.
 *
 * Since: 3.92
 */
361 362 363 364 365 366 367 368 369 370
void
gtk_center_box_set_end_widget (GtkCenterBox *self,
                               GtkWidget    *child)
{
  if (self->end_widget)
    gtk_widget_unparent (self->end_widget);

  self->end_widget = child;
  if (child)
    gtk_widget_set_parent (child, GTK_WIDGET (self));
371 372

  update_css_node_order (self);
373 374
}

375 376 377 378 379 380 381 382 383 384
/**
 * gtk_center_box_get_start_widget:
 * @self: a #GtkCenterBox
 *
 * Gets the start widget.
 *
 * Returns: the start widget.
 *
 * Since: 3.92
 */
385 386 387 388 389 390
GtkWidget *
gtk_center_box_get_start_widget (GtkCenterBox *self)
{
  return self->start_widget;
}

391 392 393 394 395 396 397 398 399 400
/**
 * gtk_center_box_get_center_widget:
 * @self: a #GtkCenterBox
 *
 * Gets the center widget.
 *
 * Returns: the center widget.
 *
 * Since: 3.92
 */
401 402 403 404 405 406
GtkWidget *
gtk_center_box_get_center_widget (GtkCenterBox *self)
{
  return self->center_widget;
}

407 408 409 410 411 412 413 414 415 416
/**
 * gtk_center_box_get_end_widget:
 * @self: a #GtkCenterBox
 *
 * Gets the end widget.
 *
 * Returns: the end widget.
 *
 * Since: 3.92
 */
417 418 419 420 421
GtkWidget *
gtk_center_box_get_end_widget (GtkCenterBox *self)
{
  return self->end_widget;
}