Imported Upstream version 8.2.2

[platform/upstream/harfbuzz.git] / util / shape-consumer.hh

diff --git a/util/shape-consumer.hh b/util/shape-consumer.hh
index 220daa4..15c193f 100644 (file)
--- a/util/shape-consumer.hh
+++ b/util/shape-consumer.hh
@@ -24,58 +24,80 @@
  * Google Author(s): Behdad Esfahbod
  */
 
-#include "options.hh"
-
 #ifndef HB_SHAPE_CONSUMER_HH
 #define HB_SHAPE_CONSUMER_HH
 
+#include "font-options.hh"
+#include "shape-options.hh"
+#include "text-options.hh"
+
 
 template <typename output_t>
-struct shape_consumer_t
+struct shape_consumer_t : shape_options_t
 {
-  shape_consumer_t (option_parser_t *parser)
-                 : shaper (parser),
-                   output (parser) {}
+  void add_options (option_parser_t *parser)
+  {
+    shape_options_t::add_options (parser);
+    output.add_options (parser);
+  }
 
-  void init (const font_options_t *font_opts)
+  template <typename app_t>
+  void init (const app_t *app)
   {
-    font = hb_font_reference (font_opts->get_font ());
-    output.init (font_opts);
     failed = false;
+    buffer = hb_buffer_create ();
+
+    output.init (buffer, app);
   }
-  void consume_line (hb_buffer_t  *buffer,
-                    const char   *text,
-                    unsigned int  text_len)
+  template <typename app_t>
+  bool consume_line (app_t &app)
   {
+    unsigned int text_len;
+    const char *text;
+    if (!(text = app.get_line (&text_len)))
+      return false;
+
     output.new_line ();
 
-    shaper.populate_buffer (buffer, text, text_len);
-    output.consume_text (buffer, text, text_len, shaper.utf8_clusters);
+    for (unsigned int n = num_iterations; n; n--)
+    {
+      populate_buffer (buffer, text, text_len, app.text_before, app.text_after, app.font);
+      if (n == 1)
+       output.consume_text (buffer, text, text_len, utf8_clusters);
 
-    if (!shaper.shape (font, buffer)) {
-      failed = true;
-      hb_buffer_set_length (buffer, 0);
-      output.shape_failed (buffer, text, text_len, shaper.utf8_clusters);
-      return;
+      const char *error = nullptr;
+      if (!shape (app.font, buffer, &error))
+      {
+       failed = true;
+       output.error (error);
+       if (hb_buffer_get_content_type (buffer) == HB_BUFFER_CONTENT_TYPE_GLYPHS)
+         break;
+       else
+         return true;
+      }
     }
 
-    output.consume_glyphs (buffer, text, text_len, shaper.utf8_clusters);
+    if (glyphs)
+      output.consume_glyphs (buffer, nullptr, 0, false);
+    else
+      output.consume_glyphs (buffer, text, text_len, utf8_clusters);
+    return true;
   }
-  void finish (const font_options_t *font_opts)
+  template <typename app_t>
+  void finish (const app_t *app)
   {
-    output.finish (font_opts);
-    hb_font_destroy (font);
-    font = NULL;
+    output.finish (buffer, app);
+    hb_buffer_destroy (buffer);
+    buffer = nullptr;
   }
 
   public:
-  bool failed;
+  bool failed = false;
 
   protected:
-  shape_options_t shaper;
   output_t output;
 
-  hb_font_t *font;
+  hb_buffer_t *buffer = nullptr;
 };