text:
_LIBCPP_BEGIN_NAMESPACE_STD

condition_variable::~condition_variable()
{
    pthread_cond_destroy(&__cv_);
}

void
condition_variable::notify_one() _NOEXCEPT
{
    pthread_cond_signal(&__cv_);
}

void
condition_variable::notify_all() _NOEXCEPT
{
    pthread_cond_broadcast(&__cv_);
}

void
condition_variable::wait(unique_lock<mutex>& lk) _NOEXCEPT
{
    if (!lk.owns_lock())
        __throw_system_error(EPERM,
                                  "condition_variable::wait: mutex not locked");
    int ec = pthread_cond_wait(&__cv_, lk.mutex()->native_handle());
    if (ec)
        __throw_system_error(ec, "condition_variable wait failed");
}

void
condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
     chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) _NOEXCEPT
{
    using namespace chrono;
    if (!lk.owns_lock())
        __throw_system_error(EPERM,
                            "condition_variable::timed wait: mutex not locked");
    nanoseconds d = tp.time_since_epoch();
    if (d > nanoseconds(0x59682F000000E941))
        d = nanoseconds(0x59682F000000E941);
    timespec ts;
    seconds s = duration_cast<seconds>(d);
    typedef decltype(ts.tv_sec) ts_sec;
    _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
    if (s.count() < ts_sec_max)
    {
        ts.tv_sec = static_cast<ts_sec>(s.count());
        ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
    }
    else
    {
        ts.tv_sec = ts_sec_max;
        ts.tv_nsec = giga::num - 1;
    }
    int ec = pthread_cond_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
    if (ec != 0 && ec != ETIMEDOUT)
        __throw_system_error(ec, "condition_variable timed_wait failed");
}

void
notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
{
    __thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
}

_LIBCPP_END_NAMESPACE_STD

#endif // !_LIBCPP_HAS_NO_THREADS


text:
import React, {MouseEventHandler} from "react";
import SyntaxHighlighter from 'react-syntax-highlighter';
import ReactMarkdown from 'react-markdown';
import remarkMath from 'remark-math';
import rehypeKatex from 'rehype-katex';
import rehypeRaw from 'rehype-raw';

import 'katex/dist/katex.min.css';
import {atomOneLight} from 'react-syntax-highlighter/dist/esm/styles/hljs';
import {Link} from "react-router-dom";

const SimpleButton: React.FC<{onClick: MouseEventHandler}> = ({onClick, children}) =>
  <button className="simple-button" onClick={onClick}>{children}</button>;

function renderSyntax(language: string = 'python') {
  let outerLanguage = language;

  const Renderer: React.FC<{value: string, language?: string,}> = ({value, language}) =>
    <SyntaxHighlighter
      style={atomOneLight}
      language={language || outerLanguage}>{value}</SyntaxHighlighter>;

  return Renderer;
}

const initialExpandState = {expanded: false};
type ExpandState = Readonly<typeof initialExpandState>;
class Expandable extends React.Component<any, any> {
  readonly state: ExpandState = initialExpandState;
  toggle = () => {
    this.setState({expanded: !this.state.expanded});
  };
}

const LabeledInputGroup: React.FC<{label: string,}> = ({label, children,}) =>

    {children}
    {label}
  ;

const Markdown = (props: any) => {
  const newProps = {
    ...props,
    className: 'markdown',
    remarkPlugins: [
      remarkMath,
    ],
    rehypePlugins: [
      rehypeKatex,
      rehypeRaw,
    ],
    escapeHtml: false,
    components: {
      ...props.components,
      code({node, inline, className, children, ...props}: any) {
        const match = /language-(\w+)/.exec(className || 'python')
        return !inline && match ? (
          <SyntaxHighlighter
            children={String(children).replace(/\n$/, '')}
            style={atomOneLight}
            language={match[1]}
            PreTag="div"
            {...props}
          />
        ) : (

            {children}

        )
      }
    }
  };
  return <ReactMarkdown {...newProps} />;
};

const InlineMarkdown = (props: any) => {
  return <Markdown {...props}/>
};

const SuperSecretCat: React.FC = () =>

;

const WrapLink: React.FC<{ to: string, }> = ({to, children}) =>
  to.startsWith('http') ? {children} ⤤ :
    <Link to={to}>{children}</Link>;

type DynamicMarkdownProps = {
  articleId: string
}
type DynamicMarkdownState = {
  markdown: string
};
class DynamicMarkdown extends React.Component<DynamicMarkdownProps, DynamicMarkdownState> {
  constructor(props: DynamicMarkdownProps) {
    super(props);
    this.state = { markdown: "" }
  }

  async componentDidMount() {
    const file = await import(`./md/${this.props.articleId}.md`);
    const response = await fetch(file.default);
    const text = await response.text();

    this.setState({markdown: text });
  }

  render() {
    return (
      <Markdown>{this.state.markdown}</Markdown>
    );
  }
}

export {
  SimpleButton,
  LabeledInputGroup,
  WrapLink,
  renderSyntax,
  DynamicMarkdown,
  Markdown,
  InlineMarkdown,
  SuperSecretCat,

  // virtual components
  Expandable,
}

redpajama_set_name: RedPajamaGithub


text:
\section{Theorie}
Im Folgenden wird der Photoeffekt (lichtelektrischer Effekt) betrachtet, bei dem die Elektronenenergie
in Abhängigkeit der Wellenlänge des Lichtes untersucht wird.

\subsection{Lichtelektrischer Effekt: Phänomen und Erklärung}
Beim Photoeffekt geht es darum eine Festkörperoberfläche (Photokathode) mit negativem Potential
mit monochromatischem Licht zu bestrahlen. Dabei befindet sich die Photokathode in einem Vakuum.
Die dadurch ausgestoßenen
Elektronen werden mit Hilfe einer Auffängerelektrode aufgefangen, welche ein positives Potential besitzt.
Dieser Vorgang ist in Abbildung \ref{Photoeffekt} veranschaulicht.
\begin{figure}[h!]
  \centering
  \includegraphics[width=0.8\textwidth]{Rohdaten/Photoeffekt.png}
  \caption{Aufbau zur Veranschaulichung des Photoeffekts.[1]}
  \label{Photoeffekt}
\end{figure}
\FloatBarrier

Aus diesem Vorgang lässt sich Folgern, das es eine Grenzfrequenz gibt unter der keine
Elektronen aus der Oberfläche austreten. Treten aber Elektronen aus der Oberfläche aus
bzw. ist die Grenzfrequenz überschritten, so ist die Zahl der Elektronen pro Zeiteinheit
proportional zur Lichtintensität.

Da sich diese Ergebnisse nicht durch das Wellenmodell erklären lassen, wird im Rahmen
des Korpuskularmodells das Licht als Photonen oder Lichtquanten angenommen. Diese sind äquivalent
mit den Plankschen Energiequanten.
Diese beinhalten, das monochromatisches Licht aus Photonen besteht, die sich mit Lichtgechwindigkeit
c bewegen und die Energie h$\nu$ besitzten. $\nu$ stellt hier die Frequenz dar.
Im Rahmen des Photoeffektes übertragen die Photonen ihre Energie auf ein Elektron, welches dann
genug Energie hat um aus der Oberfläche auszutreten, daher wird diese Energie auch Austrittsenergie
A$_\mathrm{k}$ genannt.
Mit de Relation
\begin{equation}
  \mathrm{h} \nu = \mathrm{E_\mathrm{kin}} + \mathrm{A_k}
\end{equation}
ergibt sich die Gesetztmäßigkeit
\begin{align*}
  \mathrm{h} \nu < \mathrm{A_k}
\end{align*}
, was wieder das Auftreten einer Grenzfrequenz erklärt.

\subsection{Untersuchung durch Gegenfeldmethode}
Zur Erzeugung des monochromatischen Lichtes wird eine Hg-Dampflampe verwendet.
\begin{figure}[h!]
  \centering
  \includegraphics[width=0.4\textwidth]{Rohdaten/Photozelle.png}
  \caption{Darstellung des Aufbaus einer Photozelle.[1]}
  \label{Photozelle}
\end{figure}
Das von der Hg-Lampe ausgesendete Licht wird durch eine Kondensorlinse auf eine Spaltblende gerichtet und durch
eine Abbildungslinse in ein Geradenrisma gelenkt, welches das monochromatische Licht in seine Spektralfarben
zerlegt. Nun treffen die Lichtstrahle auf einen Eintritsspalt, welcher dafür verwendet wird
einzelne Spektralfarben getrennt voneinander untersuchen zu können. Hinter dem Eintrittspalt befindet sich
eine durch ein Gehäuse geschützte Photozelle, dessen Aufbau in Abbildung \ref{Photozelle} zu erkennen ist.
Die Photozelle befindet sich zudem
auf einem Schwenkarm, der dazu dient durch verändern des Winkels einzelne verschiedene Farben zu betrachten.
Zu sehen ist dieser Aufbau in Abbildung \ref{Aufbau}.

