<editor-fold defaultstate="collapsed" desc="Sections related">
325552
private void createSections(final BufferedImage IMAGE) {
        if (!getSections().isEmpty() && bImage != null) {
            final double OUTER_RADIUS = bImage.getWidth() * 0.3411214953f;
            final double INNER_RADIUS = isExpandedSectionsEnabled() ? OUTER_RADIUS - bImage.getWidth() * 0.12f : OUTER_RADIUS - bImage.getWidth() * 0.023364486f;
            final Ellipse2D INNER = new Ellipse2D.Double(0, 0, 1, 1);

            switch (getOrientation()) {
                case NORTH_EAST:
                    INNER.setFrame(-bImage.getWidth() * 0.45, bImage.getWidth() * 0.195, 4 * INNER_RADIUS, 4 * INNER_RADIUS);
                    break;

                case SOUTH_EAST:
                    INNER.setFrame(-bImage.getWidth() * 0.45, -bImage.getWidth() * 0.45, 4 * INNER_RADIUS, 4 * INNER_RADIUS);
                    break;

                case SOUTH_WEST:
                    INNER.setFrame(bImage.getWidth() * 0.195, -bImage.getWidth() * 0.45, 4 * INNER_RADIUS, 4 * INNER_RADIUS);
                    break;

                case NORTH_WEST:

                default:
                    final double INNER_OFFSET = isExpandedSectionsEnabled() ? bImage.getWidth() * 0.38 : bImage.getWidth() * 0.195;
                    INNER.setFrame(INNER_OFFSET, INNER_OFFSET, 4 * INNER_RADIUS, 4 * INNER_RADIUS);
                    break;
            }

            double stopAngle;
            double startAngle;
            final Point2D SECTION_OFFSET = new Point2D.Double(0, 0);

            for (Section section : getSections()) {
                switch (getOrientation()) {
                    case NORTH_EAST:
                        if (!isLogScale()) {
                            stopAngle = 90 - Math.toDegrees((getMaxValue() - section.getStop() - getMinValue()) * getAngleStep());
                            startAngle = 90 - Math.toDegrees((getMaxValue() - section.getStart() - getMinValue()) * getAngleStep());
                        } else {
                            stopAngle = 90 - Math.toDegrees(UTIL.logOfBase(BASE, getMaxValue() - section.getStop() - getMinValue()) * getLogAngleStep());
                            startAngle = 90 - Math.toDegrees(UTIL.logOfBase(BASE, getMaxValue() - section.getStart() - getMinValue()) * getLogAngleStep());
                        }
                        SECTION_OFFSET.setLocation(-bImage.getWidth() * 0.403271028, bImage.getWidth() * 0.148271028);
                        break;

                    case SOUTH_EAST:
                        if (!isLogScale()) {
                            stopAngle = 0 - Math.toDegrees((getMaxValue() - section.getStop() - getMinValue()) * getAngleStep());
                            startAngle = 0 - Math.toDegrees((getMaxValue() - section.getStart() - getMinValue()) * getAngleStep());
                        } else {
                            stopAngle = 0 - Math.toDegrees(UTIL.logOfBase(BASE, getMaxValue() - section.getStop() - getMinValue()) * getLogAngleStep());
                            startAngle = 0 - Math.toDegrees(UTIL.logOfBase(BASE, getMaxValue() - section.getStart() - getMinValue()) * getLogAngleStep());
                        }
                        SECTION_OFFSET.setLocation(-bImage.getWidth() * 0.403271028, -bImage.getWidth() * 0.403271028);
                        break;

                    case SOUTH_WEST:
                        if (!isLogScale()) {
                            stopAngle = 270 - Math.toDegrees((section.getStop() - getMinValue()) * getAngleStep());
                            startAngle = 270 - Math.toDegrees((section.getStart() - getMinValue()) * getAngleStep());
                        } else {
                            stopAngle = 270 - Math.toDegrees(UTIL.logOfBase(BASE, section.getStop() - getMinValue()) * getLogAngleStep());
                            startAngle = 270 - Math.toDegrees(UTIL.logOfBase(BASE, section.getStart() - getMinValue()) * getLogAngleStep());
                        }
                        SECTION_OFFSET.setLocation(bImage.getWidth() * 0.148271028, -bImage.getWidth() * 0.403271028);
                        break;

                    case NORTH_WEST:

                    default:
                        if (!isLogScale()) {
                            stopAngle = 180 - Math.toDegrees((section.getStop() - getMinValue()) * getAngleStep());
                            startAngle = 180 - Math.toDegrees((section.getStart() - getMinValue()) * getAngleStep());
                        } else {
                            stopAngle = 180 - Math.toDegrees(UTIL.logOfBase(BASE, section.getStop() - getMinValue()) * getLogAngleStep());
                            startAngle = 180 - Math.toDegrees(UTIL.logOfBase(BASE, section.getStart() - getMinValue()) * getLogAngleStep());
                        }
                        SECTION_OFFSET.setLocation(bImage.getWidth() * 0.148271028, bImage.getWidth() * 0.148271028);
                        break;
                }

                final Arc2D OUTER_ARC = new Arc2D.Double(java.awt.geom.Arc2D.PIE);
                OUTER_ARC.setFrame(SECTION_OFFSET.getX(), SECTION_OFFSET.getY(), 4 * OUTER_RADIUS, 4 * OUTER_RADIUS);
                OUTER_ARC.setAngleStart(startAngle);
                OUTER_ARC.setAngleExtent(stopAngle - startAngle);
                final Area SECTION = new Area(OUTER_ARC);

                SECTION.subtract(new java.awt.geom.Area(INNER));

                section.setSectionArea(SECTION);
            }

            // Draw the sections
            if (isSectionsVisible() && IMAGE != null) {
                final Graphics2D G2 = IMAGE.createGraphics();
                G2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                for (Section section : getSections()) {
                    G2.setColor(isTransparentAreasEnabled() ? section.getTransparentColor() : section.getColor());
                    G2.fill(section.getSectionArea());
                }
                G2.dispose();
            }
        }
    }
