public static IDocument createDocument1(){
   IDocument doc = new Document(){
      public String getDefaultLineDelimiter(){
         return String.valueOf(AssistConstants.LINE_DELIM_NL) /*super.getDefaultLineDelimiter()*/;
      }
   };
   IDocumentPartitioner partitioner = new DefaultPartitioner(
         new HPartitionScanner(), 
         new String[] {
             HPartitionScanner.COMMENT,
             HPartitionScanner.PROPERTY_VALUE});
   partitioner.connect(doc);
   doc.setDocumentPartitioner(partitioner);
   
   return doc;  
}
 

public static IDocument createDocument2() {
    IDocument document = new Document();
    if( document != null) {
        IDocumentPartitioner partitioner = new XMLPartitioner(
                new XMLPartitionScanner(), new String[] {
                        XMLPartitionScanner.XML_START_TAG,
                        XMLPartitionScanner.XML_PI,
                        XMLPartitionScanner.XML_DOCTYPE,
                        XMLPartitionScanner.XML_END_TAG,
                        XMLPartitionScanner.XML_TEXT,
                        XMLPartitionScanner.XML_CDATA,
                        XMLPartitionScanner.XML_COMMENT });
        partitioner.connect(document);
        document.setDocumentPartitioner(partitioner);
    }
    return document;
}
 

@Override
protected IDocument createDocument(Object element) throws CoreException {
	IDocument document = null;
	if (isWorkspaceExternalEditorInput(element)) {
		document= createEmptyDocument();
		if (setDocumentContent(document, (IEditorInput) element, getEncoding(element))) {
			setupDocument(element, document);
		}
	} else {
		document = super.createDocument(element);
	}
	if (document != null) {
		IDocumentPartitioner partitioner = documentPartitioner.get();
		partitioner.connect(document);
		document.setDocumentPartitioner(partitioner);
	}
	return document;
}
 

/**
 * Sets document's partitioner. 
 *
 * @param document the document to be processed
 * @param partitioningType the partitioning for which to set the partitioner
 * @param partitioner the document's new partitioner
 * 
 * @see org.eclipse.jface.text.IDocumentExtension3#setDocumentPartitioner(IDocument,String,IDocumentPartitioner)
 * @see IDocumentPartitioningListener
 */
public static void setDocumentPartitioning( IDocument document
                                          , String partitioningType
                                          , IDocumentPartitioner partitioner ) 
{
    // Setting the partitioner will trigger a partitionChanged listener that
    // will attempt to use the partitioner to initialize the document's
    // partitions. Therefore, need to connect first.
    partitioner.connect(document);
    if (document instanceof IDocumentExtension3) {
        IDocumentExtension3 extension3= (IDocumentExtension3) document;
        extension3.setDocumentPartitioner(partitioningType, partitioner);
    } else {
        document.setDocumentPartitioner(partitioner);
    }
}
 

/**
    * Gets the data provider for the current page
    */
   @Override
public void loadData() throws CoreException {
   	final TLCOutputSourceRegistry modelCheckSourceRegistry = TLCOutputSourceRegistry.getModelCheckSourceRegistry();
   	final TLCModelLaunchDataProvider provider = modelCheckSourceRegistry.getProvider(getModel());
	if (provider != null) {
		provider.addDataPresenter(this);
	} else {
		// no data provider
		reinit();
	}

	// constant expression
	final Document document = new Document(getModel().getEvalExpression());
	final IDocumentPartitioner partitioner = new TLAFastPartitioner(
			TLAEditorActivator.getDefault().getTLAPartitionScanner(), TLAPartitionScanner.TLA_PARTITION_TYPES);
	document.setDocumentPartitioner(TLAPartitionScanner.TLA_PARTITIONING, partitioner);
	partitioner.connect(document);
	if (expressionEvalInput != null) {
		expressionEvalInput.setDocument(document);
	}
}
 

@Override
public void connect(Object element) throws CoreException
{
	super.connect(element);

	IDocument document = getDocument(element);
	if (document != null)
	{
		CompositePartitionScanner partitionScanner = new CompositePartitionScanner(XMLSourceConfiguration
				.getDefault().createSubPartitionScanner(), new NullSubPartitionScanner(),
				new NullPartitionerSwitchStrategy());
		IDocumentPartitioner partitioner = new ExtendedFastPartitioner(partitionScanner, XMLSourceConfiguration
				.getDefault().getContentTypes());
		partitionScanner.setPartitioner((IExtendedPartitioner) partitioner);
		partitioner.connect(document);
		document.setDocumentPartitioner(partitioner);
		CommonEditorPlugin.getDefault().getDocumentScopeManager()
				.registerConfiguration(document, XMLSourceConfiguration.getDefault());
	}
}
 

