public void contextInitialized(ServletContextEvent sce) {
      ServletContext sc = sce.getServletContext();

      ServletRegistration sr = sc.addServlet("NewServlet", "test.NewServlet");
      sr.setInitParameter("servletInitName", "servletInitValue");
      sc.addServletMapping("NewServlet", new String[] {"/newServlet"});
  }

add(new ListView("mylist",someList){
  @Override
  protected void populateItem(ListItem item){
    item.add(new PageLink("deleteThisEntry",new DeletePage(item.getModel())));
  }};
});

/**
 * This constructor is ideal if a Page object was passed in from a previous Page. Construct a
 * link to the Page. Warning: DO NOT use this for constructing links to pages you didn't already
 * have an instance of. This constructor is strongly discouraged for anything other than linking
 * back to the same page.
 * 
 * @param id
 *            See component
 * @param page
 *            The page
 * @deprecated rather than using this class/ constructor, use normal {@link Link links} and call
 *             setResponsePage in their {@link Link#onClick() onClick} methods.
 */
@Deprecated
public PageLink(final String id, final Page<?> page)

@SomeFunkyAnnotationForInterception
class DeletePage extends WebPage{
 public DeletePage(IModel objectToDelete){
   deleteObject(objectToDelete.getObject());
   setResponsePage(DeletionDonePage.class);
 }
 //...
}

new PageLink(id,new XYPage(...))

new Link(id){ 
 public void onClick(){
  setResponsePage(new XYPage(...));
 }
}

final class GuiceJobFactory implements JobFactory
{
    private final Injector guice;

    @Inject
    public GuiceJobFactory(final Injector guice)
    {
        this.guice = guice;
    }

    @Override
    public Job newJob(final TriggerFiredBundle bundle) throws SchedulerException
    {
        JobDetail jobDetail = bundle.getJobDetail();
        Class jobClass = jobDetail.getJobClass();
        return (Job) guice.getInstance(jobClass);
    }

}

public class Quartz
{
    private final Scheduler scheduler;

    @Inject
    public Quartz(final SchedulerFactory factory, final GuiceJobFactory jobFactory) throws SchedulerException
    {
        scheduler = factory.getScheduler();
        scheduler.setJobFactory(jobFactory);
        scheduler.start();
    }

    public final Scheduler getScheduler()
    {
        return scheduler;
    }

    public void shutdown()
    {
        try
        {
            scheduler.shutdown();
        }
        catch (SchedulerException e)
        {
	    // ... handle it
        }
    }
}

public class QuartzModule extends AbstractModule
{
    @Override
    protected void configure()
    {
        bind(SchedulerFactory.class).to(StdSchedulerFactory.class).in(Scopes.SINGLETON);
        bind(GuiceJobFactory.class).in(Scopes.SINGLETON);
        bind(Quartz.class).in(Scopes.SINGLETON);
    }
}

public static <T> T newInstance(final Class<T> c)
    {
        try
        {
            Constructor<T> constructor = c.getDeclaredConstructor(new Class[] {});
            if (constructor != null)
            {
                constructor.setAccessible(true);
                return constructor.newInstance((Object[]) null);
            }
            else
            {
                throw new IllegalArgumentException("Cannot find empty Contructor for class '" + c.getName() + "'");
            }
        }
        catch (SecurityException e)
        {
            throw ExceptionHelper.wrap(e);
        }
        catch (IllegalArgumentException e)
        {
            throw ExceptionHelper.wrap(e);
        }
        catch (InstantiationException e)
        {
            throw ExceptionHelper.wrap(e);
        }
        catch (IllegalAccessException e)
        {
            throw ExceptionHelper.wrap(e);
        }
        catch (InvocationTargetException e)
        {
            throw ExceptionHelper.wrap(e);
        }
        catch (NoSuchMethodException e)
        {
            throw ExceptionHelper.wrap(e);
        }
    }

public class NicEditTextAreaBehavior extends AbstractBehavior {

	private Component<TextArea<String>> textArea;
	private Boolean fullPanel = Boolean.TRUE;
	
	private static final ResourceReference NICEDIT_JAVASCRIPT =
		new JavascriptResourceReference(NicEditTextAreaBehavior.class, "nicEdit.js");
	
