footer of the note
        :param trigger: trigger object
        :param data: data to be used
        :param content: add the footer of the note to the content
        :return: content string
515751
def _footer(trigger, data, content):
        
        # footer of the note
        footer = EvernoteMgr.set_note_footer(data, trigger)
        content += footer
        return content
1079370
def process(self, content):
        
        log.debug('processing:\n%s', content)
        self.reset()
        if content.tag is None:
            content.tag = content.value.__class__.__name__
        document = Document()
        self.append(document, content)
        return document.root()
215676
def create_content(self, cli, width, height):
        
        buffer = self._buffer(cli)

        # Get the document to be shown. If we are currently searching (the
        # search buffer has focus, and the preview_search filter is enabled),
        # then use the search document, which has possibly a different
        # text/cursor position.)
        def preview_now():
            """ True when we should preview a search. """
            return bool(self.preview_search(cli) and
                        cli.buffers[self.search_buffer_name].text)

        if preview_now():
            if self.get_search_state:
                ss = self.get_search_state(cli)
            else:
                ss = cli.search_state

            document = buffer.document_for_search(SearchState(
                text=cli.current_buffer.text,
                direction=ss.direction,
                ignore_case=ss.ignore_case))
        else:
            document = buffer.document

        get_processed_line = self._create_get_processed_line_func(cli, document)
        self._last_get_processed_line = get_processed_line

        def translate_rowcol(row, col):
            " Return the content column for this coordinate. "
            return Point(y=row, x=get_processed_line(row).source_to_display(col))

        def get_line(i):
            " Return the tokens for a given line number. "
            tokens = get_processed_line(i).tokens

            # Add a space at the end, because that is a possible cursor
            # position. (When inserting after the input.) We should do this on
            # all the lines, not just the line containing the cursor. (Because
            # otherwise, line wrapping/scrolling could change when moving the
            # cursor around.)
            tokens = tokens + [(self.default_char.token, ' ')]
            return tokens

        content = UIContent(
            get_line=get_line,
            line_count=document.line_count,
            cursor_position=translate_rowcol(document.cursor_position_row,
                                             document.cursor_position_col),
            default_char=self.default_char)

        # If there is an auto completion going on, use that start point for a
        # pop-up menu position. (But only when this buffer has the focus --
        # there is only one place for a menu, determined by the focussed buffer.)
        if cli.current_buffer_name == self.buffer_name:
            menu_position = self.menu_position(cli) if self.menu_position else None
            if menu_position is not None:
                assert isinstance(menu_position, int)
                menu_row, menu_col = buffer.document.translate_index_to_position(menu_position)
                content.menu_position = translate_rowcol(menu_row, menu_col)
            elif buffer.complete_state:
                # Position for completion menu.
                # Note: We use 'min', because the original cursor position could be
                #       behind the input string when the actual completion is for
                #       some reason shorter than the text we had before. (A completion
                #       can change and shorten the input.)
                menu_row, menu_col = buffer.document.translate_index_to_position(
                    min(buffer.cursor_position,
                        buffer.complete_state.original_document.cursor_position))
                content.menu_position = translate_rowcol(menu_row, menu_col)
            else:
                content.menu_position = None

        return content
1179331
def add_note(self, note):
        
        for n in self.selected_tracks:
            self.tracks[n] + note
1311689
public function footer()
    {
        $this->SetY(- 15);
        $this->drawLine();
        $this->SetFontSize(10);
        $this->Cell(0, 10, $this->infoTextForFooter, 0, false, 'L', 0, '', 0, false, 'T', 'M');
        $textForFooterRight = __('Page_{0}_of_{1}', [$this->getAliasNumPage(), $this->getAliasNbPages()]);
        $this->Cell(0, 10, $textForFooterRight, 0, false, 'R', 0, '', 0, false, 'T', 'M');
        $this->SetFontSize(12);
    }
