ui-style.cpp

Go to the documentation of this file.

/*
  UiStyle  -  manage coherent UI styling
 
   Copyright (C)
     2008,            Joel Holdsworth <joel@airwebreathe.org.uk>
     2017,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
 
#include "stage/workspace/ui-style.hpp"
#include "stage/timeline/timeline-widget.hpp"
#include "stage/style-scheme.hpp"
#include "stage/config-keys.hpp"
#include "lib/searchpath.hpp"
#include "lib/file.hpp"
#include "lib/util.hpp"
 
#include <gtkmm/stylecontext.h>
 
using Gtk::IconSize;
using Gtk::IconFactory;
 
 
 
namespace stage {
namespace workspace {
  
  IconSize UiStyle::GiantIconSize = Gtk::ICON_SIZE_INVALID;
  IconSize UiStyle::MenuIconSize = Gtk::ICON_SIZE_INVALID;
  
  
  
  
  UiStyle::UiStyle()
    : Gtk::UIManager()
    , iconSearchPath_{Config::get (KEY_ICON_PATH)}
    , resourceSerachPath_{Config::get (KEY_UIRES_PATH)}
    , styleAdviceTrackBody_{"style(trackBody)"}
    , styleAdviceTrackRuler_{"style(trackRuler)"}
    {
      Glib::set_application_name (Config::get (KEY_TITLE));
      
      registerAppIconSizes();
      registerStockItems();
      
      setTheme (Config::get (KEY_STYLESHEET));
    }
  
  
  
  void
  UiStyle::setTheme (string const& stylesheetName)
  {
    auto screen = Gdk::Screen::get_default();
    auto css_provider = Gtk::CssProvider::create();
    try
      {
        css_provider->load_from_path (lib::resolveModulePath (stylesheetName, resourceSerachPath_));
      }
    catch(Glib::Error const& failure)
      {
        WARN (stage, "Failure while loading stylesheet '%s': %s", cStr(stylesheetName), cStr(failure.what()));
      }
    
    Gtk::StyleContext::add_provider_for_screen (screen, css_provider,
                                                GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
  }
  
  
  
  void
  UiStyle::prepareStyleContext (timeline::TimelineWidget const& timeline)
  {
    // the first Timeline triggers initialisation
    if (styleAdviceTrackBody_.isGiven()) return;
    
    Gtk::WidgetPath path = timeline.getBodyWidgetPath();
    GType scopeNode = Gtk::Box::get_type();
    int pos = path.path_append_type (scopeNode);                         // build a "virtual" CSS node to represent the track scope
    
    gtk_widget_path_iter_set_object_name (path.gobj(), pos, NODE_fork);  // override the generic node name with a custom widget type "fork"
    path.iter_add_class(pos, CLASS_timeline_fork);                       // decorate this CSS node with a CSS class ".timeline__fork" (distinguish it from asset bins)
                                                                         // deliberately we *do not* invoke path.iter_set_name(pos, "id") to add an #ID
    for (int i=0; i<pos; ++i)                                            // reset any state flags accidentally set (resulting in pseudo classes like ":backdrop")
      gtk_widget_path_iter_set_state(path.gobj(), i, GTK_STATE_FLAG_NORMAL);
    PStyleContext style = Gtk::StyleContext::create();                   // create a new style context and configure it according to the path defined thus far
    style->set_screen(Gdk::Screen::get_default());
    style->set_path (path);
    styleAdviceTrackBody_.setAdvice (style);                             // publish as Advice "style(trackBody)"
    
    pos = path.path_append_type (scopeNode);                             // append another nested "virtual" CSS node to represent the a ruler track
    gtk_widget_path_iter_set_object_name (path.gobj(), pos, NODE_frame); // ...but this time we explicitly use the conventional Name "frame" (hard wired default by GTK)
                                                                         // note: the node is deliberately left as 'frame' to pick up existing styling
    path.iter_add_class(pos, CLASS_timeline_ruler);                      // decorate with CSS class ".timeline__ruler" to identify position within the system
    style = Gtk::StyleContext::create();                                 // create another style context...
    style->set_path (path);                                              // ...for this nested path. (Note: Gtk takes a copy of the path, see gtk_style_context_set_path(), line 1120)
    styleAdviceTrackRuler_.setAdvice (style);                            // publish as Advice "style(trackRuler)"
  }
  
  
  
  
  Cairo::RefPtr<Cairo::SolidPattern>
  UiStyle::readStyleColourProperty (Gtk::Widget& widget
                                   ,const gchar * property_name
                                   ,guint16 red, guint16 green, guint16 blue)
  {
    REQUIRE (property_name);
    
    // TODO: Can we get rid of the GdkColor completely here?
    GdkColor *color;
    gtk_widget_style_get(widget.gobj(), property_name, &color, NULL);
    
    Cairo::RefPtr<Cairo::SolidPattern> pattern;
    // Did the colour load successfully?
    if (color != NULL)
      {
        pattern = Cairo::SolidPattern::create_rgb ( (double)color->red   / 0xFFFF,
                                                    (double)color->green / 0xFFFF,
                                                    (double)color->blue  / 0xFFFF);
      }
    else
      {
        WARN (stage, "%s style value failed to load", property_name);
        
        pattern = Cairo::SolidPattern::create_rgb ( red, green, blue );
      }
    
    return pattern;
  }
  
  
  void
  UiStyle::registerAppIconSizes()
  {
    if(GiantIconSize == Gtk::ICON_SIZE_INVALID)
      GiantIconSize = IconSize::register_new ("giant", 48, 48);
    if(MenuIconSize == Gtk::ICON_SIZE_INVALID)
      MenuIconSize = IconSize::register_new ("menu", 16, 16);
  }
  
  
  void
  UiStyle::registerStockItems()
  {                                      
    Glib::RefPtr<IconFactory> factory = Gtk::IconFactory::create();
    
    addStockIconSet(factory, "panel-assets",   "panel_assets",  _("_Assets"));
    addStockIconSet(factory, "panel-play",     "panel_play",    _("_Play"));
    addStockIconSet(factory, "panel-viewer",   "panel_viewer",  _("_Viewer"));
    addStockIconSet(factory, "panel-infobox",  "panel_infobox", _("_InfoBox"));
    addStockIconSet(factory, "panel-timeline", "panel_timeline",_("_Timeline"));
    addStockIconSet(factory, "panel-timeline", "panel_timeline_obsolete",_("_ZombieTimeline"));
    
    addStockIconSet(factory, "window-new"     ,"new_window"             ,_("New _Window"));
    
    addStockIconSet(factory, "placement"      ,ICON_placement           ,_("_Placement"));
    addStockIconSet(factory, "arrow-hand"     ,ICON_arrow_hand_menu     ,_("_Menu"));
    addStockIconSet(factory, "arrow-hand"     ,ICON_arrow_hand_down     ,_("_Expand"));
    addStockIconSet(factory, "arrow-hand"     ,ICON_arrow_hand_up       ,_("_Collapse"));
    
    addStockIconSet(factory, "tool-arrow",     "tool_arrow",    _("_Arrow"));
    addStockIconSet(factory, "tool-i-beam",    "tool_i_beam",   _("_I-Beam"));
    
    addStockIconSet(factory, "track-disabled", "track_disabled",_("Track Disabled"));
    addStockIconSet(factory, "track-enabled",  "track_enabled", _("Track Enabled"));
    addStockIconSet(factory, "track-locked",   "track_locked",  _("Track Locked"));
    addStockIconSet(factory, "track-unlocked", "track_unlocked",_("Track Unlocked"));
    
    factory->add_default(); //Add factory to list of factories.
  }
  
  
  bool
  UiStyle::addStockIconSet (Glib::RefPtr<IconFactory> const& factory
                           ,Literal iconName
                           ,Literal id
                           ,Literal label)
  {
    Glib::RefPtr<Gtk::IconSet> icon_set = Gtk::IconSet::create();
    cuString uIconName{iconName}, uLabel{label}; // even while we're just passing through a C-string to GTK,
                                                //  unfortunately Glib::ustring wraps a std::string
    
    // Load all the sizes, wildcarding the largest icon to be loaded
    bool found{false};
    found |= addStockIcon (icon_set, uIconName, GiantIconSize, not found);
    found |= addStockIcon (icon_set, uIconName, Gtk::ICON_SIZE_BUTTON, not found);
    found |= addStockIcon (icon_set, uIconName, Gtk::ICON_SIZE_MENU,   not found);
    found |= addStockIcon (icon_set, uIconName, Gtk::ICON_SIZE_LARGE_TOOLBAR, not found);
    found |= addStockIcon (icon_set, uIconName, MenuIconSize, not found);
    
    if (not found)
      {
        // No icons were loaded
        ERROR (stage, "Unable to load icon '%s'", iconName);
        return false;
      }
    
    // Add the icon set to the icon factory
    const Gtk::StockID stock_id(id);
    factory->add(stock_id, icon_set);
    Gtk::Stock::add(Gtk::StockItem(stock_id, uLabel));             
    return true;
  }
  
  
  bool
  UiStyle::addStockIcon (Glib::RefPtr<Gtk::IconSet> const& icon_set
                        ,cuString& icon_name
                        ,Gtk::IconSize size
                        ,bool wildcard)
  {
    // Try the icon theme
    if (addThemeIconSource(icon_set, icon_name, size, wildcard))
      return true;
    
    // Try to resolve the icon via the configured search path
    lib::SearchPathSplitter iconLocations{iconSearchPath_};
    for (auto const& location : iconLocations)
      if (addNonThemeIconSource (icon_set
                                ,location
                                ,icon_name
                                ,size
                                ,wildcard))
        return true;
    
    return false; // icon not found
  }
  
  
  bool
  UiStyle::addThemeIconSource (Glib::RefPtr<Gtk::IconSet> const& icon_set
                              ,cuString& icon_name
                              ,Gtk::IconSize size
                              ,bool wildcard)
  {
    // Get the size
    int width = 0, height = 0;
    if(!IconSize::lookup(size, width, height))
      return false;
    REQUIRE(width > 0);
    
    // Try to load the icon
    Glib::RefPtr<Gtk::IconTheme> theme = Gtk::IconTheme::get_default();
    REQUIRE(theme);
    
    Gtk::IconInfo info = theme->lookup_icon(icon_name, width, (Gtk::IconLookupFlags)0);
    
    if (!info) return false; // unable to resolve Icon
    
    cuString path(info.get_filename());
    return addStockIconFromPath(path, icon_set, size, wildcard);
  }
  
  
  bool
  UiStyle::addNonThemeIconSource (Glib::RefPtr<Gtk::IconSet> const& icon_set
                                 ,cuString& base_dir
                                 ,cuString& icon_name
                                 ,Gtk::IconSize size
                                 ,bool wildcard)
  {
    // Get the size
    int width = 0, height = 0;
    if(!IconSize::lookup(size, width, height))
      return false;
    REQUIRE(width > 0);
    
    // Try to load the icon
    cuString path(Glib::ustring::compose("%1/%2x%3/%4.png",
      base_dir, width, height, icon_name));
    return addStockIconFromPath(path, icon_set, size, wildcard);
  }
  
  
  bool
  UiStyle::addStockIconFromPath (string path
                                ,Glib::RefPtr<Gtk::IconSet> const& icon_set
                                ,Gtk::IconSize size
                                ,bool wildcard)
  {
    if (not fs::exists (path)) return false;
    
    try {
        Gtk::IconSource source;
        source.set_pixbuf(Gdk::Pixbuf::create_from_file(path));
        source.set_size_wildcarded(wildcard);
        source.set_size(size);
        
        icon_set->add_source(source);
        
        return true;
      }
    
    catch(Glib::Exception const& ex)
      {
        WARN (stage, "Failure when accessing icon '%s'. Problem: %s", cStr(path), cStr(ex.what()));
        return false;
      }
  }
  
  
  
}}// namespace stage::workspace