def update(self, item):
        objectEventNotify(ObjectWillBeModifiedEvent(item))

        item.title = _element_value(self, self.element, 'title')
        item.description = _element_value(self, self.element, 'description')

        objectEventNotify(ObjectModifiedEvent(item))

    def handle_submit(self, converted):
        context = self.context
        request = self.request
        workflow = self.workflow
        # *will be* modified event
        objectEventNotify(ObjectWillBeModifiedEvent(context))
        if 'security_state' in converted:
            if workflow is not None:
                workflow.transition_to_state(context, request,
                                             converted['security_state'])

        context.title = converted['title']
        context.text = converted['text']
        context.description = extract_description(converted['text'])

        # Tags and attachments
        set_tags(context, request, converted['tags'])
        creator = authenticated_userid(request)
        attachments_folder = context['attachments']
        upload_attachments(
            filter(lambda x: x is not None, converted['attachments']),
            attachments_folder,
            creator, request)

        # modified
        context.modified_by = authenticated_userid(request)
        objectEventNotify(ObjectModifiedEvent(context))

        location = resource_url(context, request)
        self.filestore.clear()
        return HTTPFound(location=location)

 def __delitem__(self, key):
     delnode = self[key]
     super(LifecycleNode, self).__delitem__(key)
     if self._notify_suppress:
         return
     objectEventNotify(self.events['removed'](delnode, oldParent=self,
                                              oldName=key))

    def handle_submit(self, converted):
        request = self.request
        context = self.context

        # *will be* modified event
        objectEventNotify(ObjectWillBeModifiedEvent(context))

        simple_fields = ['title', 'text', 'caption', 'publication_date']
        for field in simple_fields:
            setattr(context, field, converted[field])

        # save tags, attachments, photo
        set_tags(context, request, converted['tags'])
        userid = authenticated_userid(request)
        attachments_folder = context['attachments']
        upload_attachments(converted['attachments'], attachments_folder,
                           userid, request)
        handle_photo_upload(context, converted)
        self.filestore.clear

        # mark as modified
        context.modified_by = userid
        objectEventNotify(ObjectModifiedEvent(context))

        location = resource_url(context, request)
        msg = "?status_message=News%20Item%20edited"
        return HTTPFound(location=location+msg)

 def detach(_next, self, key):
     self._notify_suppress = True
     node = _next(self, key)
     self._notify_suppress = False
     objectEventNotify(self.events['detached'](node, oldParent=self,
                                               oldName=key))
     return node

    def handle_submit(self, converted):
        context = self.context
        request = self.request
        workflow = self.workflow
        # *will be* modified event
        objectEventNotify(ObjectWillBeModifiedEvent(context))
        if workflow is not None:
            if 'security_state' in converted:
                workflow.transition_to_state(context, request,
                                             converted['security_state'])

        context.text = converted['text']
        context.description = extract_description(converted['text'])
        newtitle = converted['title']
        if newtitle != context.title:
            context.change_title(newtitle)

        # Save the tags on it
        set_tags(context, request, converted['tags'])

        # Modified
        context.modified_by = authenticated_userid(request)
        objectEventNotify(ObjectModifiedEvent(context))

        location = model_url(context, request)
        msg = "?status_message=Wiki%20Page%20edited"
        return HTTPFound(location=location+msg)

    def remove(self, name, send_events=True):
        """See IFolder."""
        name = unicodify(name)
        other = self.data[name]

        if send_events:
            objectEventNotify(ObjectWillBeRemovedEvent(other, self, name))

        if hasattr(other, '__parent__'):
            del other.__parent__

        if hasattr(other, '__name__'):
            del other.__name__

        # backwards compatibility: add a Length _num_objects to folders that
        # have none
        if self._num_objects is None:
            self._num_objects = Length(len(self.data))

        del self.data[name]
        self._num_objects.change(-1)

        if self._order is not None:
            self._order = tuple([x for x in self._order if x != name])

        if send_events:
            objectEventNotify(ObjectRemovedEvent(other, self, name))

        return other

    def handle_submit(self, converted):
        context = self.context
        request = self.request
        objectEventNotify(ObjectWillBeModifiedEvent(context))
        workflow = self.workflow
        if workflow is not None:
            if 'security_state' in converted:
                workflow.transition_to_state(context, request,
                                             converted['security_state'])
        context.title = converted['title']
        context.description = converted['description']
        context.text = converted['text']
        # NB: this is an edit form, so tags are added immediately via
        # AJAX; we needn't deal with setting them in the form post
        tools_present = [None]
        available_tools = self.available_tools
        for info in available_tools:
            component = info['component']
            tool_name = info['name']
            tools_present.append(tool_name)
            present = component.is_present(context, request)
            if (not present) and tool_name in converted['tools']:
                component.add(context, request)
            if present and (tool_name not in converted['tools']):
                component.remove(context, request)
                tools_present.remove(tool_name)
        if converted['default_tool'] in tools_present:
            context.default_tool = converted['default_tool']
        elif not (context.default_tool in tools_present):
            context.default_tool = None

        # *modified* event
        objectEventNotify(ObjectModifiedEvent(context))
        location = model_url(context, request)
        return HTTPFound(location=location)

    def handle_submit(self, converted):
        context = self.context
        request = self.request
        workflow = self.workflow

        # *will be* modified event
        objectEventNotify(ObjectWillBeModifiedEvent(context))
        if workflow is not None:
            if 'security_state' in converted:
                workflow.transition_to_state(context, request,
                                             converted['security_state'])

        context.title = converted['title']
        context.text = converted['text']
        context.description = extract_description(converted['text'])

        # Save the tags on it
        set_tags(context, request, converted['tags'])

        # Save new attachments
        creator = authenticated_userid(request)
        if support_attachments(context):
            upload_attachments(converted['attachments'], context['attachments'],
                               creator, request)

        # Modified
        context.modified_by = authenticated_userid(request)
        objectEventNotify(ObjectModifiedEvent(context))

        location = model_url(context, request,
                             query={'status_message':'Forum Topic Edited'})
        return HTTPFound(location=location)