\begin{figure}[h!]
  \centering
  \includegraphics[width=0.8\textwidth]{Rohdaten/Aufbau.png}
  \caption{Aufbau des Optischen Aufbaus.[1]}
  \label{Aufbau}
\end{figure}
\FloatBarrier

Um die Energie der ausgelösten Elektronen messen zu können wird die Gegenfeldmethode (Abb. \ref{Gegenfeld})
verwendet, bei der auf die Kathoden-Anoden-Strecke eine variable Spannung gegeben wird um die ankommenden
Elektronen abbzubremsen. Nur Elektronen, die eine Energie höher als e$_0$U haben.
\begin{figure}[h!]
  \centering
  \includegraphics[width=0.8\textwidth]{Rohdaten/Gegenfeld.png}
  \caption{Schaltbild der Apparatur Gegenfeldmethode.[1]}
  \label{Gegenfeld}
\end{figure}
\FloatBarrier

Wenn v$_\mathrm{max}$ die maximale Geschwindigkeit der Elektronen darstellt, kommt bei einer Gegenspannung
von U$_\mathrm{g}$ keine Elektronen mehr an der Fotokathode an. Dadurch lässt sich
\begin{equation}
  \mathrm{e}_0 U_\mathrm{g} = \frac{1}{2} v_\mathrm{max}^2
\end{equation}
formullieren. Hierbei ist m$_0$ die Ruhemasse des Elektrons und e$_0$ seine Elementarladung.
Die Energie des Elektrons lässt sich berechnen durch
\begin{equation}
\mathrm{h} \nu = e_0 U_\mathrm{g} + A_k
\end{equation}
berechnen.  \\
In der Realität verschwindet der Photostrom jedoch nicht einfach.
Das Verhalten der Energieverteilung der Elektronen lässt sich daher nach der Fermi-Dirac-Statistik beschreiben.
Diese in Abbildung \ref{fermi} zu sehende Statistik bedeutet. Das der Photonstrom nur langsam abnimmt, bis er
bei einem gewissen U$_\mathrm{g}$ auf 0 abfällt.
\begin{figure}[h!]
  \centering
  \includegraphics[width=0.8\textwidth]{Rohdaten/fermi.png}
  \caption{Photostrom in Abhängigkeit der Bremsspannung.[1]}
  \label{fermi}
\end{figure}
In diesem Versuch kann man den parabolischen Zusammenhang zwischen Photostrom und Bremsspannung
\begin{equation}
  I_\mathrm{Ph} \sim \mathrm{U}^2
\end{equation} darstellen.


text:
package org.olat.core.gui.dev.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.olat.core.gui.UserRequest;
import org.olat.core.gui.Windows;
import org.olat.core.gui.components.Component;
import org.olat.core.gui.components.Container;
import org.olat.core.gui.components.Window;
import org.olat.core.gui.components.link.Link;
import org.olat.core.gui.components.link.LinkFactory;
import org.olat.core.gui.components.panel.Panel;
import org.olat.core.gui.components.util.ComponentUtil;
import org.olat.core.gui.components.velocity.VelocityContainer;
import org.olat.core.gui.control.Controller;
import org.olat.core.gui.control.DefaultController;
import org.olat.core.gui.control.Event;
import org.olat.core.gui.control.WindowControl;
import org.olat.core.gui.control.controller.BasicController;
import org.olat.core.gui.control.floatingresizabledialog.FloatingResizableDialogController;
import org.olat.core.gui.control.generic.spacesaver.ExpColController;
import org.olat.core.gui.control.winmgr.WindowBackOfficeImpl;
import org.olat.core.gui.control.winmgr.WindowManagerImpl;
import org.olat.core.gui.render.Renderer;
import org.olat.core.gui.render.StringOutput;
import org.olat.core.gui.render.intercept.DebugHelper;
import org.olat.core.gui.util.bandwidth.SlowBandWidthSimulator;

/**
 *
 * Description:

 *
 *

 * Initial Date:  20.05.2006

 *
 * @author Felix Jost
 */
public class DevelopmentController extends BasicController {
	private VelocityContainer myContent;
	private Panel mainpanel;

	private final WindowBackOfficeImpl wboImpl;
	private ExpColController spacesaverController;
	private Component mainComp;

	private Link web10Link;
	private Link web20Link;
	private Link web20hlLink;
	private Link web21Link;

	private Link showJson;
	private Link showComponentTree;

	private List<Link> modes = new ArrayList<Link>();

	private Link chosenMode;
	private WindowManagerImpl winMgrImpl;
	private Link debugLink;
	private boolean treeShown = false;

	private int pageCnt =0; // only for visual indication

	// fast polling while developing: no more need to push browser reload!
	private Link toggleAutorefresh;
	private boolean autorefresh = false;
	private Controller floatCtr;
	private Controller bandwithController;
	private Link devToolLink;

	/**
	 * @param ureq
	 * @param wControl
	 * @param navElem
	 */
	public DevelopmentController(UserRequest ureq, WindowControl wControl, WindowBackOfficeImpl wboImpl) {
		super(ureq, wControl);
		this.wboImpl = wboImpl;
		this.winMgrImpl = wboImpl.getWinmgrImpl();

		// set up the main layout
		myContent = createVelocityContainer("index");

		// create four links to switch between modes.
		// a special case here: these link must work in regular mode (normal uri with full screen refresh (as
		// opposed to partial page refresh )in order to switch modes correctly.
		// (grouping only needed for coloring)
		modes.add(web10Link = LinkFactory.deAjaxify(LinkFactory.createButtonSmall("web10", myContent, this)));
		modes.add(web20Link = LinkFactory.deAjaxify(LinkFactory.createButtonSmall("web20", myContent, this)));
		modes.add(web20hlLink = LinkFactory.deAjaxify(LinkFactory.createButtonSmall("web20hl", myContent, this)));
		modes.add(web21Link = LinkFactory.deAjaxify(LinkFactory.createButtonSmall("web21", myContent, this)));
		modes.add(debugLink = LinkFactory.deAjaxify(LinkFactory.createButtonSmall("debug", myContent, this)));
		modes.add(showJson = LinkFactory.deAjaxify(LinkFactory.createButtonSmall("showJson", myContent, this)));

		// commands
		showComponentTree = LinkFactory.deAjaxify(LinkFactory.createButton("showComponentTree", myContent, this));
		myContent.contextPut("compdump", "");
		//boolean iframepost = wboImpl.getGlobalSettings().getAjaxFlags().isIframePostEnabled();
		myContent.contextPut("sys", this);

		toggleAutorefresh = LinkFactory.createButtonSmall("toggleAutorefresh", myContent, this);
		// do it with web 1.0 full page reload timer
		myContent.contextPut("autorefresh", "false");

		// slow bandwidth simulation
		SlowBandWidthSimulator sbs = Windows.getWindows(ureq).getSlowBandWidthSimulator();
		bandwithController = sbs.createAdminGUI().createController(ureq, getWindowControl());
		myContent.put("bandwidth",bandwithController.getInitialComponent());

		mainpanel = new Panel("developermainpanel");
		Component protectedMainPanel = DebugHelper.createDebugProtectedWrapper(mainpanel);

		devToolLink = LinkFactory.createCustomLink("devTool", "devTool", "", Link.NONTRANSLATED, myContent, this);
		devToolLink.setCustomEnabledLinkCSS("b_dev o_noprint");
		devToolLink.setTitle(translate("devTool"));
		spacesaverController = new ExpColController(ureq, getWindowControl(), false, protectedMainPanel, devToolLink);

		mainComp = DebugHelper.createDebugProtectedWrapper(spacesaverController.getInitialComponent());
		putInitialPanel(mainComp);
	}

	/**
	 * [used by velocity]
	 * @return
	 */
	public String time() {
		return ""+System.currentTimeMillis();
	}

	/**
	 * [used by velocity]
	 * @return a hex color
	 */

	public String modthree() {
		int n = ++pageCnt % 3;
		switch (n) {
			case 0: return "FF0000";
			case 1: return "00FF00";
			case 2: return "0000FF";
			default: return "n/a"; // cannot happen
		}
	}

