var kb = UI.store

var myDocument = outline.document // is this ok?

// UI.log.warn("myDocument when it's set is "+myDocument.location);

this.menuId = 'predicateMenu1'

/* //namespace information, as a subgraph of the knowledge base, is built in showMenu

// hq, print and trim functions

var qp = function qp (str) {

console.log(str + '\n')

}

// var tabont = UI.ns.tabont;

// var foaf = UI.ns.foaf

const rdf = UI.ns.rdf

// var RDFS = UI.ns.rdfs

// var OWL = UI.ns.owl

// var dc = UI.ns.dc

// var rss = UI.ns.rss

// var contact = UI.ns.contact

// var mo = UI.ns.mo

var bibo = UI.rdf.Namespace('http://purl.org/ontology/bibo/') // hql for pubsPane

// var dcterms = UI.rdf.Namespace('http://purl.org/dc/terms/')

var dcelems = UI.rdf.Namespace('http://purl.org/dc/elements/1.1/')

var movedArrow = false // hq

// var updateService=new updateCenter(kb);

if (!UserInputFormula) {

UserInputFormula = new UI.rdf.Formula()

UserInputFormula.superFormula = kb

// UserInputFormula.registerFormula("Your Work");

}

if (!TempFormula) TempFormula = new UI.rdf.IndexedFormula()

// Use RDFIndexedFormula so add returns the statement

TempFormula.name = 'TempFormula'

if (!UI.store.updater) UI.store.updater = new UI.rdf.UpdateManager(kb)

return {

// updateService: updateService,

sparqler: UI.store.updater,

lastModified: null, // the last <input> being modified, .isNew indicates whether it's a new input

lastModifiedStat: null, // the last statement being modified

statIsInverse: false, // whether the statement is an inverse

// Called when the blue cross under the default pane is clicked.

// Add a new row to a property list ( P and O)

addNewPredicateObject: function addNewPredicateObject (e) {

if (UI.utils.getTarget(e).className !== 'bottom-border-active') return

var This = outline.UserInput

var target = UI.utils.getTarget(e)

// UI.log.warn(ancestor(target,'TABLE').textContent);

var insertTr = myDocument.createElement('tr')

UI.utils.ancestor(target, 'DIV').insertBefore(insertTr, UI.utils.ancestor(target, 'TR'))

var tempTr = myDocument.createElement('tr')

var reqTerm1 = This.generateRequest('(TBD)', tempTr, true)

insertTr.appendChild(tempTr.firstChild)

var reqTerm2 = This.generateRequest('(Enter text or drag an object onto this field)', tempTr, false)

insertTr.appendChild(tempTr.firstChild)

// there should be an elegant way of doing this

// Take the why of the last TR and write to it.

if (UI.utils.ancestor(target, 'TR').previousSibling && // there is a previous predicate/object line

UI.utils.ancestor(target, 'TR').previousSibling.AJAR_statement) {

let preStat = UI.utils.ancestor(target, 'TR').previousSibling.AJAR_statement

// This should always(?) input a non-inverse statement

This.formUndetStat(insertTr, preStat.subject, reqTerm1, reqTerm2, preStat.why, false)

} else { // no previous row: write to the document defining the subject

var subject = UI.utils.getAbout(kb, UI.utils.ancestor(target.parentNode.parentNode, 'TD'))

var doc = kb.sym(UI.rdf.Util.uri.docpart(subject.uri))

This.formUndetStat(insertTr, subject, reqTerm1, reqTerm2, doc, false)

}

outline.walk('moveTo', insertTr.firstChild)

UI.log.info('addNewPredicateObject: selection = ' + outline.getSelection().map(function (item) { return item.textContent }).join(', '))

this.startFillInText(outline.getSelection()[0])

},

// Called when a blue cross on a predicate is clicked

// tr.AJAR_inverse stores whether the clicked predicate is an inverse one

// tr.AJAR_statement (an incomplete statement in TempFormula) stores the destination(why), now

// determined by the preceding one (is this good?)

addNewObject: function addNewObject (e) {

var predicateTd = UI.utils.getTarget(e).parentNode.parentNode

// var predicateTerm = UI.utils.getAbout(kb, predicateTd)

var isInverse = predicateTd.parentNode.AJAR_inverse

// var titleTerm=UI.utils.getAbout(kb,UI.utils.ancestor(predicateTd.parentNode,'TD'));

// set pseudo lastModifiedStat here

this.lastModifiedStat = predicateTd.parentNode.AJAR_statement

var insertTr = this.appendToPredicate(predicateTd)

var reqTerm = this.generateRequest(' (Error) ', insertTr, false)

let preStat = insertTr.previousSibling.AJAR_statement

if (!isInverse) { this.formUndetStat(insertTr, preStat.subject, preStat.predicate, reqTerm, preStat.why, false) } else { this.formUndetStat(insertTr, reqTerm, preStat.predicate, preStat.object, preStat.why, true) }

outline.walk('moveTo', insertTr.lastChild)

this.startFillInText(insertTr.lastChild)

// this.statIsInverse=false;

},

// Called when delete is pressed

Delete: function Delete (selectedTd) {

this.deleteTriple(selectedTd, false)

},

// Called when enter is pressed

Enter: function Enter (selectedTd) {

this.literalModification(selectedTd)

},

// Called when a selected cell is clicked again

Click: function Click (e) {

var target = UI.utils.getTarget(e)

if (UI.utils.getTerm(target).termType !== 'Literal') return

this.literalModification(target)

// this prevents the generated inputbox to be clicked again

e.preventDefault()

e.stopPropagation()

},

// Called when paste is called (Ctrl+v)

pasteFromClipboard: function pasteFromClipboard (address, selectedTd) {

function termFrom (fromCode) {

var term = outline.clipboard[fromCode].shift()

if (term === null) {

UI.log.warn('no more element in clipboard!')

return

}

switch (fromCode) {

case 'predicates':

case 'objects':

var allArray = outline.clipboard.all

for (var i = 0; true; i++) {

if (term.sameTerm(allArray[i])) {

allArray.splice(i, 1)

break

}

}

break

case 'all':

throw new Error('hostorical code not understood - what is theCollection?')

/*

}

return term

}

var term

switch (selectedTd.className) {

case 'undetermined selected':

term = selectedTd.nextSibling ? termFrom('predicates') : termFrom('objects')

if (!term) return

break

case 'pred selected': // paste objects into this predicate

term = termFrom('objects')

if (!term) return

break

case 'selected': // header <TD>, undetermined generated

var returnArray = termFrom('all')

if (!returnArray) return

term = returnArray[0]

this.insertTermTo(selectedTd, term, returnArray[1])

return

}

this.insertTermTo(selectedTd, term)

},

// a general entry point for any event except Click&Enter(goes to literalModification)

// do a little inference to pick the right input box

startFillInText: function startFillInText (selectedTd) {

switch (this.whatSortOfEditCell(selectedTd)) {

case 'DatatypeProperty-like':

// this.clearMenu();

// selectedTd.className='';

UI.utils.emptyNode(selectedTd)

this.lastModified = this.createInputBoxIn(selectedTd, ' (Please Input) ')

this.lastModified.isNew = false

this.lastModified.select()

break

case 'predicate':

// the goal is to bring back all the menus (with autocomplete functionality

// this.performAutoCompleteEdit(selectedTd,['PredicateAutoComplete',

// this.choiceQuery('SuggestPredicateByDomain')]);

this.performAutoCompleteEdit(selectedTd, 'PredicateAutoComplete')

break

case 'ObjectProperty-like':

case 'no-idea':

// menu should be either function that

this.performAutoCompleteEdit(selectedTd, 'GeneralAutoComplete')

/*

}

},

literalModification: function literalModification (selectedTd) {

UI.log.debug('entering literal Modification with ' + selectedTd + selectedTd.textContent)

// var This=outline.UserInput;

if (selectedTd.className.indexOf(' pendingedit') !== -1) {

UI.log.warn('The node you attempted to edit has a request still pending.\n' +

'Please wait for the request to finish (the text will turn black)\n' +

'before editing this node again.')

return true

}

var target = selectedTd

var about = this.getStatementAbout(target) // timbl - to avoid alert from random clicks

if (!about) return

try {

var obj = UI.utils.getTerm(target)

var trNode = UI.utils.ancestor(target, 'TR')

} catch (e) {

UI.log.warn('userinput.js: ' + e + UI.utils.getAbout(kb, selectedTd))

UI.log.error(target + ' getStatement Error:' + e)

}

try { var tdNode = trNode.lastChild } catch (e) { UI.log.error(e + '@' + target) }

// seems to be a event handling problem of firefox3

/*

// ignore clicking trNode.firstChild (be careful for <div> or <span>)

// if (e.type!='keypress'&&target!=tdNode && UI.utils.ancestor(target,'TD')!=tdNode) return;

if (obj.termType === 'Literal') {

tdNode.removeChild(tdNode.firstChild) // remove the text

if (obj.value.match('\n')) { // match a line feed and require <TEXTAREA>

var textBox = myDocument.createElement('textarea')

textBox.appendChild(myDocument.createTextNode(obj.value))

textBox.setAttribute('rows', (obj.value.match(/\n/g).length + 1).toString())

// g is for global(??)

textBox.setAttribute('cols', '100') // should be the size of <TD>

textBox.setAttribute('class', 'textinput')

tdNode.appendChild(textBox)

this.lastModified = textBox

} else {

this.lastModified = this.createInputBoxIn(tdNode, obj.value)

}

this.lastModified.isNew = false

// Kenny: What should be expected after you click a editable text element?

// Choice 1

this.lastModified.select()

// Choice 2 - direct the key cursor to where you click (failed attempt)

// --------------------------------------------------------------------------

// duplicate the event so user can edit without clicking twice

// var e2=myDocument.createEvent("MouseEvents");

// e2.initMouseEvent("click",true,true,window,0,0,0,0,0,false,false,false,false,0,null);

// inputBox.dispatchEvent(e2);

// ---------------------------------------------------------------------------

}

return true // this is not a valid modification

},

performAutoCompleteEdit: function performAutoCompleteEdit (selectedTd, menu) {

UI.utils.emptyNode(selectedTd)

qp('perform AutoCompleteEdit. THIS IS=' + this)

this.lastModified = this.createInputBoxIn(selectedTd, '')

this.lastModified.select()

this.lastModified.addEventListener('keypress', this.getAutoCompleteHandler(menu), false)

/* keypress!?

// this pops up the autocomplete menu

// Pops up the menu even though no keypress has occurred

// 1 is a dummy variable for the "enterEvent"

this.getAutoCompleteHandler(menu)(1)

},

backOut: function backOut () {

this.deleteTriple(this.lastModified.parentNode, true)

this.lastModified = null

},

clearMenu: function clearMenu () {

var menu = myDocument.getElementById(this.menuID)

if (menu) {

menu.parentNode.removeChild(menu)

// emptyNode(menu);

}

},

/* goes here when either this is a literal or escape from menu and then input text */

