GUI for font-variant-xxx, parse 'font-variant-ligatures'. This is a work in progress.

(bzr r14148)

13 files changed, 655 insertions, 25 deletions

diff --git a/src/desktop-style.cpp b/src/desktop-style.cpp
index afdc3064a..118f983bb 100644
--- a/src/desktop-style.cpp
+++ b/src/desktop-style.cpp
@@ -1168,6 +1168,63 @@ objects_query_fontstyle (const std::vector<SPItem*> &objects, SPStyle *style_res
     }
 }
 
+int
+objects_query_fontvariants (const std::vector<SPItem*> &objects, SPStyle *style_res)
+{
+    bool set = false;
+
+    int texts = 0;
+
+    SPILigatures* ligatures_res = &(style_res->font_variant_ligatures);
+    ligatures_res->computed =
+        SP_CSS_FONT_VARIANT_LIGATURES_COMMON |
+        SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL;
+    ligatures_res->value = 0;
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
+
+        if (!isTextualItem(obj)) {
+            continue;
+        }
+
+        SPStyle *style = obj->style;
+        if (!style) {
+            continue;
+        }
+
+        texts ++;
+
+        SPILigatures* ligatures_in = &(style->font_variant_ligatures);
+        // computed stores which bits are on/off, only valid if same between all selected objects.
+        // value stores which bits are different between objects. This is a bit of an abuse of
+        // the values but then we don't need to add new variables to class.
+        if (set) {
+            ligatures_res->value  |= (ligatures_res->computed ^ ligatures_in->computed );
+            ligatures_res->computed &= ligatures_in->computed;
+        } else {
+            set = true;
+            ligatures_res->computed  = ligatures_in->computed;
+        }
+    }
+
+    bool different = (style_res->font_variant_position.value !=
+                      style_res->font_variant_position.computed );
+
+    if (texts == 0 || !set)
+        return QUERY_STYLE_NOTHING;
+
+    if (texts > 1) {
+        if (different) {
+            return QUERY_STYLE_MULTIPLE_DIFFERENT;
+        } else {
+            return QUERY_STYLE_MULTIPLE_SAME;
+        }
+    } else {
+        return QUERY_STYLE_SINGLE;
+    }
+}
+
+
 /**
  * Write to style_res the baseline numbers.
  */