	private static final ResourceReference NICEDIT_ICONS = new
ResourceReference(NicEditTextAreaBehavior.class,
		"nicEditorIcons.gif");
	
	public NicEditTextAreaBehavior() {
	}
	
	public NicEditTextAreaBehavior(Boolean fullPanel) {
		this.fullPanel = fullPanel;
	}	
	
	@Override @SuppressWarnings("unchecked")
	public void bind(Component component) {
		this.textArea = component;
		component.setOutputMarkupId(true);
	}
	
	@Override
	public void renderHead(IHeaderResponse response) {
		super.renderHead(response);
		response.renderJavascriptReference(NICEDIT_JAVASCRIPT);
		response.renderOnDomReadyJavascript("new nicEditor({iconsPath : '"+
RequestCycle.get().urlFor(
				NICEDIT_ICONS) +"', fullPanel : "+ fullPanel +"}).panelInstance('"
+ textArea.getMarkupId() + "');");
	}
}

import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.ComponentTag;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.model.IModel;

/**
*  @author Thijs Vonk
**/
public class AnchoredBookmarkablePageLink extends BookmarkablePageLink {

 private static final long serialVersionUID = 1L;

 private IModel stringAnchor;

 public AnchoredBookmarkablePageLink(String id, Class pageClass, IModel anchor) {
   super(id, pageClass);
   this.stringAnchor = anchor;
 }

 public AnchoredBookmarkablePageLink(String id, Class pageClass, PageParameters params, IModel anchor) {
   super(id, pageClass, params);
   this.stringAnchor = anchor;
 }

 @Override
 protected CharSequence appendAnchor(ComponentTag tag, CharSequence url) {
   url = url + "#" + stringAnchor.getObject().toString();
   return url;
 }
 
}

void foo(int i) throws IllegalArgumentException

package org.apache.wicket.guice;

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

import org.apache.wicket.Application;
import org.apache.wicket.proxy.IProxyTargetLocator;

import com.google.inject.Key;
import com.google.inject.TypeLiteral;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;

class GuiceProxyTargetLocator implements IProxyTargetLocator
{
    private static final long serialVersionUID = 1L;

    private final Annotation bindingAnnotation;

    private transient Type type;
    private final String serializedType;

    GuiceProxyTargetLocator(final Type type, final Annotation bindingAnnotation)
    {
        this.type = type;
        final XStream xstream = new XStream(new DomDriver());
        this.serializedType = xstream.toXML(type);
        this.bindingAnnotation = bindingAnnotation;
    }

    public Object locateProxyTarget()
    {
        final GuiceInjectorHolder holder = (GuiceInjectorHolder) Application.get().getMetaData(
                GuiceInjectorHolder.INJECTOR_KEY);

        if (this.type == null)
        {
            final XStream xstream = new XStream(new DomDriver());
            this.type = (Type) xstream.fromXML(this.serializedType);
        }

        // using TypeLiteral to retrieve the key gives us automatic support for
        // Providers and other injectable TypeLiterals
        final Key<?> key;

        if (this.bindingAnnotation == null)
        {
            key = Key.get(TypeLiteral.get(this.type));
        }
        else
        {
            key = Key.get(TypeLiteral.get(this.type), this.bindingAnnotation);
        }
        return holder.getInjector().getInstance(key);
    }
}

package org.apache.wicket.guice;

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

import org.apache.wicket.Application;
import org.apache.wicket.proxy.IProxyTargetLocator;

import com.google.inject.Key;
import com.google.inject.TypeLiteral;