clearInputAndSave: function clearInputAndSave (e) {

if (!this.lastModified) return

if (!this.lastModified.isNew) {

try {

var obj = this.getStatementAbout(this.lastModified).object

} catch (e) { return }

}

var s = this.lastModifiedStat // when 'isNew' this is set at addNewObject()

if (this.lastModified.value !== this.lastModified.defaultValue) {

if (this.lastModified.value === '') {

// ToDo: remove this

this.lastModified.value = this.lastModified.defaultValue

this.clearInputAndSave()

return

} else if (this.lastModified.isNew) {

s = new UI.rdf.Statement(s.subject, s.predicate, kb.literal(this.lastModified.value), s.why)

// TODO: DEFINE ERROR CALLBACK

var defaultpropview = this.views.defaults[s.predicate.uri]

var trCache = UI.utils.ancestor(this.lastModified, 'TR')

try {

UI.store.updater.update([], [s], function (uri, success, errorBody) {

if (!success) {

UI.log.error('Error occurs while inserting ' + s + '\n\n' + errorBody + '\n')

// UI.log.warn("Error occurs while inserting "+s+'\n\n'+errorBody);

outline.UserInput.deleteTriple(trCache.lastChild, true)

}

})

} catch (e) {

UI.log.error('Error inserting fact ' + s + ':\n\t' + e + '\n')

return

}

s = kb.add(s.subject, s.predicate, kb.literal(this.lastModified.value), s.why)

} else {

if (this.statIsInverse) {

UI.log.error("Invalid Input: a literal can't be a subject in RDF/XML")

this.backOut()

return

}

var s1, s2, s3

switch (obj.termType) {

case 'Literal':

// generate path and nailing from current values

// TODO: DEFINE ERROR CALLBACK

var valueCache = this.lastModified.value

trCache = UI.utils.ancestor(this.lastModified, 'TR')

var oldValue = this.lastModified.defaultValue

s2 = $rdf.st(s.subject, s.predicate, kb.literal(this.lastModified.value), s.why)

try {

UI.store.updater.update([s], [s2], function (uri, success, errorBody) {

if (success) {

obj.value = valueCache

} else {

UI.log.warn('Error occurs while editing ' + s + '\n\n' + errorBody)

trCache.lastChild.textContent = oldValue

}

trCache.lastChild.className = trCache.lastChild.className.replace(/ pendingedit/g, '')

})

} catch (e) {

UI.log.warn('Error occurs while editing ' + s + ':\n\t' + e)

return

}

// obj.value=this.lastModified.value;

// UserInputFormula.statements.push(s);

break

case 'BlankNode': // a request refill with text

// var newStat

var textTerm = kb.literal(this.lastModified.value, '')

// <Feature about="labelChoice">

if (s.predicate.termType === 'Collection') { // case: add triple ????????? Weird - tbl

var selectedPredicate = s.predicate.elements[0] // @@ TBL elements is a list on the predicate??

if (kb.any(undefined, selectedPredicate, textTerm)) {

if (!e) { // keyboard

var tdNode = this.lastModified.parentNode

e = {}

e.pageX = UI.utils.findPos(tdNode)[0]

e.pageY = UI.utils.findPos(tdNode)[1] + tdNode.clientHeight

}

this.showMenu(e, 'DidYouMeanDialog', undefined, {'dialogTerm': kb.any(undefined, selectedPredicate, textTerm), 'bnodeTerm': s.subject})

} else {

s1 = UI.utils.ancestor(UI.utils.ancestor(this.lastModified, 'TR').parentNode, 'TR').AJAR_statement

s2 = $rdf.st(s.subject, selectedPredicate, textTerm, s.why)

var type = kb.the(s.subject, rdf('type'))

s3 = kb.anyStatementMatching(s.subject, rdf('type'), type, s.why)

// TODO: DEFINE ERROR CALLBACK

// because the table is repainted, so...

trCache = UI.utils.ancestor(UI.utils.ancestor(this.lastModified, 'TR'), 'TD').parentNode

try {

UI.store.updater.update([], [s1, s2, s3], function (uri, success, errorBody) {

if (!success) {

console.log('Error occurs while editing ' + s1 + '\n\n' + errorBody)

outline.UserInput.deleteTriple(trCache.lastChild, true) // @@@@ This

}

})

} catch (e) {

console.log('Error occurs while editing ' + s1 + ':\n\t' + e)

return

}

kb.remove(s)

kb.add(s.subject, selectedPredicate, textTerm, s.why) // was: newStat =

// a subtle bug occurs here, if foaf:nick hasn't been dereferneced,

// this add will cause a repainting

}

var enclosingTd = UI.utils.ancestor(this.lastModified.parentNode.parentNode, 'TD')

const defaultPane = panes.default // @@ check

outline.outlineExpand(enclosingTd, s.subject, {'pane': defaultPane, 'already': true})

outline.walk('right', outline.focusTd)

// </Feature>

} else {

this.fillInRequest('object', this.lastModified.parentNode, kb.literal(this.lastModified.value))

return // The new Td is already generated by fillInRequest, so it's done.

}

break

}

}

} else if (this.lastModified.isNew) { // generate 'Request', there is no way you can input ' (Please Input) '

var trNode = UI.utils.ancestor(this.lastModified, 'TR')

var reqTerm = this.generateRequest('(To be determined. Re-type of drag an object onto this field)')

var preStat = trNode.previousSibling.AJAR_statement // the statement of the same predicate

this.formUndetStat(trNode, preStat.subject, preStat.predicate, reqTerm, preStat.why, false)

// this why being the same as the previous statement

this.lastModified = null

// UI.log.warn("test .isNew)");

return

} else if (s.predicate.termType === 'Collection') {

kb.removeMany(s.subject)

var upperTr = UI.utils.ancestor(UI.utils.ancestor(this.lastModified, 'TR').parentNode, 'TR')

preStat = upperTr.AJAR_statement

reqTerm = this.generateRequest('(To be determined. Re-type of drag an object onto this field)')

this.formUndetStat(upperTr, preStat.subject, preStat.predicate, reqTerm, preStat.why, false)

outline.replaceTD(outline.outlineObjectTD(reqTerm, defaultpropview), upperTr.lastChild)

this.lastModified = null

return

} else

/*

if (this.statIsInverse) {

if (s.subject.termType === 'BlankNode') {

this.backOut()

return

}

} else {

if (s.object.termType === 'BlankNode') {

this.backOut()

return

}

}

// case modified - literal modification only(for now).

trNode = UI.utils.ancestor(this.lastModified, 'TR')

// var defaultpropview = this.views.defaults[s.predicate.uri]

if (!this.statIsInverse) {

// this is for an old feature

// outline.replaceTD(outline.outlineObjectTD(s.object, defaultpropview),trNode.lastChild);

outline.replaceTD(outline.outlineObjectTD(kb.literal(this.lastModified.value), defaultpropview), trNode.lastChild)

} else {

outline.replaceTD(outline.outlineObjectTD(s.subject, defaultpropview), trNode.lastChild)

}

if (this.lastModified.value !== this.lastModified.defaultValue) { trNode.lastChild.className += ' pendingedit' }

// trNode.AJAR_statement=s;//you don't have to set AJAR_inverse because it's not changed

// This is going to be painful when predicate-edit allowed

this.lastModified = null

},

/* deletes the triple corresponding to selectedTd, remove that Td. */

deleteTriple: function deleteTriple (selectedTd, isBackOut) {

// ToDo: complete deletion of a node

UI.log.debug('deleteTriple entered')

// allow a pending node to be deleted if it's a backout sent by SPARQL update callback

if (!isBackOut && selectedTd.className.indexOf(' pendingedit') !== -1) {

console.log('The node you attempted to edit has a request still pending.\n' +

'Please wait for the request to finish (the text will turn black)\n' +

'before editing this node again.')

outline.walk('up')

return

}

var removedTr

// var afterTr

var s = this.getStatementAbout(selectedTd)

if (!isBackOut &&

!kb.whether(s.object, rdf('type'), UI.ns.link('Request')) &&

// Better to check whether provenance is internal?

!kb.whether(s.predicate, rdf('type'), UI.ns.link('Request')) &&

!kb.whether(s.subject, rdf('type'), UI.ns.link('Request'))) {

UI.log.debug('about to send SPARQLUpdate')

try {

UI.store.updater.update([s], [], function (uri, success, errorBody) {

if (success) {

removefromview()

} else {

// removedTr.AJAR_statement=kb.add(s.subject,s.predicate,s.object,s.why);

console.log('Error occurs while deleting ' + s + '\n\n' + errorBody)

selectedTd.className = selectedTd.className.replace(/ pendingedit/g, '')

}

})

selectedTd.className += ' pendingedit'

} catch (e) {

UI.log.error(e)

UI.log.warn('Error deleting statement ' + s + ':\n\t' + e)

return

}

UI.log.debug('SPARQLUpdate sent')

} else { // removal of an undetermined statement associated with pending TRs

// TempFormula.remove(s);

}

UI.log.debug('about to remove ' + s)

UI.log.debug('removed')

outline.walk('up')

removedTr = selectedTd.parentNode

// afterTr = removedTr.nextSibling

function removefromview () {

var trIterator

for (trIterator = removedTr;

trIterator.childNodes.length === 1;

trIterator = trIterator.previousSibling);

if (trIterator === removedTr) {

var theNext = trIterator.nextSibling

if (theNext.nextSibling && theNext.childNodes.length === 1) {

var predicateTd = trIterator.firstChild

predicateTd.setAttribute('rowspan', parseInt(predicateTd.getAttribute('rowspan')) - 1)

theNext.insertBefore(trIterator.firstChild, theNext.firstChild)

}

removedTr.parentNode.removeChild(removedTr)

} else { // !DisplayOptions["display:block on"].enabled){

predicateTd = trIterator.firstChild

predicateTd.setAttribute('rowspan', parseInt(predicateTd.getAttribute('rowspan')) - 1)

removedTr.parentNode.removeChild(removedTr)

}

}

if (isBackOut) removefromview()

},

/* clipboard principle: copy wildly, paste carefully

clipboardInit: function clipboardInit () {

outline.clipboard = {}

outline.clipboard.objects = []

outline.clipboard.predicates = []

outline.clipboard.all = []

},

copyToClipboard: function copyToClipboard (address, selectedTd) {

/*

var term = UI.utils.getTerm(selectedTd)

switch (selectedTd.className) {

case 'selected': // table header

case 'obj selected':

// var objects = outline.clipboard.objects

outline.clipboard.objects.unshift(term)

break

case 'pred selected':

case 'pred internal selected':

outline.clipboard.predicates.unshift(term)

}

outline.clipboard.all.unshift(term)

},

insertTermTo: function insertTermTo (selectedTd, term, isObject) {

switch (selectedTd.className) {

case 'undetermined selected':

var defaultpropview = this.views.defaults[selectedTd.parentNode.AJAR_statement.predicate.uri]

this.fillInRequest(selectedTd.nextSibling ? 'predicate' : 'object', selectedTd, term)

break

case 'pred selected': // paste objects into this predicate

var insertTr = this.appendToPredicate(selectedTd)

var preStat = selectedTd.parentNode.AJAR_statement

defaultpropview = this.views.defaults[preStat.predicate.uri]

insertTr.appendChild(outline.outlineObjectTD(term, defaultpropview))

// modify store and update here

var isInverse = selectedTd.parentNode.AJAR_inverse

if (!isInverse) { insertTr.AJAR_statement = kb.add(preStat.subject, preStat.predicate, term, preStat.why) } else { insertTr.AJAR_statemnet = kb.add(term, preStat.predicate, preStat.object, preStat.why) }

try {

UI.store.updater.update([ ], [insertTr.AJAR_statement], function (uri, success, errorBody) {

if (!success) {

UI.log.error('userinput.js (pred selected): Fail trying to insert statement ' +

insertTr.AJAR_statement + ': ' + errorBody)

}

})

} catch (e) {

UI.log.error('Exception trying to insert statement ' +

insertTr.AJAR_statement + ': ' + UI.utils.stackString(e))

return

}

insertTr.AJAR_inverse = isInverse

UserInputFormula.statements.push(insertTr.AJAR_statement)

break

case 'selected': // header <TD>, undetermined generated

var paneDiv = UI.utils.ancestor(selectedTd, 'TABLE').lastChild

var newTr = paneDiv.insertBefore(myDocument.createElement('tr'), paneDiv.lastChild)

// var titleTerm=UI.utils.getAbout(kb,UI.utils.ancestor(newTr,'TD'));

preStat = newTr.previousSibling.AJAR_statement

if (typeof isObject === 'undefined') isObject = true

if (isObject) { // object inserted

this.formUndetStat(newTr, preStat.subject, this.generateRequest('(TBD)', newTr, true), term, preStat.why, false)

// defaultpropview temporaily not dealt with

newTr.appendChild(outline.outlineObjectTD(term))

outline.walk('moveTo', newTr.firstChild)

this.startFillInText(newTr.firstChild)

} else { // predicate inserted

// existing predicate not expected

var reqTerm = this.generateRequest('(To be determined. Re-type of drag an object onto this field)', newTr)

this.formUndetStat(newTr, preStat.subject, term, reqTerm, preStat.why, false)

newTr.insertBefore(outline.outlinePredicateTD(term, newTr, false, false), newTr.firstChild)

outline.walk('moveTo', newTr.lastChild)

this.startFillInText(newTr.lastChild)

}

break

}

},

Refill: function Refill (e, selectedTd) {

UI.log.info('Refill' + selectedTd.textContent)

var isPredicate = selectedTd.nextSibling

var predicateQuery

if (isPredicate) { // predicateTd

if (selectedTd.nextSibling.className === 'undetermined') {

/* Make set of proprties to propose for a predicate.

/* SELECT ?pred

/* SELECT ?pred ?class

/* SELECT ?pred

var subject = UI.utils.getAbout(kb, UI.utils.ancestor(selectedTd, 'TABLE').parentNode)

var subjectClass = kb.any(subject, rdf('type'))

var sparqlText = []

var endl = '.\n'

sparqlText[0] = 'SELECT ?pred WHERE{\n?pred ' + rdf('type') + rdf('Property') + '.\n' +

'?pred ' + UI.ns.rdfs('domain') + subjectClass + '.}' // \n is required? SPARQL parser bug?

sparqlText[1] = 'SELECT ?pred ?class\nWHERE{\n' +

'?pred ' + rdf('type') + rdf('Property') + '.\n' +

subjectClass + UI.ns.rdfs('subClassOf') + ' ?class.\n' +

'?pred ' + UI.ns.rdfs('domain') + ' ?class.\n}'

sparqlText[2] = 'SELECT ?pred WHERE{\n' +

subject + rdf('type') + kb.variable('subjectClass') + endl +

kb.variable('pred') + UI.ns.rdfs('domain') + kb.variable('subjectClass') + endl +

'}'

predicateQuery = sparqlText.map($rdf.SPARQLToQuery)

} else {

// ------selector

/* SELECT ?pred

// Candidate

/* SELECT ?pred

subject = UI.utils.getAbout(kb, UI.utils.ancestor(selectedTd, 'TABLE').parentNode)

subjectClass = kb.any(subject, rdf('type'))

var object = selectedTd.parentNode.AJAR_statement.object

// var objectClass = (object.termType === 'Literal') ? UI.ns.rdfs('Literal') : kb.any(object, rdf('type'))

// var sparqlText="SELECT ?pred WHERE{\n?pred "+rdf('type')+rdf('Property')+".\n"+

// "?pred "+UI.ns.rdfs('domain')+subjectClass+".\n"+

// "?pred "+UI.ns.rdfs('range')+objectClass+".\n}"; // \n is required? SPARQL parser bug?

sparqlText = 'SELECT ?pred WHERE{' + subject + rdf('type') + '?subjectClass' + '.\n' +

object + rdf('type') + '?objectClass' + '.\n' +

'?pred ' + UI.ns.rdfs('domain') + '?subjectClass' + '.\n' +

'?pred ' + UI.ns.rdfs('range') + '?objectClass' + '.\n}' // \n is required? SPARQL parser bug?

predicateQuery = $rdf.SPARQLToQuery(sparqlText)

}

// -------presenter

// ToDo: how to sort selected predicates?