root/trunk/src/leds/Leds.d

/*
 * This file is part of leds.
 * 
 * leds is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * leds is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with leds; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


module leds.Leds;

//debug=startup;

version(linux) private import std.c.linux.linux;

private import leds.Workspace;
private import leds.Language;
private import leds.Trash;
private import property.Props;
private import property.Properties;
private import property.PropertiesUI;
//private import ext.dconf.DConf;

private import std.stdio;
    
private import std.c.time;
//private import leds.trash;
    
private import dool.String;
private import dool.io.Path;
private import dool.io.FileException;

private import gtk.Main;

private import gthread.Thread;

public:
const int VERSION_MAJOR = 0;
const int VERSION_MINOR = 9;
const int VERSION_MICRO = 79;
const char[] VERSION_QUAL = "beta";

private:
extern(C)
{
     char* getenv(char*);
};

public:

const char [] leadsHeaderMessage = 
"#"
"\n# leds preferences file"
"\n#"
"\n"
"\n#"
"\n# This file was generated automatically by leds"
"\n# editing this file is not recomended"
"\n#"
"\n"
"\n"
;

static const char [] ledsAboutMessage = 
"leds\n"
"Light Editor for D w/ Scintilla\n"
" \n"
"build with gtkD\n"
" \n"
"by Antonio Monteiro\n"
;

static const char[] defaultShortcus = 
"if if ( $cursor )\\n{\\n\\n}\\n"
"\nife if ( $cursor )\\n{\\n\\n}\\nelse\\n{\\n}\\n"
"\nfor for ( $cursor;  ;i++)\\n{\\n}\\n"
"\nfori for ( ini i=0; i < $cursor ;i++)\\n{\\n}\\n"
"\nsw switch ( $cursor )\\n{\\ncase :\\n\\tbreak;\\n\\ndefault:\\n\\tbreak;\\n}\\n"
"\nwh while ( $cursor )\\n{\\n}\\n"
"\ndo do\\n{\\n\\n$cursor\\n} while ( );\\n"
"\ntry try\\n{\\n\\n$cursor\\n}\\n catch (  )\\n{\\n}\\n"
"\nca catch (  )\\n{\\n}\\n"
;
static const char[] dShortcus = 
"fore foreach( $cursor ; )\\n{\\n}\\n"
"\nmain int main(char[][] args)\\n{\\n$cursor\\n\\nreturn 0;\\n}\\n"
;
static const char[] javaShortcus = 
"main public static void main(String[] args)\\n{\\n}\\n"
;

private import leds.KeyMap;

/**
 * leds
 */
public:
class Leds : PropertiesUICaller
{   
    private:

    Properties props;

    /**
     * all the workspaces. For now only one is supported.
     */
    Workspace[] workspaces;

    int exitCode = 0;
    /** if we are about to exit this will be set to true */
    bit closing = false;

    /**
     * When true leds won't open projects at startup
     * setup by command line "-nop"
     */
    bit noProjects = false;
    //DConf dConf;
    
    String ledsHome;// = "~/.leds";
    String ledsData;// = "~/.leds_data";
    
    public String editorType;
    
    String projectsDir;
    String projectExtension;

    static Leds thisLeds;
    
    /** A global to hold the last find string */
    String previousFindString;

    /** if we are working without home directory this will be false */
    bit homeExists;
    
    Trash trash;
    
    alias String[String] Shortcuts;
    Shortcuts[String] contextShortcuts;
    
    /**
     * get a common instance of Leds.
     * A new Leds will be created if none exists
     */
    static public Leds leds()
    {
        if ( thisLeds is null )
        {
            char[][] args;
            thisLeds = new Leds();
            thisLeds.init(args);
        }
        return thisLeds;
    }
    
    /**
     * get a common instance of Leds.
     * A new Leds will be created if none exists
     */
    static public Leds leds(char[][]args)
    {
        if ( thisLeds is null )
        {
            thisLeds = new Leds();
            thisLeds.init(args);
        }
        return thisLeds;
    }