@Override
public void disconnect(Object element)
{
	FileInfo fileInfo = getFileInfo(element);

	if (fileInfo != null && fileInfo.fCount == 1)
	{
		IDocument document = getDocument(element);

		if (document != null)
		{
			IDocumentPartitioner partitioner = document.getDocumentPartitioner();

			if (partitioner != null)
			{
				partitioner.disconnect();
				document.setDocumentPartitioner(null);
			}
		}
	}

	super.disconnect(element);
}
 

@Override
public void connect(Object element) throws CoreException {
	super.connect(element);

	IDocument document = getDocument(element);
	if (document != null) {
		CompositePartitionScanner partitionScanner = new CompositePartitionScanner(defaultPartitioningConfiguration.createSubPartitionScanner(),
				primaryPartitioningConfiguration.createSubPartitionScanner(), partitionerSwitchStrategy);
		IDocumentPartitioner partitioner = new ExtendedFastPartitioner(partitionScanner, TextUtils.combine(new String[][] { CompositePartitionScanner.SWITCHING_CONTENT_TYPES,
				defaultPartitioningConfiguration.getContentTypes(), primaryPartitioningConfiguration.getContentTypes() }));
		partitionScanner.setPartitioner((IExtendedPartitioner) partitioner);
		partitioner.connect(document);
		document.setDocumentPartitioner(partitioner);
		CommonEditorPlugin.getDefault().getDocumentScopeManager()
				.registerConfigurations(document, new IPartitioningConfiguration[] { defaultPartitioningConfiguration, primaryPartitioningConfiguration });
	}
}
 

public SourceEditor() {
    setSourceViewerConfiguration(new TextUMLSourceViewerConfiguration(this));
    // set the document provider to create the partitioner
    setDocumentProvider(new FileDocumentProvider() {
        protected IDocument createDocument(Object element) throws CoreException {
            IDocument document = super.createDocument(element);
            if (document != null) {
                // this will create partitions
                IDocumentPartitioner partitioner = new FastPartitioner(new PartitionScanner(),
                        ContentTypes.CONFIGURED_CONTENT_TYPES);
                partitioner.connect(document);
                document.setDocumentPartitioner(partitioner);
            }
            return document;
        }
    });
}
 

/**
 * Checks if the partitioner is correctly set in the document.
 * @return the partitioner that is set in the document
 */
public static IDocumentPartitioner checkPartitionScanner(IDocument document,
        IGrammarVersionProvider grammarVersionProvider) {
    if (document == null) {
        return null;
    }

    IDocumentExtension3 docExtension = (IDocumentExtension3) document;
    IDocumentPartitioner partitioner = docExtension.getDocumentPartitioner(IPythonPartitions.PYTHON_PARTITION_TYPE);
    if (partitioner == null) {
        addPartitionScanner(document, grammarVersionProvider);
        //get it again for the next check
        partitioner = docExtension.getDocumentPartitioner(IPythonPartitions.PYTHON_PARTITION_TYPE);
    }
    if (!(partitioner instanceof PyPartitioner)) {
        Log.log("Partitioner should be subclass of PyPartitioner. It is " + partitioner.getClass());
    }

    return partitioner;
}
 

/**
 * @see http://help.eclipse.org/help31/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/editors_documents.htm
 * @see http://jroller.com/page/bobfoster -  Saturday July 16, 2005
 * @param document the document where we want to add the partitioner
 * @return the added document partitioner (or null)
 */
public static IDocumentPartitioner addPartitionScanner(IDocument document,
        IGrammarVersionProvider grammarVersionProvider) {
    if (document != null) {
        IDocumentExtension3 docExtension = (IDocumentExtension3) document;
        IDocumentPartitioner curr = docExtension.getDocumentPartitioner(IPythonPartitions.PYTHON_PARTITION_TYPE);

        if (curr == null) {
            //set the new one
            PyPartitioner partitioner = createPyPartitioner();
            partitioner.connect(document);
            docExtension.setDocumentPartitioner(IPythonPartitions.PYTHON_PARTITION_TYPE, partitioner);
            return partitioner;
        } else {
            return curr;
        }
    }
    return null;
}
 

