def __init__(self, iface):
        self.iface = iface
        try:
            from .tests import testerplugin
            from qgistester.tests import addTestModule
            addTestModule(testerplugin, 'MIL-STD-2525')
        except:
            pass

        self._rendererMetadata = MilStd2525RendererMetadata()
        self._widgetWrapperFactory = SIDCWidgetWrapperFactory()

        QgsRendererV2Registry.instance().addRenderer(self._rendererMetadata)
        QgsEditorWidgetRegistry.instance().registerWidget('SIDC code editor', self._widgetWrapperFactory)

    def setReferencingFeature(self, feature=QgsFeature()):
        self.deactivateMapTool()
        self.referencingFeature = QgsFeature(feature)
        self.deleteWrapper()

        # disable relation reference widget if no referencing feature
        self.referencedFeatureLayout.setEnabled(feature.isValid())

        # set line edit
        if not self.relation.isValid() or not feature.isValid():
            self.referencingFeatureLineEdit.clear()
            return
        self.referencingFeatureLineEdit.setText("%s" % feature.id())

        fieldIdx = self.referencingFieldIndex()
        widgetConfig = self.relation.referencingLayer().editorWidgetV2Config(fieldIdx)
        self.relationWidgetWrapper = QgsEditorWidgetRegistry.instance().create("RelationReference",
                                                                               self.relation.referencingLayer(),
                                                                               fieldIdx,
                                                                               widgetConfig,
                                                                               self.relationReferenceWidget,
                                                                               self,
                                                                               self.editorContext)

        self.relationWidgetWrapper.setEnabled(self.relation.referencingLayer().isEditable())
        self.relationWidgetWrapper.setValue(feature[fieldIdx])
        self.relationWidgetWrapper.valueChanged.connect(self.foreignKeyChanged)
        # override field definition to allow map identification
        self.relationReferenceWidget.setAllowMapIdentification(True)
        self.relationReferenceWidget.setEmbedForm(False)

        # update drawn link
        self.highlightReferencingFeature()
        self.drawLink()

    def setUpClass(cls):
        """
        Setup the involved layers and relations for a n:m relation
        :return:
        """
        QgsEditorWidgetRegistry.initEditors()
        cls.dbconn = u'dbname=\'qgis_test\' host=localhost port=5432 user=\'postgres\' password=\'postgres\''
        if 'QGIS_PGTEST_DB' in os.environ:
            cls.dbconn = os.environ['QGIS_PGTEST_DB']
        # Create test layer
        cls.vl_b = QgsVectorLayer(cls.dbconn + ' sslmode=disable key=\'pk\' table="qgis_test"."books" sql=', 'test', 'postgres')
        cls.vl_a = QgsVectorLayer(cls.dbconn + ' sslmode=disable key=\'pk\' table="qgis_test"."authors" sql=', 'test', 'postgres')
        cls.vl_link = QgsVectorLayer(cls.dbconn + ' sslmode=disable key=\'pk\' table="qgis_test"."books_authors" sql=', 'test', 'postgres')

        QgsMapLayerRegistry.instance().addMapLayer(cls.vl_b)
        QgsMapLayerRegistry.instance().addMapLayer(cls.vl_a)
        QgsMapLayerRegistry.instance().addMapLayer(cls.vl_link)

        relMgr = QgsProject.instance().relationManager()

        cls.rel_a = QgsRelation()
        cls.rel_a.setReferencingLayer(cls.vl_link.id())
        cls.rel_a.setReferencedLayer(cls.vl_a.id())
        cls.rel_a.addFieldPair('fk_author', 'pk')
        cls.rel_a.setRelationId('rel_a')
        assert(cls.rel_a.isValid())
        relMgr.addRelation(cls.rel_a)

        cls.rel_b = QgsRelation()
        cls.rel_b.setReferencingLayer(cls.vl_link.id())
        cls.rel_b.setReferencedLayer(cls.vl_b.id())
        cls.rel_b.addFieldPair('fk_book', 'pk')
        cls.rel_b.setRelationId('rel_b')
        assert(cls.rel_b.isValid())
        relMgr.addRelation(cls.rel_b)

        # Our mock QgsVectorLayerTools, that allow injecting data where user input is expected
        cls.vltools = VlTools()

        assert(cls.vl_a.isValid())
        assert(cls.vl_b.isValid())
        assert(cls.vl_link.isValid())

    def testEditorWidgetTypes(self):
        """Test that editor widget types can be fetched from the qgis_editor_widget_styles table"""

        vl = QgsVectorLayer('%s table="qgis_test"."widget_styles" sql=' % (self.dbconn), "widget_styles", "postgres")
        self.assertTrue(vl.isValid())
        fields = vl.dataProvider().fields()

        setup1 = fields.field("fld1").editorWidgetSetup()
        self.assertFalse(setup1.isNull())
        self.assertEqual(setup1.type(), "FooEdit")
        self.assertEqual(setup1.config(), {"param1": "value1", "param2": "2"})

        best1 = QgsEditorWidgetRegistry.instance().findBest(vl, "fld1")
        self.assertEqual(best1.type(), "FooEdit")
        self.assertEqual(best1.config(), setup1.config())

        self.assertTrue(fields.field("fld2").editorWidgetSetup().isNull())

        best2 = QgsEditorWidgetRegistry.instance().findBest(vl, "fld2")
        self.assertEqual(best2.type(), "TextEdit")

 def setUpClass(cls):
     """Run before all tests"""
     cls.dbconn = "dbname='qgis_test'"
     if "QGIS_PGTEST_DB" in os.environ:
         cls.dbconn = os.environ["QGIS_PGTEST_DB"]
     # Create test layers
     cls.vl = QgsVectorLayer(
         cls.dbconn + ' sslmode=disable key=\'pk\' srid=4326 type=POINT table="qgis_test"."someData" (geom) sql=',
         "test",
         "postgres",
     )
     assert cls.vl.isValid()
     cls.provider = cls.vl.dataProvider()
     cls.poly_vl = QgsVectorLayer(
         cls.dbconn
         + ' sslmode=disable key=\'pk\' srid=4326 type=POLYGON table="qgis_test"."some_poly_data" (geom) sql=',
         "test",
         "postgres",
     )
     assert cls.poly_vl.isValid()
     cls.poly_provider = cls.poly_vl.dataProvider()
     QgsEditorWidgetRegistry.instance().initEditors()
     cls.con = psycopg2.connect(cls.dbconn)

    def __init__(self, iface, data, data_path=""):
        QDialog.__init__(self)
        self.setupUi(self)
        self.settings = MySettings()
        self.data = data
        self.currentProjectId = None
        self.channelNameEdit.setFocus()
        self.cancel = False

        self.data_path_line_edit.setText(data_path)
        self.pdf_path_widget.setDefaultRoot(data_path)

        self.cannotImportLabel.hide()
        self.progressBar.setTextVisible(True)
        self.progressBar.hide()
        self.cancelButton.hide()

        self.pdf_path_widget.setDefaultRoot(data_path)

        self.relationWidgetWrapper = None
        maintenance_layer = QgsMapLayerRegistry.instance().mapLayer(self.settings.value("maintenance_layer"))
        if maintenance_layer is not None:
            field_idx = maintenance_layer.fieldNameIndex('fk_operating_company')
            widget_config = maintenance_layer.editorWidgetV2Config(field_idx)
            editor_context = QgsAttributeEditorContext()
            editor_context.setVectorLayerTools(iface.vectorLayerTools())
            self.relationWidgetWrapper = QgsEditorWidgetRegistry.instance().create("ValueRelation",
                                                                                   maintenance_layer,
                                                                                   field_idx,
                                                                                   widget_config,
                                                                                   self.operatingCompanyComboBox,
                                                                                   self,
                                                                                   editor_context)

        self.sectionWidget.finish_init(iface, self.data)

        for p_id, project in self.data.items():
            self.projectCombo.addItem(project['Name'], p_id)

        self.channelNameEdit.setText('')