    /**
     * Don't allow external instanciations
     */
    private: this()
    {
        previousFindString = new String();
        projectsDir = new String("projects");
        projectExtension = new String("lpj");
        ledsHome = new String();
        ledsData = new String();
        editorType = new String("scintilla");
    }
    
    //extern(C) static void t(Leds leds)
    //{
    //  int count = 0;
    //  while(true)
    //  {
    //      printf("ThreadG %.*s %d\n",leds.getHomeDir(), count++);
    //      sleep(1);
    //  }
    //}
        

    /**
     * setup Leds.
     * - determone the home directories
     * - creates a workspace
     */
    private: void init(char[][]args)
    {
        debug(startup) printf("Leds.init 1\n");
        ledsHome = Path.join(getAppData(),".leds3");
        ledsData = Path.join(getAppData(),".leds3_data");

        assert(ledsHome !is null);
        assert(ledsData !is null);
        
        //dConf = new DConf();
        //ThreadG tg = new ThreadG((void*)&t, (void*)this, 0, true, true, ThreadPriority.NORMAL, error);

        //printf("Plugin error before new Plugin %.*s\n",Plugin.error());
        //Plugin plugin = new Plugin("../Plug.o",PluginFlags.BIND_LAZY);
        //printf("Plugin error after new Plugin %.*s\n",Plugin.error());
        
        String[] filesToOpen;
        bit exitNow = parseArgs(args, filesToOpen);

        debug(startup) printf("Leds.init 2\n");
        if ( exitNow )
        {
            closing = true;
        }
        else
        {
            debug(startup) printf("Leds.init 3\n");
            homeExists = confirmHomeExists();
            ledsHome.println("Using home = ");
            ledsData.println("Using data = ");
            if ( !homeExists )
            {
                printf("No home or data directory exist!\nprojects cannot be created or saved!\n\n");
            }

            debug(startup) printf("Leds.init 4\n");
            setProps();
            debug(startup) printf("Leds.init 5\n");
            setKeys();
            debug(startup) printf("Leds.init 6\n");
            setShortcuts();
            debug(startup) printf("Leds.init 7\n");
    
            Workspace workspace = new Workspace("main", this, !noProjects);
            debug(startup) printf("Leds.init 8\n");
            workspaces ~= workspace;
            workspace.showAll();
            debug(startup) printf("Leds.init 9\n");
            if ( filesToOpen is null || filesToOpen.length == 0 )
            {
                debug(startup) printf("Leds.init 10\n");
                workspace.openSavedState();
                debug(startup) printf("Leds.init 10a\n");
            }
            else
            {
                debug(startup) printf("Leds.init 11\n");
                workspace.openFiles(filesToOpen);
            }
            debug(startup) printf("Leds.init 12\n");
            workspace.setBGColor();
            workspace.setFont();
            debug(startup) printf("Leds.init 13\n");
        }
    }
    
    /**
     * \support multiple workspaces
     */
    public Workspace getWorkspace()
    {
        return workspaces[0];
    }
    
    private bit confirmHomeExists()
    {
        bit homeOK = true;
        bit homeNotDir = false;
        bit dataNotDir = false;
        try
        {
            if ( !Path.exists(ledsHome) )
            {
                Path.mkdirs(ledsHome);
            }
            if ( !Path.isDir(ledsHome) )
            {
                homeNotDir = true;
            }
        }
        catch ( FileException fe)
        {
            try
            {
                Path.mkdir(ledsHome);
            }
            catch ( FileException mkdirHomeFE )
            {
                homeOK = false;
            }
        }
        try
        {
            if ( !Path.exists(ledsData) )
            {
                Path.mkdirs(ledsData);
                Path.mkdir(Path.join(ledsData,"projects"));
            }
            if ( !Path.isDir(ledsData) )
            {
                dataNotDir = true;
            }
        }
        catch ( FileException fe)
        {
            try
            {
                Path.mkdir(ledsData);
                Path.mkdir(Path.join(ledsData,"projects"));
            }
            catch ( FileException mkdirHomeFE )
            {
                homeOK = false;
            }
        }
        return homeOK;
    }
    