	/**
	 * @see org.olat.core.gui.control.DefaultController#event(org.olat.core.gui.UserRequest,
	 *      org.olat.core.gui.components.Component, org.olat.core.gui.control.Event)
	 */
	public void event(UserRequest ureq, Component source, Event event) {
		if (source == devToolLink) {
			removeAsListenerAndDispose(floatCtr);
			floatCtr = new FloatingResizableDialogController(ureq, getWindowControl(), myContent, "Brasato Development Tool", 1000, 200, 10, 60, true, true);
			listenTo(floatCtr);
			mainpanel.setContent(floatCtr.getInitialComponent());
		} else if (source == web10Link) {
			// choose regular mode
			winMgrImpl.setShowDebugInfo(false);
			winMgrImpl.setAjaxEnabled(false);
			winMgrImpl.setForScreenReader(false);
			winMgrImpl.setHighLightingEnabled(false);
			winMgrImpl.setShowJSON(false);
			winMgrImpl.setIdDivsForced(false);
			chosenMode = web10Link;
			updateUI();
		} else if (source == web20Link) {
			// enable ajax / generic-dom-replacement GDR mode
			winMgrImpl.setShowDebugInfo(false);
			winMgrImpl.setAjaxEnabled(true);
			winMgrImpl.setForScreenReader(false);
			winMgrImpl.setHighLightingEnabled(false);
			winMgrImpl.setShowJSON(false);
			winMgrImpl.setIdDivsForced(false);
			chosenMode = web20Link;
			updateUI();
		} else if (source == web20hlLink) {
			// ajax mode with highlighting
			winMgrImpl.setShowDebugInfo(false);
			winMgrImpl.setAjaxEnabled(true);
			winMgrImpl.setForScreenReader(false);
			winMgrImpl.setHighLightingEnabled(true);
			winMgrImpl.setShowJSON(false);
			//brasato:: setIdDivsForced is removed!! check if it works
			winMgrImpl.setIdDivsForced(false);
			chosenMode = web20hlLink;
			updateUI();
		} else if (source == web21Link) {
			// enable screenreader support:
			// - different html templates where appropriate.
			// - different Component-renderers where appropriate.
			// - mark changed components with jump-marker and allow usage of accesskey
			winMgrImpl.setShowDebugInfo(false);
			winMgrImpl.setAjaxEnabled(false);
			winMgrImpl.setForScreenReader(true);
			winMgrImpl.setHighLightingEnabled(false);
			winMgrImpl.setShowJSON(false);
			winMgrImpl.setIdDivsForced(false);
			chosenMode = web21Link;
			updateUI();
		} else if (source == debugLink) {
			// debug mode requires web 1.0 mode at the moment
			winMgrImpl.setShowDebugInfo(true);
			winMgrImpl.setAjaxEnabled(false);
			winMgrImpl.setForScreenReader(false);
			winMgrImpl.setHighLightingEnabled(false);
			winMgrImpl.setShowJSON(false);
			winMgrImpl.setIdDivsForced(false);
			chosenMode = debugLink;
			updateUI();
		} else if (source == showComponentTree) {
			if (treeShown) {
				// hide component tree
				myContent.contextPut("compdump", "");
				winMgrImpl.setIdDivsForced(false);
			} else {
				winMgrImpl.setIdDivsForced(true);
				updateComponentTree();
			}
			treeShown = !treeShown;
		} else if (source == showJson) {
			winMgrImpl.setShowDebugInfo(false);
			winMgrImpl.setAjaxEnabled(true);
			winMgrImpl.setForScreenReader(false);
			winMgrImpl.setHighLightingEnabled(true);
			winMgrImpl.setShowJSON(true);
			winMgrImpl.setIdDivsForced(false);
			chosenMode = showJson;
			updateUI();
		} else if (source == toggleAutorefresh) {
			autorefresh = !autorefresh;
			if (autorefresh) {
				myContent.contextPut("autorefresh", "true");
			} else {
				myContent.contextPut("autorefresh", "false");
			}
		} else if (event == ComponentUtil.VALIDATE_EVENT) {
			// todo update mode
			if (treeShown) {
				updateComponentTree();
			}
		}
	}

	@Override
	protected void event(UserRequest ureq, Controller source, Event event) {
		if (source == floatCtr) {
			if (event.equals(Event.DONE_EVENT)) {
				spacesaverController.toggleUi();
			}
		}
	}

	private void updateComponentTree() {
		Window win = wboImpl.getWindow();
		StringOutput sb = new StringOutput();
		renderDebugInfo(win.getContentPane(), sb, true);
		myContent.contextPut("compdump", sb.toString());
	}

	private void updateUI() {
		// update mode.
		for (Link li : modes) {
			li.setCustomEnabledLinkCSS("b_button b_small");
			li.setEnabled(true);
		}
		//(chosenMode.setCustomEnabledLinkCSS("o_main_button_sel");
		chosenMode.setEnabled(false);
		chosenMode.setCustomDisabledLinkCSS("b_button b_small");
		myContent.contextPut("compdump", "");

	}

	/**
	 * @see org.olat.core.gui.control.DefaultController#doDispose(boolean)
	 */
	protected void doDispose() {
		// floatCtr auto disposed by basic controller
		if (spacesaverController != null) spacesaverController.dispose();
		if (bandwithController != null) bandwithController.dispose();
	}