1132242
protected void __pLayoutSection(String name) {
        String s = layoutSections.get(name);
        if (null == s) s = layoutSections0.get(name);
        else {
            String s0 = layoutSections0.get(name);
            if (s0 == null) s0 = "";
            s = s.replace("\u0000\u0000inherited\u0000\u0000", s0);
        }
        p(s);
    }
344297
private void handleGlobalArguments(Section section) {
		for (String key : section.keySet()) {
			switch (key) {
			case OPTION_OFFLINE_MODE:
				if (section.get(key).toLowerCase().equals("true")) {
					this.offlineMode = true;
				}
				break;
			case OPTION_QUIET:
				if (section.get(key).toLowerCase().equals("true")) {
					this.quiet = true;
				}
				break;
			case OPTION_CREATE_REPORT:
				this.reportFilename = section.get(key);
				break;
			case OPTION_DUMP_LOCATION:
				this.dumpDirectoryLocation = section.get(key);
				break;
			case OPTION_FILTER_LANGUAGES:
				setLanguageFilters(section.get(key));
				break;
			case OPTION_FILTER_SITES:
				setSiteFilters(section.get(key));
				break;
			case OPTION_FILTER_PROPERTIES:
				setPropertyFilters(section.get(key));
				break;
			case OPTION_LOCAL_DUMPFILE:
				this.inputDumpLocation = section.get(key);
				break;
			default:
				logger.warn("Unrecognized option: " + key);
			}
		}
	}
913712
public void addSection(final Section SECTION) {
        if (null == SECTION) return;
        sections.add(SECTION);
        Collections.sort(sections, new SectionComparator());
        fireUpdateEvent(SECTION_EVENT);
    }
446801
function(header) {
        header = $(header);

        var options = this.options,
            section = header.next(), // section
            index = header.data('accordion-index'),
            height = parseInt(section.data('accordion-height'), 10),
            isNode = (this.node && this.node.is(header));

        this.fireEvent('showing', [section, header, this.index]);

        // Allow simultaneous open and closed sections
        // Or allow the same section to collapse
        if (options.mode === 'click' && (options.multiple || options.collapsible && isNode)) {
            if (section.is(':shown') && this.node) {
                section.css('max-height', 0).conceal(true);
                header.aria('toggled', false).removeClass('is-active');

            } else {
                section.css('max-height', height).reveal(true);
                header.aria('toggled', true).addClass('is-active');
            }

        // Only one open at a time
        } else {

            // Exit early so we don't mess with animations
            if (isNode) {
                return;
            }

            this.sections.css('max-height', 0).conceal(true);
            section.css('max-height', height).reveal(true);

            this.headers.aria('toggled', false).removeClass('is-active');
            header.aria('toggled', true).addClass('is-active');
        }

        this.index = index;
        this.node = header;

        this.fireEvent('shown', [section, header, index]);
    }