class GuiceProxyTargetLocator implements IProxyTargetLocator {
    private static final long serialVersionUID = 1L;
    private final Annotation bindingAnnotation;
    private transient Type type;
    private Class serializableType;
    GuiceProxyTargetLocator(final Type type, final Annotation bindingAnnotation) {
        this.type = type;
        if (type instanceof Class) {
            this.serializableType = (Class) type;
        }
        this.bindingAnnotation = bindingAnnotation;
    }
    public Object locateProxyTarget() {
        final GuiceInjectorHolder holder = (GuiceInjectorHolder) Application.get().getMetaData(
                GuiceInjectorHolder.INJECTOR_KEY);
        if (this.type == null) {
            if (this.serializableType != null) {
                this.type = this.serializableType;
            }
            else {
                throw new IllegalStateException("Used a non-Class type for injection, which is not Serializable.");
            }
        }
        // using TypeLiteral to retrieve the key gives us automatic support for
        // Providers and other injectable TypeLiterals
        final Key<?> key;
        if (this.bindingAnnotation == null) {
            key = Key.get(TypeLiteral.get(this.type));
        }
        else {
            key = Key.get(TypeLiteral.get(this.type), this.bindingAnnotation);
        }
        return holder.getInjector().getInstance(key);
    }
}

/**
 * Adds an AJAX-Indicator to DropDownChoice 
 * @author Eyal Golan
 */
class DropDownChoiceWithAjaxIndicator extends DropDownChoice implements IAjaxIndicatorAware
{
    private static final long serialVersionUID = 1365817942506006686L;
    private final WicketAjaxIndicatorAppender indicatorAppender = new WicketAjaxIndicatorAppender();

    public DropDownChoiceWithAjaxIndicator(final String id, final IModel choices, final IChoiceRenderer renderer,
            final MarkupContainer markupContainer)
    {
        super(id, choices, renderer);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final IModel model, final IModel choices,
            final IChoiceRenderer renderer, final MarkupContainer markupContainer)
    {
        super(id, model, choices, renderer);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final IModel model, final IModel choices,
            final MarkupContainer markupContainer)
    {
        super(id, model, choices);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final IModel model, final List<Serializable> data,
            final IChoiceRenderer renderer, final MarkupContainer markupContainer)
    {
        super(id, model, data, renderer);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final IModel model, final List<Serializable> choices,
            final MarkupContainer markupContainer)
    {
        super(id, model, choices);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final IModel choices, final MarkupContainer markupContainer)
    {
        super(id, choices);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final List<Serializable> data,
            final IChoiceRenderer renderer, final MarkupContainer markupContainer)
    {
        super(id, data, renderer);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final List<Serializable> choices,
            final MarkupContainer markupContainer)
    {
        super(id, choices);
        init(markupContainer);
    }

    public DropDownChoiceWithAjaxIndicator(final String id, final MarkupContainer markupContainer)
    {
        super(id);
        init(markupContainer);
    }

    public String getAjaxIndicatorMarkupId()
    {
        return this.indicatorAppender.getMarkupId();
    }

    private void init(final MarkupContainer markupContainer)
    {
        add(this.indicatorAppender);
    }
}

/**
 * Form that uses a random uuid token in order to prevent nasty people from messing around (also known as cross site request forgery) ;) 
 * @author igor vaynberg 
 */
class SecureForm extends Form
{
    public SecureForm(final String id)
    {
        super(id);
    }
    private static final long serialVersionUID = 1L;
    private static final String TOKEN_NAME = "SECURE_FORM_TOKEN";
    private String token;

    @Override
    protected void onBeforeRender()
    {
        super.onBeforeRender();
        this.token = UUID.randomUUID().toString();
    }

    @Override
    protected void onComponentTagBody(final MarkupStream markupStream, final ComponentTag openTag)
    {
        super.onComponentTagBody(markupStream, openTag);
        getResponse().write("<input type='hidden' name='" + this.TOKEN_NAME + "' value='" + this.token + "'/>");
    }

    @Override
    public boolean process()
    {
        if (!this.token.equals(getRequest().getParameter(this.TOKEN_NAME)))
        {
            throw new IllegalStateException("token mismatch");
        }
        return super.process();
    }
}

/**
 * Provides a list of Breadcrumbs. THIS IS ONLY A TEMPLATE. DO NOT USE UNMODIFIED 
 * @author igor vaynberg 
 */
public abstract class BreadcrumbPage extends Page
{
    private List<BreadcrumbPage> history = new ArrayList<BreadcrumbPage>();

    public BreadcrumbPage()
    {
        add(new ListView("history", new PropertyModel(this, "history"))
        {
            @Override
            protected void populateItem(final ListItem item)
            {
                final Link link = new Link("link", item.getModel())
                {
                    @Override
                    protected void onClick()
                    {
                        getRequestCycle().setResponsePage((BreadcrumbPage) getModelObject());
                    }
                };
                link.add(new Label("title", ((BreadcrumbPage) item.getModelObject()).getTitle()));
            }
        });
    }

