deprecate SCViewHolder-layRight

[supercollider.git] / SCClassLibrary / Common / GUI / Document.sc

// Since SC v3.2 dev, Document is an ABSTRACT class. Can't be instantiated directly.
// Subclasses provide the editor-specific implementation, e.g. CocoaDocument for the standard Mac interface.
// Subclasses also (in their SC code files) add a "implementationClass" method to Document to tell it to use them.

Document {

        classvar <dir="", <wikiDir="", <allDocuments, >current;
        classvar <>globalKeyDownAction, <> globalKeyUpAction, <>initAction;

        classvar <>autoRun = true;
        classvar <>wikiBrowse = true;

        classvar <>implementationClass;
        classvar <postColor;
        classvar <theme, <themes;

        //don't change the order of these vars:
        var <dataptr, <>keyDownAction, <>keyUpAction, <>mouseUpAction;
        var <>toFrontAction, <>endFrontAction, <>onClose, <>mouseDownAction;

        var <stringColor;

        var <envir, savedEnvir;
        var <editable;

          *initClass{
                allDocuments = [];
          }

        *startup {
                var num, doc;
                num = this.numberOfOpen;
                num.do { | i |
                        doc = this.newFromIndex(i);
                };
                postColor = Color.black;
                themes = (
                        default: (
                                classColor: Color(0, 0, 0.75, 1),
                                textColor: Color(0, 0, 0, 1),
                                stringColor: Color(0.375, 0.375, 0.375, 1),
                                commentColor: Color(0.75, 0, 0, 1),
                                symbolColor: Color(0, 0.45, 0, 1),
                                numberColor: Color(0, 0, 0, 1),
                                specialValsColor: Color(0.2, 0.2, 0.75, 1), // true false nil inf
                                specialVarsColor: Color(0.4, 0.4, 0.75, 1), // super, thisProcess
                                declColor: Color(0, 0, 1, 1), // var, const, args
                                puncColor: Color(0, 0, 0, 1),
                                environColor: Color(1.0, 0.4, 0, 1)
                                )
                        );
                theme = themes.default;
        }

        *open { | path, selectionStart=0, selectionLength=0, envir |
                var doc, env;
                env = currentEnvironment;
                if(this.current.notNil) { this.current.restoreCurrentEnvironment };
                doc = Document.implementationClass.prBasicNew.initFromPath(path, selectionStart, selectionLength);
                if (doc.notNil) {
                        doc.envir_(envir)
                } {
                        currentEnvironment = env
                };
                ^doc
        }

        *new { | title="Untitled", string="", makeListener=false, envir |
                var doc, env;
                env = currentEnvironment;
                if(this.current.notNil) { this.current.restoreCurrentEnvironment };
                doc = Document.implementationClass.new(title, string, makeListener);
                if (doc.notNil) {
                        doc.envir_(envir)
                } {
                        currentEnvironment = env
                };
                ^doc
        }

        *dir_ { | path |
                path = path.standardizePath;
                if(path == "") { dir = path } {
                        if(pathMatch(path).isEmpty) { ("there is no such path:" + path).postln } {
                                dir = path ++ "/"
                        }
                }
        }

        *wikiDir_ { | path |
                path = path.standardizePath;
                if(path == "") {wikiDir = path } {
                        if(pathMatch(path).isEmpty) { ("there is no such path:" + path).postln } {
                                wikiDir = path ++ "/"
                        }
                }
        }

        *standardizePath { | p |
                var pathName;
                pathName = PathName(p.standardizePath);
                ^if(pathName.isRelativePath) {
                        dir  ++ pathName.fullPath
                } {
                        pathName.fullPath
                }
        }
        *abrevPath { | path |
                if(path.size < dir.size) { ^path };
                if(path.copyRange(0,dir.size - 1) == dir) {
                        ^path.copyRange(dir.size, path.size - 1)
                };
                ^path
        }

        *openDocuments {
                ^allDocuments
        }

        *hasEditedDocuments {
                allDocuments.do { | doc, i |
                        if(doc.isEdited) {
                                ^true;
                        }
                }
                ^false
        }

        *closeAll { | leavePostWindowOpen = true |
                allDocuments.do { | doc, i |
                        if(leavePostWindowOpen.not) {
                                doc.close;
                        } {
                                if(doc.isListener.not) {
                                        doc.close;
                                }
                        }
                }
        }

        *closeAllUnedited { | leavePostWindowOpen = true |
                var listenerWindow;
                allDocuments.do({ | doc, i |
                        if(doc.isListener,{
                                listenerWindow = doc;
                        },{
                                if(doc.isEdited.not, {
                                        doc.close;
                                        });
                        })
                });
                if(leavePostWindowOpen.not, {
                        listenerWindow.close;
                })
        }

        *current {
                if ( thisProcess.platform.hasFeature( \emacs ), {
                        ^this.implementationClass.current;
                });
                ^current;
        }

        *listener {
                ^allDocuments[this.implementationClass.prGetIndexOfListener];
        }
        isListener {
                ^allDocuments.indexOf(this) == this.class.prGetIndexOfListener
        }

// document setup

        path {
                ^this.prGetFileName
        }
        path_ { |apath|
                this.prSetFileName(apath);
        }
        dir { var path = this.path; ^path !? { path.dirname } }
        name {
                ^this.title
        }

        name_ { |aname|
                this.title_(aname)
        }

        title {
                ^this.prGetTitle
        }

        title_ { | argName |
                this.prSetTitle(argName);
        }

        background_ { | color |
                this.prSetBackgroundColor(color);
        }
        background {
                var color;
                color = Color.new;
                this.prGetBackgroundColor(color);
                ^color;
        }

        selectedBackground_ { | color |
                this.prSetSelectedBackgroundColor(color);
        }

        selectedBackground {
                var color;
                color = Color.new;
                this.prGetSelectedBackgroundColor(color);
                ^color;
        }

        *postColor_ { | col |
                postColor = col;
                ^Document.implementationClass.postColor_(col);
        }

        stringColor_ { | color, rangeStart = -1, rangeSize = 0 |
                stringColor = color;
                this.setTextColor(color,rangeStart, rangeSize);
        }
        bounds {
                ^this.prGetBounds(Rect.new);
        }
        bounds_ { | argBounds |
                ^this.prSetBounds(argBounds);
        }

// interaction:

        close {
                this.prclose
        }

        front {
                ^this.subclassResponsibility(thisMethod)
        }

        unfocusedFront {
                ^this.subclassResponsibility(thisMethod)
        }

        alwaysOnTop_ { |boolean=true|
                ^this.subclassResponsibility(thisMethod)
        }

        alwaysOnTop {
                ^this.subclassResponsibility(thisMethod)
        }

        syntaxColorize {
                ^this.subclassResponsibility(thisMethod)
        }

        selectLine { | line |
                this.prSelectLine(line);
        }

        selectRange { | start=0, length=0 |
                ^this.subclassResponsibility(thisMethod)
        }

        editable_ { | abool=true |
                editable = abool;
                this.prIsEditable_(abool);
        }
        removeUndo {
                ^this.subclassResponsibility(thisMethod)
        }

        promptToSave_ { | bool |
                ^this.subclassResponsibility(thisMethod)
        }

        promptToSave {
                ^this.subclassResponsibility(thisMethod)
        }

        underlineSelection {
                ^this.subclassResponsibility(thisMethod)
        }

        *setTheme { | themeName |
                theme = themes[themeName];
                thisProcess.platform.writeClientCSS;
                Document.implementationClass.prSetSyntaxColorTheme(
                        theme.textColor,
                        theme.classColor,
                        theme.stringColor,
                        theme.symbolColor,
                        theme.commentColor,
                        theme.numberColor,
                        theme.specialValsColor,
                        theme.specialVarsColor,
                        theme.declColor,
                        theme.puncColor,
                        theme.environColor
                );
        }

// state info
        isEdited {
                ^this.subclassResponsibility(thisMethod)
        }
        isFront {
                ^Document.current === this
        }

        selectionStart {
                ^this.selectedRangeLocation
        }

        selectionSize {
                ^this.selectedRangeSize
        }

        string { | rangestart, rangesize = 1 |
                if(rangestart.isNil,{
                ^this.text;
                });
                ^this.rangeText(rangestart, rangesize);
        }

        string_ { | string, rangestart = -1, rangesize = 1 |
                this.insertTextRange(string, rangestart, rangesize);
        }
        selectedString {
                ^this.selectedText
        }


        font_ { | font, rangestart = -1, rangesize=0 |
                this.setFont(font, rangestart, rangesize)
        }

        selectedString_ { | txt |
                this.prinsertText(txt)
        }

        currentLine {
                ^this.getSelectedLines(this.selectionStart, 0);
        }

        getSelectedLines { | rangestart = -1, rangesize = 0 |
                var start, end, str, max;
                str = this.string;
                max = str.size;
                start = rangestart;
                end = start + rangesize;
                while {
                        str[start] !== Char.nl and: { start >= 0 }
                } { start = start - 1 };
                while {
                        str[end] !== Char.nl and: { end < max }
                } { end = end + 1 };
                ^str.copyRange(start + 1, end);
        }

//actions:

        didBecomeKey {
                this.class.current = this;
                this.saveCurrentEnvironment;
                toFrontAction.value(this);
        }

        didResignKey {
                endFrontAction.value(this);
                this.restoreCurrentEnvironment;
        }

        makeWikiPage { | wikiWord, extension=(".rtf"), directory |
                var filename, file, doc, string, dirName;
                directory = directory ? wikiDir;
                filename = directory ++ wikiWord ++ extension;
                file = File(filename, "w");
                if (file.isOpen) {
                        string = "{\\rtf1\\mac\\ansicpg10000\\cocoartf102\\n{\\fonttbl}\n"
                                "{\\colortbl;\\red255\\green255\\blue255;}\n"
                                "Write about " ++ wikiWord ++ " here.\n}";
                        file.write(string);
                        file.close;

                        doc = this.class.open(filename);
                        doc.path = filename;
                        doc.selectRange(0,0x7FFFFFFF);
                        doc.onClose = {
                                if(doc.string == ("Write about " ++ wikiWord ++ " here.")) {
                                        unixCmd("rm" + filename)
                                };
                        };
                } {
                        // in a second try, check if a path must be created.
                        // user makes double click on string.
                        dirName = wikiWord.dirname;
                        if(dirName != ".") {
                                dirName = directory ++ dirName;
                                "created directory: % \n".postf(dirName);
                                dirName.mkdir;
                        };
                }
        }

        openWikiPage {
                var selectedText, filename, index, directory;
                var extensions = #[".rtf", ".sc", ".scd", ".txt", "", ".rtfd", ".html"];
                selectedText = this.selectedText;
                index = this.selectionStart;

                this.selectRange(index, 0);

                // refer to local link with round parens
                if(selectedText.first == $( /*)*/ and: {/*(*/ selectedText.last == $) }) {
                                selectedText = selectedText[1 .. selectedText.size-2];
                                directory = Document.current.path.dirname ++ "/";
                } {
                                directory = wikiDir;
                };

                case { selectedText[0] == $* }
                {
                        // execute file
                        selectedText = selectedText.drop(1);
                        extensions.do { |ext|
                                filename = directory ++ selectedText ++ ext;
                                if (File.exists(filename)) {
                                        // open existing wiki page
                                        filename.load;
                                        ^this
                                }
                                {
                                filename = "Help/help-scripts/" ++ selectedText ++ ext;
                                if (File.exists(filename)) {
                                        // open help-script document
                                        filename.load;
                                        ^this
                                }
                                }
                        };
                }
                { selectedText.first == $[ and: { selectedText.last == $] }}
                {
                        // open help file
                        selectedText[1 .. selectedText.size-2].openHelpFile
                }
                { selectedText.containsStringAt(0, "http://")
                        or: { selectedText.containsStringAt(0, "file://") } }
                {
                        // open URL
                        openOS(selectedText)
                }
                { selectedText.containsStringAt(selectedText.size-1, "/") }
                {
                        Document(selectedText,
                                pathMatch(directory ++ selectedText).collect({ |it|it.basename ++ "\n"}).join
                        )
                }

                {
                        if(index + selectedText.size > this.text.size) { ^this };
                        extensions.do { |ext|
                                filename = directory ++ selectedText ++ ext;
                                if (File.exists(filename)) {
                                        // open existing wiki page
                                        this.class.open(filename);
                                        ^this
                                }
                        };
                        // make a new wiki page
                        this.makeWikiPage(selectedText, nil, directory);
                };
        }

        mouseUp{ | x, y, modifiers, buttonNumber, clickCount, clickPos |
                mouseUpAction.value(this, x, y, modifiers, buttonNumber, clickCount);           if (wikiBrowse and: { this.linkAtClickPos(clickPos).not }
                        and: { this.selectUnderlinedText(clickPos) } ) {
                        ^this.openWikiPage
                };
        }

        keyDown { | character, modifiers, unicode, keycode |
                this.class.globalKeyDownAction.value(this,character, modifiers, unicode, keycode);
                keyDownAction.value(this,character, modifiers, unicode, keycode);
        }

        keyUp { | character, modifiers, unicode, keycode |
                this.class.globalKeyUpAction.value(this,character, modifiers, unicode, keycode);
                keyUpAction.value(this,character, modifiers, unicode, keycode);
        }

        == { | doc |
                ^if(this.path.isNil or: { doc.path.isNil }) { doc === this } {
                        this.path == doc.path
                }
        }

        hash {
                ^(this.path ? this).hash
        }

        *defaultUsesAutoInOutdent_ {|bool|
                Document.implementationClass.prDefaultUsesAutoInOutdent_(bool)
        }

        usesAutoInOutdent_ {|bool|
                this.prUsesAutoInOutdent_(bool)
        }

        *prDefaultUsesAutoInOutdent_{|bool|
                this.subclassResponsibility(thisMethod);
        }

        prUsesAutoInOutdent_{|bool|
                ^this.subclassResponsibility(thisMethod);
        }


// private implementation

        prIsEditable_{ | editable=true |
                ^this.subclassResponsibility(thisMethod)
        }
        prSetTitle { | argName |
                ^this.subclassResponsibility(thisMethod)
        }
        prGetTitle {
                ^this.subclassResponsibility(thisMethod)
        }
        prGetFileName {
                ^this.subclassResponsibility(thisMethod)
        }
        prSetFileName { | apath |
                ^this.subclassResponsibility(thisMethod)
        }
        prGetBounds { | argBounds |
                ^this.subclassResponsibility(thisMethod)
        }

        prSetBounds { | argBounds |
                ^this.subclassResponsibility(thisMethod)
        }

        *prSetSyntaxColorTheme{ |textC, classC, stringC, symbolC, commentC, numberC, specialValsC, specialVarsC, declC, puncC, environC|
                ^this.subclassResponsibility(thisMethod);
        }

        // if range is -1 apply to whole doc
        setFont { | font, rangeStart= -1, rangeSize=100 |
                ^this.subclassResponsibility(thisMethod)
        }

        setTextColor { | color,  rangeStart = -1, rangeSize = 0 |
                ^this.subclassResponsibility(thisMethod)
        }

        text {
                ^this.subclassResponsibility(thisMethod)
        }
        selectedText {
                ^this.subclassResponsibility(thisMethod)
        }
        selectUnderlinedText { | clickPos |
                ^this.subclassResponsibility(thisMethod)
        }

        linkAtClickPos { | clickPos |
                ^this.subclassResponsibility(thisMethod)
        }

        rangeText { | rangestart=0, rangesize=1 |
                ^this.subclassResponsibility(thisMethod)
        }

        prclose {
                ^this.subclassResponsibility(thisMethod)
        }

        closed {
                onClose.value(this); // call user function
                this.restoreCurrentEnvironment;
                allDocuments.remove(this);
                dataptr = nil;
        }

        prinsertText { | dataPtr, txt |
                ^this.subclassResponsibility(thisMethod)
        }
        insertTextRange { | string, rangestart, rangesize |
                ^this.subclassResponsibility(thisMethod)
        }

        prAdd {
                allDocuments = allDocuments.add(this);
                this.editable = true;
                if (autoRun) {
                        if (this.rangeText(0,7) == "/*RUN*/")
                        {
                                this.text.interpret;
                        }
                };
                current = this;
                initAction.value(this);

        }

        //this is called after recompiling the lib
        *prnumberOfOpen {
                ^this.subclassResponsibility(thisMethod)
        }
        *numberOfOpen {
                thisProcess.platform.when(\_NumberOfOpenTextWindows) {
                        ^this.prnumberOfOpen
                } { ^allDocuments.size };
                ^0
        }

        *newFromIndex { | idx |
                ^super.new.initByIndex(idx)
        }
        initByIndex { | idx |
                //allDocuments = allDocuments.add(this);
                var doc;
                doc = this.prinitByIndex(idx);
                if(doc.isNil,{^nil});
                this.prAdd;
        }
        prinitByIndex { | idx |
                ^this.subclassResponsibility(thisMethod)
        }

        //this is called from the menu: open, new
        *prGetLast {
                ^Document.implementationClass.prBasicNew.initLast
        }

        initLast {
                ^this.subclassResponsibility(thisMethod)
        }

        prGetLastIndex {
                ^this.subclassResponsibility(thisMethod)
        }

        // private open
        initFromPath { | path, selectionStart, selectionLength |
                var stpath;
        //      path = apath;
                stpath = this.class.standardizePath(path);
                this.propen(stpath, selectionStart, selectionLength);
                if(dataptr.isNil,{
                        this.class.allDocuments.do{ |d|
                                        if(d.path == stpath.absolutePath){
                                                ^d
                                        }
                                };
                        ^nil
                });
                this.background_(Color.white);
                ^this.prAdd;
        }
        propen { | path, selectionStart=0, selectionLength=0 |
                ^this.subclassResponsibility(thisMethod)
        }

        // private newTextWindow
        initByString{ | argTitle, str, makeListener |

                this.prinitByString(argTitle, str, makeListener);
                this.background_(Color.white);
                if(dataptr.isNil,{^nil});
                this.prAdd;
                this.title = argTitle;

        }
        prinitByString { | title, str, makeListener |
                ^this.subclassResponsibility(thisMethod)
        }

        // other private
        // if -1 whole doc

        prSetBackgroundColor { | color |
                ^this.subclassResponsibility(thisMethod)
        }
        prGetBackgroundColor { | color |
                ^this.subclassResponsibility(thisMethod)
        }
        prSetSelectedBackgroundColor { | color |
                ^this.subclassResponsibility(thisMethod);
        }
        prGetSelectedBackgroundColor { | color |
                ^this.subclassResponsibility(thisMethod);
        }
        selectedRangeLocation {
                ^this.subclassResponsibility(thisMethod)
        }
        selectedRangeSize {
                ^this.subclassResponsibility(thisMethod)
        }

        prSelectLine { | line |
                ^this.subclassResponsibility(thisMethod)
        }

        *prGetIndexOfListener {
                ^this.subclassResponsibility(thisMethod)
        }


        //---not yet implemented
        // ~/Documents
        // /Volumes
        // Music/Patches

        //*reviewUnsavedDocumentsWithAlertTitle
        //*saveAllDocuments
        //*recentDocumentPaths
        //save
        //saveAs
        //print
        //
        //hasPath  was loaded


// Environment handling  Document with its own envir must set and restore currentEnvironment on entry and exit.
// Requires alteration of *open, *new, closed, didBecomeKey, and didResignKey

        envir_ { | ev |
                envir = ev;
                if (this.class.current == this) {
                        if (savedEnvir.isNil) {
                                this.saveCurrentEnvironment
                        }
                }
        }

        restoreCurrentEnvironment {
                if (envir.notNil) { currentEnvironment = savedEnvir };
        }

        saveCurrentEnvironment {
                if (envir.notNil) {
                        savedEnvir = currentEnvironment;
                        currentEnvironment = envir;
                }
        }

        *prBasicNew {
                ^super.new
        }

}