def __init__(self, filename, contentType='text/html', form=None,
     request=None):
     self.template = ViewPageTemplateFile(filename, content_type=contentType)
     zope.component.adapter(
         util.getSpecification(form),
         util.getSpecification(request))(self)
     zope.interface.implementer(IPageTemplate)(self)

 def __init__(self, filename, contentType='text/html',
              context=None, request=None, view=None,
              field=None, widget=None):
     self.template = ViewPageTemplateFile(filename, content_type=contentType)
     zope.component.adapter(
         util.getSpecification(context),
         util.getSpecification(request),
         util.getSpecification(view),
         util.getSpecification(field),
         util.getSpecification(widget))(self)
     zope.interface.implementer(interfaces.IWidgetLayoutTemplate)(self)

 def _add_validator(self, field, value):
     validator = resolveDottedName(value)
     if not IValidator.implementedBy(validator):
         raise ValueError(
             "z3c.form.interfaces.IValidator not implemented by %s."
             % value)
     provideAdapter(validator,
         (None, None, None, getSpecification(field), None),
         IValidator,
         )

def ErrorViewDiscriminators(errorView, error=None, request=None, widget=None, field=None, form=None, content=None):
    zope.component.adapter(
        util.getSpecification(error),
        util.getSpecification(request),
        util.getSpecification(widget),
        util.getSpecification(field),
        util.getSpecification(form),
        util.getSpecification(content),
    )(errorView)

            if invitations_nr > allowed:
                if allowed <= 0:
                    msg = _(u'error_participation_quota_reached',
                            default=u'The participation quota is reached, '
                            'you cannot add any further participants.')
                else:
                    msg = _('error_too_many_participants',
                            default=u'You cannot invite so many participants '
                            'any more. Can only add ${num} more participants.',
                            mapping={'num': allowed})
                raise Invalid(msg)

        return errors

WidgetsValidatorDiscriminators(NumberOfAdressesAndUsersValidator,
                               schema=getSpecification(IInviteSchema,
                                                       force=True))
provideAdapter(NumberOfAdressesAndUsersValidator)


class RolesValidator(SimpleFieldValidator):
    """Validator for validating the e-mail addresses field
    """

    def validate(self, roles):
        registry = getUtility(IRegistry)
        config = registry.forInterface(IParticipationRegistry)

        if not config.allow_multiple_roles and not roles:
            msg = _(u'error_no_roles', default=u'Please select a role')
            raise Invalid(msg)

class CommaSeparatedConverter(BaseDataConverter):
    adapts(ITuple, ICommaSeparatedWidget)

    def toFieldValue(self, value):
        """Return the tuple of strings

        :rtype tuple of strings:
        """
        if value is None:
            return self.field.missing_value
        return value


# plone intranet uses a dublincore override
@adapter(getSpecification(pi_IDublinCore['subjects']), IWorkspaceAppFormLayer)
@implementer(IFieldWidget)
def CommaSeparatedFieldWidget(field, request):
    return FieldWidget(field, CommaSeparatedWidget(request))


class IPatDatePickerWidget(IWidget):
    """ Marker interface """