    public:
    
    /**
     * loops through the args to process each one.
     * @param args the args
     * @param filesToOpen the files to open from the command line
     * @return true if we should exit the program
     */
    bit parseArgs(char[][] args, inout String[] filesToOpen)
    {
        int i = 1;
        while ( i>0 && i < args.length )
        {
            char [] arg = args[i];
            printf("args[%d] = '%.*s'\n", i, arg);
            if ( arg[0] == '-' )
            {
                i = processOption(i,args);
            }
            else
            {
                filesToOpen ~= new String(arg);
                ++i;
            }
        }
        
        return i<0;
    }

    /**
     * processes one option and returns the next offset value.
     * @return the next offset value or -1 if the program should exit
     */
    int processOption(int offset, char[][] args)
    {
        switch(args[offset])
        {
            case "-home", "--home":
                ledsHome = new String(args[++offset]);
                break;
                
            case "-data", "--data":
                ledsData = new String(args[++offset]);
                break;

            case "-nop", "--nop":
                noProjects = true;
                break;
                
            case "-h", "--help":
                printf((getAppName().toString() ~ "\n\0").ptr);
                printf( "usage: leds [options] files -GTK[GTK options]\n\n"
                        "options:\n"
                        "  -h, --help     print this help and exit\n"
                        "  -v, --version  print leds version and exit\n"
                        " --home          specify leds home directory [default ~/.leds]\n"
                        " --data          specify leds data directory [default ~/.leds_data]\n"
                        " --editor        the editor to use\n"
                        "                 'textView' the internal code editor (obsolete)\n"
                        "                 'sv' the new GtkSourceView (incomplete)\n"
                        "                 'sc' the Scintilla editor (default)\n"
                        " --nop           do not open projects\n"
                        "\n"
                        "files            files to open\n"
                        "-GTK             subsequente areguments will not be process by leds\n"
                        "                 but will be passed to GTK\n"
                        );
                offset = -2;
                break;
                
            case "-v", "--version":
                printf((getAppName().toString() ~ "\n\0").ptr);
                offset = -2;
                break;
            
            case "--editor":
                editorType = new String(args[++offset]);
                break;
            
            case "-sv":
                editorType = new String("sv");
                break;
            
            default:
                printf("Unknown option %.*s ignored\n",args[offset]);
                break;
        }
        ++offset;
        return offset;
    }

    String getPreviousFindString()
    {
        return previousFindString;
    }

    void setPreviousFindString(String previousFindString)
    {
        this.previousFindString.set(previousFindString);
    }

    /**
     * saves the preferences and exits
     * @param code the code that generated this exit request
     * @param force if true the program will exit anyway
     * @return true it the exit should proced false if the application should not exit
     */
    public bit exit(int code, bit force)
    {
    
        exitCode = code;
        closing = true;

        saveProps();
        
        return true;
    }

    public String getHomeDir()
    {
        return ledsHome;
    }
    
    public String getDataDir()
    {
        return ledsData;
    }

    public String getUser()
    {
        return String.newz(getenv("USER\0"));
    }

    public String getAppData()
    {
        version(Win32)
        {
            return String.newz(getenv("APPDATA\0"));
        }
        else
        {
            return String.newz(getenv("HOME\0"));
        }
    }

    public String getUserHome()
    {
        version(Win32)
        {
            return String.newz(getenv("HOMEPATH\0"));
        }
        else
        {
            return String.newz(getenv("HOME\0"));
        }
    }

    public String getProjectsDir()
    {
        return Path.join(getDataDir(),projectsDir);
    }

    public String getProjectExtension()
    {
        return projectExtension;
    }
    
    public String getProjectFileName(String name)
    {
        String filename = Path.join(getProjectsDir(),name);
        return Path.addExt(filename,projectExtension);
    }