	/**
	 * used by velocityrenderdecorator
	 * @param target
	 */
	private void renderDebugInfo(Component root, StringOutput target, boolean showDebugInfo) {
		target.append("
");
		int cnt = cntTree(root);
		int size = DefaultController.getControllerCount();
		target.append("Component Tree: count: " + cnt + "  |  Controllers (global: active and not disposed): "+size+"");
		target.append("

");
		Map<Controller, List<Component>> controllerInfos = new HashMap<Controller, List<Component>>();
		dumpTree(target, root, 0, controllerInfos);
		target.append("
");
		// now dump the controller info
		for (Controller controller : controllerInfos.keySet()) {
			try {
				Component initComp = controller.getInitialComponent();
				target.append("
Controller "+controller.getClass().getName()+" :"+controller.hashCode());
				appendDivCodeForComponent("Initial Component: ",target, initComp, 20);
				List<Component> listenTo = controllerInfos.get(controller);
				for (Component component : listenTo) {
					appendDivCodeForComponent("", target, component, 20);
				}
				target.append("

");
			} catch (Exception e) {
				// some components like window dont like being called for the initialcomponent
				// -> ignore
			}
		}
	}

	private void appendDivCodeForComponent(String pre, StringOutput sb, Component current, int marginLeft) {
		String pcid = Renderer.getComponentPrefix(current);
		sb.append("

");

		String cname = current.getClass().getName();
		cname = cname.substring(cname.lastIndexOf('.') + 1);
		sb.append(pre+"" + cname  + " (" + current.getComponentName() + " id "+current.getDispatchID()+") ");
		sb.append((current.isVisible()? "":"INVISIBLE ")+(current.isEnabled()? "":" NOT ENABLED ")+current.getExtendedDebugInfo()+", "+current.getListenerInfo()+"
");
		sb.append("

");
	}

	private void dumpTree(StringOutput sb, Component current, int indent, Map<Controller, List<Component>> controllerInfos) {
		// add infos,
		Controller lController = org.olat.core.gui.dev.Util.getListeningControllerFor(current);
		if (lController != null) {
			List<Component> lcomps = controllerInfos.get(lController);
			if (lcomps == null) {
				// first entry
				lcomps = new ArrayList<Component>();
				controllerInfos.put(lController, lcomps);
			}
			lcomps.add(current);
		}

		int pxInd = indent * 25;
		String pcid = Renderer.getComponentPrefix(current);
		sb.append("

");

		String cname = current.getClass().getName();
		cname = cname.substring(cname.lastIndexOf('.') + 1);

		sb.append("" + cname  + " (" + current.getComponentName() + " id "+current.getDispatchID()+") ");
		if (current == mainComp) { // suppress detail and subtree for our controller here
			sb.append(" --suppressing output, since developmentcontroller --

");
		} else {
				sb.append((current.isVisible()? "":"INVISIBLE ")+(current.isEnabled()? "":" NOT ENABLED ")+current.getExtendedDebugInfo()+", "+current.getListenerInfo()+"
");
			sb.append("

");
			if (current instanceof Container) {
				Container co = (Container) current;
				for (Component child:co.getComponents()) {
					dumpTree(sb, child, indent + 1, controllerInfos);
				}
			}
		}
	}

	private int cntTree(Component current) {
		int cnt = 1;
		if (current instanceof Container) {
			Container co = (Container) current;
			for (Component child:co.getComponents()) {
				cnt += cntTree(child);
			}
		}
		return cnt;
	}
}

class ControllerInfo {
	private List<Component> listeningTo;

	ControllerInfo(Controller controller) {
		listeningTo = new ArrayList<Component>();
	}

	void addListeningComponent(Component listener) {
		listeningTo.add(listener);
	}
}


text:
#pragma once
#include <aws/config/ConfigService_EXPORTS.h>
#include <aws/config/ConfigServiceRequest.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/config/model/ComplianceType.h>

namespace Aws
{
namespace ConfigService
{
namespace Model
{

  /**
   *

   */
  class AWS_CONFIGSERVICE_API DescribeComplianceByConfigRuleRequest : public ConfigServiceRequest
  {
  public:
    DescribeComplianceByConfigRuleRequest();
    Aws::String SerializePayload() const override;

    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline const Aws::Vector<Aws::String>& GetConfigRuleNames() const{ return m_configRuleNames; }

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline void SetConfigRuleNames(const Aws::Vector<Aws::String>& value) { m_configRuleNamesHasBeenSet = true; m_configRuleNames = value; }

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline void SetConfigRuleNames(Aws::Vector<Aws::String>&& value) { m_configRuleNamesHasBeenSet = true; m_configRuleNames = value; }

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline DescribeComplianceByConfigRuleRequest& WithConfigRuleNames(const Aws::Vector<Aws::String>& value) { SetConfigRuleNames(value); return *this;}

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline DescribeComplianceByConfigRuleRequest& WithConfigRuleNames(Aws::Vector<Aws::String>&& value) { SetConfigRuleNames(value); return *this;}

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline DescribeComplianceByConfigRuleRequest& AddConfigRuleNames(const Aws::String& value) { m_configRuleNamesHasBeenSet = true; m_configRuleNames.push_back(value); return *this; }

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline DescribeComplianceByConfigRuleRequest& AddConfigRuleNames(Aws::String&& value) { m_configRuleNamesHasBeenSet = true; m_configRuleNames.push_back(value); return *this; }

    /**
     *
Specify one or more AWS Config rule names to filter the results by rule.

     */
    inline DescribeComplianceByConfigRuleRequest& AddConfigRuleNames(const char* value) { m_configRuleNamesHasBeenSet = true; m_configRuleNames.push_back(value); return *this; }

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline const Aws::Vector<ComplianceType>& GetComplianceTypes() const{ return m_complianceTypes; }

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline void SetComplianceTypes(const Aws::Vector<ComplianceType>& value) { m_complianceTypesHasBeenSet = true; m_complianceTypes = value; }

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline void SetComplianceTypes(Aws::Vector<ComplianceType>&& value) { m_complianceTypesHasBeenSet = true; m_complianceTypes = value; }

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline DescribeComplianceByConfigRuleRequest& WithComplianceTypes(const Aws::Vector<ComplianceType>& value) { SetComplianceTypes(value); return *this;}

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline DescribeComplianceByConfigRuleRequest& WithComplianceTypes(Aws::Vector<ComplianceType>&& value) { SetComplianceTypes(value); return *this;}

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline DescribeComplianceByConfigRuleRequest& AddComplianceTypes(const ComplianceType& value) { m_complianceTypesHasBeenSet = true; m_complianceTypes.push_back(value); return *this; }

    /**
     *
Filters the results by compliance.

The allowed values are
     * COMPLIANT, NON_COMPLIANT, and
     * INSUFFICIENT_DATA.

     */
    inline DescribeComplianceByConfigRuleRequest& AddComplianceTypes(ComplianceType&& value) { m_complianceTypesHasBeenSet = true; m_complianceTypes.push_back(value); return *this; }

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline const Aws::String& GetNextToken() const{ return m_nextToken; }

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline DescribeComplianceByConfigRuleRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline DescribeComplianceByConfigRuleRequest& WithNextToken(Aws::String&& value) { SetNextToken(value); return *this;}

    /**
     *
The nextToken string returned on a previous page that you use to
     * get the next page of results in a paginated response.

     */
    inline DescribeComplianceByConfigRuleRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}

  private:
    Aws::Vector<Aws::String> m_configRuleNames;
    bool m_configRuleNamesHasBeenSet;
    Aws::Vector<ComplianceType> m_complianceTypes;
    bool m_complianceTypesHasBeenSet;
    Aws::String m_nextToken;
    bool m_nextTokenHasBeenSet;
  };

} // namespace Model
} // namespace ConfigService
} // namespace Aws


text:
package com.lepacheco.nettyexamples.kvstore;

import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;

/**
 * Created by pacheco on 9/3/15.
 */
public class KVClientInitializer extends ChannelInitializer {
    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(
                // inbound
                new LengthFieldBasedFrameDecoder(1024*1024*1024, 0, 4, 0, 4),
                new KVMessageDecoder(),
                // outbound
                new LengthFieldPrepender(4),
                new KVMessageEncoder(),
                // app
                new KVClientHandler()
        );
    }
}


text:
https://www.npmjs.com/package/watchify

Update any source file and your browserify bundle will be recompiled on the spot.

```
//Para instalarlo
npm install --global watchify

//Crear script dentro de package.json dentro de "scripts"
"watch": "watchify app.js -o index.js"

//Luego, desde la consola:
npm run watch

```


text:
package com.graphhopper.routing.util.parsers;

import com.graphhopper.reader.ReaderRelation;
import com.graphhopper.reader.ReaderWay;
import com.graphhopper.routing.ev.EncodedValue;
import com.graphhopper.routing.ev.EncodedValueLookup;
import com.graphhopper.routing.ev.EnumEncodedValue;
import com.graphhopper.routing.ev.RouteNetwork;
import com.graphhopper.storage.IntsRef;
import com.graphhopper.util.Helper;

import java.util.List;

import static com.graphhopper.routing.util.EncodingManager.getKey;

public class OSMFootNetworkTagParser implements RelationTagParser {
    private EnumEncodedValue<RouteNetwork> footRouteEnc;
    // used for internal transformation from relations into footRouteEnc
    private EnumEncodedValue<RouteNetwork> transformerRouteRelEnc;

    @Override
    public void createRelationEncodedValues(EncodedValueLookup lookup, List<EncodedValue> registerNewEncodedValue) {
        registerNewEncodedValue.add(transformerRouteRelEnc = new EnumEncodedValue<>(getKey("foot", "route_relation"), RouteNetwork.class));
    }

    @Override
    public IntsRef handleRelationTags(IntsRef relFlags, ReaderRelation relation) {
        RouteNetwork oldFootNetwork = transformerRouteRelEnc.getEnum(false, relFlags);
        if (relation.hasTag("route", "hiking") || relation.hasTag("route", "foot")) {
            String tag = Helper.toLowerCase(relation.getTag("network", ""));
            RouteNetwork newFootNetwork = RouteNetwork.LOCAL;
            if ("lwn".equals(tag)) {
                newFootNetwork = RouteNetwork.LOCAL;
            } else if ("rwn".equals(tag)) {
                newFootNetwork = RouteNetwork.REGIONAL;
            } else if ("nwn".equals(tag)) {
                newFootNetwork = RouteNetwork.NATIONAL;
            } else if ("iwn".equals(tag)) {
                newFootNetwork = RouteNetwork.INTERNATIONAL;
            }
            if (oldFootNetwork == RouteNetwork.OTHER || oldFootNetwork.ordinal() > newFootNetwork.ordinal())
                transformerRouteRelEnc.setEnum(false, relFlags, newFootNetwork);
        }

        return relFlags;
    }

    @Override
    public void createEncodedValues(EncodedValueLookup lookup, List<EncodedValue> registerNewEncodedValue) {
        registerNewEncodedValue.add(footRouteEnc = new EnumEncodedValue<>(RouteNetwork.key("foot"), RouteNetwork.class));
    }

    @Override
    public IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, boolean ferry, IntsRef relationFlags) {
        // just copy value into different bit range
        RouteNetwork footNetwork = transformerRouteRelEnc.getEnum(false, relationFlags);
        footRouteEnc.setEnum(false, edgeFlags, footNetwork);
        return edgeFlags;
    }
}


text:
var su = require('stylus/lib/utils.js'),
    n = require('stylus/lib/nodes'),
    u = require('../common/utils.js');

module.exports = {};

module.exports['scale-geometric-progression'] = function(base, value, rate) {
  return new n.Unit(base.val * Math.pow(rate.val, (value.val - 1)),
      (value.type ? value.type: (base.type ? base.type : rate.type)));
};

module.exports['scale-geometric-progression_reverse'] =
function(base, value, rate, round) {
  round = typeof round == 'undefined' ? false : round.val;

  var r = Math.log(value.val / base.val) / Math.log(rate.val) + 1;

  return new n.Unit(round ? Math.round(r) : r,
      (value.type ? value.type: (base.type ? base.type : rate.type)));
};

module.exports['scale-modular'] = module.exports['scale-geometric-progression'];
module.exports['scale-modular_reverse'] =
  module.exports['scale-geometric-progression_reverse'];

module.exports['scale-arithmetic-progression'] = function(base, value, d) {
  d = typeof d == 'undefined' ? base : d;

  return new n.Unit(base.val + (d.val * (value.val - 1)),
      (value.type ? value.type: (base.type ? base.type : d.type)));
};

module.exports['scale-arithmetic-progression_reverse'] =
function(base, value, d, round) {
  d = typeof d == 'undefined' ? base : d;
  round = typeof round == 'undefined' ? false : round.val;

  var r = (value.val - base.val) / d.val + 1;

  return new n.Unit(round ? Math.round(r) : r,
      (value.type ? value.type: (base.type ? base.type : d.type)));
};

module.exports['scale-exponential-growth'] = function(base, value, rate) {
  return new n.Unit(base.val * Math.pow((rate.val + 1), value.val),
      (value.type ? value.type: (base.type ? base.type : rate.type)));
};

module.exports['scale-exponential-growth_reverse'] =
function(base, value, rate) {
  round = typeof round == 'undefined' ? false : round.val;

  var r = Math.log(value.val / base.val) / Math.log(rate.val + 1);

  return new n.Unit(round ? Math.round(r) : r,
      (value.type ? value.type: (base.type ? base.type : rate.type)));
};

module.exports['scale-expotential'] = function(base, value, rate) {
  return new n.Unit(base.val * Math.exp(rate.val * value.val),
      (value.type ? value.type: (base.type ? base.type : rate.type)));
};

module.exports['scale-expotential_reverse'] = function(base, value, rate) {
  var exp = Math.exp(1);

  return new n.Unit(Math.log(value.val / base.val) / Math.log(exp) / rate.val,
      (value.type ? value.type: (base.type ? base.type : rate.type)));
};

module.exports['scale-qubic'] = function(a, b, c, d, x) {
  return new n.Unit(
    a.val * Math.pow(x.val, 3) + b.val * Math.pow(x.val, 2)
      + c.val * x.val + d.val,
    x.type ? x.type : d.type);
};


text:
using ActiproSoftware.Text;

namespace NQuery.Authoring.ActiproWpf.Classification
{
    public interface INQueryClassificationTypes
    {
        IClassificationType WhiteSpace { get; }
        IClassificationType Comment { get; }
        IClassificationType Keyword { get; }
        IClassificationType Punctuation { get; }
        IClassificationType Identifier { get; }
        IClassificationType StringLiteral { get; }
        IClassificationType NumberLiteral { get; }
        IClassificationType SchemaTable { get; }
        IClassificationType DerivedTable { get; }
        IClassificationType CommonTableExpression { get; }
        IClassificationType Column { get; }
        IClassificationType Method { get; }
        IClassificationType Property { get; }
        IClassificationType Function { get; }
        IClassificationType Aggregate { get; }
        IClassificationType Operator { get; }
        IClassificationType Variable { get; }
        IClassificationType Unnecessary { get; }
    }
}


text:
//---------------------------------------------------------------------------
// Gorka Suárez García - Ing. Tec. Inf. de Gestión 2º B.
// Práctica 03 - Grupo 03.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#include "FConfidentes.h"
#include "DelincuenteComun.h"
#include "DelincuenteConfidente.h"
#include "CaraComun.h"
#include "CaraConfidente.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "FTodosDelincuentes"
#pragma resource "*.dfm"
TConfidentes *Confidentes;
//---------------------------------------------------------------------------
__fastcall TConfidentes::TConfidentes(TComponent* Owner,
                                      ContenedorDelincuentes * delincuentes)
    : TTodosDelincuentes(Owner, delincuentes)
{
}
//---------------------------------------------------------------------------
void __fastcall TConfidentes::FormClose(TObject *Sender,
      TCloseAction &Action)
{
    this->delincuentes = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TConfidentes::FormShow(TObject *Sender)
{
    this->posicionar(0);
}
//---------------------------------------------------------------------------
/**
 * Función para actualizar la cara mostrada en el memo del formulario.
 */
void __fastcall TConfidentes::dibujaCara (Cara * cara)
{
    if(cara->getClassName() == "CaraConfidente")
    {
        CaraConfidente * auxcc = (CaraConfidente *) cara;
        auxcc->dibujaSupervisor(this->Retrato->Canvas);
    }
    else
    {
        cara->dibuja(this->Retrato->Canvas);
    }
}
//---------------------------------------------------------------------------
// Fin TConfidentes.cpp
//---------------------------------------------------------------------------


text:
package galvin.swing.text.macros;

import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement( name = "MacroList" )
@XmlAccessorType( XmlAccessType.FIELD )
public class MacroList
{
    private List<Macro> macros = new ArrayList();

    public List<Macro> getMacros()
    {
        return macros;
    }

    public void setMacros( List<Macro> macros )
    {
        this.macros = macros;
    }
}


text:
//
//   Copyright 2016  Cityzen Data
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
//

package com.warp10.app;

import android.app.AlertDialog;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.DialogPreference;
import android.preference.PreferenceManager;
import android.preference.PreferenceScreen;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;

/**
 * Created by ahebert on 1/8/16.
 * PreferenceType to add a new preference
 */
public class AddSensorPreference extends DialogPreference {

    /**
     * Key counter
     */
    public static volatile int count = 1001;
    /**
     * SensorPreference attribute --> The resulting preference
     */
    SensorPreference sensorPreference;

    /**
     * The page context
     */
    Context ctx;

    /**
     * Constructor - store the context and load the layout sensor
     * @param context
     * @param attrs
     */
    public AddSensorPreference(Context context, AttributeSet attrs) {
        super(context, attrs);
        setDialogLayoutResource(com.warp10.app.R.layout.sensor_layout);
        this.setDialogTitle("Add a sensor description");
        setDialogIcon(null);
        ctx = context;
    }

    /**
     * When clicked open a dialog containing the layout sensor
     * Put null on currentTitle and value
     * Add 2 buttons save and cancel
     * On save, update and register current sensor preference
     * On cancel, do nothing
     * @param view
     */
    public void onBindDialogView(View view) {
        super.onBindDialogView(view);

        /**
         * Set null on title
         */
        EditText ed = (EditText) view.findViewById(com.warp10.app.R.id.currentSensorTitle);
        ed.setText("NULL");

        /**
         * Set null on value
         */
        EditText ed2 = (EditText) view.findViewById(com.warp10.app.R.id.currentSensorValue);
        ed2.setText("NULL");

        final View myView = view;
        Button okButton = (Button) view.findViewById(com.warp10.app.R.id.currentSensorOk);

        /**
         * Save new title and value to create a new sensor preference
         */
        okButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EditText title = (EditText) myView.findViewById(com.warp10.app.R.id.currentSensorTitle);
                EditText value = (EditText) myView.findViewById(com.warp10.app.R.id.currentSensorValue);
                String myValue = title.getText().toString() + " [" + value.getText().toString() + "]";
                getPreferenceManager().setSharedPreferencesName(SensorsFragment.NAME_SHARED_FILE_SENSORS);
                SharedPreferences sharedPreferences = getPreferenceManager().getSharedPreferences();
                //Log.d("" + countValue, myValue);
                sharedPreferences.edit().putString(sensorPreference.getKey(), myValue).apply();
                sensorPreference.setTitle(title.getText().toString());
                //getPreferenceManager().setSharedPreferencesName(SensorsFragment.NAME_SHARED_FILE_SENSORS);
                PreferenceScreen preferenceScreen = (PreferenceScreen) getPreferenceManager().findPreference("sensorPrefScreen");
                preferenceScreen.addPreference(sensorPreference);
                getDialog().dismiss();
            }
        });

        /**
         * End the dialog
         */
        Button cancelButton = (Button) view.findViewById(com.warp10.app.R.id.currentSensorCancel);
        cancelButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                getDialog().dismiss();
            }
        });

        /**
         * Do not put on screen the delete button wich exist in the layout sensor
         */
        Button deleteButton = (Button) view.findViewById(com.warp10.app.R.id.currentSensorDelete);
        ViewGroup layout = (ViewGroup) deleteButton.getParent();
        if(null!=layout) //for safety only  as you are doing onClick
            layout.removeView(deleteButton);
    }

    /**
     * Function used to prepare the dialog
     * Delete positive and negative buttons of the view
     * Create a new sensor preference, with a key that doesn't exist yet
     * @param builder view builder
     */
    protected void onPrepareDialogBuilder(AlertDialog.Builder builder){
        super.onPrepareDialogBuilder(builder);
        builder.setPositiveButton(null, null);
        builder.setNegativeButton(null, null);
        getPreferenceManager().setSharedPreferencesName(SensorsFragment.NAME_SHARED_FILE_SENSORS);
        SharedPreferences sharedPreferences = getPreferenceManager().getSharedPreferences();
        while (sharedPreferences.contains("" + count)){
            count++;
        }
        sensorPreference = new SensorPreference(ctx, null,"" + count);
        count++;
    }
}


text:
{% extends "_layout.html" %}

{% block content %}
    {% with messages = get_flashed_messages(with_categories=True) %}
        {% if messages %}
            {% for category, message in messages %}

{{ message }}

            {% endfor %}
        {% endif %}
    {% endwith %}

    login
    register
{% endblock %}


text:
clientkeys = awful.util.table.join(
    -- fullscreen client toggle
    --
    keydoc.group("Client keys"),
      -- awful.key({ modkey,           }, "f",      function (c) c.fullscreen = not c.fullscreen  end, "toggle fullscreen"),
      awful.key({ modkey, "Shift"   }, "c",      function (c) c:kill()                         end, "kill"),
      awful.key({ modkey, "Control" }, "space",  awful.client.floating.toggle                     , "toggle floating"),
      awful.key({ modkey, "Control" }, "Return", function (c) c:swap(awful.client.getmaster()) end, "get master"),
      awful.key({ modkey,           }, "o",      awful.client.movetoscreen                        , "move to other screen"),
      awful.key({ modkey,           }, "t",      function (c) c.ontop = not c.ontop            end, "toggle on-top"),

      -- maximize client toggle (M)
      awful.key({ modkey, "Shift"   }, "m",
          function (c)
              c.maximized_horizontal = not c.maximized_horizontal
              c.maximized_vertical   = not c.maximized_vertical
          end, "toggle maximized"),

      -- minimize client (N)
      awful.key({ modkey, "Shift"   }, "n",
          function (c)
              -- The client currently has the input focus, so it cannot be
              -- minimized, since minimized clients can't have the focus.
              c.minimized = true
          end, "minimize client")

)


text:
#pragma checksum "..\..\DefaultLegend.xaml" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "2AB98F42568893E6AE91549ABF24BE62"
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using LiveCharts.Wpf;
using System;
using System.Diagnostics;
using System.Windows;
using System.Windows.Automation;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Markup;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Effects;
using System.Windows.Media.Imaging;
using System.Windows.Media.Media3D;
using System.Windows.Media.TextFormatting;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Shell;

namespace LiveCharts.Wpf {

    /// <summary>
    /// DefaultLegend
    /// </summary>
    public partial class DefaultLegend : System.Windows.Controls.UserControl, System.Windows.Markup.IComponentConnector {

        #line 35 "..\..\DefaultLegend.xaml"
        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
        internal LiveCharts.Wpf.DefaultLegend This;

        #line default
        #line hidden

        private bool _contentLoaded;

        /// <summary>
        /// InitializeComponent
        /// </summary>
        [System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")]
        public void InitializeComponent() {
            if (_contentLoaded) {
                return;
            }
            _contentLoaded = true;
            System.Uri resourceLocater = new System.Uri("/LiveCharts.Wpf;component/defaultlegend.xaml", System.UriKind.Relative);

            #line 1 "..\..\DefaultLegend.xaml"
            System.Windows.Application.LoadComponent(this, resourceLocater);

            #line default
            #line hidden
        }

        [System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")]
        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes")]
        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
        void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) {
            switch (connectionId)
            {
            case 1:
            this.This = ((LiveCharts.Wpf.DefaultLegend)(target));
            return;
            }
            this._contentLoaded = true;
        }
    }
}


text:
#ifndef JUCE_INCLUDEMODULEHEADERS_H_INCLUDED
#define JUCE_INCLUDEMODULEHEADERS_H_INCLUDED

#include "../juce_audio_plugin_client.h"

using namespace juce;

namespace juce
{
    #if JUCE_MAC
     #define Point     juce::Point
     #define Component juce::Component

     void repostCurrentNSEvent();
    #endif

    //==============================================================================
    inline const PluginHostType& getHostType()
    {
        static PluginHostType hostType;
        return hostType;
    }
}

extern AudioProcessor* JUCE_CALLTYPE createPluginFilterOfType (AudioProcessor::WrapperType);

#endif   // JUCE_INCLUDEMODULEHEADERS_H_INCLUDED


text:
import {
  SHOW_INFO_BUBBLE,
  HIDE_INFO_BUBBLE,
  UPDATE_HOVER_POLYGON,
  SET_INFO_BUBBLE_MOUSE_INSIDE,
  SHOW_DESCRIPTION,
  HIDE_DESCRIPTION
} from '../actions'

/**
 * Conditionally dispatches `SHOW_INFO_BUBBLE` only if info bubble is not visible.
 */
export function showInfoBubble () {
  return (dispatch, getState) => {
    if (getState().infoBubble.visible === false) {
      dispatch({ type: SHOW_INFO_BUBBLE })
    }
  }
}

/**
 * Conditionally dispatches `HIDE_INFO_BUBBLE` only if info bubble is visible.
 */
export function hideInfoBubble () {
  return (dispatch, getState) => {
    if (getState().infoBubble.visible === true) {
      dispatch({ type: HIDE_INFO_BUBBLE })
    }
  }
}

export function updateHoverPolygon (polygon) {
  return {
    type: UPDATE_HOVER_POLYGON,
    hoverPolygon: polygon
  }
}

export function setInfoBubbleMouseInside (bool) {
  return {
    type: SET_INFO_BUBBLE_MOUSE_INSIDE,
    value: bool
  }
}

export function showDescription () {
  return {
    type: SHOW_DESCRIPTION
  }
}

export function hideDescription () {
  return {
    type: HIDE_DESCRIPTION
  }
}


text:
package org.workcraft.formula.sat;

import org.junit.BeforeClass;
import org.junit.Ignore;
import org.workcraft.formula.cnf.Cnf;
import org.workcraft.formula.encoding.onehot.CnfGeneratingOptimiser;
import org.workcraft.plugins.shared.CommonSatSettings;
import org.workcraft.plugins.shared.CommonSatSettings.SatSolver;

@Ignore // This only works with MINISAT solver which is not supported in Travis OSX
public class CnfSolverTests extends SolverTests {

    @BeforeClass
    public static void setSatSolver() {
        CommonSatSettings.setSatSolver(SatSolver.MINISAT);
    }

    @Override
    protected LegacySolver<Cnf> createSolver() {
        return new LegacySolver<Cnf>(
                new CnfGeneratingOptimiser(),
                new SimpleCnfTaskProvider());
    }

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!-- This web.xml file is not required when using Servlet 3.0 container,
see implementation details http://jersey.java.net/nonav/documentation/latest/jax-rs.html#d4e194 -->
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <servlet>
        <servlet-name>REST API</servlet-name>
        <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>com.sun.jersey.config.property.packages</param-name>
            <param-value>info.labeling.rest</param-value>
        </init-param>
        <init-param>
            <param-name>com.sun.jersey.spi.container.ContainerResponseFilters</param-name>
            <param-value>info.labeling.rest.CORSFilter</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>REST API</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>


text:
require File.expand_path('../../../spec_helper', __FILE__)

describe "File#initialize" do
  it "needs to be reviewed for spec completeness"
end

describe "File#initialize" do
  after :each do
    @io.close if @io
  end

  it "accepts encoding options in mode parameter" do
    @io = File.new(__FILE__, 'r:UTF-8:iso-8859-1')
    @io.external_encoding.to_s.should == 'UTF-8'
    @io.internal_encoding.to_s.should == 'ISO-8859-1'
  end

  it "accepts encoding options as a hash parameter" do
    @io = File.new(__FILE__, 'r', :encoding => 'UTF-8:iso-8859-1')
    @io.external_encoding.to_s.should == 'UTF-8'
    @io.internal_encoding.to_s.should == 'ISO-8859-1'
  end
end


text:
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:keepScreenOn="true"
    android:background="@color/black"
    tools:context=".CompassActivity" >

    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:src="@drawable/ic_launcher" />

</FrameLayout>


text:
from nose.tools import eq_
from textwrap import dedent

from pyquery import PyQuery as pq

from kitsune.search import es_utils, synonym_utils
from kitsune.search.tests import ElasticTestCase, SynonymFactory
from kitsune.sumo.tests import LocalizingClient
from kitsune.sumo.tests import TestCase
from kitsune.sumo.urlresolvers import reverse
from kitsune.wiki.tests import DocumentFactory, RevisionFactory
from kitsune.search.tasks import update_synonyms_task

class TestSynonymModel(TestCase):

    def test_serialize(self):
        syn = SynonymFactory(from_words="foo", to_words="bar")
        eq_("foo => bar", unicode(syn))

class TestFilterGenerator(TestCase):

    def test_name(self):
        """Test that the right name is returned."""
        name, _ = es_utils.es_get_synonym_filter('en-US')
        eq_(name, 'synonyms-en-US')

    def test_no_synonyms(self):
        """Test that when there are no synonyms an alternate filter is made."""
        _, body = es_utils.es_get_synonym_filter('en-US')
        eq_(body, {
            'type': 'synonym',
            'synonyms': ['firefox => firefox'],
            })

    def test_with_some_synonyms(self):
        SynonymFactory(from_words='foo', to_words='bar')
        SynonymFactory(from_words='baz', to_words='qux')

        _, body = es_utils.es_get_synonym_filter('en-US')

        expected = {
            'type': 'synonym',
            'synonyms': [
                'foo => bar',
                'baz => qux',
            ],
        }

        eq_(body, expected)

class TestSynonymParser(TestCase):

    def testItWorks(self):
        synonym_text = dedent("""
            one, two => apple, banana
            three => orange, grape
            four, five => jellybean
            """)
        synonyms = set([
            ('one, two', 'apple, banana'),
            ('three', 'orange, grape'),
            ('four, five', 'jellybean'),
        ])
        eq_(synonyms, synonym_utils.parse_synonyms(synonym_text))

    def testTooManyArrows(self):
        try:
            synonym_utils.parse_synonyms('foo => bar => baz')
        except synonym_utils.SynonymParseError as e:
            eq_(len(e.errors), 1)
        else:
            assert False, "Parser did not catch error as expected."

    def testTooFewArrows(self):
        try:
            synonym_utils.parse_synonyms('foo, bar, baz')
        except synonym_utils.SynonymParseError as e:
            eq_(len(e.errors), 1)
        else:
            assert False, "Parser did not catch error as expected."

class SearchViewWithSynonyms(ElasticTestCase):
    client_class = LocalizingClient

    def test_synonyms_work_in_search_view(self):
        d1 = DocumentFactory(title='frob')
        d2 = DocumentFactory(title='glork')
        RevisionFactory(document=d1, is_approved=True)
        RevisionFactory(document=d2, is_approved=True)

        self.refresh()

        # First search without synonyms
        response = self.client.get(reverse('search'), {'q': 'frob'})
        doc = pq(response.content)
        header = doc.find('#search-results h2').text().strip()
        eq_(header, 'Found 1 result for frob for All Products')

        # Now add a synonym.
        SynonymFactory(from_words='frob', to_words='frob, glork')
        update_synonyms_task()
        self.refresh()

        # Forward search
        response = self.client.get(reverse('search'), {'q': 'frob'})
        doc = pq(response.content)
        header = doc.find('#search-results h2').text().strip()
        eq_(header, 'Found 2 results for frob for All Products')

        # Reverse search
        response = self.client.get(reverse('search'), {'q': 'glork'})
        doc = pq(response.content)
        header = doc.find('#search-results h2').text().strip()
        eq_(header, 'Found 1 result for glork for All Products')


text:
var __key = require("./../internal/key");
var __ref = require("./../internal/ref");
var __prefix = require("./../internal/prefix");
var __parent = require("./../internal/parent");
var __context = require("./../internal/context");
var __version = require("./../internal/version");
var __refIndex = require("./../internal/ref-index");
var __refsLength = require("./../internal/refs-length");

var $ref = require("./../types/ref");

var getBoundValue = require("./../get/getBoundValue");

var isArray = Array.isArray;
var promote = require("./../lru/promote");
var hasOwn = require("./../support/hasOwn");
var isObject = require("./../support/isObject");
var isExpired = require("./../support/isExpired");
var isFunction = require("./../support/isFunction");
var isPrimitive = require("./../support/isPrimitive");
var expireNode = require("./../support/expireNode");
var incrementVersion = require("./../support/incrementVersion");
var mergeValueOrInsertBranch = require("./../support/mergeValueOrInsertBranch");

/**
 * Sets a list of PathMaps into a JSON Graph.
 * @function
 * @param {Object} model - the Model for which to insert the PathMaps.
 * @param {Array.<PathMapEnvelope>} pathMapEnvelopes - the a list of @PathMapEnvelopes to set.
 * @return {Array.<Path>} - a list of optimized paths for the successfully set values.
 */

module.exports = function setPathMaps(model, pathMapEnvelopes, x, errorSelector, comparator) {

    var modelRoot = model._root;
    var lru = modelRoot;
    var expired = modelRoot.expired;
    var version = incrementVersion();
    var bound = model._path;
    var cache = modelRoot.cache;
    var node = bound.length ? getBoundValue(model, bound).value : cache;
    var parent = node[__parent] || cache;
    var initialVersion = cache[__version];

    var requestedPath = [];
    var requestedPaths = [];
    var optimizedPaths = [];
    var optimizedIndex = bound.length;
    var pathMapIndex = -1;
    var pathMapCount = pathMapEnvelopes.length;

    while (++pathMapIndex < pathMapCount) {

        var pathMapEnvelope = pathMapEnvelopes[pathMapIndex];
        var optimizedPath = bound.slice(0);
        optimizedPath.index = optimizedIndex;

        setPathMap(
            pathMapEnvelope.json, 0, cache, parent, node,
            requestedPaths, optimizedPaths, requestedPath, optimizedPath,
            version, expired, lru, comparator, errorSelector
        );
    }

    var newVersion = cache[__version];
    var rootChangeHandler = modelRoot.onChange;

    if (isFunction(rootChangeHandler) && initialVersion !== newVersion) {
        rootChangeHandler();
    }

    return [requestedPaths, optimizedPaths];
};

/* eslint-disable no-constant-condition */
function setPathMap(
    pathMap, depth, root, parent, node,
    requestedPaths, optimizedPaths, requestedPath, optimizedPath,
    version, expired, lru, comparator, errorSelector) {

    var keys = getKeys(pathMap);

    if (keys && keys.length) {

        var keyIndex = 0;
        var keyCount = keys.length;
        var optimizedIndex = optimizedPath.index;

        do {
            var key = keys[keyIndex];
            var child = pathMap[key];
            var branch = isObject(child) && !child.$type;
            var results = setNode(
                root, parent, node, key, child,
                branch, false, requestedPath, optimizedPath,
                version, expired, lru, comparator, errorSelector
            );
            requestedPath[depth] = key;
            requestedPath.index = depth;
            optimizedPath[optimizedPath.index++] = key;
            var nextNode = results[0];
            var nextParent = results[1];
            if (nextNode) {
                if (branch) {
                    setPathMap(
                        child, depth + 1,
                        root, nextParent, nextNode,
                        requestedPaths, optimizedPaths, requestedPath, optimizedPath,
                        version, expired, lru, comparator, errorSelector
                    );
                } else {
                    promote(lru, nextNode);
                    requestedPaths.push(requestedPath.slice(0, requestedPath.index + 1));
                    optimizedPaths.push(optimizedPath.slice(0, optimizedPath.index));
                }
            }
            if (++keyIndex >= keyCount) {
                break;
            }
            optimizedPath.index = optimizedIndex;
        } while (true);
    }
}
/* eslint-enable */

function setReference(
    value, root, node, requestedPath, optimizedPath,
    version, expired, lru, comparator, errorSelector) {

    var reference = node.value;
    optimizedPath.splice(0, optimizedPath.length);
    optimizedPath.push.apply(optimizedPath, reference);

    if (isExpired(node)) {
        optimizedPath.index = reference.length;
        expireNode(node, expired, lru);
        return [undefined, root];
    }

    promote(lru, node);

    var container = node;
    var parent = root;

    node = node[__context];

    if (node != null) {
        parent = node[__parent] || root;
        optimizedPath.index = reference.length;
    } else {

        var index = 0;
        var count = reference.length - 1;

        parent = node = root;

        do {
            var key = reference[index];
            var branch = index < count;
            var results = setNode(
                root, parent, node, key, value,
                branch, true, requestedPath, optimizedPath,
                version, expired, lru, comparator, errorSelector
            );
            node = results[0];
            if (isPrimitive(node)) {
                optimizedPath.index = index;
                return results;
            }
            parent = results[1];
        } while (index++ < count);

        optimizedPath.index = index;

        if (container[__context] !== node) {
            var backRefs = node[__refsLength] || 0;
            node[__refsLength] = backRefs + 1;
            node[__ref + backRefs] = container;
            container[__context] = node;
            container[__refIndex] = backRefs;
        }
    }

    return [node, parent];
}

function setNode(
    root, parent, node, key, value,
    branch, reference, requestedPath, optimizedPath,
    version, expired, lru, comparator, errorSelector) {

    var type = node.$type;

    while (type === $ref) {

        var results = setReference(
            value, root, node, requestedPath, optimizedPath,
            version, expired, lru, comparator, errorSelector);

        node = results[0];

        if (isPrimitive(node)) {
            return results;
        }

        parent = results[1];
        type = node && node.$type;
    }

    if (type !== void 0) {
        return [node, parent];
    }

    if (key == null) {
        if (branch) {
            throw new Error("`null` is not allowed in branch key positions.");
        } else if (node) {
            key = node[__key];
        }
    } else {
        parent = node;
        node = parent[key];
    }

    node = mergeValueOrInsertBranch(
        parent, node, key, value,
        branch, reference, requestedPath, optimizedPath,
        version, expired, lru, comparator, errorSelector
    );

    return [node, parent];
}

function getKeys(pathMap) {

    if (isObject(pathMap) && !pathMap.$type) {
        var keys = [];
        var itr = 0;
        if (isArray(pathMap)) {
            keys[itr++] = "length";
        }
        for (var key in pathMap) {
            if (key[0] === __prefix || key[0] === "$" || !hasOwn(pathMap, key)) {
                continue;
            }
            keys[itr++] = key;
        }
        return keys;
    }

    return void 0;
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <artifactId>kylo-nifi-hadoop-processors</artifactId>
  <parent>
    <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
    <artifactId>kylo-nifi-hadoop-bundle</artifactId>
    <version>0.10.1-SNAPSHOT</version>
  </parent>
  <properties>
    <plugin.license.parentRelative>../../../../../</plugin.license.parentRelative>
  </properties>
  <packaging>jar</packaging>

  <profiles>
    <profile>
      <!-- This profile will add the MapR repository for resolving
          MapR Hadoop artifacts for the Hadoop bundles -->
      <id>mapr</id>
      <dependencies>
        <dependency>
          <groupId>org.apache.hadoop</groupId>
          <artifactId>hadoop-hdfs</artifactId>
          <version>${hadoop.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.hadoop</groupId>
          <artifactId>hadoop-yarn-api</artifactId>
          <version>${hadoop.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.hadoop</groupId>
          <artifactId>hadoop-mapreduce-client-contrib</artifactId>
          <version>${hadoop.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.hadoop</groupId>
          <artifactId>hadoop-annotations</artifactId>
          <version>${hadoop.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.hadoop</groupId>
          <artifactId>hadoop-client</artifactId>
          <version>${hadoop.version}</version>
        </dependency>
      </dependencies>
    </profile>
  </profiles>

  <dependencies>
    <dependency>
      <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
      <artifactId>kylo-nifi-framework-api</artifactId>
      <version>${project.version}</version>
    </dependency>

    <dependency>
      <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
      <artifactId>kylo-nifi-security-api</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
      <artifactId>kylo-nifi-hadoop-service-api</artifactId>
    </dependency>

    <dependency>
      <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
      <artifactId>kylo-nifi-hadoop-properties-v1</artifactId>
      <version>${project.version}</version>
    </dependency>

    <!-- Apache Commons -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-distcp</artifactId>
      <version>${hadoop.version}</version>
    </dependency>

    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-mapreduce-client-core</artifactId>
      <version>${hadoop.version}</version>
    </dependency>

    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.nifi</groupId>
      <artifactId>nifi-api</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.nifi</groupId>
      <artifactId>nifi-processor-utils</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.nifi</groupId>
      <artifactId>nifi-properties</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.nifi</groupId>
      <artifactId>nifi-utils</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.avro</groupId>
      <artifactId>avro</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <version>${hadoop.version}</version>
      <scope>provided</scope>
      <exclusions>
        <exclusion>
          <artifactId>httpclient</artifactId>
          <groupId>org.apache.httpcomponents</groupId>
        </exclusion>
        <exclusion>
          <artifactId>jersey-core</artifactId>
          <groupId>com.sun.jersey</groupId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.apache.nifi</groupId>
      <artifactId>nifi-mock</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
      <artifactId>kylo-nifi-framework-v1</artifactId>
      <version>${project.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.thinkbiganalytics.kylo.integrations</groupId>
      <artifactId>kylo-nifi-security-v1</artifactId>
      <version>${project.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>license-maven-plugin</artifactId>
        <configuration>
          <excludes combine.children="append">
            <exclude>**/AbstractHadoopProcessor.java</exclude>
            <exclude>**/ExecuteHQL.java</exclude>
            <exclude>**/JdbcCommon.java</exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>


text:
<?php
/* @var $this yii\web\View */
/* @var $form yii\widgets\ActiveForm */
/* @var $generator yii\mongodb\gii\model\Generator */

echo $form->field($generator, 'collectionName');
echo $form->field($generator, 'databaseName');
echo $form->field($generator, 'attributeList');
echo $form->field($generator, 'modelClass');
echo $form->field($generator, 'ns');
echo $form->field($generator, 'baseClass');
echo $form->field($generator, 'db');
echo $form->field($generator, 'enableI18N')->checkbox();
echo $form->field($generator, 'messageCategory');


text:
package org.epri.pt2;

import java.io.File;

import junit.framework.TestCase;

import org.epri.pt2.sniffer.PCAPEthListener;

public class DNP3PacketParserTest extends TestCase {
	private String fileName = "packets/dnp3_xmaster_slave.pcap";
	private File file;
	private PCAPEthListener listener;

	public DNP3PacketParserTest(String name) {
		super(name);
	}

	protected void setUp() throws Exception {
		super.setUp();
//
//		file = new File(fileName);
//
//		listener = new PCAPEthListener(file);
		//listener.setFilter("tcp port 20000");
	}

	protected void tearDown() throws Exception {
		super.tearDown();
	}

	public void testAll() {

		//listener.connect();

		//while(listener.isOpen());
	}
}


text:
<Type Name="AnimatedBox" FullName="Hyena.Widgets.AnimatedBox">
  <TypeSignature Language="C#" Value="public abstract class AnimatedBox : Gtk.Container" />
  <AssemblyInfo>
    <AssemblyName>Hyena.Gui</AssemblyName>
    <AssemblyVersion>1.3.1.0</AssemblyVersion>
    <AssemblyVersion>1.4.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>Gtk.Container</BaseTypeName>
  </Base>
  <Interfaces />
  <Docs>
    To be added.
    <remarks>To be added.</remarks>
  </Docs>
  <Members>

    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected AnimatedBox (bool horizontal);" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <Parameters><Parameter Name="horizontal" Type="System.Boolean" /></Parameters>
      <Docs><param name="horizontal">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Blocking">
      <MemberSignature Language="C#" Value="public Hyena.Widgets.Blocking Blocking { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>Hyena.Widgets.Blocking</ReturnType></ReturnValue>
      <Docs>To be added.<value>To be added.</value><remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Contains">
      <MemberSignature Language="C#" Value="public bool Contains (Gtk.Widget widget);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Boolean</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /></Parameters>
      <Docs><param name="widget">To be added.</param>To be added.<returns>To be added.</returns><remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Duration">
      <MemberSignature Language="C#" Value="public uint Duration { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.UInt32</ReturnType></ReturnValue>
      <Docs>To be added.<value>To be added.</value><remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Easing">
      <MemberSignature Language="C#" Value="public Hyena.Gui.Theatrics.Easing Easing { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>Hyena.Gui.Theatrics.Easing</ReturnType></ReturnValue>
      <Docs>To be added.<value>To be added.</value><remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="EndPadding">
      <MemberSignature Language="C#" Value="public int EndPadding { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Int32</ReturnType></ReturnValue>
      <Docs>To be added.<value>To be added.</value><remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /></Parameters>
      <Docs><param name="widget">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, Hyena.Gui.Theatrics.Easing easing);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="easing">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, uint duration);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, Hyena.Gui.Theatrics.Easing easing, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="easing">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, uint duration, Hyena.Gui.Theatrics.Easing easing);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="easing">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, uint duration, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackEnd">
      <MemberSignature Language="C#" Value="public void PackEnd (Gtk.Widget widget, uint duration, Hyena.Gui.Theatrics.Easing easing, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="easing">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /></Parameters>
      <Docs><param name="widget">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, Hyena.Gui.Theatrics.Easing easing);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="easing">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, uint duration);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, Hyena.Gui.Theatrics.Easing easing, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="easing">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, uint duration, Hyena.Gui.Theatrics.Easing easing);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="easing">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, uint duration, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="PackStart">
      <MemberSignature Language="C#" Value="public void PackStart (Gtk.Widget widget, uint duration, Hyena.Gui.Theatrics.Easing easing, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="easing">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /></Parameters>
      <Docs><param name="widget">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, Hyena.Gui.Theatrics.Easing easing);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="easing">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, uint duration);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, Hyena.Gui.Theatrics.Easing easing, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="easing">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, uint duration, Hyena.Gui.Theatrics.Easing easing);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="easing">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, uint duration, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public void Remove (Gtk.Widget widget, uint duration, Hyena.Gui.Theatrics.Easing easing, Hyena.Widgets.Blocking blocking);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters><Parameter Name="widget" Type="Gtk.Widget" /><Parameter Name="duration" Type="System.UInt32" /><Parameter Name="easing" Type="Hyena.Gui.Theatrics.Easing" /><Parameter Name="blocking" Type="Hyena.Widgets.Blocking" /></Parameters>
      <Docs><param name="widget">To be added.</param><param name="duration">To be added.</param><param name="easing">To be added.</param><param name="blocking">To be added.</param>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="RemoveAll">
      <MemberSignature Language="C#" Value="public void RemoveAll ();" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Void</ReturnType></ReturnValue>
      <Parameters />
      <Docs>To be added.<remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="Spacing">
      <MemberSignature Language="C#" Value="public int Spacing { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Int32</ReturnType></ReturnValue>
      <Docs>To be added.<value>To be added.</value><remarks>To be added.</remarks></Docs>
    </Member><Member MemberName="StartPadding">
      <MemberSignature Language="C#" Value="public int StartPadding { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>

      <AssemblyVersion>1.3.1.0</AssemblyVersion><AssemblyVersion>1.4.0.0</AssemblyVersion></AssemblyInfo>
      <ReturnValue><ReturnType>System.Int32</ReturnType></ReturnValue>
      <Docs>To be added.<value>To be added.</value><remarks>To be added.</remarks></Docs>
    </Member>
  </Members>
</Type>