@implementer_only(IPatDatePickerWidget)
class PatDatePickerWidget(Widget):
    """pat-date-picker gives us a list of strings with the date first and the
    time second. To extract the value we need to convert that to a datetime
    object.

from z3c.form.widget import FieldWidget
from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from zope.interface import implementer
from zope.component import adapter
from plone.app.dexterity.behaviors.metadata import ICategorization
from plone.app.dexterity.behaviors.metadata import IOwnership
from plone.app.widgets.dx.select2 import TagsWidget
from plone.app.widgets.interfaces import IWidgetsLayer


@adapter(getSpecification(ICategorization['subjects']), IWidgetsLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
    widget = FieldWidget(field, TagsWidget(request))
    widget.ajax_suggest = 'plone.app.vocabularies.Keywords'
    return widget


@adapter(getSpecification(IOwnership['contributors']), IWidgetsLayer)
@implementer(IFieldWidget)
def ContributorsFieldWidget(field, request):
    widget = FieldWidget(field, TagsWidget(request))
    widget.ajax_suggest = 'plone.app.vocabularies.Users'
    return widget


@adapter(getSpecification(IOwnership['creators']), IWidgetsLayer)
@implementer(IFieldWidget)
def CreatorsFieldWidget(field, request):
    widget = FieldWidget(field, TagsWidget(request))

# -*- coding: utf-8 -*-
from zope.component import adapter
from z3c.form.interfaces import IFormLayer
from z3c.form.util import getSpecification
from plone.formwidget.querystring.widget import QueryStringFieldWidget
from plone.app.contenttypes.behaviors.collection import ICollection


QueryStringFieldWidget = adapter(
    getSpecification(ICollection['query']),
    IFormLayer
)(QueryStringFieldWidget)

        try:
            dr = DateRange(obj.first, obj.last)
            try:
                validateTermsForOverlap(self.view.context, dr, None)
            except TermOverlapError, e:
                errors += (e, )
        except ValueError, e:
            errors += (Invalid(_("Term must begin before it ends.")), )
        except NoInputData:
            return errors
        return errors

WidgetsValidatorDiscriminators(
    AddTermFormValidator,
    view=TermAddForm,
    schema=getSpecification(ITermForm, force=True))


class EditTermFormValidator(InvariantsValidator):

    def validateObject(self, obj):
        errors = super(EditTermFormValidator, self).validateObject(obj)
        try:
            dr = DateRange(obj.first, obj.last)
            try:
                validateTermsForOverlap(self.view.context.__parent__, dr,
                                        self.view.context)
            except TermOverlapError, e:
                errors += (e, )
        except ValueError, e:
            errors += (Invalid(_("Term must begin before it ends.")), )

    # icalendar event uid
    sync_uid = schema.TextLine(required=False)
    form.mode(sync_uid='hidden')

    @invariant
    def validate_start_end(data):
        # data_postprocessing sets end=start if open_end
        if data.start > data.end and not data.open_end:
            raise StartBeforeEnd(
                _("error_end_must_be_after_start_date",
                  default=u"End date must be after start date.")
            )


@adapter(getSpecification(IEventBasic['start']), IPloneFormLayer)
@implementer(IFieldWidget)
def StartDateFieldWidget(field, request):
    widget = FieldWidget(field, DatetimeWidget(request))
    widget.default_timezone = default_timezone
    return widget


@adapter(getSpecification(IEventBasic['end']), IPloneFormLayer)
@implementer(IFieldWidget)
def EndDateFieldWidget(field, request):
    widget = FieldWidget(field, DatetimeWidget(request))
    widget.default_timezone = default_timezone
    return widget

    """ Recurring Event Schema.
    """
    recurrence = schema.Text(
        title=_(
            u'label_event_recurrence',
            default=u'Recurrence'
        ),
        description=_(
            u'help_event_recurrence',
            default=u'Define the event recurrence rule.'
        ),
        required=False
    )


@adapter(getSpecification(IEventRecurrence['recurrence']), IPloneFormLayer)
@implementer(IFieldWidget)
def RecurrenceFieldWidget(field, request):
    # Please note: If you create a new behavior with superclasses IEventBasic
    # and IRecurrence, then you have to reconfigure the dotted path value of
    # the start_field parameter for the RecurrenceWidget to the new
    # behavior name, like: IMyNewBehaviorName.start.
    widget = FieldWidget(field, RecurrenceWidget(request))
    widget.start_field = 'IEventBasic.start'
    widget.first_day = first_weekday_sun0
    widget.show_repeat_forever = False
    return widget


class IEventLocation(model.Schema):
    """ Event Location Schema.

try:
    from plone.app.relationfield.behavior import IRelatedItems
    HAS_RF = True
except ImportError:
    HAS_RF = False

try:
    from plone.app.contenttypes.behaviors.collection import ICollection
    from plone.app.contenttypes.behaviors.richtext import IRichText
    HAS_PAC = True
except ImportError:
    HAS_PAC = False