def demo_events(load_zcml):
    gsm = getGlobalSiteManager()

    if load_zcml:
        from zope.configuration.xmlconfig import xmlconfig
        fname = __file__[:-3] + '.zcml'
        xmlconfig(open(fname))
    else:
        gsm.registerHandler(me.handle_some_event)
        gsm.registerHandler(me.handle_object_modified_event,
                            [me.IData, me.IObjectModifiedEvent])

    obj = me.Data()
    evt = me.SomeEvent()
    evt.object = obj

    if load_zcml:
        notify(evt)
    else:
        handle(evt)

    assert obj.data == 'changed'

    obj.data = 'unchanged'

    if load_zcml:
        notify(me.ObjectModifiedEvent(obj))
    else:
        objectEventNotify(me.ObjectModifiedEvent(obj))

    assert obj.data == 'changed'

    print "Done"

 def __delitem__(_next, self, key):
     delnode = self[key]
     _next(self, key)
     if self._notify_suppress:
         return
     objectEventNotify(self.events['removed'](delnode, oldParent=self,
                                              oldName=key))

    def handle_submit(self, converted):
        request = self.request
        context = self.context
        # *will be* modified event
        objectEventNotify(ObjectWillBeModifiedEvent(context))
        if converted.get('middle_portlets'):
            middle_portlets = split_lines(converted['middle_portlets'])
        else:
            middle_portlets = []
        if converted.get('right_portlets'):
            right_portlets = split_lines(converted['right_portlets'])
        else:
            right_portlets = []
        context.title = converted['title']
        context.address = converted['address']
        context.city = converted['city']
        context.state = converted['state']
        context.country = converted['country']
        context.zipcode = converted['zipcode']
        context.telephone = converted['telephone']
        context.navigation = clean_html(converted['navigation'])
        context.middle_portlets = middle_portlets
        context.right_portlets = right_portlets
        context.css = converted['css']
        # *modified* event
        objectEventNotify(ObjectModifiedEvent(context))

        location = resource_url(context.__parent__['intranets'], request)
        return HTTPFound(location=location)

    def handle_submit(self, params):
        context = self.context
        objectEventNotify(ObjectWillBeModifiedEvent(context))

        if self.use_folder_options:
            noLongerProvides(context, IReferencesFolder)
            noLongerProvides(context, INetworkNewsMarker)
            noLongerProvides(context, INetworkEventsMarker)
            marker = params.get("marker")
            if marker == "reference_manual":
                alsoProvides(context, IReferencesFolder)
            elif marker == "network_news":
                alsoProvides(context, INetworkNewsMarker)
            elif marker == "network_events":
                alsoProvides(context, INetworkEventsMarker)

        keywords = params.get("keywords")
        if keywords is not None:
            context.search_keywords = keywords

        weight = params.get("weight")
        if weight is not None:
            context.search_weight = weight

        if self.use_unlock and params.get("unlock"):
            lock.clear(context)

        objectEventNotify(ObjectModifiedEvent(context))
        return HTTPFound(
            location=resource_url(self.context, self.request, query={"status_message": "Advanced settings changed."})
        )

    def handle_submit(self, converted):
        context = self.context
        request = self.request
        userid = authenticated_userid(request)
        # *will be* modified event
        objectEventNotify(ObjectWillBeModifiedEvent(context))

        context.title = converted['title']
        context.text = converted['text']
        context.description = extract_description(converted['text'])

        # tags and attachments
        set_tags(context, request, converted['tags'])
        creator = userid
        attachments_folder = context['attachments']
        upload_attachments(converted['attachments'], attachments_folder,
                           creator, request)

        # modified
        context.modified_by = userid
        objectEventNotify(ObjectModifiedEvent(context))

        self.filestore.clear()
        location = resource_url(context, request)
        msg = "?status_message=Page%20edited"
        return HTTPFound(location=location+msg)

    def add(self, name, other, send_events=True):
        """See IFolder."""
        if not isinstance(name, basestring):
            raise TypeError("Name must be a string rather than a %s" %
                            name.__class__.__name__)
        if not name:
            raise TypeError("Name must not be empty")

        name = unicodify(name)

        if name in self.data:
            raise KeyError('An object named %s already exists' % name)

        if send_events:
            objectEventNotify(ObjectWillBeAddedEvent(other, self, name))
        other.__parent__ = self
        other.__name__ = name

        # backwards compatibility: add a Length _num_objects to folders that
        # have none
        if self._num_objects is None:
            self._num_objects = Length(len(self.data))

        self.data[name] = other
        self._num_objects.change(1)

        if self._order is not None:
            self._order += (name,)

        if send_events:
            objectEventNotify(ObjectAddedEvent(other, self, name))