    public Trash getTrash()
    {
        if ( trash is null )
        {
            trash = new Trash(Path.join(getHomeDir(),"trash.zip"),
                                        getPropValue("trashSize",1000000));
        }
        return trash;
    }
    void setProps()
    {
        props = new Properties();
        

        props.add(PropsTypes.TEXT, "outputScroll", "yes", "Ouput scroll on write","run","Workspace.");
        props.add(PropsTypes.TEXT, "execCommand", "", "Set 'Execute' command","build","Workspace.");
        props.add(PropsTypes.TEXT, "stopCommand", "", "Set 'stop' command","","Workspace.");
        props.add(PropsTypes.YES_NO, "saveOnExit", "yes", "Save on exit","","Workspace.");
        props.add(PropsTypes.YES_NO, "showProjectView", "yes", "Show project view","","Workspace.");
        props.add(PropsTypes.YES_NO, "showCodeBrowser", "yes", "Show code browser","","Workspace.");
        props.add(PropsTypes.YES_NO, "showWideTreeTooltip", "no", "Show wide tree tooltip","","Workspace.");
        props.add(PropsTypes.YES_NO, "showfileBrowser", "yes", "Show file browser","","Workspace.");
        props.add(PropsTypes.YES_NO, "closeButtonOnTabs", "yes", "Close on tabs","","Workspace.");
        props.add(PropsTypes.YES_NO, "wideConsole", "no", "Wide console","","Workspace.layout.");
        props.add(PropsTypes.FONT,   "fontBrowsers", "", "Browers Font","","Workspace.Fonts.");
        props.add(PropsTypes.INT,    "fontSizeBrowsers", "", "Browers Font size","","Workspace.Fonts.");
        props.add(PropsTypes.FONT,   "fontConsoles", "", "Consoles Font","","Workspace.Fonts.");
        props.add(PropsTypes.INT,    "fontSizeConsoles", "", "Consoles Font size","","Workspace.Fonts.");

        props.add(PropsTypes.YES_NO, "showHidden", "no", "Show hidden files","","Projects.");
        props.add(PropsTypes.YES_NO, "popupBuildOutput", "yes", "Show Build Window","","Projects.");
        props.add(PropsTypes.YES_NO, "backgroundBuild", "yes", "Allow background build","","Projects.");
        props.add(PropsTypes.YES_NO, "hierarquicalView", "no", "Hierarquical view","","Projects.");

        props.add(PropsTypes.YES_NO, "scrollOnWrite", "yes", "Scroll on write","","Console.");
        props.add(PropsTypes.YES_NO, "newOnRun", "yes", "Open new for every run","","Console.");

        props.add(PropsTypes.INT,    "tabWidth", "4", "Tab width","","Editor.");
        props.add(PropsTypes.YES_NO, "useTabs", "yes", "Use Tabs","","Editor.");
        
        props.add(PropsTypes.YES_NO, "lineNumbers", "no", "Show line numbers","","Editor.");
        props.add(PropsTypes.YES_NO, "codeFolding", "no", "Code folding","","Editor.");
        props.add(PropsTypes.YES_NO, "fastSearch", "yes", "Fast search","","Editor.");
        props.add(PropsTypes.LIST,   "codePage", "*Default*:*Default*:UTF-8:DBCS", "codePage","","Editor.");
        props.add(PropsTypes.FONT,   "font", "", "Font","","Editor.");
        props.add(PropsTypes.INT,    "fontSize", "", "Font size","","Editor.");
        props.add(PropsTypes.YES_NO, "antiAliasing", "no", "Anti-Aliasing","","Editor.");
        props.add(PropsTypes.YES_NO, "autoIndent", "yes", "Auto-Indent","","Editor.");
        props.add(PropsTypes.YES_NO, "smartSemiColon", "yes", "Smart Semicolon","","Editor.");
        props.add(PropsTypes.YES_NO, "smartCurlyBrace", "yes", "Smart Curly Brace","","Editor.");

        props.add(PropsTypes.YES_NO, "autoHelp", "no", "show Definition when clicking in editor","","Editor.");
        props.add(PropsTypes.YES_NO, "autoComplete", "no", "Auto complete when typing","","Editor.");

        // configurable keys
        
        String l = new String("leds");
        KeyMap.addKeyMap(l, props);
        KeyMap.setCurrKeyMap(l);
        
        // configurable colors
        props.add(PropsTypes.COLOR, "color.keyWord", "", "Keyword","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.Comment", "", "Comment","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.CommentLine", "", "Comment line","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.CommentDoc", "", "Comment doc","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.string", "", "String","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.stringEOL", "", "String EOL","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.char", "", "Character","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.number", "", "Number","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.braceMath", "", "Brace match","","Editor.Colors.");
        props.add(PropsTypes.COLOR, "color.braceUnmatched", "", "Brace unmatched","","Editor.Colors.");

        // format code
        props.add(PropsTypes.YES_NO, "autoDocComments", "yes", "Doc Comments","","Editor.Format.");
        props.add(PropsTypes.YES_NO, "emptyDocComments", "no", "Empty Doc Comments","","Editor.Format.");
        props.add(PropsTypes.YES_NO, "ddocComments", "no", "Ddoc Comment style","","Editor.Format.");
        props.add(PropsTypes.INT, "docCommentsLineLength", "80", "Doc Comments max line length","","Editor.Format.");

        // shortcuts
        props.add(PropsTypes.MULTY_TEXT, "shortcut", "", "shorcuts","","Editor.shortcuts.");

        //### All language specific Properties ######################################################
        Language.setPropsForAll(props);
        
        //props.add(PropsTypes.YES_NO, "duiGL", "", "use dui openGL","","");

        //### java ########################################################
        
        
        // advanced options
        
        props.add(PropsTypes.INT, "trashSize", "", "Trash size","","Advanced.");
        
        // non visible props

        props.add(PropsTypes.INT, "main.left", "0", "","",".");
        props.add(PropsTypes.INT, "main.top", "0", "","",".");
        props.add(PropsTypes.INT, "main.width", "550", "","",".");
        props.add(PropsTypes.INT, "main.height", "650", "","",".");
        props.add(PropsTypes.INT, "main.leftPos", "50", "","",".");
        props.add(PropsTypes.INT, "main.leftOpen", "yes", "","",".");
        props.add(PropsTypes.INT, "main.bottomPos", "50", "","",".");
        props.add(PropsTypes.INT, "main.bottomOpen", "yes", "","",".");
        props.add(PropsTypes.INT, "main.dummy", "50", "","",".");

        props.add(PropsTypes.MULTY_TEXT, "openedFiles", "", "","",".");
        props.add(PropsTypes.MULTY_TEXT, "recentFiles", "", "","",".");

        props.add(PropsTypes.TEXT, "key.currKeyMap", "leds", "current key map","",".");

        props.load(Path.join(getHomeDir(),"preferences.leds").toString());
        
    }