@adapter(getSpecification(ICategorization['subjects']), IWidgetsLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
    widget = FieldWidget(field, AjaxSelectWidget(request))
    widget.vocabulary = 'plone.app.vocabularies.Keywords'
    return widget


@adapter(getSpecification(ICategorization['language']), IWidgetsLayer)
@implementer(IFieldWidget)
def LanguageFieldWidget(field, request):
    widget = FieldWidget(field, SelectWidget(request))
    return widget


@adapter(getSpecification(IPublication['effective']), IWidgetsLayer)

from zope.i18nmessageid import MessageFactory
# Set up the i18n message factory for our package
MessageFactory = MessageFactory('collective.publications')

from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from z3c.form.interfaces import IFormLayer
from plone.app.dexterity.behaviors.metadata import ICategorization

from five import grok

from collective.z3cform.widgets.token_input_widget import TokenInputFieldWidget

def SubjectsFieldWidget(field, request):
    field.index_name = 'Subject'
    return TokenInputFieldWidget(field, request)

grok.global_adapter(
    SubjectsFieldWidget,
    (getSpecification(ICategorization['subjects']),
     IFormLayer),
    IFieldWidget,
)

    from plone.app.z3cform.interfaces import IDateField, IDatetimeField


@adapter(IDateField, IFormLibraryProductLayer)
@implementer(IFieldWidget)
def TypeADateFieldWidget(field, request, extra=None):
    return FieldWidget(field, TypeADateWidget(request))


@adapter(IDatetimeField, IFormLibraryProductLayer)
@implementer(IFieldWidget)
def TypeADatetimeFieldWidget(field, request, extra=None):
    return FieldWidget(field, TypeADatetimeWidget(request))


@adapter(getSpecification(IPublication["effective"]), IFormLibraryProductLayer)
@implementer(IFieldWidget)
def EffectiveDateFieldWidget(field, request):
    widget = FieldWidget(field, TypeADatetimeWidget(request))
    widget.pattern_options.setdefault("date", {})
    widget.pattern_options["date"]["firstDay"] = first_weekday()
    return widget


@adapter(getSpecification(IPublication["expires"]), IFormLibraryProductLayer)
@implementer(IFieldWidget)
def ExpirationDateFieldWidget(field, request):
    widget = FieldWidget(field, TypeADatetimeWidget(request))
    widget.pattern_options.setdefault("date", {})
    widget.pattern_options["date"]["firstDay"] = first_weekday()
    return widget

        if portal_type is None:
            return ''

        types_tool = api.portal.get_tool('portal_types')
        fti = getattr(types_tool, portal_type, None)
        if fti is None:
            return ''

        behaviors = getattr(fti, 'behaviors', None) or []
        if 'plone.app.blocks.layoutbehavior.ILayoutAware' not in behaviors:
            return ''

        return fti.default_view

    def _context_selected_layout(self):
        """Return the current layout for the layout aware context if we
        are on the layout aware context
        """
        if not ILayoutAware(self.context, None):
            return ''
        selectable_layout = ISelectableBrowserDefault(self.context, None)
        if not selectable_layout:
            return ''
        return selectable_layout.getLayout()


@adapter(getSpecification(ILayoutAware['content']), IMosaicLayer)
@implementer(IFieldWidget)
def LayoutFieldWidget(field, request):  # noqa
    return FieldWidget(field, LayoutWidget(request))

        default=1000,
        min=1,
    )


    view_template = schema.Choice(title=_(u"Display mode"),
                                  source=_(u"Available Listing Views"),
                                  required=True)


class IContentListingTileLayer(Interface):
    """Layer (request marker interface) for content listing tile views"""


