antos-frontend/src/core/BaseDialog.coffee

# Copyright 2017-2018 Xuan Sang LE <xsang.le AT gmail DOT com>

# AnTOS Web desktop is is licensed under the GNU General Public
# License v3.0, see the LICENCE file for more information

# This program 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 3 of 
# the License, or (at your option) any later version.

# This program 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 this program. If not, see https://www.gnu.org/licenses/.
class SubWindow extends this.OS.GUI.BaseModel
    constructor: (name) ->
        super name, null
        @parent = undefined
        @modal = false
        
    quit: () ->
        evt = new Ant.OS.GUI.BaseEvent("exit")
        @onexit(evt)
        if not evt.prevent
            delete @.observable
            ($ @scheme).remove() if @scheme
            @dialog.quit() if @dialog
    init: () ->
    main: () ->
    meta: () ->
        @parent.meta()
    show: () ->
        @trigger 'focus'
        ($ @scheme).css "z-index", window._zindex + 2
    hide: () ->
        @trigger 'hide'

SubWindow.type = 3
this.OS.GUI.SubWindow = SubWindow

class BaseDialog extends SubWindow
    constructor: (name) ->
        super name
        @handle = undefined

    onexit: (e) ->
        @parent.dialog = undefined if @parent

this.OS.GUI.BaseDialog = BaseDialog
###
    this dialog rende a tag as main content
    and a list of buttons, the behaviour of
    the button is specified by user. The conf
    object is in the follow form
    {
        tag: <tag_name>,
        buttons:[
            {
                label: 'buton label',
                onclick: function(d){...}
            }, ...
        ]
    }
###
class BasicDialog extends BaseDialog
    constructor: ( name, @conf, @title) ->
        super name
    
    init: () ->
        @title = @name if not @title
        html = "<afx-app-window  data-id = '#{@name}'  width='#{@conf.width}' height='#{@conf.height}'>"
        html += "<afx-hbox><div data-width='7'></div><afx-vbox><div data-height='5'></div>"
        html += "<#{v.tag} #{v.att}  data-id = 'content#{k}'></#{v.tag}>" for k,v of @conf.tags
        html += "<div data-height = '35' style=' text-align:right;padding-top:3px;'>"
        html += "<afx-button data-id = 'bt#{k}' text = '#{v.label}' style='margin-left:5px;'></afx-button>" for k,v of @conf.buttons
        html += "</div><div data-height='5'></div></afx-vbox><div data-width='7'></div></afx-hbox></afx-app-window>"
        #render the html
        Ant.OS.GUI.htmlToScheme html, @, @host
    
    main: () ->
        @scheme.set "apptitle", @title
        @scheme.set "minimizable", false
        @scheme.set "resizable", @conf.resizable if @conf.resizable isnt undefined
        me = @
        f = (_v) -> () -> _v.onclick me
        # bind action to button
        ( (me.find "bt#{k}").set "onbtclick", f(v) ) for k, v of @conf.buttons
        @conf.filldata @ if @conf.filldata
        @conf.xtra @ if @conf.xtra

this.OS.GUI.BasicDialog = BasicDialog

class PromptDialog extends BasicDialog
    constructor: () ->
        super "PromptDialog", {
            tags: [
                { tag: "afx-label" },
                { tag: "input", att: "type = 'text' data-height='25'" }
            ],
            width: 200,
            height: 120,
            resizable: false,
            buttons: [
                {
                    label: "__(Ok)",
                    onclick: (d) ->
                        txt = (d.find "content1").value
                        return d.quit() if txt is ""
                        d.handle txt if d.handle
                        d.quit()
                },
                {
                    label: "__(Cancel)",
                    onclick: (d) -> d.quit()
                }
            ],
            filldata: (d) ->
                return unless d.data
                (d.find "content0").set "text", d.data.label
                (d.find "content1").value = d.data.value if d.data.value
                $(d.find "content1").attr("type", d.data.type) if d.data.type
            xtra: (d) ->
                $( d.find "content1" ).keyup (e) ->
                    (d.find "bt0").trigger() if e.which is 13
        }

this.OS.register "PromptDialog", PromptDialog

class CalendarDialog extends BasicDialog
    constructor: () ->
        super "CalendarDialog", {
            tags: [{ tag: 'afx-calendar-view' }],
            width: 300,
            height: 230,
            resizable: false,
            buttons: [
                {
                    label: "__(Ok)",
                    onclick: (d) ->
                        date = (d.find "content0").get "selectedDate"
                        if date
                            d.handle date if d.handle
                            d.quit()
                        else
                            d.notify __("Please select a date")
                },
                {
                    label: "__(Cancel)",
                    onclick: (d) -> d.quit()
                }
            ]
        }
this.OS.register "CalendarDialog", CalendarDialog

class ColorPickerDialog extends BasicDialog
    constructor: () ->
        super "ColorPickerDialog", {
            tags: [{ tag: 'afx-color-picker' }, {tag:'div', att: 'data-height="5"' }],
            width: 313,
            height: 250,
            resizable: false,
            buttons: [
                {
                    label: "__(Ok)",
                    onclick: (d) ->
                        c = (d.find "content0").get "selectedColor"
                        if c
                            d.handle c if d.handle
                            d.quit()
                        else
                            d.notify "Please select a color"
                },
                {
                    label: "__(Cancel)",
                    onclick: (d) -> d.quit()
                }
            ]
        }