def represent_value(values, feature, parent):
    """
        Returns a fields representation using the layer widget configuration

        <h4>Syntax</h4>
        <p>represent_value(<i>value</i>, <i>layername</i>, <i>fieldname</i>)</p>

        <h4>Arguments</h4>
        <p><i>  value</i> &rarr; value of a field. This value will be represented.
        <p><i>  layername</i> &rarr; a string. Must be the either the layer id or the layer name
        of the layer on which this feature is located.</p>
        <p><i>  fieldname</i> &rarr; a string. Must be a field name on the layer.</p>

        <h4>Example</h4>
        <p><pre>represent_value("type", 'type', 'houses')</pre></p>
    """
    value=values[0]
    field_name=values[1]
    layer_name=values[2]

    layers = QgsMapLayerRegistry.instance().mapLayers()
    try:
      layer = layers[layer_name]
    except KeyError:
      try:
        layer = [l for l in layers.iteritems() if l[1].name() == layer_name][0][1]
      except IndexError:
        parent.setEvalErrorString(u'No layer with id or name {} found'.format(layer_name))
        return False

    field_index = layer.fields().fieldNameIndex(field_name)
    if field_index < 0:
        parent.setEvalErrorString(u'Field with name {} not found on layer'.format(field_name, layer_name))
        return False

    widget_type = layer.editFormConfig().widgetType(field_index)
    widget_config = layer.editFormConfig().widgetConfig(field_index)
    widget_factory = QgsEditorWidgetRegistry.instance().factory(widget_type)
    return widget_factory.representValue(layer, field_index, widget_config, None, value)

        if self.mLabel is not None:
            self.mLineEdit.setText(fileName)