/**
 * Get the current line up to where the cursor is without any comments or literals.
 */
public String getLineContentsToCursor(boolean removeComments, boolean removeLiterals) throws BadLocationException {
    if (removeComments == false || removeLiterals == false) {
        throw new RuntimeException("Currently only accepts removing the literals and comments.");
    }
    int cursorOffset = getAbsoluteCursorOffset();

    IRegion lineInformationOfOffset = doc.getLineInformationOfOffset(cursorOffset);
    IDocumentPartitioner partitioner = PyPartitionScanner.checkPartitionScanner(doc);
    if (partitioner == null) {
        throw new RuntimeException("Partitioner not set up.");
    }

    StringBuffer buffer = new StringBuffer();
    int offset = lineInformationOfOffset.getOffset();
    int length = lineInformationOfOffset.getLength();
    for (int i = offset; i <= offset + length && i < cursorOffset; i++) {
        String contentType = partitioner.getContentType(i);
        if (contentType.equals(IPythonPartitions.PY_DEFAULT)) {
            buffer.append(doc.getChar(i));
        } else {
            buffer.append(' ');
        }
    }
    return buffer.toString();
}
 

protected void setupDocument(Object element, IDocument document) {
	String content = getString(element);
	document.set(content);

	IDocumentPartitioner partitioner = documentPartitioner.get();
	partitioner.connect(document);
	document.setDocumentPartitioner(partitioner);

	XtextResource resource = createResource(element);
	loadResource(element, resource);
	if (resource!=null) {
		((XtextDocument) document).setInput(resource);
	}
}
 

protected IDocument createDocument(Object element) throws CoreException {
	IDocument document = super.createDocument(element);
	if (document != null) {
		IDocumentPartitioner partitioner =
			new DefaultPartitioner(
				new JimplePartitionScanner(),
				new String[] { JimplePartitionScanner.JIMPLE_STRING});
		partitioner.connect(document);
		document.setDocumentPartitioner(partitioner);
	}
	return document;
}
 

public void setupPartitioningIfNotSet(IDocument document) {
	if(document instanceof IDocumentExtension3) {
		IDocumentExtension3 extension3 = (IDocumentExtension3) document;
		
		String partitioning = TextSettings_Actual.PARTITIONING_ID;
		
		if(extension3.getDocumentPartitioner(partitioning) == null) {
			IDocumentPartitioner partitioner = createDocumentPartitioner();
			partitioner.connect(document);
			extension3.setDocumentPartitioner(partitioning, partitioner);
		}
	}
}
 

public void setup(IDocument document) {
	if (document instanceof IDocumentExtension3) {
		IDocumentExtension3 extension3= (IDocumentExtension3) document;

		IDocumentPartitioner partitioner = 
		    new FastPartitioner(
		            new FastLaTeXPartitionScanner(), 
		            FastLaTeXPartitionScanner.TEX_PARTITION_TYPES);

		extension3.setDocumentPartitioner(TexEditor.TEX_PARTITIONING, partitioner);
        
		partitioner.connect(document);
		
	}	
}
 

/**
 * Returns the partitioner for the given partitioning or <code>null</code> if
 * no partitioner is registered.
 *
 * @param document the document to be processed
 * @param  partitioningType the partitioning for which to set the partitioner
 * @return the partitioner for the given partitioning
 * 
 * @see org.eclipse.jface.text.IDocumentExtension3#getDocumentPartitioner(IDocument,String)
 */
public static IDocumentPartitioner getPartitioner( IDocument document
                                                 , String partitioningType ) 
{
    IDocumentPartitioner result = null;
    if (document instanceof IDocumentExtension3) {
        IDocumentExtension3 extension = (IDocumentExtension3) document;
        result = extension.getDocumentPartitioner(partitioningType);
    } else if (document != null){
        result = document.getDocumentPartitioner();
    }
    return result;
}
 

/**
 * Creates and sets document's partitioner. 
 *
 * @param document the document for setup
 * @see org.eclipse.core.filebuffers.IDocumentSetupParticipant#setup(org.eclipse.jface.text.IDocument)
 */
public static void setupPartitioner(IDocument document) {
    if (PartitionUtils.getPartitioner(document, IModulaPartitions.M2_PARTITIONING) == null) {
        IDocumentPartitioner partitioner = createDocumentPartitioner();
        PartitionUtils.setDocumentPartitioning(document, IModulaPartitions.M2_PARTITIONING, partitioner); 
    }
}
 

public static ModulaFastPartitioner getModulaFastPartitioner(IDocument document) {
  	IDocumentPartitioner documentPartitioner = PartitionUtils.getPartitioner(document, IModulaPartitions.M2_PARTITIONING);
if (documentPartitioner instanceof ModulaFastPartitioner) {
	return (ModulaFastPartitioner) documentPartitioner;
}
return null;
  }
 

@Override
public void setUp() throws Exception {
	super.setUp();
	document = get(XtextDocument.class);
	IDocumentPartitioner partitioner = get(IDocumentPartitioner.class);
	partitioner.connect(document);
	document.setDocumentPartitioner(partitioner);
}
 

@Override
public void setUp() throws Exception {
  super.setUp();
  this.document = this.<XtextDocument>get(XtextDocument.class);
  IDocumentPartitioner partitioner = this.<IDocumentPartitioner>get(IDocumentPartitioner.class);
  partitioner.connect(this.document);
  this.document.setDocumentPartitioner(partitioner);
}
 

public void setup(IDocument document) {
    if (document instanceof IDocumentExtension3) {
        IDocumentExtension3 extension3= (IDocumentExtension3) document;
        IDocumentPartitioner partitioner= new TLAFastPartitioner(TLAEditorActivator.getDefault().getTLAPartitionScanner(), TLAPartitionScanner.TLA_PARTITION_TYPES);
                                            // Changed from FastPartitioner by LL on 12 Aug 2012
        extension3.setDocumentPartitioner(TLAPartitionScanner.TLA_PARTITIONING, partitioner);
        partitioner.connect(document);
    }
}
 

public IStructuredDocument clone(IDocument original) {
  IModelManager modelManager = StructuredModelManager.getModelManager();
  String modelId = getModelId(original);
  if (modelId == null) {
    GWTPluginLog.logError("Could not get a model ID for the document to be formatted.");
    return null;
  }

  /*
   * The XML formatter requires a managed model (discovered by it crashing
   * when given an unmanaged model.) Unfortunately, we cannot create a managed
   * in-memory (i.e. non-file backed) model via IModelManager API (there is
   * one method that may work, but it is deprecated.) Instead, we copy the
   * existing model into a temp model with ID "temp".
   */
  try {
    IStructuredModel modelClone = modelManager.copyModelForEdit(modelId,
        "structuredDocumentClonerModel" + nextId.getAndIncrement());
    modelClone.setBaseLocation(getModelBaseLocation(original));

    IStructuredDocument documentClone = modelClone.getStructuredDocument();
    documentClone.set(original.get());

    // Create and connect the partitioner to the document
    IDocumentPartitioner tempPartitioner = documentPartitionerFactory.createDocumentPartitioner();
    ((IDocumentExtension3) documentClone).setDocumentPartitioner(
        partitioning, tempPartitioner);
    tempPartitioner.connect(documentClone);

    // Save the cloned model so we can release it later
    modelClones.put(documentClone, modelClone);

    return documentClone;
  } catch (ResourceInUse e1) {
    GWTPluginLog.logError(e1,
        "Could not copy the original model to be formatted.");
    return null;
  }
}
 

@Override
protected IDocumentPartitioner getDocumentPartitioner()
{
	CompositePartitionScanner partitionScanner = new CompositePartitionScanner( //
			SVGSourceConfiguration.getDefault().createSubPartitionScanner(), //
			new NullSubPartitionScanner(), //
			new NullPartitionerSwitchStrategy() //
	);
	IDocumentPartitioner partitioner = new ExtendedFastPartitioner( //
			partitionScanner, //
			SVGSourceConfiguration.getDefault().getContentTypes() //
	);
	return partitioner;
}
 