this.OS.register "ColorPickerDialog", ColorPickerDialog

class InfoDialog extends BasicDialog
    constructor: () ->
        super "InfoDialog", {
            tags: [{ tag: 'afx-grid-view' }],
            width: 250,
            height: 300,
            resizable: true,
            buttons: [ { label: "__(Cancel)", onclick: (d) -> d.quit() } ],
            filldata: (d) ->
                return unless d.data
                rows = []
                rows.push [ { value: k }, { value: v } ] for k, v of d.data
                (d.find "content0").set "rows", rows
        }
this.OS.register "InfoDialog", InfoDialog


class YesNoDialog extends BasicDialog
    constructor: () ->
        super "YesNoDialog", {
            tags: [{ tag: "afx-label" }],
            width: 300,
            height: 100,
            resizable: true,
            buttons: [
                {
                    label: "__(Yes)", onclick: (d) ->
                        d.handle true if d.handle
                        d.quit()
                },
                {
                    label: "__(No)", onclick: (d) ->
                        d.handle false if d.handle
                        d.quit()
                }
            ],
            filldata: (d) ->
                return unless d.data
                l = d.find "content0"
                for k, v of d.data
                    l.set k, v
        }
this.OS.register "YesNoDialog", YesNoDialog

class SelectionDialog extends BasicDialog
    constructor: () ->
        super "SelectionDialog", {
            tags: [{ tag: "afx-list-view" }],
            width: 250,
            height: 300,
            resizable: false,
            buttons: [
                {
                    label: "__(Ok)", onclick: (d) ->
                        el = d.find "content0"
                        it = el.get "selected"
                        return unless it
                        d.handle it if d.handle
                        d.quit()
                },
                { label: "__(Cancel)", onclick: (d) -> d.quit() }
            ],
            filldata: (d) ->
                return unless d.data
                (d.find "content0").set "items", d.data
            xtra: (d) ->
                ( d.find "content0" ).set "onlistdbclick", (e) ->
                    (d.find "bt0").trigger()
            
        }
this.OS.register "SelectionDialog", SelectionDialog

class AboutDialog extends BaseDialog
    constructor: () ->
        super "AboutDialog"

    init: () ->
        @render "os://resources/schemes/about.html"

    main: () ->
        mt = @meta()
        @scheme.set "apptitle", __("About: {0}",mt.name)
        (@find "mylabel").set "*", {icon:mt.icon, iconclass:mt.iconclass, text:"#{mt.name}(v#{mt.version})"}
        ($ @find "mydesc").html mt.description
        # grid data for author info
        return unless mt.info
        rows = []
        rows.push [ { value: k }, { value: v } ] for k, v of mt.info
        (@find "mygrid").set "rows", rows
        
this.OS.register "AboutDialog", AboutDialog

class FileDiaLog extends BaseDialog
    constructor: () ->
        super "FileDiaLog"
    
    init: () ->
        @render "os://resources/schemes/filedialog.html"
    
    main: () ->
        fileview = @find "fileview"
        location = @find "location"
        filename = @find "filename"
        me = @
        @scheme.set "apptitle", @title
        fileview.set "fetch", (e, f) ->
            return unless e.child
            e.child.path.asFileHandle().read (d) ->
                return me.error __("Resource not found: {0}", e.child.path) if d.error
                f d.result
        setroot = (path) ->
            path.asFileHandle().read (d) ->
                if(d.error)
                    return me.error __("Resource not found: {0}", path)
                fileview.set "path", path
                fileview.set "data", d.result
        if not @data or not @data.root
            location.set "onlistselect", (e) ->
                return unless e and e.data.path
                setroot e.data.path
            location.set "items", ( i for i in @systemsetting.VFS.mountpoints when i.type isnt "app" )
            location.set "selected", 0 unless location.get "selected"
        else
            $(location).hide()
            @trigger "calibrate"
            setroot @data.root
        fileview.set "onfileselect", (f) ->
            ($ filename).val f.filename  if f.type is "file"
        (@find "bt-ok").set "onbtclick", (e) ->
            f = fileview.get "selectedFile"
            return me.notify __("Please select a file/fofler") unless f
            return me.notify __("Please select {0} only", me.data.type) if me.data and me.data.type and me.data.type isnt f.type
            if me.data and me.data.mimes
                #verify the mime
                m = false
                if f.mime
                    for v in me.data.mimes
                        if f.mime.match (new RegExp v, "g")
                            m = true
                            break
                return me.notify __("Only {0} could be selected", me.data.mimes.join(",")) unless m
            d = f.path
            d = f.path.asFileHandle().parent() if f.type is "file"
            me.handle d, ($ filename).val(), f.path, f if me.handle
            #sel = if  me.data and me.data.selection then me.data.selection else "file"
            #me.handle f, ($ filename).val() if me.handle and ((f.type is sel) or (sel is "*"))
            me.quit()

        (@find "bt-cancel").set "onbtclick", (e) ->
            me.quit()
        if @data and @data.file
            ($ filename).css("display", "block").val @data.file.basename or "Untitled"
            @trigger "resize"
        fileview.set "showhidden", @data.hidden if @data and @data.hidden

this.OS.register "FileDiaLog", FileDiaLog