    public BreadcrumbPage(final BreadcrumbPage crumb)
    {
        this();
        this.history.add(crumb); // FIXME you´ll want to limit the list´s size
    }

    protected abstract IModel getTitle();
}

/**
 * @author igor vaynberg 
 */
public class DropDownIdChoice extends DropDownChoice
{

    public DropDownIdChoice(String id, IModel model, IModel choices, IChoiceRenderer renderer, Class<?> type)
    {
        super(id, model, choices, renderer);
        setType(type);
    }

    @Override
    public String getModelValue()
    {
        final Object id = getModelObject();
        if (id != null)
        {
            return getConverter(getType()).convertToString(id, getLocale());
        }
        else
        {
            return NO_SELECTION_VALUE;
        }
    }
}

/**
 * Form that divides submit-events to inital and resubmit. 
 * @author igor vaynberg 
 */
abstract class ResubmitSafeForm extends Form
{
    private boolean submitted;
    private static final long serialVersionUID = 1L;

    public ResubmitSafeForm(final String id)
    {
        super(id);
    }

    public ResubmitSafeForm(final String id, final IModel model)
    {
        super(id, model);
    }

    protected abstract void onInitialSubmit();

    protected abstract void onResubmit();

    protected final void onSubmitted()
    {
        if (!this.submitted)
        {
            onInitialSubmit();
            this.submitted = true;
        }
        else
        {
            onResubmit();
        }
    }
}

/**
 * Simple Link that renders its Model as a textual body
 * @author Al Maw
 */
abstract class TextLink extends Link
{
    public TextLink(final String id, final IModel model)
    {
        super(id, model);
    }

    @Override
    protected void onComponentTagBody(final MarkupStream markupStream, final ComponentTag openTag)
    {

        // Draw anything before the body?
        if (!isLinkEnabled() && (getBeforeDisabledLink() != null))
        {
            getResponse().write(getBeforeDisabledLink());
        }
        replaceComponentTagBody(markupStream, openTag, getModelObjectAsString());

        // Draw anything after the body?
        if (!isLinkEnabled() && (getAfterDisabledLink() != null))
        {
            getResponse().write(getAfterDisabledLink());
        }

    }
}

/**
 * Adds hint-text to texfield, that will be erased onFocus 
 * @author igor vaynberg 
 */
public class TextFieldHintBehaviour extends AbstractBehavior
{
    private String pseudoUniqueJavascriptVariableName = this.getClass().getSimpleName()
            + String.valueOf(System.nanoTime());

    public TextFieldHintBehaviour(final IModel hintTextModel)
    {
        this.hint = hintTextModel;
    }

    private final IModel hint;
    private Component c;

    private String hintColor = "gray";
    private String textColor = "black";

    @Override
    public void bind(final Component component)
    {
        super.bind(component);
        this.c = component;
        this.c.setOutputMarkupId(true);
    }

    @Override
    public void renderHead(final IHeaderResponse response)
    {
        response.renderOnDomReadyJavascript("var " + this.pseudoUniqueJavascriptVariableName
                + "=document.getElementById('" + this.c.getMarkupId() + "');" + this.pseudoUniqueJavascriptVariableName
                + ".value='" + this.hint.getObject() + "';" + this.pseudoUniqueJavascriptVariableName
                + ".style['color']='" + this.hintColor + "';");
    }

    @Override
    public void onComponentTag(final Component component, final ComponentTag tag)
    {
        super.onComponentTag(component, tag);
        tag.put("onfocus", "if (this.value=='" + this.hint.getObject() + "') {this.value=''; this.style['color']='"
                + this.textColor + ";'}");
    }

    public String getHintColor()
    {
        return this.hintColor;
    }

    public void setHintColor(final String hintColor)
    {
        this.hintColor = hintColor;
    }

    public String getTextColor()
    {
        return this.textColor;
    }

    public void setTextColor(final String textColor)
    {
        this.textColor = textColor;
    }
}