@Override
public void connect(Object element) throws CoreException
{
	super.connect(element);

	IDocument document = getDocument(element);

	if (document != null)
	{
		CompositePartitionScanner partitionScanner = new CompositePartitionScanner( //
			SVGSourceConfiguration.getDefault().createSubPartitionScanner(), //
			new NullSubPartitionScanner(), //
			new NullPartitionerSwitchStrategy() //
		);
		IDocumentPartitioner partitioner = new ExtendedFastPartitioner( //
			partitionScanner, //
			SVGSourceConfiguration.getDefault().getContentTypes() //
		);

		partitionScanner.setPartitioner((IExtendedPartitioner) partitioner);
		partitioner.connect(document);
		document.setDocumentPartitioner(partitioner);

		CommonEditorPlugin.getDefault().getDocumentScopeManager().registerConfiguration( //
			document, //
			SVGSourceConfiguration.getDefault() //
		);
	}
}
 

@Override
protected IDocumentPartitioner getDocumentPartitioner()
{
	CompositePartitionScanner partitionScanner = new CompositePartitionScanner(XMLSourceConfiguration.getDefault()
			.createSubPartitionScanner(), new NullSubPartitionScanner(), new NullPartitionerSwitchStrategy());
	IDocumentPartitioner partitioner = new ExtendedFastPartitioner(partitionScanner, XMLSourceConfiguration
			.getDefault().getContentTypes());
	return partitioner;
}
 

@Override
protected IDocumentPartitioner getDocumentPartitioner()
{
	IDocumentPartitioner partitioner = new ExtendedFastPartitioner(new JSSourcePartitionScannerJFlex(),
			JSSourceConfiguration.getDefault().getContentTypes());
	return partitioner;
}
 

private List<ITypedRegion> allGroovyPartitions(IDocument document) {
    final IDocumentPartitioner partitioner = document.getDocumentPartitioner();
    final ITypedRegion[] regions = partitioner.computePartitioning(0, document.getLength());
    final List<ITypedRegion> groovyPartions = new ArrayList<>();
    for (int i = 0; i < regions.length; i++) {
        final ITypedRegion partition = regions[i];
        if (PatternExpressionViewer.GROOVY_EXPRESSION_CONTENT_TYPE.equals(partition.getType())) {
            groovyPartions.add(partition);
        }
    }
    return groovyPartions;
}
 

@Override
protected IDocumentPartitioner getDocumentPartitioner()
{
	IDocumentPartitioner partitioner = new ExtendedFastPartitioner(new CSSSourcePartitionScannerJFlex(),
			CSSSourceConfiguration.getDefault().getContentTypes());
	return partitioner;
}
 

/**
 * @param composite
 */
public SourceViewer createSourcePreview(Composite composite, IScriptFormatterFactory factory)
{
	IPreferenceStore generalTextStore = EditorsUI.getPreferenceStore();
	// TODO - Note that we pass the factory's preferences store and not calling to this.getPrefereceStore.
	// In case we decide to unify the preferences into the this plugin, we might need to change this.
	IPreferenceStore store = new ChainedPreferenceStore(new IPreferenceStore[] { factory.getPreferenceStore(),
			generalTextStore });
	SourceViewer fPreviewViewer = createPreviewViewer(composite, null, null, false, SWT.V_SCROLL | SWT.H_SCROLL
			| SWT.BORDER, store);
	if (fPreviewViewer == null)
	{
		return null;
	}
	SourceViewerConfiguration configuration = (SourceViewerConfiguration) factory
			.createSimpleSourceViewerConfiguration(fColorManager, store, null, false);
	fPreviewViewer.configure(configuration);
	if (fPreviewViewer.getTextWidget().getTabs() == 0)
	{
		fPreviewViewer.getTextWidget().setTabs(4);
	}
	new ScriptSourcePreviewerUpdater(fPreviewViewer, configuration, store);
	fPreviewViewer.setEditable(false);
	IDocument document = new Document();
	fPreviewViewer.setDocument(document);
	IPartitioningConfiguration partitioningConfiguration = (IPartitioningConfiguration) factory
			.getPartitioningConfiguration();
	CompositePartitionScanner partitionScanner = new CompositePartitionScanner(
			partitioningConfiguration.createSubPartitionScanner(), new NullSubPartitionScanner(),
			new NullPartitionerSwitchStrategy());
	IDocumentPartitioner partitioner = new ExtendedFastPartitioner(partitionScanner,
			partitioningConfiguration.getContentTypes());
	partitionScanner.setPartitioner((IExtendedPartitioner) partitioner);
	partitioner.connect(document);
	document.setDocumentPartitioner(partitioner);
	return fPreviewViewer;
}