@@ -1577,6 +1634,8 @@ sp_desktop_query_style_from_list (const std::vector<SPItem*> &list, SPStyle *sty
         return objects_query_fontfamily (list, style);
     } else if (property == QUERY_STYLE_PROPERTY_FONTSTYLE) {
         return objects_query_fontstyle (list, style);
+    } else if (property == QUERY_STYLE_PROPERTY_FONTVARIANTS) {
+        return objects_query_fontvariants (list, style);
     } else if (property == QUERY_STYLE_PROPERTY_FONTNUMBERS) {
         return objects_query_fontnumbers (list, style);
     } else if (property == QUERY_STYLE_PROPERTY_BASELINES) {
@@ -1598,6 +1657,7 @@ sp_desktop_query_style_from_list (const std::vector<SPItem*> &list, SPStyle *sty
 int
 sp_desktop_query_style(SPDesktop *desktop, SPStyle *style, int property)
 {
+    // Used by text tool and in gradient dragging
     int ret = desktop->_query_style_signal.emit(style, property);
 
     if (ret != QUERY_STYLE_NOTHING)
diff --git a/src/desktop-style.h b/src/desktop-style.h
index a72f49776..e5fe50440 100644
--- a/src/desktop-style.h
+++ b/src/desktop-style.h
@@ -47,6 +47,7 @@ enum { // which property was queried (add when you need more)
     QUERY_STYLE_PROPERTY_FONT_SPECIFICATION, //-inkscape-font-specification
     QUERY_STYLE_PROPERTY_FONTFAMILY, // font-family
     QUERY_STYLE_PROPERTY_FONTSTYLE, // font style 
+    QUERY_STYLE_PROPERTY_FONTVARIANTS, // font variants (OpenType features)
     QUERY_STYLE_PROPERTY_FONTNUMBERS, // size, spacings
     QUERY_STYLE_PROPERTY_BASELINES, // baseline-shift
     QUERY_STYLE_PROPERTY_MASTEROPACITY, // opacity
@@ -71,6 +72,7 @@ int objects_query_fillstroke (const std::vector<SPItem*> &objects, SPStyle *styl
 int objects_query_fontnumbers (const std::vector<SPItem*> &objects, SPStyle *style_res);
 int objects_query_fontstyle (const std::vector<SPItem*> &objects, SPStyle *style_res);
 int objects_query_fontfamily (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_fontvariants (const std::vector<SPItem*> &objects, SPStyle *style_res);
 int objects_query_opacity (const std::vector<SPItem*> &objects, SPStyle *style_res);
 int objects_query_strokewidth (const std::vector<SPItem*> &objects, SPStyle *style_res);
 int objects_query_miterlimit (const std::vector<SPItem*> &objects, SPStyle *style_res);
diff --git a/src/style-enums.h b/src/style-enums.h
index f235b6699..36eab216d 100644
--- a/src/style-enums.h
+++ b/src/style-enums.h
@@ -74,16 +74,15 @@ enum SPCSSFontStretch {
 
 // Can select more than one
 enum SPCSSFontVariantLigatures {
-    SP_CSS_FONT_VARIANT_LIGATURES_NORMAL,
-    SP_CSS_FONT_VARIANT_LIGATURES_NONE,
-    SP_CSS_FONT_VARIANT_LIGATURES_COMMON,
-    SP_CSS_FONT_VARIANT_LIGATURES_NO_COMMON,
-    SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY,
-    SP_CSS_FONT_VARIANT_LIGATURES_NO_DISCRETIONARY,
-    SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL,
-    SP_CSS_FONT_VARIANT_LIGATURES_NO_HISTORICAL,
-    SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL,
-    SP_CSS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL
+    SP_CSS_FONT_VARIANT_LIGATURES_NONE            = 0,
+    SP_CSS_FONT_VARIANT_LIGATURES_COMMON          = 1,
+    SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY   = 2,
+    SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL      = 4,
+    SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL      = 8,
+    SP_CSS_FONT_VARIANT_LIGATURES_NOCOMMON        = 16,
+    SP_CSS_FONT_VARIANT_LIGATURES_NODISCRETIONARY = 32,
+    SP_CSS_FONT_VARIANT_LIGATURES_NOHISTORICAL    = 64,
+    SP_CSS_FONT_VARIANT_LIGATURES_NOCONTEXTUAL    = 128
 };
 
 enum SPCSSFontVariantPosition {
@@ -102,6 +101,7 @@ enum SPCSSFontVariantCaps {
     SP_CSS_FONT_VARIANT_CAPS_TITLING,
 };
 
+// Can select more than one (see spec)
 enum SPCSSFontVariantNumeric {
     SP_CSS_FONT_VARIANT_NUMERIC_NORMAL,
     SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS,
@@ -376,16 +376,15 @@ static SPStyleEnum const enum_font_stretch[] = {
 };
 
 static SPStyleEnum const enum_font_variant_ligatures[] = {
-    {"normal", SP_CSS_FONT_VARIANT_LIGATURES_NORMAL},
-    {"none", SP_CSS_FONT_VARIANT_LIGATURES_NONE},
-    {"common-ligatures", SP_CSS_FONT_VARIANT_LIGATURES_COMMON},
-    {"no-common-ligatures", SP_CSS_FONT_VARIANT_LIGATURES_NO_COMMON},
-    {"discretionary-ligatures", SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY},
-    {"no-discretionary-ligatures", SP_CSS_FONT_VARIANT_LIGATURES_NO_DISCRETIONARY},
-    {"historical-ligatures", SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL},
-    {"nohistorical-ligatures", SP_CSS_FONT_VARIANT_LIGATURES_NO_HISTORICAL},
-    {"contextual", SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL},
-    {"no-contextual", SP_CSS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL},
+    {"none",                         SP_CSS_FONT_VARIANT_LIGATURES_NONE},
+    {"common-ligatures",             SP_CSS_FONT_VARIANT_LIGATURES_COMMON},
+    {"discretionary-ligatures",      SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY},
+    {"historical-ligatures",         SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL},
+    {"contextual",                   SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL},
+    {"no-common-ligatures",          SP_CSS_FONT_VARIANT_LIGATURES_NOCOMMON},
+    {"no-discretionary-ligatures",   SP_CSS_FONT_VARIANT_LIGATURES_NODISCRETIONARY},
+    {"no-historical-ligatures",      SP_CSS_FONT_VARIANT_LIGATURES_NOHISTORICAL},
+    {"no-contextual",                SP_CSS_FONT_VARIANT_LIGATURES_NOCONTEXTUAL},
     {NULL, -1}
 };
     
diff --git a/src/style-internal.cpp b/src/style-internal.cpp
index 915282301..7f6f6400d 100644
--- a/src/style-internal.cpp
+++ b/src/style-internal.cpp
@@ -45,6 +45,8 @@
 #include <sigc++/functors/ptr_fun.h>
 #include <sigc++/adaptors/bind.h>
 
+#include <glibmm/regex.h>
+
 // TODO REMOVE OR MAKE MEMBER FUNCTIONS
 void sp_style_fill_paint_server_ref_changed(  SPObject *old_ref, SPObject *ref, SPStyle *style);
 void sp_style_stroke_paint_server_ref_changed(SPObject *old_ref, SPObject *ref, SPStyle *style);
@@ -664,6 +666,135 @@ SPIEnum::operator==(const SPIBase& rhs) {
 }
 
 
+// SPIEnumBits ----------------------------------------------------------
+// Used for 'font-variant-xxx'
+void
+SPIEnumBits::read( gchar const *str ) {
+
+    if( !str ) return;
+    std::cout << "SPIEnumBits: " << name << ": " << str << std::endl;
+    if( !strcmp(str, "inherit") ) {
+        set = true;
+        inherit = true;
+    } else {
+        for (unsigned i = 0; enums[i].key; i++) {
+            if (!strcmp(str, enums[i].key)) {
+                std::cout << "  found: " << enums[i].key << std::endl;
+                set = true;
+                inherit = false;
+                value += enums[i].value;
+                /* Save copying for values not needing it */
+                computed = value;
+            }
+        }
+    }
+}
+
+const Glib::ustring
+SPIEnumBits::write( guint const flags, SPIBase const *const base) const {
+
+    SPIEnum const *const my_base = dynamic_cast<const SPIEnum*>(base);
+    if ( (flags & SP_STYLE_FLAG_ALWAYS) ||
+         ((flags & SP_STYLE_FLAG_IFSET) && this->set) ||
+         ((flags & SP_STYLE_FLAG_IFDIFF) && this->set
+          && (!my_base->set || this != my_base )))
+    {
+        if (this->inherit) {
+            return (name + ":inherit;");
+        }
+        if (this->value == 0 ) {
+            return (name + ":normal");
+        }
+        Glib::ustring return_string = name + ":";
+        unsigned j = 1;
+        for (unsigned i = 0; enums[i].key; ++i) {
+            if (j & this->value ) {
+                return_string += enums[i].value + " ";
+            }
+            j *= 2;
+        }
+        return return_string;
+    }
+    return Glib::ustring("");
+}
+
+
+// SPILigatures -----------------------------------------------------
+// Used for 'font-variant-ligatures'
+void
+SPILigatures::read( gchar const *str ) {
+
+    if( !str ) return;
+
+    value = SP_CSS_FONT_VARIANT_LIGATURES_COMMON | SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL;
+    if( !strcmp(str, "inherit") ) {
+        set = true;
+        inherit = true;
+    } else if (!strcmp(str, "normal" )) {
+        // Defaults for TrueType
+        inherit = false;
+        set = true;
+    } else if (!strcmp(str, "none" )) {
+        value = SP_CSS_FONT_VARIANT_LIGATURES_NONE;
+        inherit = false;
+        set = true;
+    } else {
+        // We need to parse in order
+        std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s+", str );
+        for( unsigned i = 0; i < tokens.size(); ++i ) {
+            for (unsigned j = 0; enums[j].key; ++j ) {
+                if (tokens[i].compare( enums[j].key ) == 0 ) {
+                    set = true;
+                    inherit = false;
+                    if( enums[j].value < SP_CSS_FONT_VARIANT_LIGATURES_NOCOMMON ) {
+                        // Turn on
+                        value |= enums[j].value;
+                    } else {
+                        // Turn off
+                        value &= ~(enums[j].value >> 4);
+                    }
+                }
+            }
+        }
+    }
+    computed = value;
+}
+
+const Glib::ustring
+SPILigatures::write( guint const flags, SPIBase const *const base) const {
+
+    SPIEnum const *const my_base = dynamic_cast<const SPIEnum*>(base);
+    if ( (flags & SP_STYLE_FLAG_ALWAYS) ||
+         ((flags & SP_STYLE_FLAG_IFSET) && this->set) ||
+         ((flags & SP_STYLE_FLAG_IFDIFF) && this->set
+          && (!my_base->set || this != my_base )))
+    {
+        if (this->inherit) {
+            return (name + ":inherit;");
+        }
+        if (value == SP_CSS_FONT_VARIANT_LIGATURES_NONE ) {
+                return (name + ":none;");
+        }
+        if (value == (SP_CSS_FONT_VARIANT_LIGATURES_COMMON +
+                      SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL) ) {
+                return (name + ":normal;");
+        }
+
+        Glib::ustring return_string = name + ":";
+        if ( !(value & SP_CSS_FONT_VARIANT_LIGATURES_COMMON) )
+            return_string += "no-common-ligatures ";
+        if (   value & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY )
+            return_string += "discretionary-ligatures ";
+        if (   value & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL )
+            return_string += "historical-ligatures ";
+        if ( !(value & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL) )
+            return_string += "no-contextual ";
+        return_string.erase( return_string.size() - 1 );
+        return_string += ";";
+        return return_string;
+    }
+    return Glib::ustring("");
+}
 
 // SPIString ------------------------------------------------------------
 
diff --git a/src/style-internal.h b/src/style-internal.h
index a8f0c5096..ea966866a 100644
--- a/src/style-internal.h
+++ b/src/style-internal.h
@@ -510,6 +510,55 @@ private:
 };
 
 
+/// SPIEnum w/ bits, allows values with multiple key words.
+class SPIEnumBits : public SPIEnum
+{
+
+public:
+    SPIEnumBits() :
+        SPIEnum( "anonymous_enumbits", NULL )
+    {}
+
+    SPIEnumBits( Glib::ustring const &name, SPStyleEnum const *enums, unsigned value = 0, bool inherits = true ) :
+        SPIEnum( name, enums, value, inherit )
+    {}
+
+    virtual ~SPIEnumBits()
+    {}
+
+    virtual void read( gchar const *str );
+    virtual const Glib::ustring write( guint const flags = SP_STYLE_FLAG_IFSET,
+                                       SPIBase const *const base = NULL ) const;
+
+};
+
+
+/// SPIEnum w/ extra bits. The 'font-variants-ligatures' property is a complete mess that needs
+/// special handling. For OpenType fonts the values 'common-ligatures', 'contextual',
+/// 'no-discretionary-ligatures', and 'no-historical-ligatures' are not useful but we still must be
+/// able to parse them.
+class SPILigatures : public SPIEnum
+{
+
+public:
+    SPILigatures() :
+        SPIEnum( "anonymous_enumligatures", NULL )
+    {}
+
+    SPILigatures( Glib::ustring const &name, SPStyleEnum const *enums) :
+        SPIEnum( name, enums,
+                 SP_CSS_FONT_VARIANT_LIGATURES_COMMON | SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL)
+    {}
+
+    virtual ~SPILigatures()
+    {}
+
+    virtual void read( gchar const *str );
+    virtual const Glib::ustring write( guint const flags = SP_STYLE_FLAG_IFSET,
+                                       SPIBase const *const base = NULL ) const;
+};
+
+
 /// String type internal to SPStyle.
 // Used for 'marker', ..., 'font', 'font-family', 'inkscape-font-specification'
 class SPIString : public SPIBase
diff --git a/src/style-test.h b/src/style-test.h
index cd6769b24..fec0da0f8 100644
--- a/src/style-test.h
+++ b/src/style-test.h
@@ -137,6 +137,17 @@ public:
             TestCase("font-weight:bolder"),
             TestCase("font-stretch:condensed"),                  // SPIEnum
 
+            TestCase("font-variant-ligatures:none"),             // SPILigatures
+            TestCase("font-variant-ligatures:normal"),
+            TestCase("font-variant-ligatures:no-common-ligatures"),
+            TestCase("font-variant-ligatures:discretionary-ligatures"),
+            TestCase("font-variant-ligatures:historical-ligatures"),
+            TestCase("font-variant-ligatures:no-contextual"),
+            TestCase("font-variant-ligatures:common-ligatures", "font-variant-ligatures:normal"),
+            TestCase("font-variant-ligatures:contextual", "font-variant-ligatures:normal"),
+            TestCase("font-variant-ligatures:no-common-ligatures historical-ligatures"),
+            TestCase("font-variant-ligatures:historical-ligatures no-contextual"),
+            
             // Should be moved down
             TestCase("text-indent:12em"),                        // SPILength?
             TestCase("text-align:center"),                       // SPIEnum
diff --git a/src/style.cpp b/src/style.cpp
index 49a13604b..4d93841eb 100644
--- a/src/style.cpp
+++ b/src/style.cpp
@@ -119,7 +119,7 @@ SPStyle::SPStyle(SPDocument *document_in, SPObject *object_in) :
     font_specification( "-inkscape-font-specification"       ),  // SPIString
 
     // Font variants
-    font_variant_ligatures( "font-variant-ligatures",  enum_font_variant_ligatures,  SP_CSS_FONT_VARIANT_LIGATURES_NORMAL  ),
+    font_variant_ligatures( "font-variant-ligatures",  enum_font_variant_ligatures ),
     font_variant_position(  "font-variant-position",   enum_font_variant_position,   SP_CSS_FONT_VARIANT_POSITION_NORMAL   ),
     font_variant_caps(      "font-variant-caps",       enum_font_variant_caps,       SP_CSS_FONT_VARIANT_CAPS_NORMAL       ),
     font_variant_numeric(   "font-variant-numeric",    enum_font_variant_numeric,    SP_CSS_FONT_VARIANT_NUMERIC_NORMAL    ),
diff --git a/src/style.h b/src/style.h
index 2618662f5..f82fad9b0 100644
--- a/src/style.h
+++ b/src/style.h
@@ -113,7 +113,7 @@ public:
 
     /* Font variants -------------------- */
     /** Font variant ligatures */
-    SPIEnum font_variant_ligatures;
+    SPILigatures font_variant_ligatures;
     /** Font variant position (subscript/superscript) */
     SPIEnum font_variant_position;
     /** Font variant caps (small caps) */
diff --git a/src/ui/dialog/text-edit.cpp b/src/ui/dialog/text-edit.cpp
index 815aa12ef..98ea7f9f7 100644
--- a/src/ui/dialog/text-edit.cpp
+++ b/src/ui/dialog/text-edit.cpp
@@ -69,6 +69,7 @@ TextEdit::TextEdit()
       font_label(_("_Font"), true),
       layout_frame(),
       text_label(_("_Text"), true),
+      vari_label(_("_Variants"), true),
       setasdefault_button(_("Set as _default")),
       close_button(Gtk::Stock::CLOSE),
       apply_button(Gtk::Stock::APPLY),
@@ -195,7 +196,8 @@ TextEdit::TextEdit()
 
     notebook.append_page(font_vbox, font_label);
     notebook.append_page(text_vbox, text_label);
-
+    notebook.append_page(vari_vbox, vari_label);
+    
     /* Buttons */
     setasdefault_button.set_use_underline(true);
     apply_button.set_can_default();
@@ -384,6 +386,11 @@ void TextEdit::onReadSelection ( gboolean dostyle, gboolean /*docontent*/ )
         gtk_entry_set_text ((GtkEntry *) gtk_bin_get_child ((GtkBin *) spacing_combo), sstr);
         g_free(sstr);
 
+        // Update font variant widget
+        //int result_variants =
+        sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTVARIANTS);
+        vari_vbox.update( query.font_variant_ligatures.computed, query.font_variant_ligatures.value );
+
     }
     blocked = false;
 }
diff --git a/src/ui/dialog/text-edit.h b/src/ui/dialog/text-edit.h
index 117ad2e28..f088fd337 100644
--- a/src/ui/dialog/text-edit.h
+++ b/src/ui/dialog/text-edit.h
@@ -32,6 +32,7 @@
 #include "ui/widget/panel.h"
 #include "ui/widget/frame.h"
 #include "ui/dialog/desktop-tracker.h"
+#include "ui/widget/font-variants.h"
 
 class SPItem;
 struct SPFontSelector;
@@ -213,6 +214,9 @@ private:
     GtkWidget *text_view; // TODO - Convert this to a Gtk::TextView, but GtkSpell doesn't seem to work with it
     GtkTextBuffer *text_buffer;
 
+    Inkscape::UI::Widget::FontVariants vari_vbox;
+    Gtk::Label vari_label;
+    
     Gtk::HBox button_row;
     Gtk::Button setasdefault_button;
     Gtk::Button close_button;
diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert
index e18b790bd..305076a9d 100644
--- a/src/ui/widget/Makefile_insert
+++ b/src/ui/widget/Makefile_insert
@@ -21,8 +21,10 @@ ink_common_sources +=	\
 	ui/widget/entry.h        \
 	ui/widget/filter-effect-chooser.h \
 	ui/widget/filter-effect-chooser.cpp \
-	ui/widget/gimpspinscale.c      \
-	ui/widget/gimpspinscale.h        \
+	ui/widget/font-variants.h      	\
+	ui/widget/font-variants.cpp     \
+	ui/widget/gimpspinscale.c	\
+	ui/widget/gimpspinscale.h       \
 	ui/widget/gimpcolorwheel.c \
 	ui/widget/gimpcolorwheel.h \
 	ui/widget/frame.cpp      \
diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp
new file mode 100644
index 000000000..46fbc2aa4
--- /dev/null
+++ b/src/ui/widget/font-variants.cpp
@@ -0,0 +1,246 @@
+/*
+ * Author:
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright (C) 2015 Tavmong Bah
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <gtkmm.h>
+#include <glibmm/i18n.h>
+
+#include <iostream>
+
+#include "font-variants.h"
+
+// For updating from selection
+#include "desktop.h"
+#include "selection.h"
+#include "style.h"
+#include "sp-text.h"
+#include "sp-tspan.h"
+#include "sp-tref.h"
+#include "sp-textpath.h"
+#include "sp-item-group.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+  FontVariants::FontVariants () :
+    Gtk::VBox (),
+    _ligatures_frame          ( Glib::ustring(_("Ligatures"    )) ),
+    _ligatures_common         ( Glib::ustring(_("Common"       )) ),
+    _ligatures_discretionary  ( Glib::ustring(_("Discretionary")) ),
+    _ligatures_historical     ( Glib::ustring(_("Historical"   )) ),
+    _ligatures_contextual     ( Glib::ustring(_("Contextual"   )) ),
+
+    _position_frame           ( Glib::ustring(_("Position"     )) ),
+    _position_normal          ( Glib::ustring(_("Normal"       )) ),
+    _position_sub             ( Glib::ustring(_("Subscript"    )) ),
+    _position_super           ( Glib::ustring(_("Superscript"  )) ),
+
+    _caps_frame               ( Glib::ustring(_("Capitals"     )) ),
+    _caps_normal              ( Glib::ustring(_("Normal"       )) ),
+    _caps_small               ( Glib::ustring(_("Small"        )) ),
+    _caps_all_small           ( Glib::ustring(_("All small"    )) ),
+    _caps_petite              ( Glib::ustring(_("Petite"       )) ),
+    _caps_all_petite          ( Glib::ustring(_("All petite"   )) ),
+    _caps_unicase             ( Glib::ustring(_("Unicase"      )) ),
+    _caps_titling             ( Glib::ustring(_("Titling"      )) ),
+
+    _numeric_frame            ( Glib::ustring(_("Numeric"      )) ),
+    _numeric_lining           ( Glib::ustring(_("Lining"       )) ),
+    _numeric_old_style        ( Glib::ustring(_("Old Style"    )) ),
+    _numeric_default_style    ( Glib::ustring(_("Default Style")) ),
+    _numeric_proportional     ( Glib::ustring(_("Proportional" )) ),
+    _numeric_tabular          ( Glib::ustring(_("Tabular"      )) ),
+    _numeric_default_width    ( Glib::ustring(_("Default Width")) ),
+    _numeric_diagonal         ( Glib::ustring(_("Diagonal"     )) ),
+    _numeric_stacked          ( Glib::ustring(_("Stacked"      )) ),
+    _numeric_default_fractions( Glib::ustring(_("Default Fractions")) ),
+    _numeric_ordinal          ( Glib::ustring(_("Ordinal"      )) ),
+    _numeric_slashed_zero     ( Glib::ustring(_("Slashed Zero" )) )
+
+
+  {
+
+    // Ligatures --------------------------
+    _ligatures_common.set_tooltip_text(
+      _("Common ligatures. On by default. OpenType tables: 'liga', 'clig'"));
+    _ligatures_discretionary.set_tooltip_text(
+      _("Discretionary ligatures. Off by default. OpenType table: 'dlig'"));
+    _ligatures_historical.set_tooltip_text(
+      _("Historical ligatures. Off by default. OpenType table: 'hlig'"));
+    _ligatures_contextual.set_tooltip_text(
+      _("Contextual forms. On by default. OpenType table: 'calt'"));
+
+
+    _ligatures_common.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_discretionary.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_historical.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_contextual.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) );
+    _ligatures_vbox.add( _ligatures_common );
+    _ligatures_vbox.add( _ligatures_discretionary );
+    _ligatures_vbox.add( _ligatures_historical );
+    _ligatures_vbox.add( _ligatures_contextual );
+    _ligatures_frame.add( _ligatures_vbox );
+    add( _ligatures_frame );
+
+    ligatures_init();
+    
+    // Position ----------------------------------
+    _position_vbox.add( _position_normal );
+    _position_vbox.add( _position_sub );
+    _position_vbox.add( _position_super );
+    _position_frame.add( _position_vbox );
+    add( _position_frame );
+
+    // Group buttons
+    Gtk::RadioButton::Group position_group = _position_normal.get_group();
+    _position_sub.set_group(position_group);
+    _position_super.set_group(position_group);
+    _position_normal.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) );
+    _position_sub.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) );
+    _position_super.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) );
+
+    position_init();
+
+    // Caps ----------------------------------
+    _caps_vbox.add( _caps_normal );
+    _caps_vbox.add( _caps_small );
+    _caps_vbox.add( _caps_all_small );
+    _caps_vbox.add( _caps_petite );
+    _caps_vbox.add( _caps_all_petite );
+    _caps_vbox.add( _caps_unicase );
+    _caps_vbox.add( _caps_titling );
+    _caps_frame.add( _caps_vbox );
+    add( _caps_frame );
+
+    // Group buttons
+    Gtk::RadioButton::Group caps_group = _caps_normal.get_group();
+    _caps_small.set_group(caps_group);
+    _caps_all_small.set_group(caps_group);
+    _caps_petite.set_group(caps_group);
+    _caps_all_petite.set_group(caps_group);
+    _caps_unicase.set_group(caps_group);
+    _caps_titling.set_group(caps_group);
+    _caps_normal.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_all_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_petite.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_all_petite.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_unicase.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+    _caps_titling.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) );
+
+    caps_init();
+
+    // Numeric ------------------------------
+    _numeric_stylebox.add( _numeric_default_style );
+    _numeric_stylebox.add( _numeric_lining );
+    _numeric_stylebox.add( _numeric_old_style );
+    _numeric_vbox.add( _numeric_stylebox );
+    _numeric_widthbox.add( _numeric_default_width );
+    _numeric_widthbox.add( _numeric_proportional );
+    _numeric_widthbox.add( _numeric_tabular );
+    _numeric_vbox.add( _numeric_widthbox );
+    _numeric_fractionbox.add( _numeric_default_fractions );
+    _numeric_fractionbox.add( _numeric_diagonal );
+    _numeric_fractionbox.add( _numeric_stacked );
+    _numeric_vbox.add( _numeric_fractionbox );
+    _numeric_vbox.add( _numeric_ordinal );
+    _numeric_vbox.add( _numeric_slashed_zero );
+    _numeric_frame.add( _numeric_vbox );
+    add( _numeric_frame );
+    
+    // Group buttons
+    Gtk::RadioButton::Group style_group = _numeric_default_style.get_group();
+    _numeric_lining.set_group(style_group);
+    _numeric_old_style.set_group(style_group);
+
+    Gtk::RadioButton::Group width_group = _numeric_default_width.get_group();
+    _numeric_proportional.set_group(width_group);
+    _numeric_tabular.set_group(width_group);
+
+    Gtk::RadioButton::Group fraction_group = _numeric_default_fractions.get_group();
+    _numeric_diagonal.set_group(fraction_group);
+    _numeric_stacked.set_group(fraction_group);
+
+    show_all_children();
+  }
+
+  void
+  FontVariants::ligatures_init() {
+      // std::cout << "FontVariants::ligatures_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::ligatures_callback() {
+      // std::cout << "FontVariants::ligatures_callback()" << std::endl;
+  }
+
+  void
+  FontVariants::position_init() {
+      // std::cout << "FontVariants::position_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::position_callback() {
+      // std::cout << "FontVariants::position_callback()" << std::endl;
+  }
+
+  void
+  FontVariants::caps_init() {
+      // std::cout << "FontVariants::caps_init()" << std::endl;
+  }
+  
+  void
+  FontVariants::caps_callback() {
+      // std::cout << "FontVariants::caps_callback()" << std::endl;
+  }
+
+  void
+  FontVariants::numeric_init() {
+      std::cout << "FontVariants::numeric_init()" << std::endl;
+      // _numeric_tabular.set_inconsistent();
+  }
+  
+  void
+  FontVariants::numeric_callback() {
+      // std::cout << "FontVariants::numeric_callback()" << std::endl;
+  }
+
+  void
+  FontVariants::update( unsigned all, unsigned mix ) {
+      // std::cout << "FontVariants::update" << std::endl;
+
+      _ligatures_common.set_active(        all & SP_CSS_FONT_VARIANT_LIGATURES_COMMON );
+      _ligatures_discretionary.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY );
+      _ligatures_historical.set_active(    all & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL );
+      _ligatures_contextual.set_active(    all & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL );
+      
+      _ligatures_common.set_inconsistent(        mix & SP_CSS_FONT_VARIANT_LIGATURES_COMMON );
+      _ligatures_discretionary.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY );
+      _ligatures_historical.set_inconsistent(    mix & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL );
+      _ligatures_contextual.set_inconsistent(    mix & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL );
+  }
+
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/font-variants.h b/src/ui/widget/font-variants.h
new file mode 100644
index 000000000..bef14c4bd
--- /dev/null
+++ b/src/ui/widget/font-variants.h
@@ -0,0 +1,119 @@
+/*
+ * Author:
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright (C) 2015 Tavmong Bah
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information.
+ */
+
+#ifndef INKSCAPE_UI_WIDGET_FONT_VARIANT_H
+#define INKSCAPE_UI_WIDGET_FONT_VARIANT_H
+
+// Temp: both frame and expander
+#include <gtkmm/frame.h>
+#include <gtkmm/expander.h>
+#include <gtkmm/checkbutton.h>
+#include <gtkmm/radiobutton.h>
+
+class SPDesktop;
+class SPObject;
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+/**
+ * A container for selecting font variants (OpenType Features).
+ */
+class FontVariants : public Gtk::VBox
+{
+
+public:
+
+    /**
+     * Constructor
+     */
+    FontVariants();
+
+protected:
+    // To start, use four check buttons.
+    Gtk::Expander       _ligatures_frame;
+    Gtk::VBox           _ligatures_vbox;
+    Gtk::CheckButton    _ligatures_common;
+    Gtk::CheckButton    _ligatures_discretionary;
+    Gtk::CheckButton    _ligatures_historical;
+    Gtk::CheckButton    _ligatures_contextual;
+
+    // Exclusive options
+    Gtk::Expander       _position_frame;
+    Gtk::VBox           _position_vbox;
+    Gtk::RadioButton    _position_normal;
+    Gtk::RadioButton    _position_sub;
+    Gtk::RadioButton    _position_super;
+    
+    // Exclusive options (maybe a dropdown menu to save space?)
+    Gtk::Expander       _caps_frame;
+    Gtk::VBox           _caps_vbox;
+    Gtk::RadioButton    _caps_normal;
+    Gtk::RadioButton    _caps_small;
+    Gtk::RadioButton    _caps_all_small;
+    Gtk::RadioButton    _caps_petite;
+    Gtk::RadioButton    _caps_all_petite;
+    Gtk::RadioButton    _caps_unicase;
+    Gtk::RadioButton    _caps_titling;
+
+    // Complicated!
+    Gtk::Expander       _numeric_frame;
+    Gtk::VBox           _numeric_vbox;
+    Gtk::HBox           _numeric_stylebox;
+    Gtk::RadioButton    _numeric_lining;
+    Gtk::RadioButton    _numeric_old_style;
+    Gtk::RadioButton    _numeric_default_style;
+    Gtk::HBox           _numeric_widthbox;
+    Gtk::RadioButton    _numeric_proportional;
+    Gtk::RadioButton    _numeric_tabular;
+    Gtk::RadioButton    _numeric_default_width;
+    Gtk::HBox           _numeric_fractionbox;
+    Gtk::RadioButton    _numeric_diagonal;
+    Gtk::RadioButton    _numeric_stacked;
+    Gtk::RadioButton    _numeric_default_fractions;
+    Gtk::CheckButton    _numeric_ordinal;
+    Gtk::CheckButton    _numeric_slashed_zero;
+
+private:
+    void ligatures_init();
+    void ligatures_callback();
+
+    void position_init();
+    void position_callback();
+
+    void caps_init();
+    void caps_callback();
+
+    void numeric_init();
+    void numeric_callback();
+
+public:
+    void update_recursive( SPObject *object );
+    void update( unsigned all, unsigned mix );
+
+};
+
+ 
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+#endif // INKSCAPE_UI_WIDGET_FONT_VARIANT_H
+
+/* 
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :