Month: June 2022

val editor = findViewById<TextProcessor>(R.id.editor)

editor.language = JavaScriptLanguage() // or some other language you need

editor.setTextContent("your code right here")

import com.blacksquircle.ui.editorkit.mannequin.UndoStack

editor.undoStack = UndoStack()
editor.redoStack = UndoStack()

val pluginSupplier = PluginSupplier.create {
    pinchZoom { // whether or not the zoom gesture enabled
        minTextSize = 10f
        maxTextSize = 20f 
    }
    lineNumbers {
        lineNumbers = true // line numbers visibility
        highlightCurrentLine = true // whether or not the present line shall be highlighted
    }
    highlightDelimiters() // spotlight open/closed brackets beside the cursor
    autoIndentation {
        autoIndentLines = true // whether or not the auto indentation enabled
        autoCloseBrackets = true // routinely shut open parenthesis/bracket/brace
        autoCloseQuotes = true // routinely shut single/double quote when typing
    }
}
editor.plugins(pluginSupplier)

val pluginSupplier = PluginSupplier.create {
    if (preferences.isLineNumbersEnabled) {
        lineNumbers()
    }
    if (preferences.isPinchZoomEnabled) {
        pinchZoom()
    }
    // ...
}
editor.plugins(pluginSupplier)

val editor = findViewById<TextProcessor>(R.id.editor)
val scroller = findViewById<TextScroller>(R.id.scroller)

scroller.attachTo(editor)

// or utilizing Plugin DSL:

val pluginSupplier = PluginSupplier.create {
    ...
    textScroller {
        scroller = findViewById<TextScroller>(R.id.scroller)
    }
}

class AutoCompleteAdapter(context: Context) : SuggestionAdapter(context, R.format.item_suggestion) {

    override enjoyable createViewHolder(mother or father: ViewGroup): SuggestionViewHolder {
        val inflater = LayoutInflater.from(mother or father.context)
        val view = inflater.inflate(R.format.item_suggestion, mother or father, false)
        return AutoCompleteViewHolder(view)
    }
    
    class AutoCompleteViewHolder(itemView: View) : SuggestionViewHolder(itemView) {
    
        non-public val title: TextView = itemView.findViewById(R.id.title)
        
        override enjoyable bind(suggestion: Suggestion?, question: String) {
            title.textual content = suggestion?.textual content
        }
    }
}

val pluginSupplier = PluginSupplier.create {
    ...
    codeCompletion {
        suggestionAdapter = AutoCompleteAdapter(this)
    }
}

// Undo
if (editor.canUndo()) {
    editor.undo()
}

// Redo
if (editor.canRedo()) {
    editor.redo()
}

editor.onUndoRedoChangedListener = object : OnUndoRedoChangedListener {
    override enjoyable onUndoRedoChanged() {
        val canUndo = editor.canUndo()
        val canRedo = editor.canRedo()
        
        // ...
    }
}

editor.moveCaretToStartOfLine()
editor.moveCaretToEndOfLine()
editor.moveCaretToPrevWord()
editor.moveCaretToNextWord()

import com.blacksquircle.ui.editorkit.exception.LineException

attempt {
    editor.gotoLine(lineNumber)
} catch (e: LineException) {
    Toast.makeText(this, "Line doesn't exists", Toast.LENGTH_SHORT).present()
}

import com.blacksquircle.ui.editorkit.mannequin.FindParams

val params = FindParams(
    question = "perform", // textual content to seek out
    regex = false, // common expressions
    matchCase = true, // case delicate
    wordsOnly = true // phrases solely
)

editor.discover(params)

// To navigate between outcomes use findNext() and findPrevious()

val pluginSupplier = PluginSupplier.create {
    ...
    shortcuts {
        onShortcutListener = object : OnShortcutListener {
            override enjoyable onShortcut(shortcut: Shortcut): Boolean {
                val (ctrl, shift, alt, keyCode) = shortcut
                return when {
                    ctrl && keyCode == KeyEvent.KEYCODE_DPAD_LEFT -> editor.moveCaretToStartOfLine()
                    ctrl && keyCode == KeyEvent.KEYCODE_DPAD_RIGHT -> editor.moveCaretToEndOfLine()
                    alt && keyCode == KeyEvent.KEYCODE_DPAD_LEFT -> editor.moveCaretToPrevWord()
                    alt && keyCode == KeyEvent.KEYCODE_DPAD_RIGHT -> editor.moveCaretToNextWord()
                    // ...
                    else -> false
                }
            }
        }
    }
}

editor.colorScheme = EditorTheme.DARCULA // default

// or you should utilize one in all these:
EditorTheme.MONOKAI
EditorTheme.OBSIDIAN
EditorTheme.LADIES_NIGHT
EditorTheme.TOMORROW_NIGHT
EditorTheme.VISUAL_STUDIO_2013

editor.colorScheme = ColorScheme(
    textColor = Coloration.parseColor("#C8C8C8"),
    backgroundColor = Coloration.parseColor("#232323"),
    gutterColor = Coloration.parseColor("#2C2C2C"),
    gutterDividerColor = Coloration.parseColor("#555555"),
    gutterCurrentLineNumberColor = Coloration.parseColor("#FFFFFF"),
    gutterTextColor = Coloration.parseColor("#C6C8C6"),
    selectedLineColor = Coloration.parseColor("#141414"),
    selectionColor = Coloration.parseColor("#454464"),
    suggestionQueryColor = Coloration.parseColor("#4F98F7"),
    findResultBackgroundColor = Coloration.parseColor("#1C3D6B"),
    delimiterBackgroundColor = Coloration.parseColor("#616161"),
    numberColor = Coloration.parseColor("#BACDAB"),
    operatorColor = Coloration.parseColor("#DCDCDC"),
    keywordColor = Coloration.parseColor("#669BD1"),
    typeColor = Coloration.parseColor("#669BD1"),
    langConstColor = Coloration.parseColor("#669BD1"),
    preprocessorColor = Coloration.parseColor("#C49594"),
    variableColor = Coloration.parseColor("#9DDDFF"),
    methodColor = Coloration.parseColor("#71C6B1"),
    stringColor = Coloration.parseColor("#CE9F89"),
    commentColor = Coloration.parseColor("#6BA455"),
    tagColor = Coloration.parseColor("#DCDCDC"),
    tagNameColor = Coloration.parseColor("#669BD1"),
    attrNameColor = Coloration.parseColor("#C8C8C8"),
    attrValueColor = Coloration.parseColor("#CE9F89"),
    entityRefColor = Coloration.parseColor("#BACDAB")
)

import com.blacksquircle.ui.language.base.Language
import com.blacksquircle.ui.language.base.parser.LanguageParser
import com.blacksquircle.ui.language.base.supplier.SuggestionProvider
import com.blacksquircle.ui.language.base.styler.LanguageStyler

class CustomLanguage : Language {

    override enjoyable getName(): String {
        return "{custom} language"
    }

    override enjoyable getParser(): LanguageParser {
        return CustomParser()
    }

    override enjoyable getProvider(): SuggestionProvider {
        return CustomProvider()
    }

    override enjoyable getStyler(): LanguageStyler {
        return CustomStyler()
    }
}

class CustomParser : LanguageParser {

    override enjoyable execute(identify: String, supply: String): ParseResult {
        // TODO Implement parser
        val lineNumber = 0
        val columnNumber = 0
        val parseException = ParseException("describe exception right here", lineNumber, columnNumber)
        return ParseResult(parseException)
    }
}

class CustomProvider : SuggestionProvider {

    // You should utilize WordsManager
    // should you do not need to write the language-specific implementation
    non-public val wordsManager = WordsManager()

    override enjoyable getAll(): Set<Suggestion> {
        return wordsManager.getWords()
    }

    override enjoyable processLine(lineNumber: Int, textual content: String) {
        wordsManager.processLine(lineNumber, textual content)
    }

    override enjoyable deleteLine(lineNumber: Int) {
        wordsManager.deleteLine(lineNumber)
    }

    override enjoyable clearLines() {
        wordsManager.clearLines()
    }
}

class CustomStyler : LanguageStyler {

    override enjoyable execute(supply: String, scheme: ColorScheme): Listing<SyntaxHighlightSpan> {
        val syntaxHighlightSpans = mutableListOf<SyntaxHighlightSpan>()
        
        // TODO Implement syntax highlighting
        
        return syntaxHighlightSpans
    }
}