diff --git a/src/App/FeatureTest.cpp b/src/App/FeatureTest.cpp
index 94f8beb41..56da946fe 100644
--- a/src/App/FeatureTest.cpp
+++ b/src/App/FeatureTest.cpp
@@ -66,7 +66,7 @@ FeatureTest::FeatureTest()
   ConstraintFloat.setConstraints(&floatPercent);
 
   App::Color c;
-  App::Material mat;
+  App::Material mat(App::Material::GOLD);
   ADD_PROPERTY(Colour      ,(c) );
   ADD_PROPERTY(ColourList  ,(c) );
   ADD_PROPERTY(Material    ,(mat));
diff --git a/src/App/PropertyStandard.cpp b/src/App/PropertyStandard.cpp
index 33564e480..a4c3d3061 100644
--- a/src/App/PropertyStandard.cpp
+++ b/src/App/PropertyStandard.cpp
@@ -2516,6 +2516,11 @@ void PropertyMaterial::Restore(Base::XMLReader &reader)
     hasSetValue();
 }
 
+const char* PropertyMaterial::getEditorName(void) const
+{
+    return "";// "Gui::PropertyEditor::PropertyMaterialItem";
+}
+
 Property *PropertyMaterial::Copy(void) const
 {
     PropertyMaterial *p= new PropertyMaterial();
@@ -2672,6 +2677,11 @@ void PropertyMaterialList::RestoreDocFile(Base::Reader &reader)
     setValues(values);
 }
 
+const char* PropertyMaterialList::getEditorName(void) const
+{
+    return "";// "Gui::PropertyEditor::PropertyMaterialListItem";
+}
+
 Property *PropertyMaterialList::Copy(void) const
 {
     PropertyMaterialList *p = new PropertyMaterialList();
diff --git a/src/App/PropertyStandard.h b/src/App/PropertyStandard.h
index e0c109dff..d2f9defd0 100644
--- a/src/App/PropertyStandard.h
+++ b/src/App/PropertyStandard.h
@@ -952,7 +952,9 @@ public:
     
     virtual void Save (Base::Writer &writer) const;
     virtual void Restore(Base::XMLReader &reader);
-    
+
+    virtual const char* getEditorName(void) const;
+
     virtual Property *Copy(void) const;
     virtual void Paste(const Property &from);
     
@@ -1006,6 +1008,8 @@ public:
     virtual void SaveDocFile(Base::Writer &writer) const;
     virtual void RestoreDocFile(Base::Reader &reader);
 
+    virtual const char* getEditorName(void) const;
+
     virtual Property *Copy(void) const;
     virtual void Paste(const Property &from);
     virtual unsigned int getMemSize(void) const;
diff --git a/src/Gui/SoFCDB.cpp b/src/Gui/SoFCDB.cpp
index f8d864403..0ed3b6d0c 100644
--- a/src/Gui/SoFCDB.cpp
+++ b/src/Gui/SoFCDB.cpp
@@ -134,6 +134,7 @@ void Gui::SoFCDB::init()
     PropertyFloatListItem           ::init();
     PropertyIntegerListItem         ::init();
     PropertyColorItem               ::init();
+    PropertyMaterialItem            ::init();
     PropertyFileItem                ::init();
     PropertyPathItem                ::init();
     PropertyTransientFileItem       ::init();
diff --git a/src/Gui/propertyeditor/PropertyItem.cpp b/src/Gui/propertyeditor/PropertyItem.cpp
index 2207357b5..f35dba15b 100644
--- a/src/Gui/propertyeditor/PropertyItem.cpp
+++ b/src/Gui/propertyeditor/PropertyItem.cpp
@@ -57,6 +57,26 @@
 
 using namespace Gui::PropertyEditor;
 
+namespace Gui { namespace PropertyEditor {
+    static QColor toQColor(const App::Color& col)
+    {
+        return QColor(
+            (int)(255.0f*col.r),
+            (int)(255.0f*col.g),
+            (int)(255.0f*col.b)
+            );
+    }
+    static App::Color fromQColor(const QColor& col)
+    {
+        App::Color val;
+        val.r = (float)col.red() / 255.0f;
+        val.g = (float)col.green() / 255.0f;
+        val.b = (float)col.blue() / 255.0f;
+        return val;
+    }
+}
+}
+
 TYPESYSTEM_SOURCE(Gui::PropertyEditor::PropertyItem, Base::BaseClass);
 
 PropertyItem::PropertyItem() : parentItem(0), readonly(false), cleared(false)
@@ -235,7 +255,7 @@ QVariant PropertyItem::toolTip(const App::Property* prop) const
     return QVariant(QString::fromUtf8(prop->getDocumentation()));
 }
 
-QVariant PropertyItem::decoration(const App::Property* /*prop*/) const
+QVariant PropertyItem::decoration(const QVariant&) const
 {
     return QVariant();
 }
@@ -355,8 +375,13 @@ QVariant PropertyItem::data(int column, int role) const
             PropertyItem* parent = this->parent();
             if (!parent || !parent->parent())
                 return QVariant();
-            if (role == Qt::EditRole)
+            if (role == Qt::EditRole) {
                 return parent->property(qPrintable(objectName()));
+            }
+            else if (role == Qt::DecorationRole) {
+                QVariant val = parent->property(qPrintable(objectName()));
+                return decoration(val);
+            }
             else if (role == Qt::DisplayRole) {
                 QVariant val = parent->property(qPrintable(objectName()));
                 return toString(val);
@@ -368,7 +393,7 @@ QVariant PropertyItem::data(int column, int role) const
         if (role == Qt::EditRole)
             return value(propertyItems[0]);
         else if (role == Qt::DecorationRole)
-            return decoration(propertyItems[0]);
+            return decoration(value(propertyItems[0]));
         else if (role == Qt::DisplayRole)
             return toString(value(propertyItems[0]));
         else if (role == Qt::ToolTipRole)
@@ -2207,10 +2232,9 @@ PropertyColorItem::PropertyColorItem()
 {
 }
 
-QVariant PropertyColorItem::decoration(const App::Property* prop) const
+QVariant PropertyColorItem::decoration(const QVariant& value) const
 {
-    App::Color value = ((App::PropertyColor*)prop)->getValue();
-    QColor color((int)(255.0f*value.r),(int)(255.0f*value.g),(int)(255.0f*value.b));
+    QColor color = value.value<QColor>();
 
     int size = QApplication::style()->pixelMetric(QStyle::PM_ListViewIconSize);
     QPixmap p(size, size);
@@ -2232,7 +2256,7 @@ QVariant PropertyColorItem::value(const App::Property* prop) const
     assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyColor::getClassTypeId()));
 
     App::Color value = ((App::PropertyColor*)prop)->getValue();
-    return QVariant(QColor((int)(255.0f*value.r),(int)(255.0f*value.g),(int)(255.0f*value.b)));
+    return QVariant(toQColor(value));
 }
 
 void PropertyColorItem::setValue(const QVariant& value)
@@ -2240,10 +2264,7 @@ void PropertyColorItem::setValue(const QVariant& value)
     if (!value.canConvert<QColor>())
         return;
     QColor col = value.value<QColor>();
-    App::Color val;
-    val.r = (float)col.red()/255.0f;
-    val.g = (float)col.green()/255.0f;
-    val.b = (float)col.blue()/255.0f;
+    App::Color val = fromQColor(col);
     QString data = QString::fromLatin1("(%1,%2,%3)")
                     .arg(val.r,0,'f',decimals())
                     .arg(val.g,0,'f',decimals())
@@ -2276,6 +2297,314 @@ QVariant PropertyColorItem::editorData(QWidget *editor) const
 
 // --------------------------------------------------------------------
 