def appmaker(zodb_root):
    try:
        return zodb_root['app_root']
    except KeyError:
        from pyramid.threadlocal import get_current_registry
        from zope.interface import alsoProvides
        from zope.component.event import objectEventNotify
        import transaction
        from arche.utils import get_content_factories
        from arche.interfaces import IRoot
        from arche.populators import root_populator
        from arche.models.evolver import run_initial_migrations
        from arche.events import ObjectAddedEvent

        factories = get_content_factories()
        #This is where initial population takes place, but first some site setup
        if not 'initial_setup' in zodb_root or not zodb_root['initial_setup'].setup_data:
            InitialSetup = factories['InitialSetup']
            zodb_root['initial_setup'] = InitialSetup()
            transaction.commit()
            return zodb_root['initial_setup']
        else:
            #FIXME move this population to its own method so tests can use it
            #Root added
            data = dict(zodb_root['initial_setup'].setup_data)
            #Attach and remove setup context
            zodb_root['app_root'] = root = root_populator(**data)
            transaction.commit()
            run_initial_migrations(root)
            # Manually notify added event
            objectEventNotify(ObjectAddedEvent(root, None, None))
            del zodb_root['initial_setup']
            return root

 def store(self, user, data):
     assert IUser.providedBy(user)
     assert isinstance(data, dict)
     provider_data = IProviderData(user)
     #Check if data already exist and if it needs to be updated
     stored_keys = set()
     if self.name in provider_data:
         curr_data = provider_data[self.name]
         #Check existing keys
         for (k, v) in data.items():
             if curr_data.get(k, object()) != v:
                 curr_data[k] = v
                 stored_keys.add(k)
         #Remove unused keys
         for k in set(curr_data) - set(data):
             del curr_data[k]
             #We don't need to track updated here
     else:
         provider_data[self.name] = data
         stored_keys.update(data)
     if stored_keys:
         self.logger.debug("provider %s data changed for user %s", self.name, user.userid)
         event = ObjectUpdatedEvent(user, changed = ['pas_ident'])
         objectEventNotify(event)
     return stored_keys

 def handle_submit(self, converted):
     context = self.context
     request = self.request
     users = self.users
     userid = self.userid
     user = self.user
     if user is not None:
         login = converted.get('login')
         login_changed = users.get_by_login(login) != user
         if (login_changed and
             (users.get_by_id(login) is not None or
              users.get_by_login(login) is not None or
              login in context)):
             msg = "Login '%s' is already in use" % login
             raise ValidationError(login=msg)
     objectEventNotify(ObjectWillBeModifiedEvent(context))
     if user is not None:
         # Set new login
         try:
             users.change_login(userid, converted['login'])
         except ValueError, e:
             raise ValidationError(login=str(e))
         # Set group memberships
         user_groups = self.user_groups
         chosen_groups = set(converted['groups'])
         for group, group_title in self.group_options:
             if group in chosen_groups and group not in user_groups:
                 users.add_user_to_group(userid, group)
             if group in user_groups and group not in chosen_groups:
                 users.remove_user_from_group(userid, group)
         # Edit password
         if converted.get('password', None):
             users.change_password(userid, converted['password'])

    def handle_submit(self, params):
        context = self.context
        objectEventNotify(ObjectWillBeModifiedEvent(context))

        if self.use_folder_options:
            noLongerProvides(context, IReferencesFolder)
            noLongerProvides(context, INetworkNewsMarker)
            noLongerProvides(context, INetworkEventsMarker)
            marker = params.get('marker')
            if marker == 'reference_manual':
                alsoProvides(context, IReferencesFolder)
            elif marker == 'network_news':
                alsoProvides(context, INetworkNewsMarker)
            elif marker == 'network_events':
                alsoProvides(context, INetworkEventsMarker)

        keywords = params.get('keywords')
        if keywords is not None:
            context.search_keywords = keywords

        weight = params.get('weight')
        if weight is not None:
            context.search_weight = weight

        objectEventNotify(ObjectModifiedEvent(context))
        return HTTPFound(location=model_url(self.context, self.request,
                    query={'status_message': 'Advanced settings changed.'}))

def edit_referencesection_view(context, request):

    tags_list = request.POST.getall('tags')
    form = EditReferenceSectionForm(tags_list=tags_list)

    if 'form.cancel' in request.POST:
        return HTTPFound(location=model_url(context, request))

    if 'form.submitted' in request.POST:
        try:
            converted = form.validate(request.POST)
            # *will be* modified event
            objectEventNotify(ObjectWillBeModifiedEvent(context))

            context.title = converted['title']
            context.description = converted['description']

            # Save the tags on it
            set_tags(context, request, converted['tags'])

            # Modified
            context.modified_by = authenticated_userid(request)
            objectEventNotify(ObjectModifiedEvent(context))

            location = model_url(context, request)
            msg = "?status_message=Reference%20section%20edited"
            return HTTPFound(location=location+msg)

        except Invalid, e:
            fielderrors = e.error_dict
            fill_values = form.convert(request.POST)