package hsqldb.functions;
import java.util.zip.CRC32;
public class CrcUtil {
public static long crc(String data) {
CRC32 crc32 = new CRC32();
crc32.update(data.getBytes());
return crc32.getValue();
}
}

                
CREATE ALIAS CRC FOR "hsqldb.functions.CrcUtil.crc";
GRANT ALL ON CLASS "hsqldb.functions.CrcUtil" TO PUBLIC;

                
<extension
id="hsqldbEngine"
name="HSQLDB Engine"
point="org.eclipse.core.resources.natures">
<requires-nature
id="org.eclipse.jdt.core.javanature">
</requires-nature>
<runtime>
<run
class="hsqldb.nature.DBEngineNature">
</run>
</runtime>
</extension>

                
<extension
point="org.eclipse.ui.popupMenus">
<objectContribution
objectClass="org.eclipse.core.resources.IFile"
nameFilter="*.sql"
id="hsqldb.ui.SQLScriptFiles">
<visibility>
<objectState
name="projectNature"
value="hsqldb.ui.hsqldbEngine">
</objectState>
</visibility>
<action
label="Run HSQLDB Script"
class="hsqldb.ui.popup.actions.HsqldbRunScript"
menubarPath="additions"
enablesFor="1"
id="hsqldb.ui.HsqldbRunScript">
<enablement>
<objectState
name="projectSessionProperty"
value="hsqldb.ui.running">
</objectState>
</enablement>
</action>
</objectContribution>
<objectContribution
objectClass="org.eclipse.jdt.core.IJavaProject"
id="hsqldb.ui.HsqldbEngineMenu">
<menu
label="HSQLDB"
path="additions"
id="hsqldb.ui.HsqldbProject">
<separator
name="hsqldb.ui.group1">
</separator>
<separator
name="hsqldb.ui.group2">
</separator>
</menu>
</objectContribution>
<objectContribution
objectClass="org.eclipse.jdt.core.IJavaProject"
id="hsqldb.ui.HsqldbEngineActions">
<visibility>
<objectState
name="nature"
value="hsqldb.ui.hsqldbEngine">
</objectState>
</visibility>
<action
label="Run Database Manager (Standalone)"
icon="icons/dbmansa.gif"
class="hsqldb.ui.popup.actions.RunDatabaseManagerStandalone"
menubarPath="hsqldb.ui.HsqldbProject/group1"
enablesFor="1"
id="hsqldb.ui.RunDatabaseManagerStandalone">
<enablement>
<not>
<objectState
name="sessionProperty"
value="hsqldb.ui.running">
</objectState>
</not>
</enablement>
</action>
<action
label="Run Database Manager (Client)"
icon="icons/dbman.gif"
class="hsqldb.ui.popup.actions.RunDatabaseManager"
menubarPath="hsqldb.ui.HsqldbProject/group1"
enablesFor="1"
id="hsqldb.ui.RunDatabaseManager">
<enablement>
<objectState
name="sessionProperty"
value="hsqldb.ui.running">
</objectState>
</enablement>
</action>
<action
label="Stop HSQLDB Server"
icon="icons/stop.gif"
class="hsqldb.ui.popup.actions.StopHsqldbServer"
menubarPath="hsqldb.ui.HsqldbProject/group1"
enablesFor="1"
id="hsqldb.ui.StopHsqldbServer">
<enablement>
<objectState
name="sessionProperty"
value="hsqldb.ui.running">
</objectState>
</enablement>
</action>
<action
label="Start HSQLDB Server"
icon="icons/start.gif"
class="hsqldb.ui.popup.actions.StartHsqldbServer"
menubarPath="hsqldb.ui.HsqldbProject/group1"
enablesFor="1"
id="hsqldb.ui.StartHsqldbServer">
<enablement>
<not>
<objectState
name="sessionProperty"
value="hsqldb.ui.running">
</objectState>
</not>
</enablement>
</action>
</objectContribution>
<objectContribution
objectClass="org.eclipse.jdt.core.IJavaProject"
id="hsqldb.ui.JavaProjects">
<visibility>
<not>
<objectState
name="nature"
value="hsqldb.ui.hsqldbEngine">
</objectState>
</not>
</visibility>
<action
label="Add Database Engine nature"
class="hsqldb.ui.popup.actions.AddDBEngineNature"
menubarPath="hsqldb.ui.HsqldbProject/group2"
enablesFor="1"
id="hsqldb.ui.AddDBEngineNature">
</action>
</objectContribution>
<objectContribution
objectClass="org.eclipse.jdt.core.IJavaProject"
id="hsqldb.ui.HsqldbEngineProjects">
<visibility>
<objectState
name="nature"
value="hsqldb.ui.hsqldbEngine">
</objectState>
</visibility>
<action
label="Remove Database Engine nature"
class="hsqldb.ui.popup.actions.RemoveDBEngineNature"
menubarPath="hsqldb.ui.HsqldbProject/group2"
enablesFor="1"
id="hsqldb.ui.AddDBEngineNature">
</action>
</objectContribution>
</extension>

                
<extension
id="hsqldb.ui.property"
point="org.eclipse.ui.propertyPages">
<page
objectClass="org.eclipse.jdt.core.IJavaProject"
name="HSQLDB Server"
class="hsqldb.ui.properties.DBEnginePropertyPage"
id="hsqldb.ui.properties.DBEnginePropertyPage">
<filter
name="nature"
value="hsqldb.ui.hsqldbEngine">
</filter>
</page>
</extension>

                
IProject proj = currentProject.getProject();
IProjectDescription description = proj.getDescription();
// add the hsqldbEngine nature to the project
String[] natures = description.getNatureIds();
String[] newNatures = new String[natures.length + 1];
System.arraycopy(natures, 0, newNatures, 0, natures.length);
// must prefix with plugin id!!!
newNatures[natures.length] = "hsqldb.ui.hsqldbEngine";
description.setNatureIds(newNatures);
proj.setDescription(description, null);
// add the HSQLDB classpath variable
IClasspathEntry[] rawClasspath = currentProject.getRawClasspath();
IClasspathEntry[] newRawClasspath = new IClasspathEntry[
rawClasspath.length + 1];
System.arraycopy(rawClasspath, 0, newRawClasspath, 0,
rawClasspath.length);
newRawClasspath[rawClasspath.length] = JavaCore.newVariableEntry(
new Path("HSQLDB"), null, null);
currentProject.setRawClasspath(newRawClasspath, null);
// create the initial database files
IPath dbPath = proj.getLocation();
String database = dbPath.toString() + "/database";
HsqldbUtil.createEmptyHsqlDatabase(database);
// refresh project so user sees new files, libraries, etc
proj.refreshLocal(IResource.DEPTH_INFINITE, null);

                
<extension
point="org.eclipse.jdt.core.classpathVariableInitializer">
<classpathVariableInitializer
variable="HSQLDB"
class="hsqldb.ui.classpath.HsqldbVariable">
</classpathVariableInitializer>
</extension>

                
public class HsqldbVariable extends ClasspathVariableInitializer {
public HsqldbVariable() {
super();
}
public void initialize(String variable) {
// ignore the "variable" argument, since we define just one
// classpath variable
try {
JavaCore.setClasspathVariable("HSQLDB", new Path(
HsqldbUtil.getHsqldbJarPath()), null);
}
// can't create the classpath variable
catch (JavaModelException e) {
System.err.println(e);
}
}
}

                
public class RemoveDBEngineNature implements IObjectActionDelegate {
private IJavaProject currentProject;
public RemoveDBEngineNature() {
super();
}
public void setActivePart(IAction action, IWorkbenchPart targetPart) {
}
public void run(IAction action) {
try {
IProject proj = currentProject.getProject();
IProjectDescription description = proj.getDescription();
// remove the hsqldbEngine nature to the project
String[] natures = description.getNatureIds();
String[] newNatures = new String[natures.length - 1];
for(int i = 0; i < natures.length; i++) {
if (!natures[i].equals("hsqldb.ui.hsqldbEngine"))
newNatures[i] = natures[i];
}
description.setNatureIds(newNatures);
proj.setDescription(description, null);
// refresh project so user sees changes
proj.refreshLocal(IResource.DEPTH_INFINITE, null);
// as both decorators share the same visibility rules, this will work
HsqldbRunningDecorator.updateDecorators();
}
catch (Exception e) {
Shell shell = new Shell();
MessageDialog.openInformation(
shell,
"Hsqldb Ui Plug-in",
"Cannot remove HSQLDB Database Engine nature:\n" +
ActionUtil.getStatusMessages(e));
}
Shell shell = new Shell();
MessageDialog.openInformation(
shell,
"Hsqldb Ui Plug-in",
"Removed HSQLDB Database Engine from this project.\n" +
"You must manually delete database files and libraries if wanted.");
}
public void selectionChanged(IAction action, ISelection selection) {
currentProject = ActionUtil.findSelectedJavaProject(selection);
}
}

                
public class ActionUtil {
public static IJavaProject findSelectedJavaProject(ISelection selection) {
IJavaProject currentProject = null;
if (selection != null) {
if (selection instanceof IStructuredSelection) {
IStructuredSelection ss = (IStructuredSelection)selection;
Object obj = ss.getFirstElement();
if (obj instanceof IJavaProject) {
currentProject = (IJavaProject)obj;
}
}
}
return currentProject;
}
public static IFile findSelectedFile(ISelection selection) {
IFile currentFile = null;
if (selection != null) {
if (selection instanceof IStructuredSelection) {
IStructuredSelection ss = (IStructuredSelection)selection;
// as this action is enabled only for a single selection,
// it's enough to get the first element
Object obj = ss.getFirstElement();
if (obj instanceof IFile) {
currentFile = (IFile)obj;
}
}
}
return currentFile;
}
public static String getStatusMessages(Exception e) {
String msg = e.getMessage();
if (e instanceof CoreException) {
CoreException ce = (CoreException)e;    IStatus status = ce.getStatus();
IStatus[] children = status.getChildren();
for (int i = 0; i < children.length; i++)
msg += "\n" + children[i].getMessage();
System.err.println(msg);
ce.printStackTrace(System.err);
}
return msg;
}
}

                
protected static ILaunch launch(IJavaProject proj, String name,
String mainClass, String args) throws CoreException {
ILaunchManager manager =
DebugPlugin.getDefault().getLaunchManager();
ILaunchConfigurationType type =
manager.getLaunchConfigurationType(
IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
ILaunchConfiguration config = null;
// if the configuration already exists, use it!
ILaunchConfiguration[] configurations =
manager.getLaunchConfigurations(type);
for (int i = 0; i < configurations.length; i++) {
if (configurations[i].getName().equals(name))
config = configurations[i];
}
// else create a new one
if (config == null) {
ILaunchConfigurationWorkingCopy wc =
type.newInstance(null, name);
wc.setAttribute(
IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME,
proj.getProject().getName());
// current directory should be the project root
wc.setAttribute(
IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY,
proj.getProject().getLocation().toString());
// use the supplied args
wc.setAttribute(
IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME,
mainClass);
wc.setAttribute(
IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS,
args);
// saves the new config
config = wc.doSave();
}
// launches the configuration
DebugPlugin debug = DebugPlugin.getDefault();
return config.launch(ILaunchManager.RUN_MODE, null);
}

                
public void startHsqldbServer(IJavaProject proj) throws CoreException {
// build server command-line
HsqldbParams params = new HsqldbParams(proj);
String database = proj.getProject().getLocation() + "/database";
String args = "-database " + database + " " +
"-port " + params.port;
// starts the server as a Java app
ILaunch launch = HsqldbUtil.launch(proj, proj.getElementName(),
"org.hsqldb.Server", args);
// saves the mapping between (server) process and project
servers.put(launch.getProcesses()[0], proj);
// register a listener so we know when this process is finished
DebugPlugin debug = DebugPlugin.getDefault();
debug.addDebugEventListener(listener);
// so the UI will reflect there's already a server running
setRunning(proj, Boolean.TRUE);
}

                
private IDebugEventSetListener listener = new IDebugEventSetListener() {
public void handleDebugEvents(DebugEvent[] events) {
// if the event was a terminate...
if (events[0].getKind() == DebugEvent.TERMINATE) {
Object source = events[0].getSource();
if (source instanceof IProcess) {
// ...and the terminated process is a HSQLDB Server...
Object proj = servers.get(source);
if (proj != null) {
try {
//...remove it from the map and update the ui
servers.remove(source);
setRunning((IJavaProject)proj, null);
}
catch (CoreException ce) {
System.err.println("HsqldbServerTracker.handleDebugEvents");
System.err.println(ActionUtil.getStatusMessages(ce));
}
}
}
}
}
};

                
public boolean getRunning(IJavaProject javaProj) throws CoreException {
IProject proj = javaProj.getProject();
Object value = proj.getSessionProperty(new QualifiedName(
"hsqldb.ui", "running"));
return value != null;
}
public void setRunning(IJavaProject javaProj, Boolean value)
throws CoreException {
if (value != null && value.equals(Boolean.FALSE))
value = null;
IProject proj = javaProj.getProject();
proj.setSessionProperty(new QualifiedName("hsqldb.ui", "running"),
value);
HsqldbRunningDecorator.updateDecorators(javaProj);
}

                
public class HsqldbParams {
// property names
public static final String P_PORT = "serverPort";
public static final String P_USER = "serverUser";
public static final String P_PASSWD = "serverPasswd";
public int port = 9001;
public String user = "sa";
public String passwd = "";
public HsqldbParams() {}
public HsqldbParams(IJavaProject javaProject) throws CoreException {
load(javaProject);
}
public void save(IJavaProject javaProject) throws CoreException {
IProject project = javaProject.getProject();
project.setPersistentProperty(new QualifiedName (
"hsqldb.ui", P_PORT), Integer.toString(port));
project.setPersistentProperty(new QualifiedName (
"hsqldb.ui", P_USER), user);
project.setPersistentProperty(new QualifiedName (
"hsqldb.ui", P_PASSWD), passwd);
}
public void load(IJavaProject javaProject) throws CoreException {
IProject project = javaProject.getProject();
String property = project.getPersistentProperty(new QualifiedName (
"hsqldb.ui", P_PORT));
port = (property != null && property.length() > 0) ?
Integer.parseInt(property) : port;
property = project.getPersistentProperty(new QualifiedName (
"hsqldb.ui", P_USER));
user = (property != null && property.length() > 0) ? property : user;
property = project.getPersistentProperty(new QualifiedName (
"hsqldb.ui", P_PASSWD));
passwd = (property != null && property.length() > 0) ?
property : passwd;
}
}

                
public class DBEnginePropertyPage extends PropertyPage {
private HsqldbParams params;
private Text portText;
private Text userText;
private Text passwdText;
public DBEnginePropertyPage() {
super();
}
private void fillControls() {
portText.setText(Integer.toString(params.port));
userText.setText(params.user);
passwdText.setText(params.passwd);
}
private void getParams() {
params = new HsqldbParams();
try {
params.port = Integer.parseInt(portText.getText());
}
catch (NumberFormatException ne) {
// do nothing; let the default port number
}
params.user = userText.getText();
params.passwd = passwdText.getText();
}
private void addControls(Composite parent) {
Composite composite = createDefaultComposite(parent);
Label pathLabel = new Label(composite, SWT.NONE);
pathLabel.setText("&TCP Port:");
portText = new Text(composite, SWT.SINGLE | SWT.BORDER);
GridData gd = new GridData();
gd.widthHint = convertWidthInCharsToPixels(6);
portText.setLayoutData(gd);
Label userLabel = new Label(composite, SWT.NONE);
userLabel.setText("&User:");
userText = new Text(composite, SWT.SINGLE | SWT.BORDER);
gd = new GridData();
gd.widthHint = convertWidthInCharsToPixels(15);
userText.setLayoutData(gd);
Label passwdLabel = new Label(composite, SWT.NONE);
passwdLabel.setText("&Password:");
passwdText = new Text(composite, SWT.SINGLE | SWT.BORDER);
gd = new GridData();
gd.widthHint = convertWidthInCharsToPixels(15);
passwdText.setLayoutData(gd);
}
protected Control createContents(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
GridLayout layout = new GridLayout();
composite.setLayout(layout);
GridData data = new GridData(GridData.FILL);
data.grabExcessHorizontalSpace = true;
composite.setLayoutData(data);
addControls(composite);
IJavaProject proj = (IJavaProject)getElement();
try {
params = new HsqldbParams(proj);
fillControls();
}
catch (CoreException ce) {
System.err.println(ActionUtil.getStatusMessages(ce));
}
return composite;
}
private Composite createDefaultComposite(Composite parent) {
Composite composite = new Composite(parent, SWT.NULL);
GridLayout layout = new GridLayout();
layout.numColumns = 2;
composite.setLayout(layout);
GridData data = new GridData();
data.verticalAlignment = GridData.FILL;
data.horizontalAlignment = GridData.FILL;
composite.setLayoutData(data);
return composite;
}
protected void performDefaults() {
params = new HsqldbParams();
fillControls();
}
public boolean performOk() {
IJavaProject proj = (IJavaProject)getElement();
getParams();
try {
params.save(proj);
}
catch (CoreException ce) {
System.err.println(ActionUtil.getStatusMessages(ce));
return false;
}
return true;
}
}

                
<extension
point="org.eclipse.ui.decorators">
<decorator
lightweight="true"
quadrant="TOP_RIGHT"
location="TOP_RIGHT"
adaptable="true"
label="HSQLDB Engine Project"
icon="icons/dec-dbnature.gif"
state="true"
id="hsqldb.ui.hsqldbEngineDecorator">
<description>
Flags Java Projects that had the HSQLDB Engine project
nature added to them.
</description>
<enablement>
<and>
<objectClass
name="org.eclipse.jdt.core.IJavaProject">
</objectClass>
<objectState
name="nature"
value="hsqldb.ui.hsqldbEngine">
</objectState>
</and>
</enablement>
</decorator>

                
<decorator
lightweight="true"
quadrant="BOTTOM_RIGHT"
location="BOTTOM_RIGHT"
adaptable="true"
label="HSQLDB Running"
state="true"
id="hsqldb.ui.hsqldbRunningDecorator">
<description>
Flags HSQLDB Engine Projects which have a running
server instance.
</description>
<enablement>
<and>
<objectClass
     name="org.eclipse.jdt.core.IJavaProject">
</objectClass>
<and>
   <objectState
         name="nature"
         value="hsqldb.ui.hsqldbEngine">
   </objectState>
   <objectState
        name="sessionProperty"
        value="hsqldb.ui.running">
   </objectState>
</and>
</and>
</enablement>
</decorator>
</extension>

                
<decorator
lightweight="true"
quadrant="BOTTOM_RIGHT"
location="BOTTOM_RIGHT"
adaptable="true"
label="HSQLDB Running"
state="true"
class="hsqldb.ui.decorator.HsqldbRunningDecorator"
id="hsqldb.ui.hsqldbRunningDecorator">
<description>
Flags HSQLDB Engine Projects which have a running server instance.
</description>
<enablement>
<and>
<objectClass
name="org.eclipse.jdt.core.IJavaProject">
</objectClass>
<objectState
name="nature"
value="hsqldb.ui.hsqldbEngine">
</objectState>
</and>
</enablement>
</decorator>
</extension>

                
public class HsqldbRunningDecorator
extends LabelProvider
implements ILightweightLabelDecorator {
private static final ImageDescriptor runningDescriptor =
ImageDescriptor.createFromFile (
HsqldbRunningDecorator.class, "dec-running.gif");
public void decorate(Object element, IDecoration decoration) {
IJavaProject javaProj = (IJavaProject)element;
try {
if (HsqldbServerTracker.getDefault().getRunning(javaProj)) {
decoration.addOverlay(runningDescriptor);
}
}
catch (CoreException ce) {
System.err.println(ActionUtil.getStatusMessages(ce));
}
}
public static void updateDecorators(IJavaProject javaProj) {
IDecoratorManager dm =
PluginUi.getDefault().getWorkbench().getDecoratorManager();
HsqldbRunningDecorator decorator = (HsqldbRunningDecorator)
dm.getBaseLabelProvider("hsqldb.ui.hsqldbRunningDecorator");
decorator.fireUpdateDecorators(javaProj);
}
private void fireUpdateDecorators(IJavaProject proj) {
// I can generate my own event to update the decorators
// for a given resource
final LabelProviderChangedEvent ev =
new LabelProviderChangedEvent(this, proj);
Display.getDefault().asyncExec(new Runnable() {
public void run() {
fireLabelProviderChanged(ev);
}
});
}
public static void updateDecorators() {
// I can also let the workbench generate events to update all
// resources affected by a decorator
Display.getDefault().asyncExec(new Runnable() {
public void run() {
PluginUi.getDefault().getWorkbench().getDecoratorManager()
.update("hsqldb.ui.hsqldbRunningDecorator");
}
});
}

}