+TYPESYSTEM_SOURCE(Gui::PropertyEditor::PropertyMaterialItem, Gui::PropertyEditor::PropertyItem);
+
+PropertyMaterialItem::PropertyMaterialItem()
+{
+    diffuse = static_cast<PropertyColorItem*>(PropertyColorItem::create());
+    diffuse->setParent(this);
+    diffuse->setPropertyName(QLatin1String("DiffuseColor"));
+    this->appendChild(diffuse);
+
+    ambient = static_cast<PropertyColorItem*>(PropertyColorItem::create());
+    ambient->setParent(this);
+    ambient->setPropertyName(QLatin1String("AmbientColor"));
+    this->appendChild(ambient);
+
+    specular = static_cast<PropertyColorItem*>(PropertyColorItem::create());
+    specular->setParent(this);
+    specular->setPropertyName(QLatin1String("SpecularColor"));
+    this->appendChild(specular);
+
+    emissive = static_cast<PropertyColorItem*>(PropertyColorItem::create());
+    emissive->setParent(this);
+    emissive->setPropertyName(QLatin1String("EmissiveColor"));
+    this->appendChild(emissive);
+
+    shininess = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
+    shininess->setParent(this);
+    shininess->setPropertyName(QLatin1String("Shininess"));
+    this->appendChild(shininess);
+
+    transparency = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
+    transparency->setParent(this);
+    transparency->setPropertyName(QLatin1String("Transparency"));
+    this->appendChild(transparency);
+}
+
+PropertyMaterialItem::~PropertyMaterialItem()
+{
+}
+
+void PropertyMaterialItem::propertyBound()
+{
+}
+
+QColor PropertyMaterialItem::getDiffuseColor() const
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return QColor();
+
+    const QVariantList& val = value.toList();
+    return val[0].value<QColor>();
+}
+
+void PropertyMaterialItem::setDiffuseColor(const QColor& color)
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    val[0] = QVariant(color);
+    setValue(val);
+}
+
+QColor PropertyMaterialItem::getAmbientColor() const
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return QColor();
+
+    const QVariantList& val = value.toList();
+    return val[1].value<QColor>();
+}
+
+void PropertyMaterialItem::setAmbientColor(const QColor& color)
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    val[1] = QVariant(color);
+    setValue(val);
+}
+
+QColor PropertyMaterialItem::getSpecularColor() const
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return QColor();
+
+    const QVariantList& val = value.toList();
+    return val[2].value<QColor>();
+}
+
+void PropertyMaterialItem::setSpecularColor(const QColor& color)
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    val[2] = QVariant(color);
+    setValue(val);
+}
+
+QColor PropertyMaterialItem::getEmissiveColor() const
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return QColor();
+
+    const QVariantList& val = value.toList();
+    return val[3].value<QColor>();
+}
+
+void PropertyMaterialItem::setEmissiveColor(const QColor& color)
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    val[3] = QVariant(color);
+    setValue(val);
+}
+
+float PropertyMaterialItem::getShininess() const
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return 0;
+
+    const QVariantList& val = value.toList();
+    return val[4].toFloat();
+}
+
+void PropertyMaterialItem::setShininess(float s)
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    val[4] = QVariant(s);
+    setValue(val);
+}
+
+float PropertyMaterialItem::getTransparency() const
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return 0;
+
+    const QVariantList& val = value.toList();
+    return val[5].toFloat();
+}
+
+void PropertyMaterialItem::setTransparency(float t)
+{
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    val[5] = QVariant(t);
+    setValue(val);
+}
+
+QVariant PropertyMaterialItem::decoration(const QVariant& value) const
+{
+    // use the diffuse color
+    const QVariantList& val = value.toList();
+    QColor color = val[0].value<QColor>();
+
+    int size = QApplication::style()->pixelMetric(QStyle::PM_ListViewIconSize);
+    QPixmap p(size, size);
+    p.fill(color);
+
+    return QVariant(p);
+}
+
+QVariant PropertyMaterialItem::toString(const QVariant& prop) const
+{
+    // use the diffuse color
+    const QVariantList& val = prop.toList();
+    QColor value = val[0].value<QColor>();
+    QString color = QString::fromLatin1("[%1, %2, %3]")
+        .arg(value.red()).arg(value.green()).arg(value.blue());
+    return QVariant(color);
+}
+
+QVariant PropertyMaterialItem::toolTip(const App::Property* prop) const
+{
+    assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterial::getClassTypeId()));
+
+    const App::Material& value = static_cast<const App::PropertyMaterial*>(prop)->getValue();
+    QColor dc = toQColor(value.diffuseColor);
+    QColor ac = toQColor(value.ambientColor);
+    QColor sc = toQColor(value.specularColor);
+    QColor ec = toQColor(value.emissiveColor);
+
+    QString data = QString::fromUtf8(
+        "Diffuse color: [%1, %2, %3]\n"
+        "Ambient color: [%4, %5, %6]\n"
+        "Specular color: [%7, %8, %9]\n"
+        "Emissive color: [%10, %11, %12]\n"
+        "Shininess: %13\n"
+        "Transparency: %14"
+        )
+        .arg(dc.red()).arg(dc.green()).arg(dc.blue())
+        .arg(ac.red()).arg(ac.green()).arg(ac.blue())
+        .arg(sc.red()).arg(sc.green()).arg(sc.blue())
+        .arg(ec.red()).arg(ec.green()).arg(ec.blue())
+        .arg(value.shininess)
+        .arg(value.transparency)
+        ;
+
+    return QVariant(data);
+}
+
+QVariant PropertyMaterialItem::value(const App::Property* prop) const
+{
+    assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterial::getClassTypeId()));
+
+    const App::Material& value = static_cast<const App::PropertyMaterial*>(prop)->getValue();
+    QVariantList variantList;
+
+    variantList << QVariant(toQColor(value.diffuseColor));
+    variantList << QVariant(toQColor(value.ambientColor));
+    variantList << QVariant(toQColor(value.specularColor));
+    variantList << QVariant(toQColor(value.emissiveColor));
+    variantList << QVariant(value.shininess);
+    variantList << QVariant(value.transparency);
+
+    return variantList;
+}
+
+void PropertyMaterialItem::setValue(const QVariant& value)
+{
+    if (!value.canConvert<QVariantList>())
+        return;
+
+    QVariantList val = value.toList();
+    App::Color dc = fromQColor(val[0].value<QColor>());
+    App::Color ac = fromQColor(val[1].value<QColor>());
+    App::Color sc = fromQColor(val[2].value<QColor>());
+    App::Color ec = fromQColor(val[3].value<QColor>());
+    float s = val[4].toFloat();
+    float t = val[5].toFloat();
+
+    QString data = QString::fromLatin1(
+        "App.Material("
+        "DiffuseColor=(%1,%2,%3),"
+        "AmbientColor=(%4,%5,%6),"
+        "SpecularColor=(%7,%8,%9),"
+        "EmissiveColor=(%10,%11,%12),"
+        "Shininess=(%13),"
+        "Transparency=(%14),"
+        ")"
+    )
+    .arg(dc.r, 0, 'f', decimals())
+    .arg(dc.g, 0, 'f', decimals())
+    .arg(dc.b, 0, 'f', decimals())
+    .arg(ac.r, 0, 'f', decimals())
+    .arg(ac.g, 0, 'f', decimals())
+    .arg(ac.b, 0, 'f', decimals())
+    .arg(sc.r, 0, 'f', decimals())
+    .arg(sc.g, 0, 'f', decimals())
+    .arg(sc.b, 0, 'f', decimals())
+    .arg(ec.r, 0, 'f', decimals())
+    .arg(ec.g, 0, 'f', decimals())
+    .arg(ec.b, 0, 'f', decimals())
+    .arg(s, 0, 'f', decimals())
+    .arg(t, 0, 'f', decimals())
+    ;
+
+    setPropertyValue(data);
+}
+
+QWidget* PropertyMaterialItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
+{
+    Gui::ColorButton* cb = new Gui::ColorButton(parent);
+    cb->setDisabled(isReadOnly());
+    QObject::connect(cb, SIGNAL(changed()), receiver, method);
+    return cb;
+}
+
+void PropertyMaterialItem::setEditorData(QWidget *editor, const QVariant& data) const
+{
+    Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
+    cb->setColor(getDiffuseColor());
+}
+
+QVariant PropertyMaterialItem::editorData(QWidget *editor) const
+{
+    Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
+    QVariant value = data(1, Qt::EditRole);
+    if (!value.canConvert<QVariantList>())
+        return QVariant();
+
+    QVariantList val = value.toList();
+    val[0] = QVariant(cb->color());
+    return val;
+}
+
+// --------------------------------------------------------------------
+
 TYPESYSTEM_SOURCE(Gui::PropertyEditor::PropertyFileItem, Gui::PropertyEditor::PropertyItem);
 
 PropertyFileItem::PropertyFileItem()
