--- /dev/null
+package com.pentila.evalcomp.client.examen;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.gwt.http.client.RequestBuilder;
+import com.google.gwt.i18n.client.DateTimeFormat;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.google.gwt.user.client.ui.VerticalPanel;
+
+import com.gwtext.client.util.Format;
+import com.gwtextux.client.widgets.window.ToastWindow;
+import com.pentila.evalcomp.client.ConnexionServer;
+import com.pentila.evalcomp.client.i18n.Messages;
+import com.pentila.evalcomp.client.services.widget.NameValueRecord;
+import com.pentila.evalcomp.client.utilities.Tools;
+import com.pentila.evalcomp.client.utilities.UserTools;
+import com.pentila.evalcomp.client.widget.PropertyGrid;
+import com.pentila.evalcomp.domain.definition.Competence;
+import com.pentila.evalcomp.domain.definition.Domain;
+import com.pentila.evalcomp.domain.definition.Referentiel;
+import com.pentila.evalcomp.domain.examen.Famille;
+import com.pentila.evalcomp.domain.examen.Question;
+import com.smartgwt.client.core.Function;
+import com.smartgwt.client.types.Alignment;
+import com.smartgwt.client.types.EmbeddedPosition;
+import com.smartgwt.client.types.VisibilityMode;
+import com.smartgwt.client.widgets.Canvas;
+import com.smartgwt.client.widgets.IButton;
+import com.smartgwt.client.widgets.Img;
+import com.smartgwt.client.widgets.ImgButton;
+import com.smartgwt.client.widgets.Window;
+import com.smartgwt.client.widgets.events.ClickEvent;
+import com.smartgwt.client.widgets.events.ClickHandler;
+import com.smartgwt.client.widgets.form.DynamicForm;
+import com.smartgwt.client.widgets.form.fields.CheckboxItem;
+import com.smartgwt.client.widgets.form.fields.DateItem;
+import com.smartgwt.client.widgets.form.fields.FormItem;
+import com.smartgwt.client.widgets.form.fields.IntegerItem;
+import com.smartgwt.client.widgets.form.fields.PickTreeItem;
+import com.smartgwt.client.widgets.form.fields.SelectItem;
+import com.smartgwt.client.widgets.form.fields.TextAreaItem;
+import com.smartgwt.client.widgets.form.fields.events.ChangedEvent;
+import com.smartgwt.client.widgets.form.fields.events.ChangedHandler;
+import com.smartgwt.client.widgets.grid.CellFormatter;
+import com.smartgwt.client.widgets.grid.ListGridField;
+import com.smartgwt.client.widgets.grid.ListGridRecord;
+import com.smartgwt.client.widgets.grid.events.CellClickEvent;
+import com.smartgwt.client.widgets.grid.events.CellClickHandler;
+import com.smartgwt.client.widgets.grid.events.CellSavedEvent;
+import com.smartgwt.client.widgets.grid.events.CellSavedHandler;
+import com.smartgwt.client.widgets.grid.events.EditorEnterEvent;
+import com.smartgwt.client.widgets.grid.events.EditorEnterHandler;
+import com.smartgwt.client.widgets.grid.events.EditorExitEvent;
+import com.smartgwt.client.widgets.grid.events.EditorExitHandler;
+import com.smartgwt.client.widgets.layout.HLayout;
+import com.smartgwt.client.widgets.layout.SectionStack;
+import com.smartgwt.client.widgets.layout.SectionStackSection;
+import com.smartgwt.client.widgets.layout.VLayout;
+import com.smartgwt.client.widgets.tree.Tree;
+import com.smartgwt.client.widgets.tree.TreeNode;
+
+public class QuestionDetail extends VLayout {
+
+ Boolean readOnly = true;
+
+ ReponseGrid rg;
+
+ static Tree tree = null;
+
+ static Map<Long, LinkedHashMap<Long, Famille>> competenceFamilles = new HashMap<Long, LinkedHashMap<Long, Famille>>();
+
+ CellFormatter competenceFormatter = new CellFormatter(){
+
+ public String format(Object value, ListGridRecord record,
+ int rowNum, int colNum) {
+
+
+
+ if (question.getCompetence() != null){
+ String cName = question.getCompetence().getName();
+
+ return cName;
+ }
+ return "";
+
+
+ }
+ };
+
+
+ CellFormatter domainFormatter = new CellFormatter(){
+
+ public String format(Object value, ListGridRecord record,
+ int rowNum, int colNum) {
+
+
+
+ if (question.getCompetence() != null){
+
+ String dName = question.getCompetence().getDomain().getReferentiel().getName() + " - " + question.getCompetence().getDomain().getName();
+
+ return "" + dName;
+ }
+ return "";
+ }
+ };
+
+ CellFormatter idFormatter = new CellFormatter(){
+
+ public String format(Object value, ListGridRecord record,
+ int rowNum, int colNum) {
+
+ if (question.getId() == null){
+ return "**";
+ }
+
+ return Format
+ .format(
+ "<img align=top src=\"" + Tools.getBaseURL()
+ + "images/{1}\"> {0}", new String[] { question.getId().toString(), "question16.png"});
+
+
+ }
+ };
+
+
+ CellFormatter familleFormatter = new CellFormatter(){
+
+ public String format(Object value, ListGridRecord record,
+ int rowNum, int colNum) {
+
+
+
+ if (question.getFamille() != null){
+ String cName = "<b>" + question.getFamille().getFamille() + "</b><br><i>" +question.getFamille().getCommentaires()+"</i>";
+
+ return cName;
+ }else{
+ return "--";
+ }
+
+ }
+ };
+
+ private ListFieldData at = new ListFieldData(
+ Arrays.asList(
+ new FieldData("id", "id", idFormatter, FieldData.NOEDIT),
+ new FieldData("id_question", "id_question", FieldData.HIDE),
+ new FieldData("titre", "titre"),
+ new FieldData("auteur", "auteur", FieldData.SHOW, FieldData.NOEDIT),
+ new FieldData("domain", "domain", domainFormatter, FieldData.NOEDIT),
+ new FieldData("competence", "competence", competenceFormatter, FieldData.NOEDIT),
+ new FieldData("famille", "famille", familleFormatter, FieldData.EDIT),
+ new FieldData("shared", "shared", FieldData.SHOW, FieldData.EDIT),
+ new FieldData("ts_datecreation", "date", FieldData.SHOW, FieldData.NOEDIT)
+ ));
+
+
+ private ListGridRecord record;
+
+ private Question question;
+
+ private IAddDeleteWidget objectManager;
+
+ private Function callbackFunction;
+
+ private PropertyGrid innerQuestionGrid;
+
+ private Window window;
+
+
+ public QuestionDetail(ListGridRecord record, IAddDeleteWidget objectManager) {
+ this.record = record;
+ this.question = (Question)record.getAttributeAsObject("object");
+ this.objectManager = objectManager;
+ }
+
+ public QuestionDetail(Question question , IAddDeleteWidget objectManager) {
+
+ this.question = question;
+ this.objectManager = objectManager;
+ }
+
+ public QuestionDetail(Question question) {
+
+ this.question = question;
+
+ }
+
+ public void initializeInterface(){
+ if (QuestionDetail.tree == null){
+ this.initTreeRef();
+ }else{
+ createInnerGrid();
+ }
+ }
+
+ private ListGridRecord[] getFlatData() {
+
+ ListGridRecord[] ret = new ListGridRecord[at.getShowableFieldDatas().size()];
+
+ int i = 0;
+ for (FieldData field : at.getShowableFieldDatas()) {
+
+
+ Object o = QuestionUtil.apply("get", field, this.question, null);
+ if (o == null){
+ o = "";
+ }
+
+
+ String typeName = "java.lang.String";
+ try{
+ typeName = QuestionUtil.classType.getField(field.getFieldName()).getType().getQualifiedSourceName();
+
+ if (typeName.equals(Competence.class.getName()) || typeName.equals(Famille.class.getName())){
+
+ o = null;
+ }
+
+ }catch (Exception e){
+ //e.printStackTrace();
+ }
+
+
+
+ ret[i++] = new NameValueRecord(field.getFieldName(),
+ Messages.getString(field.getLabel()), o, typeName, field.getEditable());
+
+
+ }
+
+ return ret;
+
+ }
+
+ public void createInnerGrid() {
+
+
+
+ boolean r = true;
+ if (UserTools.getUser().hasRole("ROLE_MANAGER") || (question.getOwner() != null && question.getOwner().getId().equals(UserTools.getUser().getId()))){
+ r = false;
+ }
+
+
+
+ final boolean readOnlyQ = r || readOnly;
+
+
+ setMargin(5);
+ setPadding(5);
+ setAlign(Alignment.CENTER);
+ setWidth100();
+
+
+ innerQuestionGrid = new PropertyGrid(){
+
+
+
+ @Override
+ protected Canvas createRecordComponent(final ListGridRecord record2, Integer colNum) {
+
+ NameValueRecord r = (NameValueRecord) record2;
+
+
+ if ((r.getKey().equals("competence")) && colNum == 1){
+
+ PickTreeItem competencePicker = new PickTreeItem();
+ competencePicker.setCanEdit(!readOnlyQ);
+
+ competencePicker.setCanSelectParentItems(false);
+ competencePicker.setValueTree(tree);
+
+ //Question q2= (Question)record.getAttributeAsObject("object");
+
+
+ if (question != null && question.getCompetence() != null){
+ competencePicker.setValue(question.getCompetence().getName());
+ }
+
+
+ competencePicker.addChangedHandler(new ChangedHandler(){
+
+ public void onChanged(ChangedEvent event) {
+
+ PickTreeItem p = (PickTreeItem) event.getItem();
+
+ System.out.println("ECHO 1");
+
+ TreeNode tn = (tree.find(p.getValue().toString()));
+
+ //Question q = (Question)record.getAttributeAsObject("object");
+
+
+ Competence c = (Competence)tn.getAttributeAsObject("object");
+
+ question.setCompetence(c);
+
+ question.setFamille(null);
+ System.out.println("ECHO 2");
+ innerQuestionGrid.refreshFields();
+ System.out.println("ECHO 3");
+
+ }
+
+ });
+
+
+ DynamicForm df = new DynamicForm();
+
+ df.setWidth(300);
+ competencePicker.setShowTitle(false);
+
+ df.setFields(competencePicker);
+
+
+
+
+ return df;
+ }
+
+ return null;
+ }
+
+ @Override
+ public Canvas updateRecordComponent(ListGridRecord record2, Integer colNum, Canvas component, boolean recordChanged){
+
+ NameValueRecord r = (NameValueRecord) record2;
+ DynamicForm df = (DynamicForm) component;
+
+ if ((r.getKey().equals("competence")) && colNum == 1){
+
+ PickTreeItem departmentItem = (PickTreeItem)df.getFields()[0];
+
+ //Question q2= (Question)record.getAttributeAsObject("object");
+
+ if (question != null && question.getCompetence() != null){
+ departmentItem.setValue(question.getCompetence().getName());
+ }
+
+ }
+
+ return component;
+
+ }
+
+ };
+
+ innerQuestionGrid.setWidth100();
+ innerQuestionGrid.setHeight(340);
+
+ innerQuestionGrid.setShowRecordComponents(true);
+ innerQuestionGrid.setShowRecordComponentsByCell(true);
+ innerQuestionGrid.setRecordComponentPosition(EmbeddedPosition.WITHIN);
+
+ innerQuestionGrid.getNameField().setName("Name");
+ innerQuestionGrid.getNameField().setWidth("20%");
+ innerQuestionGrid.getNameField().setTitle(Messages.getString("PropertyName"));
+
+ innerQuestionGrid.getValuesField().setName("Value");
+ innerQuestionGrid.getValuesField().setWidth("80%");
+ innerQuestionGrid.getValuesField().setTitle(Messages.getString("PropertyValue"));
+
+ innerQuestionGrid.setReadOnly(readOnlyQ);
+
+ // Ici les deux sont necessaires pour le refresh du widget PickerItem pour la
+ // selection des competences
+ innerQuestionGrid.addEditorEnterHandler(new EditorEnterHandler(){
+
+ @Override
+ public void onEditorEnter(EditorEnterEvent event) {
+
+ innerQuestionGrid.redraw();
+ }
+
+ });
+
+ innerQuestionGrid.addEditorExitHandler(new EditorExitHandler(){
+
+ @Override
+ public void onEditorExit(EditorExitEvent event) {
+
+ innerQuestionGrid.refreshFields();
+ }
+
+ });
+
+
+ Map<String, FormItem> editorsMap = new HashMap<String, FormItem>();
+
+ TextAreaItem textEditor = new TextAreaItem();
+ editorsMap.put("java.lang.String",textEditor );
+
+ IntegerItem integerItem = new IntegerItem();
+ integerItem.setMask("###");
+ editorsMap.put("java.lang.Integer",integerItem );
+ editorsMap.put("int", integerItem);
+
+ CheckboxItem cbi = new CheckboxItem();
+ cbi.setShowLabel(false);
+ editorsMap.put("java.lang.Boolean", cbi);
+
+ DateItem dateItem = new DateItem();
+ editorsMap.put("java.util.Date", dateItem);
+ editorsMap.put("java.sql.Timestamp", dateItem);
+
+ editorsMap.put("competence", dateItem);
+
+ final SelectItem selectItem = new SelectItem(){
+ @Override
+ public void enable(){
+ //Question question = (Question)record.getAttributeAsObject("object");
+
+ Map<Long, Famille> sf = competenceFamilles.get(question.getCompetence().getId());
+
+ LinkedHashMap<String, String> values = new LinkedHashMap<String, String>();
+
+ for (Famille f : sf.values()){
+
+ values.put(""+f.getId(), "<b>"+f.getFamille() + "</b><br><i>" +f.getCommentaires()+"</i>");
+
+ }
+
+ setValueMap(values);
+
+ super.enable();
+ }
+ };
+
+ LinkedHashMap<String, String> values = new LinkedHashMap<String, String>();
+
+ if (question.getCompetence() != null){
+ Map<Long, Famille> sf = competenceFamilles.get(question.getCompetence().getId());
+
+
+ for (Famille f : sf.values()){
+ values.put(""+f.getId(), f.getFamille());
+ }
+ }
+
+ selectItem.setValueMap(values);
+
+ if (question != null && question.getFamille() != null){
+ selectItem.setValue(question.getFamille().getFamille());
+ }
+
+ selectItem.addChangedHandler(new ChangedHandler(){
+
+ public void onChanged(ChangedEvent event) {
+
+ //Question q = (Question)record.getAttributeAsObject("object");
+
+ Famille f = competenceFamilles.get(question.getCompetence().getId()).get(new Long((String)event.getValue()));
+
+ question.setFamille(f);
+ System.out.println("ECHO 20 " + f);
+ innerQuestionGrid.refreshFields();
+ System.out.println("ECHO 22 " + f);
+
+ //innerQuestionGrid.cancelEditing();
+
+ }
+ });
+
+
+
+ editorsMap.put(Famille.class.getName(), selectItem);
+
+
+ innerQuestionGrid.setEditorsMap("typeName", editorsMap);
+
+ final DateTimeFormat dateFormatter = DateTimeFormat.getFormat("dd/MM/yyyy");
+ CellFormatter formatter = new CellFormatter(){
+
+ public String format(Object value, ListGridRecord record2,
+ int rowNum, int colNum) {
+
+ try{
+ NameValueRecord r = (NameValueRecord) record2;
+
+ if (at.getFieldDataById(r.getKey()).getCellFormatter() != null ){
+ return at.getFieldDataById((r.getKey())).getCellFormatter().format("", record, rowNum, colNum);
+ }
+
+
+ if (r.getTypeName().equals("java.util.Date") || r.getTypeName().equals("java.sql.Timestamp")){
+ try {
+ Date dateValue = (Date) value;
+ return dateFormatter.format(dateValue);
+ } catch (Exception e) {
+ return value.toString();
+ }
+ }else if (r.getTypeName().equals("java.lang.Boolean")){
+
+
+ VerticalPanel vp = new VerticalPanel();
+ Img i = new Img();
+
+ if (value != null && (Boolean)value){
+ i.setSrc("[SKIN]DynamicForm/checked.png");
+ }else{
+ i.setSrc("[SKIN]DynamicForm/unchecked.png");
+ }
+ i.setSize("13px", "13px");
+
+ vp.add(i);
+ return vp.toString();
+ }
+
+ if (value != null){
+ return value.toString();
+ }
+ }catch(Exception e){
+ //e.printStackTrace();
+ }
+ return "";
+ }
+ };
+
+ innerQuestionGrid.getValuesField().setCellFormatter(formatter);
+
+ innerQuestionGrid.setData(getFlatData());
+
+ if (!readOnlyQ){
+
+ innerQuestionGrid.addCellClickHandler(new CellClickHandler(){
+
+ public void onCellClick(CellClickEvent event) {
+
+
+ if (event.getColNum() == 1){
+
+ NameValueRecord r = (NameValueRecord) event.getRecord();
+ ListGridField lgf = innerQuestionGrid.getField(event.getColNum());
+
+ if (r.getEditable() && !lgf.getCanEdit()){
+
+ lgf.setCanEdit(true);
+
+ }else if (!r.getEditable() && lgf.getCanEdit()){
+
+ lgf.setCanEdit(false);
+ }
+ }
+
+
+ }
+
+ });
+
+
+
+ innerQuestionGrid.setAutoSaveEdits(false);
+
+ innerQuestionGrid.addCellSavedHandler(new CellSavedHandler() {
+
+ public void onCellSaved(CellSavedEvent event) {
+ NameValueRecord nvr = (NameValueRecord) event.getRecord();
+
+ if (record != null){
+ record.setAttribute(nvr.getKey(), event.getNewValue());
+
+
+ if (objectManager != null){
+ objectManager.refreshObject(record);
+ }
+ }
+ try{
+ QuestionUtil.classType.invoke(question, QuestionUtil.getMethodName(nvr.getKey(), "set"),
+ event.getNewValue());
+ }catch (Exception e){
+
+ }
+
+
+ //grid.refreshCell(event.getRowNum(), event.getColNum());
+
+ //grid.refreshRow(grid.getRecordIndex(record));
+
+ }
+
+ });
+
+ }
+
+ rg = new ReponseGrid(readOnlyQ);
+ rg.setWidth100();
+ rg.setHeight(340);
+ rg.setQuestion(question);
+ rg.initializeInterface();
+
+
+ SectionStack sectionStack = new SectionStack();
+ sectionStack.setHeight100();
+ sectionStack.setWidth100();
+ SectionStackSection section1 = new SectionStackSection(Messages.getString("question"));
+ SectionStackSection section2 = new SectionStackSection(Messages.getString("Reponses"));
+ section1.setExpanded(true);
+ section2.setExpanded(true);
+
+ section1.setItems(innerQuestionGrid);
+ section2.setItems(rg);
+
+ if (!readOnlyQ){
+ ImgButton addButton = new ImgButton();
+ addButton.setSrc("[SKIN]actions/add.png");
+ addButton.setSize(16);
+ addButton.setShowFocused(false);
+ addButton.setShowRollOver(false);
+ addButton.setShowDown(false);
+ addButton.addClickHandler(new ClickHandler() {
+ public void onClick(ClickEvent event) {
+ rg.addFunction();
+ }
+ });
+
+ ImgButton removeButton = new ImgButton();
+ removeButton.setSrc("[SKIN]actions/remove.png");
+ removeButton.setSize(16);
+ removeButton.setShowFocused(false);
+ removeButton.setShowRollOver(false);
+ removeButton.setShowDown(false);
+ removeButton.addClickHandler(new ClickHandler() {
+ public void onClick(ClickEvent event) {
+ rg.deleteFunction();
+ }
+ });
+
+
+
+
+ section2.setControls(addButton, removeButton);
+
+ }
+ sectionStack.setSections(section1, section2);
+
+
+ sectionStack.setVisibilityMode(VisibilityMode.MULTIPLE);
+ sectionStack.setAnimateSections(true);
+
+ addMember(sectionStack);
+
+ if (!readOnlyQ){
+ HLayout hLayout = new HLayout(10);
+ hLayout.setAlign(Alignment.CENTER);
+
+
+ hLayout.setWidth100();
+ IButton saveButton = new IButton(Messages.getString("Save"));
+ saveButton.setTop(250);
+ saveButton.addClickHandler(new com.smartgwt.client.widgets.events.ClickHandler() {
+ public void onClick(com.smartgwt.client.widgets.events.ClickEvent event) {
+
+
+ Function callback = new Function(){
+
+ public void execute() {
+
+ innerQuestionGrid.saveAllEdits();
+
+ Function f = new Function(){
+
+ public void execute() {
+ ToastWindow tw = new ToastWindow(Messages
+ .getString("notification"), Messages
+ .getString("save_done"));
+ tw.show();
+
+ updateReponseGrid(question);
+
+ /*if (examenDetailPanel != null){
+ examenDetailPanel.updateQuestionWidget((Question) record.getAttributeAsObject("object"));
+ }*/
+
+ }
+
+ };
+ if (objectManager != null){
+ objectManager.saveObject(question, f);
+ }
+ }
+
+ };
+
+ rg.saveAllEdits(callback);
+
+
+ }
+ });
+ hLayout.addMember(saveButton);
+
+ IButton discardButton = new IButton(Messages.getString("Discard"));
+ discardButton.addClickHandler(new com.smartgwt.client.widgets.events.ClickHandler() {
+ public void onClick(com.smartgwt.client.widgets.events.ClickEvent event) {
+ innerQuestionGrid.discardAllEdits();
+ rg.discardAllEdits();
+ window.destroy();
+ }
+ });
+ hLayout.addMember(discardButton);
+
+ addMember(hLayout);
+ }
+
+
+ //Appel asycn !
+ if (callbackFunction != null){
+ callbackFunction.execute();
+ }
+ }
+
+ public void initTreeRef() {
+ AsyncCallback callback = new AsyncCallback() {
+
+ public void onFailure(Throwable caught) {
+ //Tools.hideLoadingRegion(getId());
+ System.out
+ .println("Probleme dans la recuperation du referentiel");
+ Tools.hideLoading();
+ }
+
+ public void onSuccess(Object result) {
+
+ tree = new Tree();
+ TreeNode treeRef = new TreeNode("root");
+
+
+
+ List<Referentiel> listRef = new ArrayList<Referentiel>(
+ (Set<Referentiel>) result);
+ Collections.sort(listRef, new Comparator<Referentiel>() {
+
+ public int compare(Referentiel ref1, Referentiel ref2) {
+ return ref1.getName().compareTo(ref2.getName());
+ }
+
+ });
+
+ List<TreeNode> ltn = new ArrayList<TreeNode>();
+
+
+
+ for (Referentiel ref : listRef) {
+ ltn.add(createTreeRefs(ref));
+ }
+
+
+
+ treeRef.setChildren(ltn.toArray(new TreeNode[ltn.size()]));
+
+ tree.setRoot(treeRef);
+
+ createInnerGrid();
+
+ Tools.hideLoading();
+
+ // Tools.hideLoadingRegion(getId());
+ }
+ };
+
+ // Tools
+ //.showLoadingRegion(
+ // getId(),
+ // Messages.getString("MAJ_referentiels"), Messages.getString("Chargement"));
+
+ Tools.showLoading(Messages.getString("MAJ"),
+ Messages.getString("Chargement"));
+
+ if (UserTools.getUser().hasRole(Tools.ROLE_GEST_INST)
+ || UserTools.getUser().hasRole(Tools.ROLE_GEST_SCO)) {
+ RequestBuilder rb = ConnexionServer.evaluationObjectService
+ .getReferentiels(callback);
+ rb.setHeader("code", "A24");
+ ConnexionServer.doSend(rb);
+ } else if (Tools.interfaceShown == Tools.EVAL_PEDA_INTERFACE
+ && UserTools.getUser().hasRole(Tools.ROLE_GEST_PEDA)) {
+ RequestBuilder rb = ConnexionServer.evaluationObjectService
+ .getReferentiels(UserTools.getUser().getUid(),
+ Tools.ROLE_GEST_PEDA, callback);
+ rb.setHeader("code", "A24");
+ ConnexionServer.doSend(rb);
+ } else {
+ RequestBuilder rb = ConnexionServer.evaluationObjectService
+ .getReferentiels(UserTools.getUser().getUid(), "%",
+ callback);
+ rb.setHeader("code", "A24");
+ ConnexionServer.doSend(rb);
+ }
+
+ }
+
+ public TreeNode createTreeRefs(Referentiel myRef) {
+ TreeNode node = new TreeNode();
+
+ node.setTitle(myRef.getName());
+ node.setIcon(Tools.getBaseURL() +"images/" + "referentiel16.png" );
+
+ List<Domain> listDom = new ArrayList<Domain>(myRef.getDomains());
+ Collections.sort(listDom, new Comparator<Domain>() {
+
+ public int compare(Domain dom1, Domain dom2) {
+ return dom1.getName().compareTo(dom2.getName());
+ }
+
+ });
+
+
+ List<TreeNode> ltn = new ArrayList<TreeNode>();
+
+ for (Domain dom : listDom) {
+ ltn.add(createTreeDomains(dom));
+ }
+
+
+ node.setChildren(ltn.toArray(new TreeNode[ltn.size()]));
+
+
+ return node;
+ }
+
+ public TreeNode createTreeDomains(Domain myDom) {
+ TreeNode node = new TreeNode();
+
+ node.setTitle(myDom.getName());
+ node.setIcon(Tools.getBaseURL() +"images/" + "domaine16.png" );
+
+ List<Domain> listDom = new ArrayList<Domain>(myDom.getDomains());
+ Collections.sort(listDom, new Comparator<Domain>() {
+
+ public int compare(Domain dom1, Domain dom2) {
+ return dom1.getName().compareTo(dom2.getName());
+ }
+
+ });
+
+
+ List<TreeNode> ltn = new ArrayList<TreeNode>();
+
+ for (Domain dom : listDom) {
+ ltn.add(createTreeDomains(dom));
+ }
+
+ List<Competence> listComp = new ArrayList<Competence>(myDom.getCompetences());
+ Collections.sort(listComp, new Comparator<Competence>() {
+
+ public int compare(Competence comp1, Competence comp2) {
+ return comp1.getName().compareTo(comp2.getName());
+ }
+
+ });
+ for (Competence comp : listComp) {
+ ltn.add(createTreeCompetence(comp));
+ //node.appendChild(createTreeCompetence(comp));
+ }
+ node.setChildren(ltn.toArray(new TreeNode[ltn.size()]));
+ return node;
+ }
+
+ public TreeNode createTreeCompetence(Competence myComp) {
+ TreeNode node = new TreeNode();
+
+ node.setTitle(myComp.getName());
+
+ node.setAttribute("object", myComp);
+
+ String url = Tools.getBaseURL() +"images/" + "competence16.png";
+
+ if (myComp.getRequired()){
+ url = Tools.getBaseURL() +"images/" + "competence16Green.png";
+ }
+
+ node.setIcon(url );
+
+ LinkedHashMap<Long, Famille> mf = new LinkedHashMap<Long, Famille>();
+
+ for (Famille f : myComp.getFamilles()){
+ mf.put(f.getId(), f);
+ }
+
+ competenceFamilles.put(myComp.getId(), mf);
+
+ return node;
+ }
+
+ public void updateReponseGrid(Question current) {
+ rg.updateGrid(current);
+
+ }
+
+ public void setCallbackFunction(Function callbackFunction) {
+
+ this.callbackFunction = callbackFunction;
+
+ }
+
+ public void refreshInnerComponent(){
+ int i = 0;
+ for (ListGridRecord lgr : innerQuestionGrid.getRecords()){
+ NameValueRecord nvr = (NameValueRecord) lgr;
+ if (nvr.getKey().equals("competence") /*|| nvr.getKey().equals("famille") */){
+ innerQuestionGrid.refreshRecordComponent(i, 1);
+
+ }
+ i++;
+ }
+
+ innerQuestionGrid.redraw();
+ }
+
+ public Boolean getReadOnly() {
+ return readOnly;
+ }
+
+ public void setReadOnly(Boolean readOnly) {
+ this.readOnly = readOnly;
+ }
+
+ public void setWindow(Window window) {
+ this.window = window;
+
+ }
+
+
+
+
+}