?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add support for Ayatana indicator to Notification plugin
[claws.git] / src / plugins / litehtml_viewer / litehtml / flex_line.cpp
blob5f966b3b155aafafabed2254a6196159cd4b524f
1 #include "html.h"
2 #include "flex_line.h"
3 #include "flex_item.h"
4 #include "render_item.h"
5
6 void litehtml::flex_line::distribute_free_space(int container_main_size)
7 {
8 // Determine the used flex factor. Sum the outer hypothetical main sizes of all items on the line.
9 // If the sum is less than the flex container’s inner main size, use the flex grow factor for the
10 // rest of this algorithm; otherwise, use the flex shrink factor.
11 int initial_free_space = container_main_size - base_size;
12 bool grow;
13 int total_flex_factor;
14 if(initial_free_space < 0)
15 {
16 grow = false;
17 total_flex_factor = total_shrink;
18 // Flex values between 0 and 1 have a somewhat special behavior: when the sum of the flex values on the line
19 // is less than 1, they will take up less than 100% of the free space.
20 // https://www.w3.org/TR/css-flexbox-1/#valdef-flex-flex-grow
21 if(total_flex_factor < 1000)
22 {
23 for(auto &item : items)
24 {
25 item->main_size += initial_free_space * item->shrink / 1000;
26 }
27 return;
28 }
29 } else
30 {
31 grow = true;
32 total_flex_factor = total_grow;
33 // Flex values between 0 and 1 have a somewhat special behavior: when the sum of the flex values on the line
34 // is less than 1, they will take up less than 100% of the free space.
35 // https://www.w3.org/TR/css-flexbox-1/#valdef-flex-flex-grow
36 if(total_flex_factor < 1000)
37 {
38 for(auto &item : items)
39 {
40 item->main_size += initial_free_space * item->grow / 1000;
41 }
42 return;
43 }
44 }
45
46 if(total_flex_factor > 0)
47 {
48 bool processed = true;
49 while (processed)
50 {
51 int sum_scaled_flex_shrink_factor = 0;
52 int sum_flex_factors = 0;
53 int remaining_free_space = container_main_size;
54 int total_not_frozen = 0;
55 for (auto &item: items)
56 {
57 if (!item->frozen)
58 {
59 sum_scaled_flex_shrink_factor += item->scaled_flex_shrink_factor;
60 if(grow)
61 {
62 sum_flex_factors += item->grow;
63 } else
64 {
65 sum_flex_factors += item->shrink;
66 }
67 remaining_free_space -= item->base_size;
68 total_not_frozen++;
69 } else
70 {
71 remaining_free_space -= item->main_size;
72 }
73 }
74 // Check for flexible items. If all the flex items on the line are frozen, free space has
75 // been distributed; exit this loop.
76 if (!total_not_frozen) break;
77
78 remaining_free_space = abs(remaining_free_space);
79 // c. Distribute free space proportional to the flex factors.
80 // If the remaining free space is zero
81 // Do nothing.
82 if (!remaining_free_space)
83 {
84 processed = false;
85 } else
86 {
87 int total_clamped = 0;
88 for (auto &item: items)
89 {
90 if (!item->frozen)
91 {
92 if(!grow)
93 {
94 // If using the flex shrink factor
95 // For every unfrozen item on the line, multiply its flex shrink factor by its
96 // inner flex base size, and note this as its scaled flex shrink factor. Find
97 // the ratio of the item’s scaled flex shrink factor to the sum of the scaled
98 // flex shrink factors of all unfrozen items on the line. Set the item’s target
99 // main size to its flex base size minus a fraction of the absolute value of the
100 // remaining free space proportional to the ratio.
101 int scaled_flex_shrink_factor = item->base_size * item->shrink;
102 item->main_size = (int) ((float) item->base_size - (float) remaining_free_space *
103 (float) scaled_flex_shrink_factor /
104 (float) sum_scaled_flex_shrink_factor);
105
106 // d. Fix min/max violations. Clamp each non-frozen item’s target main size by its used
107 // min and max main sizes and floor its content-box size at zero. If the item’s target
108 // main size was made smaller by this, it’s a max violation. If the item’s target main
109 // size was made larger by this, it’s a min violation.
110 if (item->main_size <= item->min_size)
111 {
112 total_clamped++;
113 item->main_size = item->min_size;
114 item->frozen = true;
115 }
116 if(!item->max_size.is_default() && item->main_size >= item->max_size)
117 {
118 total_clamped++;
119 item->main_size = item->max_size;
120 item->frozen = true;
121 }
122 } else
123 {
124 // If using the flex grow factor
125 // Find the ratio of the item’s flex grow factor to the sum of the flex grow
126 // factors of all unfrozen items on the line. Set the item’s target main size to
127 // its flex base size plus a fraction of the remaining free space proportional
128 // to the ratio.
129 item->main_size = (int) ((float) item->base_size +
130 (float) remaining_free_space * (float) item->grow /
131 (float) total_flex_factor);
132 // d. Fix min/max violations. Clamp each non-frozen item’s target main size by its used
133 // min and max main sizes and floor its content-box size at zero. If the item’s target
134 // main size was made smaller by this, it’s a max violation. If the item’s target main
135 // size was made larger by this, it’s a min violation.
136 if (item->main_size >= container_main_size)
137 {
138 total_clamped++;
139 item->main_size = container_main_size;
140 item->frozen = true;
141 }
142 if(!item->max_size.is_default() && item->main_size >= item->max_size)
143 {
144 total_clamped++;
145 item->main_size = item->max_size;
146 item->frozen = true;
147 }
148 }
149 }
150 }
151 if (total_clamped == 0) processed = false;
152 }
153 }
154 // Distribute remaining after algorithm space
155 int sum_main_size = 0;
156 for(auto &item : items)
157 {
158 sum_main_size += item->main_size;
159 }
160 int free_space = container_main_size - sum_main_size;
161 if(free_space > 0)
162 {
163 for(auto &item : items)
164 {
165 if(free_space == 0) break;
166 item->main_size++;
167 free_space--;
168 }
169 }
170 }
171 }
172
173 bool litehtml::flex_line::distribute_main_auto_margins(int free_main_size)
174 {
175 if(free_main_size > 0 && (num_auto_margin_main_start || num_auto_margin_main_end))
176 {
177 int add = (int) (free_main_size / (items.size() * 2));
178 for (auto &item: items)
179 {
180 if(!item->auto_margin_main_start.is_default())
181 {
182 item->auto_margin_main_start = add;
183 item->main_size += add;
184 main_size += add;
185 free_main_size -= add;
186 }
187 if(!item->auto_margin_main_end.is_default())
188 {
189 item->auto_margin_main_end = add;
190 item->main_size += add;
191 main_size += add;
192 free_main_size -= add;
193 }
194 }
195 while (free_main_size > 0)
196 {
197 for (auto &item: items)
198 {
199 if(!item->auto_margin_main_start.is_default())
200 {
201 item->auto_margin_main_start = item->auto_margin_main_start + 1;
202 free_main_size--;
203 if(!free_main_size) break;
204 }
205 if(!item->auto_margin_main_end.is_default())
206 {
207 item->auto_margin_main_end = item->auto_margin_main_end + 1;
208 free_main_size--;
209 if(!free_main_size) break;
210 }
211 }
212 }
213 return true;
214 }
215 return false;
216 }
217
218 void litehtml::flex_line::init(int container_main_size, bool fit_container, bool is_row_direction,
219 const litehtml::containing_block_context &self_size,
220 litehtml::formatting_context *fmt_ctx)
221 {
222 cross_size = 0;
223 main_size = 0;
224 first_baseline.set(0, baseline::baseline_type_none);
225 last_baseline.set(0, baseline::baseline_type_none);
226
227 if(!fit_container)
228 {
229 distribute_free_space(container_main_size);
230 }
231
232 if(is_row_direction)
233 {
234 def_value<int> first_baseline_top = 0;
235 def_value<int> first_baseline_bottom = 0;
236 def_value<int> last_baseline_top = 0;
237 def_value<int> last_baseline_bottom = 0;
238 int non_baseline_height = 0;
239
240 // Calculate maximum cross size
241 def_value<int> max_cross_size(0);
242 if(self_size.height.type != containing_block_context::cbc_value_type_auto)
243 {
244 max_cross_size = self_size.height;
245 }
246 if(self_size.max_height.type != containing_block_context::cbc_value_type_none)
247 {
248 if(max_cross_size.is_default())
249 {
250 max_cross_size = self_size.max_height;
251 } else
252 {
253 max_cross_size = std::max((int) max_cross_size, (int) self_size.max_height);
254 }
255 }
256
257 /// Render items into new size
258 /// Find line cross_size
259 /// Find line first/last baseline
260 for (auto &item: items)
261 {
262 item->el->render(0,
263 0,
264 self_size.new_width(item->main_size - item->el->content_offset_width(), containing_block_context::size_mode_exact_width), fmt_ctx, false);
265
266 if((item->align & 0xFF) == flex_align_items_baseline)
267 {
268 if(item->align & flex_align_items_last)
269 {
270 last_baseline.type(reverse_cross ? baseline::baseline_type_top : baseline::baseline_type_bottom);
271
272 int top = -item->el->get_last_baseline();
273 int bottom = top + item->el->height();
274
275 if(last_baseline_top.is_default()) last_baseline_top = top;
276 else last_baseline_top = std::min((int) last_baseline_top, top);
277
278 if(last_baseline_bottom.is_default()) last_baseline_bottom = bottom;
279 else last_baseline_bottom = std::max((int)last_baseline_bottom, bottom);
280 } else
281 {
282 first_baseline.type(reverse_cross ? baseline::baseline_type_bottom : baseline::baseline_type_top);
283 int top = -item->el->get_first_baseline();
284 int bottom = top + item->el->height();
285
286 if(first_baseline_top.is_default()) first_baseline_top = top;
287 else first_baseline_top = std::min((int) first_baseline_top, top);
288
289 if(first_baseline_bottom.is_default()) first_baseline_bottom = bottom;
290 else first_baseline_bottom = std::max((int) first_baseline_bottom, bottom);
291 }
292 } else
293 {
294 non_baseline_height = std::max(non_baseline_height, item->el->height());
295 }
296 main_size += item->el->width();
297 }
298
299 cross_size = std::max(first_baseline_bottom - first_baseline_top,last_baseline_bottom - last_baseline_top);
300 cross_size = std::max(cross_size, non_baseline_height);
301 if(!max_cross_size.is_default() && cross_size > max_cross_size)
302 {
303 cross_size = max_cross_size;
304 }
305
306 first_baseline.calc(first_baseline_top, first_baseline_bottom);
307 last_baseline.calc(last_baseline_top, last_baseline_bottom);
308 } else
309 {
310 // Calculate maximum cross size
311 def_value<int> max_cross_size(0);
312 if(self_size.width.type != containing_block_context::cbc_value_type_auto)
313 {
314 max_cross_size = self_size.width;
315 }
316 if(self_size.max_width.type != containing_block_context::cbc_value_type_none)
317 {
318 if(max_cross_size.is_default())
319 {
320 max_cross_size = self_size.max_width;
321 } else
322 {
323 max_cross_size = std::max((int) max_cross_size, (int) self_size.max_width);
324 }
325 }
326
327 for (auto &item: items)
328 {
329 int el_ret_width = item->el->render(0,
330 0,
331 self_size, fmt_ctx, false);
332 item->el->render(0,
333 0,
334 self_size.new_width_height(el_ret_width - item->el->content_offset_width(),
335 item->main_size - item->el->content_offset_height(),
336 containing_block_context::size_mode_exact_width |
337 containing_block_context::size_mode_exact_height),
338 fmt_ctx, false);
339 main_size += item->el->height();
340 cross_size = std::max(cross_size, item->el->width());
341 }
342 if(!max_cross_size.is_default() && cross_size > max_cross_size)
343 {
344 cross_size = max_cross_size;
345 }
346 }
347 }
348
349 int litehtml::flex_line::calculate_items_position(int container_main_size,
350 flex_justify_content justify_content,
351 bool is_row_direction,
352 const containing_block_context &self_size,
353 formatting_context *fmt_ctx)
354 {
355 /// Distribute main axis free space for auto-margins
356 int free_main_size = container_main_size - main_size;
357 distribute_main_auto_margins(free_main_size);
358 free_main_size = container_main_size - main_size;
359
360 /// Fix justify-content property
361 switch (justify_content)
362 {
363 case flex_justify_content_left:
364 case flex_justify_content_right:
365 if(!is_row_direction)
366 {
367 justify_content = flex_justify_content_start;
368 }
369 break;
370 case flex_justify_content_space_between:
371 // If the leftover free-space is negative or there is only a single flex item on the line, this
372 // value is identical to flex-start.
373 if(items.size() == 1 || free_main_size < 0) justify_content = flex_justify_content_flex_start;
374 break;
375 case flex_justify_content_space_around:
376 case flex_justify_content_space_evenly:
377 // If the leftover free-space is negative or there is only a single flex item on the line, this
378 // value is identical to center
379 if(items.size() == 1 || free_main_size < 0) justify_content = flex_justify_content_center;
380 break;
381 default:
382 break;
383 }
384
385 /// Distribute free main size using justify-content property
386 int main_pos = 0;
387 int add_before_item = 0;
388 int add_after_item = 0;
389 int item_remainder = 0;
390
391 /// find initial main position and spaces between items
392 switch (justify_content)
393 {
394
395 case flex_justify_content_right:
396 main_pos = free_main_size;
397 break;
398 case flex_justify_content_left:
399 case flex_justify_content_start:
400 main_pos = 0;
401 break;
402 case flex_justify_content_end:
403 main_pos = free_main_size;
404 break;
405 case flex_justify_content_flex_end:
406 if(!reverse_main)
407 {
408 main_pos = free_main_size;
409 }
410 break;
411 case flex_justify_content_center:
412 main_pos = free_main_size / 2;
413 break;
414 case flex_justify_content_space_between:
415 add_after_item = free_main_size / ((int) items.size() - 1);
416 item_remainder = free_main_size - (add_after_item * ((int) items.size() - 1));
417 break;
418 case flex_justify_content_space_around:
419 add_after_item = add_before_item = free_main_size / ((int) items.size() * 2);
420 item_remainder = free_main_size - (add_after_item * (int) items.size() * 2);
421 break;
422 case flex_justify_content_space_evenly:
423 add_before_item = free_main_size / ((int) items.size() + 1);
424 item_remainder = free_main_size - add_before_item * ((int) items.size() + 1);
425 break;
426 default:
427 if(reverse_main)
428 {
429 main_pos = free_main_size;
430 }
431 break;
432 }
433
434 /// Place all items in main and cross positions
435 int height = 0;
436 for(auto &item : items)
437 {
438 main_pos += add_before_item;
439 if(add_before_item > 0 && item_remainder > 0)
440 {
441 main_pos++;
442 item_remainder--;
443 }
444 item->place(*this, main_pos, self_size, fmt_ctx);
445 main_pos += item->get_el_main_size() + add_after_item;
446 if(add_after_item > 0 && item_remainder > 0)
447 {
448 main_pos++;
449 item_remainder--;
450 }
451 height = std::max(height, item->el->bottom());
452 }
453 return height;
454 }