com.vaadin.ui.Window.CloseEvent Java Examples

/**
 * {@inheritDoc}
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void buttonClick(ClickEvent event) {
	final TableComponent<?> table = getTable();
	VaadinView view = table.getEditorView();
	Object bean = BeanUtils.instantiate(table.getEntityClass());
	view.setModel(bean);
	ViewDialog dialog = table.getGuiFactory().newViewDialog(view);
	dialog.setModal(this.modal);
	dialog.addCloseListener(new CloseListener() {

		public void windowClose(CloseEvent e) {
			table.refresh();
		}
	});
	table.getUI().addWindow(dialog);
}
 

public static void editConfiguration(final EntityItem<PIPConfiguration> entity) {
	final PIPConfigurationEditorWindow editor = new PIPConfigurationEditorWindow(entity);
	if (entity.isPersistent()) {
		editor.setCaption("Edit PIP Configuration " + entity.getEntity().getName());
	} else {
		editor.setCaption("Create New PIP Configuration");
	}
	editor.setModal(true);
	editor.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent event) {
			if (editor.isSaved()) {
				if (entity.isPersistent() == false) {
					((XacmlAdminUI)UI.getCurrent()).getPIPConfigurations().addEntity(entity.getEntity());
				}
				((XacmlAdminUI)UI.getCurrent()).refreshPIPConfiguration();
			}
		}					
	});
	editor.center();
	UI.getCurrent().addWindow(editor);
}
 

protected void movePDP(final PDP pdp, final PDPGroup currentGroup) {
	List<PDPGroup> currentGroups = this.container.getGroups();
	Set<PDPGroup> otherGroups = new HashSet<PDPGroup>(currentGroups);
	if (otherGroups.remove(currentGroup) == false) {
		logger.warn("Group list inconsistency - failed to move pdp to selected group");
		return;
	}
	final SelectPDPGroupWindow editor = new SelectPDPGroupWindow(otherGroups, "What was this?");
	editor.setCaption("Move PDP to group");
	editor.setModal(true);
	editor.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent event) {
			if (editor.isSaved()) {
				self.container.movePDP((PDP) pdp, editor.selectedGroup());
			}
		}
	});
	editor.center();
	UI.getCurrent().addWindow(editor);
}
 

private void editButtonClick(ClickEvent event) {
    LoadBalancerDto loadBalancer = (LoadBalancerDto) sender.loadBalancerPanel.loadBalancerTable.getValue();

    Window winLoadBalancerEdit;
    if (PCCConstant.PLATFORM_TYPE_CLOUDSTACK.equals(loadBalancer.getLoadBalancer().getType())) {
        winLoadBalancerEdit = new WinCloudStackLoadBalancerEdit(loadBalancer.getLoadBalancer().getLoadBalancerNo());
    } else {
        winLoadBalancerEdit = new WinLoadBalancerEdit(loadBalancer.getLoadBalancer().getLoadBalancerNo());
    }

    winLoadBalancerEdit.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            refreshTable();
        }
    });

    getWindow().addWindow(winLoadBalancerEdit);
}
 

protected void	renamePolicy(final File policy) {
	//
	// Run the rename window
	//
	final RenamePolicyFileWindow window = new RenamePolicyFileWindow(policy.getName());
	window.setCaption("Rename Policy");
	window.setModal(true);
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;
		
		@Override
		public void windowClose(CloseEvent event) {
			String newFilename = window.getNewFilename();
			if (newFilename == null) {
				//
				// User cancelled
				//
				return;
			}
			Path newPolicy = Paths.get(policy.getParent(), newFilename);
			if (Files.exists(newPolicy)) {
				Notification.show("Cannot rename to an existing file", Notification.Type.ERROR_MESSAGE);
				return;
			}
			try {
				if (policy.renameTo(newPolicy.toFile()) == false) {
					throw new Exception("No known error, rename failed");
				}
				self.treeContainer.updateItem(newPolicy.getParent().toFile());
			} catch (Exception e) {
				Notification.show("Failed to rename file: " + e.getLocalizedMessage());
			}
		}
	});
	window.center();
	UI.getCurrent().addWindow(window);
}
 

protected CloseListener getCloseListenerForEditAndDeleteTag(final FilterHeaderEvent event) {
    return new Window.CloseListener() {
        private static final long serialVersionUID = 1L;

        @Override
        public void windowClose(final CloseEvent e) {
            removeUpdateAndDeleteColumn();
            getEventBus().publish(this, event);
        }
    };
}
 

public static void	editResolver(final EntityItem<PIPResolver> entity) {
	
	final PIPResolverEditorWindow window = new PIPResolverEditorWindow(entity);
	window.setModal(true);
	window.center();
	if (entity.isPersistent()) {
		window.setCaption("Edit Resolver");
	} else {
		window.setCaption("Create Resolver");
	}
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did the user click "save"?
			//
			if (window.isSaved() == false) {
				return;
			}
			//
			// Adding a new entity?
			//
			if (entity.isPersistent() == false) {
				//
				// Yes - let's official add it
				//
				((XacmlAdminUI)UI.getCurrent()).getPIPResolvers().addEntity(entity.getEntity());
				((XacmlAdminUI)UI.getCurrent()).refreshPIPConfiguration();
			}
		}
	});
	UI.getCurrent().addWindow(window);
}
 

protected void editCSVAttribute(final Table table, final ResolverAttribute request) {
	assert(this.isCSV());
	//
	// Prompt for the column
	//
	final ColumnSelectionWindow window = new ColumnSelectionWindow((request != null ? request.getColumn() : 0));
	if (request == null) {
		window.setCaption("Input the CSV Column for the new attribute");
	} else {
		window.setCaption("Edit the CSV Column for the attribute");
	}
	window.setModal(true);
	window.center();
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did the user save?
			//
			if (window.isSaved() == false) {
				return;
			}
			//
			// Save it if its not a new
			//
			if (request != null) {
				request.setColumn(window.getColumn());
			}
			//
			// Now we select the attribute, pass the column
			// in case this is a brand new attribute. Yeah its messy.
			//
			self.editResolverAttribute(table, request, window.getColumn());
		}
	});
	window.center();
	UI.getCurrent().addWindow(window);
}
 

public void showLogin() {
    WinLogin winLogin = new WinLogin();
    winLogin.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            // ログインに成功した場合
            Long userNo = ViewContext.getUserNo();
            if (userNo != null) {
                topBar.loginSuccess();
            }
        }
    });
    getApplication().getMainWindow().addWindow(winLogin);
}
 

private void addButtonClick(ClickEvent event) {
    WinLoadBalancerAdd winLoadBalancerAdd = new WinLoadBalancerAdd();
    winLoadBalancerAdd.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            refreshTable();
        }
    });

    getWindow().addWindow(winLoadBalancerAdd);
}
 

private void editButtonClick(Button.ClickEvent event) {
    InstanceDto instance = (InstanceDto) sender.serverPanel.serverTable.getValue();

    WinServerEdit winServerEdit = new WinServerEdit(instance.getInstance().getInstanceNo());
    winServerEdit.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            refreshTable();
        }
    });

    getWindow().addWindow(winServerEdit);
}
 

private void addButtonClick(ClickEvent event) {
    WinServerAdd winServerAdd = new WinServerAdd();
    winServerAdd.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            refreshTable();
        }
    });

    getWindow().addWindow(winServerAdd);
}
 

private void editButtonClick(Button.ClickEvent event) {
    ComponentDto component = (ComponentDto) sender.servicePanel.serviceTable.getValue();

    WinServiceEdit winServiceEdit = new WinServiceEdit(component.getComponent().getComponentNo());
    winServiceEdit.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            refreshTable();
        }
    });

    getWindow().addWindow(winServiceEdit);
}
 

private void addButtonClick(ClickEvent event) {
    WinServiceAdd winServiceAdd = new WinServiceAdd();
    winServiceAdd.addListener(new Window.CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            refreshTable();
        }
    });

    getWindow().addWindow(winServiceAdd);
}
 

public void showCloudEditWindow() {
    MyCloudManage window = new MyCloudManage();
    window.addListener(new CloseListener() {
        @Override
        public void windowClose(CloseEvent e) {
            sender.initialize();
            sender.refresh();
        }
    });
    getApplication().getMainWindow().addWindow(window);
}
 

protected void editParameter(final Object source) {
	//
	// Make a copy
	//
	final Object target = (source != null ? source : (this.config instanceof PIPConfiguration ? new PIPConfigParam() : new PIPResolverParam()));
	final PIPParamEditorWindow window = new PIPParamEditorWindow(target);
	window.setModal(true);
	window.setCaption((source == null ? "Create New Parameter" : "Edit Parameter"));
	window.center();
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did user save?
			//
			if (window.isSaved() == false) {
				return;
			}
			//
			// Yes - was it a brand new object?
			//
			if (source == null) {
				//
				// yes add it to the parent object
				//
				if (self.config instanceof PIPConfiguration) {
					((PIPConfiguration) self.config).addPipconfigParam((PIPConfigParam) target);
				} else {
					((PIPResolver) self.config).addPipresolverParam((PIPResolverParam) target);
				}
				//
				// add it to the table
				//
				Item item = self.tableParameters.addItem(target);
				if (item == null) {
					logger.error("Failed to add parameter: " + target);
				} else {
					self.tableParameters.select(target);
				}
			} else {
				//
				// Copy the parameters over
				//
				if (source instanceof PIPConfigParam) {
					((PIPConfigParam) source).setParamName(((PIPConfigParam) target).getParamName());
					((PIPConfigParam) source).setParamValue(((PIPConfigParam) target).getParamValue());
				} else {
					((PIPResolverParam) source).setParamName(((PIPResolverParam) target).getParamName());
					((PIPResolverParam) source).setParamValue(((PIPResolverParam) target).getParamValue());
				}
				//
				// Update the table
				//
				self.tableParameters.refreshRowCache();
			}
		}
	});
	UI.getCurrent().addWindow(window);
}
 

protected void	importPolicy(final File domain) {
	//
	// Get the current domain
	//
	if (! domain.isDirectory()) {
		logger.error("Table must have a directory selected to import the file.");
		return;
	}
	//
	// Create the upload window
	//
	final PolicyUploadWindow upload = new PolicyUploadWindow(Paths.get(domain.toURI()));
	upload.setCaption("Import Xacml 3.0 Policy File");
	upload.setCloseShortcut(KeyCode.ESCAPE);
	upload.setModal(true);
	upload.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Was it successful?
			//
			Path newFile = upload.getUploadedFile();
			if (newFile == null) {
				return;
			}
			//
			// Add it
			//
			self.addPolicyFileToTree(domain, newFile.toFile());
			//
			// Are we importing anything in the policy file?
			//
			boolean importAttributes = upload.importAttributes();
			boolean importObligations = upload.importObligations();
			boolean importAdvice = upload.importAdvice();
			if (importAttributes || importObligations || importAdvice) {
				//
				// Create our importer
				//
				XACMLPolicyImporter importer = new XACMLPolicyImporter();
				importer.setImportAttributes(importAttributes);
				importer.setImportObligations(importObligations);
				importer.setImportAdvice(importAdvice);		
				importer.setIgnoreStandardAttributes(upload.ignoreStandard());
				//
				// Yes load and scan the policy
				//
				new XACMLPolicyScanner(newFile, importer).scan();
			}
		}
	});
	upload.center();
	UI.getCurrent().addWindow(upload);
}
 

protected void editPolicySet(final PolicySetType policy, final PolicySetType parent) {
	logger.info("editPolicySet: " + policy + " parent " + parent);
	//
	// Create a copy
	//
	final PolicySetType newPolicySet = (policy == null ? new PolicySetType() : XACMLObjectCopy.copy(policy));
	//
	// Create window
	//
	final PolicySetEditorWindow window = new PolicySetEditorWindow(newPolicySet);
	window.setCaption(policy == null ? "Create New Policy Set" : "Edit Policy Set");
	window.setModal(true);
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did the user click save?
			//
			if (window.isSaved() == false) {
				if (logger.isDebugEnabled()) {
					logger.debug("user did NOT save");
				}
				return;
			}
			//
			// Was it a new Policy Set?
			//
			if (policy == null) {
				logger.info("adding new policy set " + newPolicySet.getPolicySetId());
				//
				// Yes - new add it in
				//
				if (newPolicySet.getTarget() == null) {
					newPolicySet.setTarget(new TargetType());
				}
				if (self.policyContainer.addItem(newPolicySet, parent) == null) {
					logger.error("Failed to add new policy set");
				} else {
					self.tree.setCollapsed(parent, false);
					self.tree.setCollapsed(newPolicySet, false);
					self.tree.select(newPolicySet);
				}
			} else {
				logger.info("updating new policy set " + newPolicySet.getPolicySetId());
				//
				// No - copy everything
				//
				policy.setDescription(newPolicySet.getDescription());
				policy.setVersion(newPolicySet.getVersion());
				policy.setPolicyCombiningAlgId(newPolicySet.getPolicyCombiningAlgId());
				//
				// Update
				//
				self.policyContainer.updateItem(policy);
			}
		}			
	});
	window.center();
	UI.getCurrent().addWindow(window);
}
 

protected void editPolicy(final PolicyType policy, final PolicySetType parent) {
	//
	// Create a copy
	//
	final PolicyType newPolicy = (policy == null ? new PolicyType() : XACMLObjectCopy.copy(policy));
	//
	// Create window
	//
	final PolicyEditorWindow window = new PolicyEditorWindow(newPolicy);
	window.setCaption(policy == null ? "Create New Policy" : "Edit Policy");
	window.setModal(true);
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did the user click save?
			//
			if (window.isSaved() == false) {
				return;
			}
			//
			// Was it a new Policy?
			//
			if (policy == null) {
				//
				// Yes - new add it in
				//
				if (newPolicy.getTarget() == null) {
					newPolicy.setTarget(new TargetType());
				}
				if (self.policyContainer.addItem(newPolicy, parent) == null) {
					logger.error("Failed to add policy");
				} else {
					self.tree.setCollapsed(parent, false);
					self.tree.setCollapsed(newPolicy, false);
					self.tree.select(newPolicy);
				}
			} else {
				//
				// No - copy everything
				//
				policy.setDescription(newPolicy.getDescription());
				policy.setVersion(newPolicy.getVersion());
				policy.setRuleCombiningAlgId(newPolicy.getRuleCombiningAlgId());
				//
				// Update
				//
				self.policyContainer.updateItem(policy);
			}
		}			
	});
	window.center();
	UI.getCurrent().addWindow(window);
}
 

protected void editRule(final RuleType rule, final PolicyType parent) {
	//
	// Create a copy
	//
	final RuleType newRule = (rule == null ? new RuleType() : XACMLObjectCopy.copy(rule));
	//
	// Create window
	//
	final RuleEditorWindow window = new RuleEditorWindow(newRule);
	window.setCaption(rule == null ? "Create New Rule" : "Edit Rule");
	window.setModal(true);
	window.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did the user click save?
			//
			if (window.isSaved() == false) {
				return;
			}
			//
			// Was this a new rule?
			//
			if (rule == null) {
				//
				// Yes a new rule
				//
				if (newRule.getTarget() == null) {
					newRule.setTarget(new TargetType());
				}
				if (self.policyContainer.addItem(newRule, parent) == null) {
					logger.error("Failed to add new rule");
				} else {
					self.tree.setCollapsed(parent, false);
					self.tree.setCollapsed(newRule, false);
					self.tree.select(newRule);
				}
			} else {
				//
				// No - editing existing rule. Copy everything
				//
				rule.setEffect(newRule.getEffect());
				rule.setDescription(newRule.getDescription());
				self.policyContainer.updateItem(rule);
			}
		}
	});
	window.center();
	UI.getCurrent().addWindow(window);
}
 

protected void editCondition(final ConditionType condition, final RuleType rule) {
	//
	// Make a copy of it first, in case the user manipulates it
	// and then decides to NOT save it
	//
	final ConditionType copyCondition = (condition == null ? new ConditionType() : XACMLObjectCopy.copy(condition));
	//
	// Create the window
	//
	final ExpressionBuilderComponent expression = new ExpressionBuilderComponent(copyCondition, 
										(copyCondition.getExpression() != null ? copyCondition.getExpression().getValue() : null), 
										null,
										self.policyContainer.getVariables());
	if (condition == null) {
		expression.setCaption("Create An Expression For The Condition");
	} else {
		expression.setCaption("Edit The Condition Expression");
	}
	expression.setModal(true);
	//
	// Add the close listener
	//
	expression.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent e) {
			//
			// Did the user hit save?
			//
			if (expression.isSaved() == false) {
				return;
			}
			//
			// Were we creating something new?
			//
			if (condition == null) {
				//
				// Yes add the new one into the container
				//
				if (self.policyContainer.addItem(copyCondition, rule) == null) {
					logger.error("Failed to add condition");
				} else {
					self.tree.setCollapsed(rule, false);
					self.tree.setCollapsed(copyCondition, false);
					self.tree.select(copyCondition);
				}
			} else {
				//
				// We were editing an existing condition, so copy
				// over the new edited expression.
				//
				condition.setExpression(copyCondition.getExpression());
				//
				// Update the container
				//
				self.policyContainer.updateItem(condition);
			}
		}			
	});
	expression.center();
	UI.getCurrent().addWindow(expression);
}
 

protected void editPDP(final PDP pdp, final PDPGroup group) {
	final EditPDPWindow editor = new EditPDPWindow(pdp, this.container.getGroups());
	if (pdp == null) {
		editor.setCaption("Create New PDP");
	} else {
		editor.setCaption("Edit PDP " + pdp.getId());
	}
	editor.setModal(true);
	editor.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent event) {
			if (editor.isSaved() == false) {
				return;
			}
			try {
				//
				// Adding a new PDP?
				//
				if (pdp == null) {
					//
					// Yes tell the container to add it
					//
					self.container.addNewPDP(editor.getPDPId(), group, editor.getPDPName(), editor.getPDPDescription());
				} else {
					//
					// No tell the container to update it
					//
					pdp.setName(editor.getPDPName());
					pdp.setDescription(editor.getPDPDescription());
					self.container.updatePDP(pdp);
				}
			} catch (Exception e) {
				String message = "Unable to create PDP.  Reason:\n" + e.getMessage();
				logger.error(message);
				AdminNotification.error(message);
			}
		}
	});
	editor.center();
	UI.getCurrent().addWindow(editor);
}
 

protected void editPDPGroup(final PDPGroup group) {
	//
	// copy the group
	//
	final StdPDPGroup copyGroup = (group == null ? null : new StdPDPGroup(group));
	//
	//
	//
	final EditPDPGroupWindow editor = new EditPDPGroupWindow(copyGroup, this.container.getGroups(), papEngine);
	if (group == null) {
		editor.setCaption("Create PDP Group");
	} else {
		editor.setCaption("Edit PDP Group " + ((PDPGroup) group).getName());
	}
	editor.setModal(true);
	editor.addCloseListener(new CloseListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void windowClose(CloseEvent event) {
			if (editor.isSaved() == false) {
				return;
			}
			if (group == null) {
				//
				// Creating a new group
				//
				try {
					self.container.addNewGroup(editor.getGroupName(), editor.getGroupDescription());
				} catch (Exception e) {
					String message = "Unable to create Group.  Reason:\n" + e.getMessage();
					logger.error(message);
					AdminNotification.error(message);
				}
			} else {
				//
				// Update group
				//
				self.container.updateGroup(editor.getUpdatedObject());
			}
		}
	});
	editor.center();
	UI.getCurrent().addWindow(editor);
}
 

/**
 * {@inheritDoc}
 */
public void windowClose(CloseEvent e) {
	if (((FormDialog) e.getWindow()).isDirty())
		loadPage();
}