class SimpleFilenameWidgetWrapperConfig(QgsEditorConfigWidget):
    def __init__(self, layer, idx, parent):
        QgsEditorConfigWidget.__init__(self, layer, idx, parent)
        
        self.setLayout(QHBoxLayout())
        self.ruleEdit = QLabel(self)
        self.ruleEdit.setText(QCoreApplication.translate('SimpleFilenameWidgetWrapperConfig','A filename without extension editor widget.'))
        self.layout().addWidget(self.ruleEdit)
 
    def config(self):
        return {}
 
    def setConfig(self, config):
        pass
                     
class SimpleFilenameWidgetWrapperFactory(QgsEditorWidgetFactory):
    def __init__(self):
        QgsEditorWidgetFactory.__init__(self, QCoreApplication.translate('SimpleFilenameWidgetWrapperFactory','Simple Filename'))
 
    def create(self, layer, fieldIdx, editor, parent):
        return SimpleFilenameWidgetWrapper(layer, fieldIdx, editor, parent)
 
    def configWidget(self, layer, idx, parent):
        return SimpleFilenameWidgetWrapperConfig(layer, idx, parent)
 
myFactory = SimpleFilenameWidgetWrapperFactory()
QgsEditorWidgetRegistry.instance().registerWidget('SimpleFilename', myFactory)

 
    def setConfig(self, config):
        self.conf = config
                     
class PreciseRangeWidgetWrapperFactory(QgsEditorWidgetFactory):
    def __init__(self):
        QgsEditorWidgetFactory.__init__(self, QCoreApplication.translate('PreciseRangeWidgetWrapperFactory','Precise Range'))
 
    def create(self, layer, fieldIdx, editor, parent):
        return PreciseRangeWidgetWrapper(layer, fieldIdx, editor, parent)
 
    def configWidget(self, layer, idx, parent):
        return PreciseRangeWidgetWrapperConfig(layer, idx, parent)
    
    def writeConfig( self, config, elem, doc, layer, idx ):
        elem.setAttribute('Min', config['Min'])
        elem.setAttribute('Max', config['Max'])
        elem.setAttribute('Step', config['Step'])
        elem.setAttribute('AllowNull', config['AllowNull'])
 
    def readConfig(self, elem, layer, idx):
        config = dict()
        config['Min'] = elem.attribute('Min')
        config['Max'] = elem.attribute('Max')
        config['Step'] = elem.attribute('Step')
        config['AllowNull'] = elem.attribute('AllowNull')
        return config
 
myFactory = PreciseRangeWidgetWrapperFactory()
QgsEditorWidgetRegistry.instance().registerWidget('PreciseRange', myFactory)

import qgis  # NOQA

from qgis.gui import (QgsSearchWidgetWrapper,
                      QgsAttributeFormEditorWidget,
                      QgsSearchWidgetToolButton,
                      QgsDefaultSearchWidgetWrapper,
                      QgsAttributeForm,
                      QgsEditorWidgetRegistry
                      )
from qgis.core import (QgsVectorLayer)
from qgis.PyQt.QtWidgets import QWidget, QDateTimeEdit
from qgis.PyQt.QtCore import QDateTime, QDate, QTime
from qgis.testing import start_app, unittest

start_app()
QgsEditorWidgetRegistry.instance().initEditors()


class PyQgsAttributeFormEditorWidget(unittest.TestCase):

    def testCurrentFilterExpression(self):
        """ Test creating an expression using the widget"""

        layer = QgsVectorLayer("Point?field=fldint:integer", "test", "memory")
        parent = QWidget()
        w = QgsDefaultSearchWidgetWrapper(layer, 0, parent)
        af = QgsAttributeFormEditorWidget(None, None)
        af.setSearchWidgetWrapper(w)

        # test that filter combines both current value in search widget wrapper and flags from search tool button
        w.lineEdit().setText('5.5')

# coding: utf-8
from qgis.gui import QgsEditorWidgetRegistry
from qgis.utils import iface

editor_widget_registry_instance = QgsEditorWidgetRegistry.instance()

# List available widgets in Text edition in tab Fields of a vector layer
print editor_widget_registry_instance.factories()  # Return a list of QgsEditorWidgetFactory
print editor_widget_registry_instance.factories().keys()

# Get QgsEditorWidgetFactory
print editor_widget_registry_instance.factory(u'Range')
print editor_widget_registry_instance.factory(u'RelationReference')


layer = iface.activeLayer()
editFormConfig = layer.editFormConfig()  # QgsEditFormConfig
idx = layer.dataProvider().fieldNameIndex('ADM0_A3')
widgetType = editFormConfig.widgetType(idx)
widgetConfig = editFormConfig.widgetConfig(idx)
wrapper = QgsEditorWidgetRegistry.instance().create(
    widgetType, layer, idx, widgetConfig, None, None)  # QgsEditorWidgetWrapper
widget = wrapper.widget()

"""
Classes below inherit from QgsEditorWidgetFactory and are the one really used.
They are casted

QgsCheckboxWidgetFactory
QgsClassificationWidgetWrapperFactory
QgsColorWidgetFactory