1039603
@Override
	protected StringBuilder endSection( String sectionName, StringBuilder sb ) {
		sb.append( "<br />\n" );
		return sb;
	}
830722
private void __addLayoutSection(String name, String section, boolean def) {
        Map<String, String> m = def ? layoutSections0 : layoutSections;
        if (m.containsKey(name)) return;
        m.put(name, section);
    }
838558
def collapsable_section(text, id:, icon_class:, open:, &block)
      CollapsableSectionPresenter.new(view_context: view_context,
                                      text: text,
                                      id: id,
                                      icon_class: icon_class,
                                      open: open).render(&block)
    end
744730
function(title, sections, values, options) {
            if (!_.isArray(sections)) sections = [sections];

            var fields = _.reduce(sections, function(prev, value) { return _.merge(prev, value); }, {});

            return Dialogs.open(null, _.defaults(options || {}, {
                "title": title,
                "sections": sections,
                "values": values || {},
                "dialog": "fields",
                "autoFocus": true,
                "valueSelector": function(that) {
                    var data = {};

                    var selectors = {
                        'text': function(el) { return el.val(); },
                        'password': function(el) { return el.val(); },
                        'textarea': function(el) { return el.val(); },
                        'number': function(el) { return el.val(); },
                        'select': function(el) { return el.val(); },
                        'checkbox': function(el) { return el.is(":checked"); },
                        'action': function(el)  { return null; }
                    };

                    _.each(fields, function(field, key) {
                        var v = selectors[field.type](that.$("*[name='"+ key+"']"));
                        if (v !== null) data[key] = v;
                    });
                    return data;
                }
            }));
        }
385627
public void addSection(String section, ConfigParams sectionParams) {
		if (section == null)
			throw new NullPointerException("Section name cannot be null");

		if (sectionParams != null) {
			for (Map.Entry<String, String> entry : sectionParams.entrySet()) {
				String key = entry.getKey();

				if (key.length() > 0 && section.length() > 0)
					key = section + "." + key;
				else if (key.length() == 0)
					key = section;

				String value = entry.getValue();

				put(key, value);
			}
		}
	}
1321553
@Override
	protected String renderSections( List<String> sectionNames ) {

		StringBuilder sb = new StringBuilder();
		if( this.options.containsKey( DocConstants.OPTION_HTML_EXPLODED )) {
			if( sectionNames.size() > 0 ) {
				sb.append( "<ul>\n" );
				for( String sectionName : sectionNames ) {

					int index = sectionName.lastIndexOf( '/' );
					String title = sectionName.substring( index + 1 );

					sb.append( "<li><a href=\"" );
					sb.append( sectionName.replace( " ", "%20" ));
					sb.append( ".html\">" );
					sb.append( title );
					sb.append( "</a></li>\n" );
				}

				sb.append( "</ul>\n" );
			}

		} else {
			sb.append( "\n<p class=\"separator\"> &nbsp; </p>\n" );
		}

		return sb.toString();
	}
655901
private void drawSections() {
		SectionTable table = data.getSectionTable();
		long sectionTableOffset = table.getOffset();
		long sectionTableSize = table.getSize();
		drawPixels(colorMap.get(SECTION_TABLE), sectionTableOffset,
				sectionTableSize);
		logger.info("x pixels: " + getXPixels());
		logger.info("y pixels: " + getYPixels());
		logger.info("bytesPerPixel: " + bytesPerPixel());
		for (SectionHeader header : table.getSectionHeaders()) {
			long sectionOffset = header.getAlignedPointerToRaw();
			logger.info("drawing section to: " + sectionOffset);
			long sectionSize = new SectionLoader(data).getReadSize(header);
			logger.info("drawing section size: " + sectionSize);
			long pixelStart = getPixelNumber(sectionOffset);
			logger.info("pixelStart: " + pixelStart);
			drawPixels(getSectionColor(header), sectionOffset, sectionSize);
		}
	}
