How to use the zope.schema.Bool function in Zope

title=_(u'Poi_label_tracker_watchers', default=u'Watchers'),
        description=_(
            u'Poi_help_tracker_watchers',
            default=(
                u"Enter the user ids of members who are watching "
                u"this tracker, one per line. E-mail addresses are "
                u"allowed too. These persons will receive "
                u"an email when an issue or response is added to the "
                u"tracker. Members can also add themselves as "
                u"watchers.")
        ),
        value_type=schema.TextLine(),
        required=False,
    )

    notification_emails = schema.Bool(
        title=_(
            u'Poi_label_sendNotificationEmails',
            default=u"Send notification emails"
        ),
        description=_(
            u'Poi_help_sendNotificationEmails',
            default=(
                u"If selected, all tracker assignees above will "
                u"receive an email for new issues and all issue "
                u"responses. Issue watchers will receive an email "
                u"for all issue responses. Issue submitters will "
                u"receive an email when the issue has been resolved.")
        ),
    )

    mailing_list = schema.TextLine(

import logging
log = logging.getLogger(__name__)


class INewsApp(IApp, IAppContainer):
    """Toplevel News singleton to contain all news content (IAppContainer)
    that also provides an IApp tile in the apps listing.
    """


class INewsSection(form.Schema):
    """News Sections can contain News Items"""

    uuid = Attribute("Stable unique id")

    section_visible = schema.Bool(
        title=_('section_visible', u'Section visible'),
        description=_(
            'description_section_visible',
            u'Show this section in the section navigation'),
        required=False,
        default=True)

    description_visible = schema.Bool(
        title=_('description_visible', u'Description visible'),
        description=_(
            'description_description_visible',
            u'Show the section description on the section page'),
        required=False,
        default=True)

"that this will not make already converted elements searchable/"
                      "not searchable, you will have to convert existing element yourself."
                      ),
        default=True)
    ocr = schema.Bool(
        title=_("OCR"),
        description=_("Extract the text from the PDF using OCR technology."),
        default=False)
    detect_text = schema.Bool(
        title=_("Detect text"),
        description=_("Detect if pdf has text before performing OCR on it. "
                      "If text is found, ocr will be skipped. "
                      "If OCR is disabled, text will always try to be "
                      "retrieved from the PDF file anyways."),
        default=True)
    auto_select_layout = schema.Bool(
        title=_("Auto select layout"),
        description=_("For pdf files."),
        default=True)
    auto_layout_file_types = schema.List(
        title=_("Auto layout file types"),
        description=_("Extra types only work with "
                      "openoffice/libreoffice installed."),
        default=['pdf'],
        value_type=schema.Choice(
            vocabulary=SimpleVocabulary(FILE_TYPES_VOCAB))
        )
    auto_convert = schema.Bool(
        title=_("Auto Convert"),
        description=_("Automatically convert files on creation "
                      "and modification."),
        default=True)

)
    )

    width = schema.Int(
        title=u'Image scale width',
        required=True,
        default=1170
    )

    height = schema.Int(
        title=u'Image scale height',
        required=True,
        default=200
    )

    enable_caption = schema.Bool(
        title=u'Show caption',
        required=False,
        default=False
    )


class Assignment(base.Assignment):
    implements(ICarouselPortlet)

    images = []
    title = u'Carousel portlet'
    width = 1170
    height = 200
    enable_caption = False

    def __init__(self, images=None, width=1170, height=200, enable_caption=False):

u'action_condition_description',
            default=u'A boolean expression'
        ),
        required=False)

    permissions = schema.List(
        title=_(u'action_permissions_heading', default=u'Permissions'),
        required=True,
        default=['View'],
        missing_value=[],
        value_type=schema.Choice(
            vocabulary='plone.app.vocabularies.Permissions'
        )
    )

    visible = schema.Bool(
        title=_(u'action_visibility_heading', default=u'Visible?'),
        default=True,
        required=False)

    position = schema.Int(
        title=_(u'action_position_heading', default=u'Position'),
        default=1,
        min=1,
        required=True)