@implementer(IValue)
@adapter(None, None, None, getSpecification(IContentListingTile['query']), None)  # noqa
class DefaultQuery(object):
    def __init__(self, context, request, form, field, widget):
        self.context = context

    def get(self):
        if IFolderish.providedBy(self.context):
            return [{
                'i': 'path',
                'o': 'plone.app.querystring.operation.string.relativePath',
                'v': '::1'
            }]
        else:
            return [{
                'i': 'path',
                'o': 'plone.app.querystring.operation.string.relativePath',

@indexer(ITask)
def index_project_manager(context):
    return [i.getId() for i in ITaskAccessor(context).project_manager]


@indexer(ITask)
def index_assignee(context):
    return [i.getId() for i in ITaskAccessor(context).assignee]


@indexer(ITask)
def index_state(context):
    return ITaskAccessor(context).state


@indexer(ITask)
def index_due(context):
    return ITaskAccessor(context).due


@adapter(getSpecification(ITaskPlannerSchema['text']), IFormLayer)
@implementer(IFieldWidget)
def TaskPlannerTextFieldWidget(field, request):
    return FieldWidget(field, RichTextWidget(request))


@adapter(getSpecification(ITaskSchema['text']), IFormLayer)
@implementer(IFieldWidget)
def TaskTextFieldWidget(field, request):
    return FieldWidget(field, RichTextWidget(request))

        """
        args = super(PatternWidget, self)._base_args()
        args['name'] = self.name
        args['value'] = self.value

        if (IAddForm.providedBy(self.form) and
                self.form.portal_type == 'uu.taskplanner') or \
           (not IAddForm.providedBy(self.form) and
                ITaskPlanner.providedBy(self.context) and
                'pattern_options' in args):
            args['pattern_options']['date'] = False

        return args


@adapter(getSpecification(ITaskCommon['project_manager']), IFormLayer)
@implementer(IFieldWidget)
def ProjectManagerFieldWidget(field, request):
    widget = FieldWidget(field, AjaxSelectWidget(request))
    widget.vocabulary = 'uu.task.Users'
    widget.pattern_options['allowNewItems'] = False
    alsoProvides(widget, IInheritParentValue)
    return widget


@adapter(getSpecification(ITaskCommon['assignee']), IFormLayer)
@implementer(IFieldWidget)
def AssigneeFieldWidget(field, request):
    widget = FieldWidget(field, AjaxSelectWidget(request))
    widget.vocabulary = 'uu.task.Users'
    widget.pattern_options['allowNewItems'] = False

    class TileRichTextWidget(RichTextWidget):
        """ """

        def _base_args(self):
            args = {
                'pattern': self.pattern,
                'pattern_options': self.pattern_options.copy(),
            }
            context = aq_parent(self.wrapped_context())
            args['name'] = self.name
            properties = getToolByName(context, 'portal_properties')
            charset = properties.site_properties.getProperty('default_charset',
                                                             'utf-8')
            value = self.value and self.value.raw_encoded or ''
            args['value'] = (self.request.get(
                self.field.getName(), value)).decode(charset)

            args.setdefault('pattern_options', {})
            merged = dict_merge(get_tinymce_options(context, self.field, self.request),  # noqa
                                args['pattern_options'])
            args['pattern_options'] = merged

            return args


    @adapter(getSpecification(IRichTextTile['text']), IFormLayer)
    @implementer(IFieldWidget)
    def TileRichTextFieldWidget(field, request):
        return FieldWidget(field, TileRichTextWidget(request))

@implementer(IFieldWidget)
def AjaxSelectFieldWidget(field, request, extra=None):
    if extra is not None:
        request = extra
    return FieldWidget(field, AjaxSelectWidget(request))


@implementer(IFieldWidget)
def RelatedItemsFieldWidget(field, request, extra=None):
    if extra is not None:
        request = extra
    return FieldWidget(field, RelatedItemsWidget(request))


if HAS_PAC:
    @adapter(getSpecification(IDXCollection['query']), IFormLayer)
    @implementer(IFieldWidget)
    def QueryStringFieldWidget(field, request):
        return FieldWidget(field, QueryStringWidget(request))

    @adapter(getSpecification(IRichText['text']), IFormLayer)
    @implementer(IFieldWidget)
    def RichTextFieldWidget(field, request):
        return FieldWidget(field, RichTextWidget(request))


class MockRequest(TestRequest):
    implements(IWidgetsLayer)


class DXFieldPermissionChecker(object):