972136
def _notebook(trigger, note_store):
        
        note = Types.Note()
        if trigger.notebook:
            # get the notebookGUID ...
            notebook_id = EvernoteMgr.get_notebook(note_store, trigger.notebook)
            # create notebookGUID if it does not exist then return its id
            note.notebookGuid = EvernoteMgr.set_notebook(note_store, trigger.notebook, notebook_id)

            if trigger.tag:
                # ... and get the tagGUID if a tag has been provided
                tag_id = EvernoteMgr.get_tag(note_store, trigger.tag)
                if tag_id is False:
                    tag_id = EvernoteMgr.set_tag(note_store, trigger.tag, tag_id)
                    # set the tag to the note if a tag has been provided
                    if tag_id:
                        note.tagGuids = tag_id

            logger.debug("notebook that will be used %s", trigger.notebook)
        return note
1142502
def add_content(self, data):
        # type: (Optional[Union[Dict[str, Any], ET.Element]]) -> None
        
        if data is None:
            return

        if isinstance(data, ET.Element):
            bytes_data = ET.tostring(data, encoding="utf8")
            self.headers['Content-Length'] = str(len(bytes_data))
            self.data = bytes_data
            return

        # By default, assume JSON
        try:
            self.data = json.dumps(data)
            self.headers['Content-Length'] = str(len(self.data))
        except TypeError:
            self.data = data
304493
def WriteFileFooter(self):
    """"""

    if self.cur_file_size != self.cur_info.size:
      raise IOError("Incorrect file size: st_size=%d, but written %d bytes." %
                    (self.cur_info.size, self.cur_file_size))

    # TODO(user):pytype: BLOCKSIZE/NUL constants are not visible to type
    # checker.
    # pytype: disable=module-attr
    blocks, remainder = divmod(self.cur_file_size, tarfile.BLOCKSIZE)
    if remainder > 0:
      self._tar_fd.fileobj.write(tarfile.NUL * (tarfile.BLOCKSIZE - remainder))
      blocks += 1
    self._tar_fd.offset += blocks * tarfile.BLOCKSIZE
    # pytype: enable=module-attr

    self._ResetState()

    return self._stream.GetValueAndReset()
1146562
private function closeFooter(Post $post, int $count): string
    {
        if (!$this->postInfo('excerpt', 'after', $post, $count)) {
            return '';
        }

        return '</footer>';
    }
1010309
def create_tag(note_store, new_tag):
        
        try:
            return note_store.createTag(new_tag).guid
        except EDAMUserException as e:
            if e.errorCode == EDAMErrorCode.DATA_CONFLICT:
                logger.info("Evernote Data Conflict Err {0}".format(e))
            elif e.errorCode == EDAMErrorCode.BAD_DATA_FORMAT:
                logger.critical("Evernote Err {0}".format(e))
            return False
599259
def add_note(self, body):
        
        from highton.models.note import Note
        created_id = self._post_request(
            endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Note.ENDPOINT,
            data=self.element_to_string(
                Note(body=body).encode()
            )
        ).headers.get('Location').replace('.xml', '').split('/')[-1]
        return Note.get(created_id)
781703
def serialize(self, content):
        
        content = super(JSONPTemplateEmitter, self).serialize(content)
        callback = self.request.GET.get('callback', 'callback')
        return '%s(%s)' % (callback, content)