class INewActionSchema(Interface):

    category = schema.Choice(
        title=_(u'Category'),
        vocabulary='plone.app.vocabularies.PortalActionCategories',

# XXX: based on OFS.OrderedFolder.OrderedFolder
class IOrderedFolder(IOrderedContainer, IFolder):

    """Ordered folder.
    """


# XXX: might contain non-API methods and outdated comments;
#      not synced with ZopeBook API Reference;
#      based on OFS.Application.Application
class IApplication(IFolder, IRoot):

    """Top-level system object"""

    isTopLevelPrincipiaApplicationObject = Bool(
        title=u"Is top level application object",
    )

    p_ = Attribute(""" """)
    misc_ = Attribute("Misc.")

    def Redirect(destination, URL1):
        """Utility function to allow user-controlled redirects"""

    ZopeRedirect = Redirect

    def __bobo_traverse__(REQUEST, name=None):
        """Bobo traverse.
        """

    def ZopeTime(*args):

class IPlominoDatabase(model.Schema):
    """ Plomino database schema
    """

    indexAttachments = schema.Bool(
        title=_('CMFPlomino_label_IndexAttachments',
            default="Index file attachments"),
        description=_('CMFPlomino_help_IndexAttachments',
            default="If enabled, files attached in File Attachment fields "
            "will be indexed. It might increase the index size."),
        default=False,
    )

    fulltextIndex = schema.Bool(
        title=_('CMFPlomino_label_FulltextIndex',
            default="Local full-text index"),
        description=_('CMFPlomino_help_FulltextIndex',
            default='If enabled, documents are full-text indexed in the '
            'Plomino index.'),
        default=True,
    )

    indexInPortal = schema.Bool(
        title=_('CMFPlomino_label_IndexInPortal',
            default="Index documents in Plone portal"),
        description=_('CMFPlomino_help_IndexInPortal',
            default="If enabled, documents are searchable in Plone search."),
        default=False,
    )

effect = schema.Choice(
        title=_(u"label_effect_title_slider_setting", default=u"Effect Type"),
        description=_(u"label_effect_description_slider_setting",
                      default=_(u"I know the product is called easySLIDER, "
                                u"but we decided to let you choose multiple "
                                u"effects now")),
        default="Slide",
        vocabulary=SimpleVocabulary.fromValues([
            'Slide',
            'Fade',
            'Crossfade'
        ])
    )

    vertical = schema.Bool(
        title=_(u"label_vertical_title_slider_setting", default=u"Vertical?"),
        description=_(u"label_vertical_description_slider_setting",
                      default=u"Should the slide transition vertically?"),
        default=False
    )

    speed = schema.Int(
        title=_(u"label_speed_title_slider_setting", default=u"Speed"),
        description=_(u"label_speed_description_slider_setting",
                      default=u"Speed at which the slide will transition."),
        default=800
    )

    odd_speed = schema.Int(
        title=_(u"label_odd_speed_title_slider_setting",
                default=u"Odd Slide Speed"),

merge_with = schema.Choice(
        title=_(u"Merge with"),
        description=_(
            u"In production mode, bundles are merged together to reduce the "
            "quantity of JS and CSS resources loaded by the browser. Choose "
            "'default' if this bundle must be available for all the visitors, "
            "choose 'logged-in' if it must be available for logged-in users "
            "only, or leave it empty if it must not be merged."),
        vocabulary=SimpleVocabulary(
            [SimpleTerm('', '', _(u"")),
             SimpleTerm('default', 'default', 'default'),
             SimpleTerm('logged-in', 'logged-in', 'logged-in')]),
        default=u"",
        required=False)

    load_async = schema.Bool(
        title=_(u"Load asynchronously"),
        description=_("Load the JavaScript files asynchronously by adding an ``async`` attribute to the script tag."),
        default=False,
        required=False)

    load_defer = schema.Bool(
        title=_(u"Load deffered"),
        description=_("Load the JavaScript files deffered after the document has been parsed but before ``DOMContentLoaded`` by adding a ``defer`` attribute to the script tag."),
        default=False,
        required=False)

class IPlominoHidewhen(model.Schema):
    """ Plomino hide-when schema
    """

    directives.widget('formula', klass='plomino-formula')
    formula = schema.Text(
        title=_('CMFPlomino_label_HidewhenFormula', default="Formula"),
        description=_('CMFPlomino_help_HidewhenFormula',
            default='If returning True, the block will be hidden.'),
        required=True,
        default=u"False",
    )

    isDynamicHidewhen = schema.Bool(
        title=_('CMFPlomino_label_isDynamicHidewhen',
            default="Dynamic Hide-when"),
        description=_('CMFPlomino_help_isDynamicHidewhen',
            default="Hide-when are evaluated dynamically when the user enters information"),
        required=True,
        default=False,
    )


class PlominoHidewhen(Item):
    implements(IPlominoHidewhen)