| /* |
| * Copyright (C) 2000 Lars Knoll (knoll@kde.org) |
| * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. |
| * All right reserved. |
| * Copyright (C) 2010 Google Inc. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library 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 |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| * |
| */ |
| |
| #include "third_party/blink/renderer/core/layout/bidi_run_for_line.h" |
| |
| #include "third_party/blink/renderer/core/layout/line/inline_iterator.h" |
| |
| namespace blink { |
| |
| static LineLayoutItem FirstLayoutObjectForDirectionalityDetermination( |
| LineLayoutItem root, |
| LineLayoutItem current = nullptr) { |
| LineLayoutItem next = current; |
| while (current) { |
| if (TreatAsIsolated(current.StyleRef()) && |
| (current.IsLayoutInline() || current.IsLayoutBlock())) { |
| if (current != root) |
| current = nullptr; |
| else |
| current = next; |
| break; |
| } |
| current = current.Parent(); |
| } |
| |
| if (!current) |
| current = root.SlowFirstChild(); |
| |
| while (current) { |
| next = nullptr; |
| if (IsIteratorTarget(current) && |
| !(current.IsText() && |
| LineLayoutText(current).IsAllCollapsibleWhitespace())) |
| break; |
| |
| if (!IsIteratorTarget(LineLayoutItem(current)) && |
| !TreatAsIsolated(current.StyleRef())) |
| next = current.SlowFirstChild(); |
| |
| if (!next) { |
| while (current && current != root) { |
| next = current.NextSibling(); |
| if (next) |
| break; |
| current = current.Parent(); |
| } |
| } |
| |
| if (!next) |
| break; |
| |
| current = next; |
| } |
| |
| return current; |
| } |
| |
| TextDirection DeterminePlaintextDirectionality(LineLayoutItem root, |
| LineLayoutItem current, |
| unsigned pos) { |
| LineLayoutItem first_layout_object = |
| FirstLayoutObjectForDirectionalityDetermination(root, current); |
| InlineIterator iter(LineLayoutItem(root), first_layout_object, |
| first_layout_object == current ? pos : 0); |
| InlineBidiResolver observer; |
| observer.SetStatus(BidiStatus(root.StyleRef().Direction(), |
| IsOverride(root.StyleRef().GetUnicodeBidi()))); |
| observer.SetPositionIgnoringNestedIsolates(iter); |
| return observer.DetermineParagraphDirectionality(); |
| } |
| |
| static inline void SetupResolverToResumeInIsolate(InlineBidiResolver& resolver, |
| LineLayoutItem root, |
| LineLayoutItem start_object) { |
| if (root != start_object) { |
| LineLayoutItem parent = start_object.Parent(); |
| SetupResolverToResumeInIsolate(resolver, root, parent); |
| NotifyObserverEnteredObject(&resolver, LineLayoutItem(start_object)); |
| } |
| } |
| |
| void ConstructBidiRunsForLine(InlineBidiResolver& top_resolver, |
| BidiRunList<BidiRun>& bidi_runs, |
| const InlineIterator& end_of_line, |
| VisualDirectionOverride override, |
| bool previous_line_broke_cleanly, |
| bool is_new_uba_paragraph) { |
| // FIXME: We should pass a BidiRunList into createBidiRunsForLine instead |
| // of the resolver owning the runs. |
| DCHECK_EQ(&top_resolver.Runs(), &bidi_runs); |
| DCHECK(top_resolver.GetPosition() != end_of_line); |
| LineLayoutItem current_root = top_resolver.GetPosition().Root(); |
| top_resolver.CreateBidiRunsForLine(end_of_line, override, |
| previous_line_broke_cleanly); |
| |
| while (!top_resolver.IsolatedRuns().IsEmpty()) { |
| // It does not matter which order we resolve the runs as long as we |
| // resolve them all. |
| BidiIsolatedRun isolated_run = top_resolver.IsolatedRuns().back(); |
| top_resolver.IsolatedRuns().pop_back(); |
| current_root = isolated_run.root; |
| |
| LineLayoutItem start_obj = isolated_run.object; |
| |
| // Only inlines make sense with unicode-bidi: isolate (blocks are |
| // already isolated). |
| // FIXME: Because enterIsolate is not passed a LayoutObject, we have to |
| // crawl up the tree to see which parent inline is the isolate. We could |
| // change enterIsolate to take a LayoutObject and do this logic there, |
| // but that would be a layering violation for BidiResolver (which knows |
| // nothing about LayoutObject). |
| LineLayoutItem isolated_inline = |
| HighestContainingIsolateWithinRoot(start_obj, current_root); |
| DCHECK(isolated_inline); |
| |
| InlineBidiResolver isolated_resolver; |
| LineMidpointState& isolated_line_midpoint_state = |
| isolated_resolver.GetMidpointState(); |
| isolated_line_midpoint_state = |
| top_resolver.MidpointStateForIsolatedRun(isolated_run.run_to_replace); |
| UnicodeBidi unicode_bidi = isolated_inline.StyleRef().GetUnicodeBidi(); |
| TextDirection direction; |
| if (unicode_bidi == UnicodeBidi::kPlaintext) { |
| direction = DeterminePlaintextDirectionality( |
| isolated_inline, is_new_uba_paragraph ? start_obj : nullptr); |
| } else { |
| DCHECK(unicode_bidi == UnicodeBidi::kIsolate || |
| unicode_bidi == UnicodeBidi::kIsolateOverride); |
| direction = isolated_inline.StyleRef().Direction(); |
| } |
| isolated_resolver.SetStatus(BidiStatus::CreateForIsolate( |
| direction, IsOverride(unicode_bidi), isolated_run.level)); |
| |
| SetupResolverToResumeInIsolate(isolated_resolver, isolated_inline, |
| start_obj); |
| |
| // The starting position is the beginning of the first run within the |
| // isolate that was identified during the earlier call to |
| // createBidiRunsForLine. This can be but is not necessarily the first |
| // run within the isolate. |
| InlineIterator iter = |
| InlineIterator(LineLayoutItem(isolated_inline), |
| LineLayoutItem(start_obj), isolated_run.position); |
| isolated_resolver.SetPositionIgnoringNestedIsolates(iter); |
| // We stop at the next end of line; we may re-enter this isolate in the |
| // next call to constructBidiRuns(). |
| // FIXME: What should end and previousLineBrokeCleanly be? |
| // rniwa says previousLineBrokeCleanly is just a WinIE hack and could |
| // always be false here? |
| isolated_resolver.CreateBidiRunsForLine(end_of_line, kNoVisualOverride, |
| previous_line_broke_cleanly); |
| |
| DCHECK(isolated_resolver.Runs().RunCount()); |
| if (isolated_resolver.Runs().RunCount()) |
| bidi_runs.ReplaceRunWithRuns(&isolated_run.run_to_replace, |
| isolated_resolver.Runs()); |
| |
| // If we encountered any nested isolate runs, save them for later |
| // processing. |
| while (!isolated_resolver.IsolatedRuns().IsEmpty()) { |
| BidiIsolatedRun run_with_context = |
| isolated_resolver.IsolatedRuns().back(); |
| isolated_resolver.IsolatedRuns().pop_back(); |
| top_resolver.SetMidpointStateForIsolatedRun( |
| run_with_context.run_to_replace, |
| isolated_resolver.MidpointStateForIsolatedRun( |
| run_with_context.run_to_replace)); |
| top_resolver.IsolatedRuns().push_back(run_with_context); |
| } |
| } |
| } |
| |
| } // namespace blink |