diff --git a/src/Gui/propertyeditor/PropertyItem.h b/src/Gui/propertyeditor/PropertyItem.h
index cacd85ef6..0850732ee 100644
--- a/src/Gui/propertyeditor/PropertyItem.h
+++ b/src/Gui/propertyeditor/PropertyItem.h
@@ -106,7 +106,7 @@ public:
 protected:
     PropertyItem();
 
-    virtual QVariant decoration(const App::Property*) const;
+    virtual QVariant decoration(const QVariant&) const;
     virtual QVariant toolTip(const App::Property*) const;
     virtual QVariant toString(const QVariant&) const;
     virtual QVariant value(const App::Property*) const;
@@ -654,7 +654,7 @@ class GuiExport PropertyColorItem: public PropertyItem
     virtual QVariant editorData(QWidget *editor) const;
 
 protected:
-    virtual QVariant decoration(const App::Property*) const;
+    virtual QVariant decoration(const QVariant&) const;
     virtual QVariant toString(const QVariant&) const;
     virtual QVariant value(const App::Property*) const;
     virtual void setValue(const QVariant&);
@@ -663,6 +663,59 @@ protected:
     PropertyColorItem();
 };
 
+/**
+* Change a material property.
+* \author Werner Mayer
+*/
+class GuiExport PropertyMaterialItem : public PropertyItem
+{
+    Q_OBJECT
+    Q_PROPERTY(QColor AmbientColor READ getAmbientColor WRITE setAmbientColor DESIGNABLE true USER true)
+    Q_PROPERTY(QColor DiffuseColor READ getDiffuseColor WRITE setDiffuseColor DESIGNABLE true USER true)
+    Q_PROPERTY(QColor SpecularColor READ getSpecularColor WRITE setSpecularColor DESIGNABLE true USER true)
+    Q_PROPERTY(QColor EmissiveColor READ getEmissiveColor WRITE setEmissiveColor DESIGNABLE true USER true)
+    Q_PROPERTY(float Shininess READ getShininess WRITE setShininess DESIGNABLE true USER true)
+    Q_PROPERTY(float Transparency READ getTransparency WRITE setTransparency DESIGNABLE true USER true)
+    TYPESYSTEM_HEADER();
+
+    virtual QWidget* createEditor(QWidget* parent, const QObject* receiver, const char* method) const;
+    virtual void setEditorData(QWidget *editor, const QVariant& data) const;
+    virtual QVariant editorData(QWidget *editor) const;
+
+    virtual void propertyBound();
+
+    QColor getAmbientColor() const;
+    void setAmbientColor(const QColor&);
+    QColor getDiffuseColor() const;
+    void setDiffuseColor(const QColor&);
+    QColor getSpecularColor() const;
+    void setSpecularColor(const QColor&);
+    QColor getEmissiveColor() const;
+    void setEmissiveColor(const QColor&);
+    float getShininess() const;
+    void setShininess(float);
+    float getTransparency() const;
+    void setTransparency(float);
+
+protected:
+    PropertyMaterialItem();
+    virtual ~PropertyMaterialItem();
+
+    virtual QVariant decoration(const QVariant&) const;
+    virtual QVariant toolTip(const App::Property*) const;
+    virtual QVariant toString(const QVariant&) const;
+    virtual QVariant value(const App::Property*) const;
+    virtual void setValue(const QVariant&);
+
+private:
+    PropertyColorItem* ambient;
+    PropertyColorItem* diffuse;
+    PropertyColorItem* specular;
+    PropertyColorItem* emissive;
+    PropertyFloatItem* shininess;
+    PropertyFloatItem* transparency;
+};
+
 /**
  * Change a file.
  * \author Werner Mayer