1044345
public static Section getSection(Section parent, Properties attributes) {
		Section section = parent.addSection("");
		setSectionParameters(section, attributes);
		return section;
	}
1005967
function section(state, startLine, endLine, silent) {
  var ch,
    level,
    tmp,
    pos = state.bMarks[startLine] + state.tShift[startLine],
    max = state.eMarks[startLine];

  if (pos >= max) {
    return false;
  }

  ch = state.src.charCodeAt(pos);

  if (ch !== 0x23 /* # */ || pos >= max) {
    return false;
  }

  // count heading level
  level = 1;
  ch = state.src.charCodeAt(++pos);
  while (ch === 0x23 /* # */ && pos < max && level <= 6) {
    level++;
    ch = state.src.charCodeAt(++pos);
  }

  if (level > 6 || (pos < max && ch !== 0x20) /* space */) {
    return false;
  }

  pos++;
  let posibleMarker = state.src.substring(pos, pos + SECTION_MARKER.length);

  if (posibleMarker !== SECTION_MARKER) {
    return false;
  }
  pos = pos + SECTION_MARKER.length;

  // Let's cut tails like '    ###  ' from the end of string

  max = state.skipCharsBack(max, 0x20, pos); // space
  tmp = state.skipCharsBack(max, 0x23, pos); // #
  if (tmp > pos && state.src.charCodeAt(tmp - 1) === 0x20 /* space */) {
    max = tmp;
  }

  state.line = startLine + 1;

  let sectionHeader = state.src.slice(pos, max).trim();

  let nextLine = startLine + 1;
  let endRecoginzed = false;
  let contentEndLine;
  let innerSectionCounter = 0;

  for (; nextLine < endLine; nextLine++) {
    let line = state.getLines(nextLine, nextLine + 1, 0, false);

    if (SECTION_OPEN_REGEXP.test(line)) {
      innerSectionCounter++;
    }
    if (line === SECTION_MARKER) {
      // skip inner sections
      if (innerSectionCounter > 0) {
        innerSectionCounter--;
        continue;
      }
      contentEndLine = nextLine - 1;
      endRecoginzed = true;
      break;
    }
  }

  if (!endRecoginzed) {
    return false;
  }

  if (silent) {
    return true;
  }

  state.line = contentEndLine + 2;

  state.tokens.push({
    type: "section_open",
    hLevel: level,
    lines: [startLine, state.line],
    level: state.level,
    header: sectionHeader
  });

  state.line = startLine + 1;
  state.parser.tokenize(state, startLine + 1, contentEndLine, false);

  state.tokens.push({
    type: "section_close",
    hLevel: level,
    level: state.level
  });

  state.line = contentEndLine + 2;
  return true;
}
507464
function () {
                var res = this._topSection;
                res.html = this._out.join("");
                this._delegate = null;
                this._out = null;
                this._topSection = null; // so that the section is not disposed in the MarkupWriter destructor
                return res;
            }
688076
def sections(self):
    """"""
    if not self._is_parsed:
      self._Parse()
      self._is_parsed = True

    return self._sections
1113627
function renderRelated(relatedList, relatedTitle, classPrefix) {
    var relatedDiv = $('<div>');
    relatedDiv.addClass(classPrefix + '-container');
    relatedTitleDiv = $('<div>');
    relatedTitleDiv.addClass(classPrefix + '-container-title');
    relatedTitleDiv.text(relatedTitle);
    relatedDiv.append(relatedTitleDiv);

    $.each(relatedList, function(index, relatedPipelineId) {
      var relatedInfoMap = STATUS_MAP.pipelines[relatedPipelineId];
      if (relatedInfoMap) {
        var relatedLink = $('<a>');
        relatedLink
            .addClass(classPrefix + '-link')
            .attr('title', 'ID #' + relatedPipelineId)
            .attr('href', '#pipeline-' + relatedPipelineId)
            .text(relatedInfoMap.classPath);
        relatedLink.click(function(event) {
            selectPipeline(relatedPipelineId);
            event.preventDefault();
        });
        relatedDiv.append(relatedLink);
      } else {
        var relatedIdDiv = $('<div>');
        relatedIdDiv
            .addClass(classPrefix + '-pipeline-id')
            .text('ID #' + relatedPipelineId);
        relatedDiv.append(relatedIdDiv);
      }
    });

    return relatedDiv;
  }