sdadataset.java

很好的UI界面源码..还有自己的输入法,可以更换风格.可以学习和使用

                rem.destroy();
                rs.closeRecordStore();
            } catch (Exception e) {
            }
        }
    }
    //行构造
    public Row newRow() {
        return new Row();
    }

    public SDADataSet() {
        internalSDADataSet();
    }

    private void internalSDADataSet() {
        Fields = new Vector();
        Rows = new Vector();
        allRows = new Vector();
        exp = new SDAExpression();
        recChangeLog = false;
        deltaFields = new Vector();
        deltaRows = new Vector();
        dataControlList = new Vector();
        dataRms = new DataSetRMS();
    }
    //从数据库加载
    public void loadFromRms(String tableName) {
        dataRms.loadTable(tableName);
        setAutoID();
        refreshDataControl();
    }
    //保存到数据库
    public void saveToRms(String tableName) {
        dataRms.WriteDataSet(tableName);
    }

    public void showAllRecord() {
        enableControls = false;
        Row row = null;
        for (int i = 0; i < allRows.size(); i++) {
            row = (Row) allRows.elementAt(i);
            if (!row.visible) {
                row.setVisible(true);
            }
        }
        enableControls();
    }

    public void setFiltered() {
        First();
        enableControls = false;
        //执行过滤
        Row row = null;
        for (int i = 0; i < allRows.size(); i++) {
            row = (Row) allRows.elementAt(i);
            row.setVisible(true);
            doDataFilter(row);
        }
        enableControls();
    }

    public boolean isAutoID() {
        return autoID;
    }

    public void setAutoID(boolean autoID) {
        this.autoID = autoID;
        setAutoID();
        refreshDataControl();
    }

    //对观察表格进行中断处理
    public void disableControls() {
        enableControls = false;
    }

    public void enableControls() {
        enableControls = true;
        refreshDataControl();
    }
    //刷新组件
    private void refreshDataControl() {
        if (enableControls) {
            for (int i = 0; i < dataControlList.size(); i++) {
                SDABaseControl ctrl = (SDABaseControl) dataControlList.elementAt(i);
                if (ctrl != null) {
                    ctrl.paint();
                }
            }
        }
    }
    //需要刷新的表格
    protected void setWatchControl(SDABaseControl control, boolean setWatch) {
        if (setWatch) {
            if (!dataControlList.contains(control)) {
                dataControlList.addElement(control);
            }
        } else {
            int id = dataControlList.indexOf(control);
            if (id > -1) {
                dataControlList.removeElementAt(id);
            }
        }
    }
    //字段操作处理
    //如果已经存在row,字段将不能够再操作
    private boolean isCanEditFields() {
        boolean result = false;
        if (recChangeLog) {
            result = false;
        } else {
            result = true;
        }
        if (Rows.size() > 0) {
            result = false;
        } else {
            result = true;
        }
        return result;
    }
    //如果没有字段，就不能够增加字段
    private boolean isCanAddRow() {
        if (Fields.size() < 1) {
            return false;
        } else {
            return true;
        }
    }
    //开始记录delta,设置以后，结构不允许变动
    public void setDeltaRecord(boolean canRecord, String keyFieldName) {
        internalSetDeltaRecord(canRecord, keyFieldName);
    }

    private void internalSetDeltaRecord(boolean canRecord, String keyFieldName) {
        if (recChangeLog && canRecord) {
            return;
        }
        recChangeLog = canRecord;
        if (recChangeLog) {
            //判断结构中有无该key
            if (!Fields.contains(keyFieldName)) {
                System.out.println("Can not find the keyFieldName:\"" + keyFieldName + "\"");
                return;
            }
            //记录当前数据信息到临时结构
            keyName = keyFieldName;
            copyToDelta();
        } else {
            //删除临时结构内容
            deleteFromDelta();
        }
    }
    //获取delpta内容
    public String getDelta() {
        return internalGetDelta();
    }

    private String internalGetDelta() {
        //比较新旧内容，计算出差异
        StringBuffer DeltaXml = new StringBuffer();
        DeltaXml.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
        DeltaXml.append("<DataSet>");
        //循环当前Rows
        Row row = null;
        Field fd = null;
        String keyValue = "";
        for (int i = 0; i < Rows.size(); i++) {
            row = (Row) Rows.elementAt(i);
            keyValue = row.getValueByFieldName(keyName);
            if (keyValue == null) {
                //新增的
                DeltaXml.append("<D us=\"Insert\">");
                for (int j = 0; j < row.valueList.size(); j++) {
                    fd = (Field) Fields.elementAt(j);
                    DeltaXml.append("<" + fd.FiledName + "><![CDATA[" + String.valueOf(row.valueList.elementAt(j)) + "]]></" + fd.FiledName + ">");
                }
                DeltaXml.append("</D>");
            }
            //查找旧的里面有无新Key值,有就比较值，不同就增，没有也增
            Row oldrow = getDeltaRow(keyName, keyValue);
            if (oldrow != null) {
                for (int j = 0; j < Fields.size(); j++) {
                    Row newrow = (Row) Rows.elementAt(i);
                    if (!newrow.valueList.elementAt(j).equals(oldrow.valueList.elementAt(j))) {
                        fd = (Field) Fields.elementAt(j);
                        DeltaXml.append("<D us=\"Modify\">");
                        for (int k = 0; k < newrow.valueList.size(); k++) {
                            fd = (Field) Fields.elementAt(k);
                            DeltaXml.append("<" + fd.FiledName + "><![CDATA[" + String.valueOf(newrow.valueList.elementAt(k)) + "]]></" + fd.FiledName + ">");
                        }
                        DeltaXml.append("</D>");
                        break;
                    }
                }
            } else {
                //增加
                DeltaXml.append("<D us=\"Insert\">");
                for (int j = 0; j < row.valueList.size(); j++) {
                    fd = (Field) Fields.elementAt(j);
                    DeltaXml.append("<" + fd.FiledName + "><![CDATA[" + String.valueOf(row.valueList.elementAt(j)) + "]]></" + fd.FiledName + ">");
                }
                DeltaXml.append("</D>");
            }
        }
        //删除的
        for (int i = 0; i < deltaRows.size(); i++) {
            row = (Row) deltaRows.elementAt(i);
            keyValue = row.getValueByFieldName(keyName);
            if (getRow(keyName, keyValue) == null) {
                //删除的
                DeltaXml.append("<D us=\"Delete\">");
                DeltaXml.append("<" + keyName + "><![CDATA[" + keyValue + "]]></" + keyName + ">");
                DeltaXml.append("</D>");
            }
        }
        DeltaXml.append("</DataSet>");
        return DeltaXml.toString();
    }
    //拷贝信息
    public Field copyField(Field fd) {
        return internalCopyField(fd);
    }

    private Field internalCopyField(Field fd) {
        if (fd == null) {
            return null;
        }
        Field CopyField = new Field(fd.FiledName, fd.FiledType, fd.CalField, fd.CalExpression);
        return CopyField;
    }

    public Row copyRow(Row row) {
        return internalCopyRow(row);
    }

    private Row internalCopyRow(Row row) {
        if (row == null) {
            return null;
        }
        Row CopyRow = new Row();
        //拷贝记录
        for (int i = 0; i < row.valueList.size(); i++) {
            String st = String.valueOf(row.valueList.elementAt(i));
            CopyRow.valueList.addElement(st);
        }
        return CopyRow;
    }
    //拷贝数据到delta记录结构
    private void copyToDelta() {
        //Fields拷贝
        for (int i = 0; i < Fields.size(); i++) {
            deltaFields.addElement(copyField((Field) Fields.elementAt(i)));
        }
        //row拷贝
        for (int i = 0; i < Rows.size(); i++) {
            deltaRows.addElement(copyRow((Row) Rows.elementAt(i)));
        }
    }
    //删除临时结构的数据
    private void deleteFromDelta() {
        //Fields删除
        deltaFields.removeAllElements();
        //行删除
        deltaRows.removeAllElements();
        System.gc();
    }
    //增加
    public void addFiled(Field field) {
        internalAddFiled(field);
    }

    private void internalAddFiled(Field field) {
        if (isCanEditFields()) {
            if (!Fields.contains(field)) {
                Fields.addElement(field);
            }
        } else {
            System.out.println("Can not edit Fields.");
        }
    }
    //清除字段
    public void close() {
        internalClearFields();
    }

    private void internalClearFields() {
        Fields.removeAllElements();
        //也得清除数据
        for (int i = 0; i < allRows.size(); i++) {
            ((Row) allRows.elementAt(i)).valueList.removeAllElements();
        }
        allRows.removeAllElements();
        Rows.removeAllElements();
        refreshDataControl();
        System.gc();
    }
    //删除字段
    public void deleteField(int fieldIndex) {
        internalDeleteField(fieldIndex);
    }

    private void internalDeleteField(int fieldIndex) {
        if (isCanEditFields()) {
            if ((fieldIndex > -1) && (fieldIndex < Fields.size())) {
                Fields.removeElementAt(fieldIndex);
            }
        } else {
            System.out.println("Can not edit Fields.");
        }
    }

    public void deleteField(String fieldName) {
        internalDeleteField(fieldName);
    }

    private void internalDeleteField(String fieldName) {
        if (isCanEditFields()) {
            for (int i = 0; i < Fields.size(); i++) {
                Field fd = (Field) Fields.elementAt(i);
                if (fd.FiledName.equals(fieldName)) {
                    Fields.removeElementAt(i);
                    fd = null;
                    break;
                }
            }
        } else {
            System.out.println("Can not edit Fields.");
        }
    }

    public void deleteField(Field field) {
        internalDeleteField(field);
    }

    private void internalDeleteField(Field field) {
        if (isCanEditFields()) {
            int index = Fields.indexOf(field);
            if (index > -1) {
                Fields.removeElementAt(index);
            }
        } else {
            System.out.println("Can not edit Fields.");
        }
    }

    public Field getField(int fieldIndex) {
        return internalGetField(fieldIndex);
    }

    private Field internalGetField(int fieldIndex) {
        Field fd = null;
        if ((fieldIndex > -1) && (fieldIndex < Fields.size())) {
            fd = (Field) Fields.elementAt(fieldIndex);
        }
        return fd;
    }

    public int getFieldIndex(String fieldName) {
        return internalGetFieldIndex(fieldName);
    }

    private int internalGetFieldIndex(String fieldName) {
        Field fd = null;
        int result = -1;
        for (int i = 0; i < Fields.size(); i++) {
            fd = (Field) Fields.elementAt(i);
            if (fd.FiledName.equals(fieldName)) {
                result = i;
            }
        }
        return result;
    }

    public int getFieldsCount() {
        return Fields.size();
    }

    public Field getField(String fieldName) {
        return internalGetField(fieldName);
    }

    private Field internalGetField(String fieldName) {
        Field fd = null;
        for (int i = 0; i < Fields.size(); i++) {
            fd = (Field) Fields.elementAt(i);
            if (fd.FiledName.equals(fieldName)) {
                break;
            }
        }
        return fd;
    }
    //获取资料    
    //记录数
    public int getRecordCount() {
        return Rows.size();
    }

    //当前记录号
    public int getRecordNo() {
        return RecNo;
    }

    public void setRecordNo(int RecNo) {
        internalSetRecordNo(RecNo);
    }

    private void internalSetRecordNo(int RecNo) {
        if (Rows.size() > 0) {
            if ((Rows.size() >= RecNo) && (RecNo > -1)) {
                this.RecNo = RecNo;
                refreshDataControl();
            }
        }
    }

    protected void doDataChangeScroll(int recNo) {
        if (onDataScrollChange != null) {
            Row row = getRow(recNo);
            onDataScrollChange.Event(row);
        }
    }

    protected void doDataChangeScroll(Row row) {
        if (onDataScrollChange != null) {
            onDataScrollChange.Event(row);
        }
    }
    //过滤
    protected void doDataFilter(Row row) {
        if (onDataFilter != null) {
            onDataFilter.Event(row);
        }
    }
    //导航
    public Row First() {
        return internalFirst();
    }

    private Row internalFirst() {
        if (Rows.size() > 0) {