    /**
     * Sets the user configurable keys
     * \todo move this to workspace level?
     * \todo allow to configure by file type?
     */
    void setKeys()
    {
        KeyMap.currKeyMap.setKeys(props);
    }

    KeyMap getCurrKeyMap()
    {
        return KeyMap.currKeyMap;
    }
    
    /**
     * Sets the shortcuts for a specific contexts
     * @param prop the collection of shortcuts for one context
     * @return the shortcuts
     */
    Shortcuts setShortcuts(char[] prop)
    {
        return setShortcuts(new String(prop));
    }

    Shortcuts setShortcuts(String prop)
    {
        Shortcuts shortcuts;
        int pos;
        foreach(String line ; prop.splitLines() )
        {
            pos = line.find(" ");
            if ( pos > 0 && pos < (line.length-1) )
            {
                shortcuts[line[0..pos]] = line[pos+1..line.length].dup;
            }
        }

        return shortcuts;
    }

    /**
     * Set all shortcuts for all contexts
     */
    void setShortcuts()
    {
        Shortcuts[String] contextShortcuts;
        contextShortcuts[new String()] = setShortcuts(props.get("shortcut",defaultShortcus));
        contextShortcuts[new String("d")] = setShortcuts(props.get("shortcut.d",dShortcus));
        contextShortcuts[new String("java")] = setShortcuts(props.get("shortcut.java",javaShortcus));
        
        this.contextShortcuts = contextShortcuts;
    }
    