1131749
function footerHTML( footer ) {
  var content = [];
  content.push( '<div class="footer-cnt"></div>' );
  if ( footer != null ) {
    // footer links
    if ( footer.linkList != null ) {
      content.push( '<div class="footer-links">' );
      for ( var i = 0; i < footer.linkList.length; i++ ) {
        if ( footer.linkList[i] ) {
        var lnk = footer.linkList[i];
        if ( lnk.target != null ) {
          content.push( '<a href="'+ $.i18n( lnk.url )+'" target="'+lnk.target+'">'+ $.i18n( lnk.text )+'</a>   ' );
        } else {
          content.push( '<a href="'+ $.i18n( lnk.url )+'">'+ $.i18n( lnk.text )+'</a>   ' );          
        }
        }
      }
      content.push( "</div>" );
    }
    if ( footer.copyrightText != null ) {
      content.push( '<div class="copyright-div">'+ $.i18n( footer.copyrightText ) +'</div>' );
    } else {
      content.push( '<div class="copyright-div">&copy; MH 2018</div>' );
    }
    
    // header hooks
    if ( footer.modules != null ) {
      for ( var i = 0; i < footer.modules.length; i++ ) {
        if ( footer.modules[i] ) {
        var fMod =  footer.modules[i];
        log( 'footerHTML', "addFooterHtml "+ fMod.type );
        var hook = getHookMethod( "addFooterHtml", fMod.type );
        if ( hook != "" ) {
          log( 'footerHTML', hook+"( ... )");
          content.push( '<div id="'+fMod.id+'" class="'+fMod.type+'"></div>' );
          
          if ( fMod.moduleConfig != null) {
            moduleConfig[ fMod.id ] = fMod.moduleConfig;
          }
          
          if ( fMod.param == null ) {
            fMod.param = {};
          }
          fMod.param.get = getUrlGETparams();
          
          hookCalls.push( hook+'( "'+fMod.id+'", "'+fMod.type+'", '+JSON.stringify(fMod.param)+' )'  );
        }
        }
      }
    }
  }
  $( '#footer' ).html( content.join("\n") );
}
1273770
async def addTrigger(self, condition, query, info):
        '''
        
        '''
        iden = self.cell.triggers.add(self.user.iden, condition, query, info=info)
        return iden
524742
function footnoteContent( $content ) {

		global $id; // This is the Post ID, [@see WP_Query::setup_postdata, ...]

		if ( ! empty( $this->footnotes ) && isset( $this->footnotes[ $id ] ) ) {
			$footnotes = $this->footnotes[ $id ];
		} else {
			return $content;
		}

		if ( $this->numbered[ $id ] ) {
			$content .= '<hr class="before-footnotes" /><div class="footnotes"><ol>';
		} else {
			$content .= '<hr class="before-footnotes" /><div class="footnotes"><ul>';
		}

		foreach ( $footnotes as $num => $footnote ) {
			$num++;
			$numlabel = "$id-$num";
			$content .= '<li id="footnote-' . $numlabel . '">' . make_clickable( $footnote ) . ' <a href="#return-footnote-' . $numlabel . '" class="return-footnote">&crarr;</a></li>';
		}

		if ( $this->numbered[ $id ] ) {
			$content .= '</ol></div>';
		} else {
			$content .= '</ul></div>';
		}

		unset( $this->footnotes[ $id ] ); // Done, reset

		return $content;
	}
626148
function VirtualizeContentsView_updateAriaForAnnouncement(item, count) {
                    if (item === this._listView.header || item === this._listView.footer) {
                        return;
                    }

                    var index = -1;
                    var type = _UI.ObjectType.item;
                    if (_ElementUtilities.hasClass(item, _Constants._headerClass)) {
                        index = this._listView._groups.index(item);
                        type = _UI.ObjectType.groupHeader;
                        _ElementUtilities._setAttribute(item, "role", this._listView._headerRole);
                        _ElementUtilities._setAttribute(item, "tabindex", this._listView._tabIndex);
                    } else {
                        index = this.items.index(item);
                        _ElementUtilities._setAttribute(item, "aria-setsize", count);
                        _ElementUtilities._setAttribute(item, "aria-posinset", index + 1);
                        _ElementUtilities._setAttribute(item, "role", this._listView._itemRole);
                        _ElementUtilities._setAttribute(item, "tabindex", this._listView._tabIndex);
                    }

                    if (type === _UI.ObjectType.groupHeader) {
                        this._listView._fireAccessibilityAnnotationCompleteEvent(-1, -1, index, index);
                    } else {
                        this._listView._fireAccessibilityAnnotationCompleteEvent(index, index, -1, -1);
                    }
                }
357619
def single(self, trigger_id, full=False):
        
        if full:
            returned_dict = self._get(self._service_url(['triggers', 'trigger', trigger_id]))
            return FullTrigger(returned_dict)
        else:
            returned_dict = self._get(self._service_url(['triggers', trigger_id]))
            return Trigger(returned_dict)