    /**
     * Gets one expanded shortcuts for one context or "" if the shortcuts is noe found
     * @param context the context (for now "", "d", "java")
     * @param shortcut the user abreviature to be expanded
     * @return the expanded shortcut or "" if not found
     */
    String getShortcut(char[] context, char[] shortcut)
    {
        return getShortcut(new String(context), new String(shortcut));
    }
    String getShortcut(String context, String shortcut)
    {
        String longcut = new String();
        if ( context in contextShortcuts )
        { 
            Shortcuts s = contextShortcuts[context];
            if ( shortcut in s )
            {
                longcut = s[shortcut];
            }
        }
        return longcut;
    }

    CodeCommand getCommandFromKey(char key)
    {
        return KeyMap.currKeyMap.getCommandFromKey(key);
    }

    void propertiesEditDone(Properties newProperties)
    {
        props = newProperties;
        saveProps();
        setKeys();
        setShortcuts();
        workspaces[0].setBGColor();
        workspaces[0].setFont();
        
    }

    Properties getProps()
    {
        if ( props is null )
        {
            setProps();
            setKeys();
            setShortcuts();
            workspaces[0].setBGColor();
        }
        return props;
    }
    
    bit propertiesValidator(Properties properties)
    {
        return true;
    }
    
    public void editPreferences()
    {
        (new PropertiesUI(this, getProps(), workspaces[0], "Preferences", true )).show();
    }
    
    String getPropValue(char[] key, char[] defaultValue)
    {
        return new String(props.get(key,defaultValue));
    }
        
    int getPropValue(char[] key, int defaultValue)
    {
        return props.get(key,defaultValue);
    }
    
    int getPropValueUInt(char[] key, uint defaultValue)
    {
        return props.get(key,defaultValue);
    }
    
    bit getPropValue(char[] key, bit defaultValue)
    {
        return props.get(key,defaultValue);
    }
        
    void setPropValue(char[] key, char[] defaultValue)
    {
        props.set(key,defaultValue);
    }
        
    void setPropValue(char[] key, int defaultValue)
    {
        props.set(key,defaultValue);
    }

    void saveProps()
    {
        props.save(Path.join(getHomeDir(),"preferences.leds").toString(),leadsHeaderMessage);
        //props.dump();
    }
        
};

private import dool.String;

String getVersionString()
{
    return new String(VERSION_MAJOR) ~ "." ~ VERSION_MINOR ~ "." ~ VERSION_MICRO ~ " " ~ VERSION_QUAL;
};

String getAppName()
{
    version(Win32)
    {
        return getVersionString().prepend("leds (Light Editor for D (Simple)), version ");
    }
    version(linux)
    {
        return getVersionString().prepend("leds (Linux Editor for D (Simple)), version ");
    }
};

private import gtkc.Loader;
private import gdk.Threads;
version(splash)
{
    private import gtk.Window;
    private import gtk.Image;
}

int main(char[][] args)
{

    Linker.dumpFailedLoads();
    
    version(Win32)
    {
        // TODO threads are still broken on windows
        Main.init(args);
    }
    else
    {
        //Main.initMultiThread(args);
        Main.init(args);
    }
    

    version(splash)
    {
        Window w = new Window(false);
        Image i = new Image("src/resources/ledsSplash.png");
        w.add(i);
        w.showAll();
    }

    debug(startup) writefln("Leds.main 1");
    Leds leds = Leds.leds(args);
    debug(startup) writefln("Leds.main 2");
    if ( !leds.closing )
    {
        debug(startup) writefln("Leds.main 3");
        version(splash) w.destroy();
        debug(startup) writefln("Leds.main 4");
        Main.run();
        //Main.mainThreads();
        debug(startup) writefln("Leds.main 5");
    }
    debug(startup) writefln("Leds.main 6");
    return leds.exitCode;
}

public static void mainThreads()
{
    gdkThreadsEnter();
    Main.run();
    gdkThreadsLeave();
}