Example usage for com.google.gwt.user.client Window confirm

List of usage examples for com.google.gwt.user.client Window confirm

  1. HOME
  2. Java
  3. com.google.gwt
  4. com.google.gwt.user.client.*
  5. Window
  6. confirm

Introduction

In this page you can find the example usage for com.google.gwt.user.client Window confirm.

Prototype

public static boolean confirm(String msg)

Source Link

Usage

From source file:org.openelis.modules.neonatalScreeningSampleLogin.client.NeonatalScreeningSampleLoginScreenUI.java

License:Open Source License

/**
 * Calls the service method to commit the data on the screen, to the
 * database. Shows any errors/warnings encountered during the commit,
 * otherwise loads the screen with the committed data.
 *//*from  w  w w.jav a2 s  .  c o m*/
protected void commitUpdate(final boolean ignoreWarning) {
    Integer accession;
    String prefix;
    PatientDO data;
    ValidationErrorsList e1;

    if (state == ADD)
        setBusy(Messages.get().adding());
    else
        setBusy(Messages.get().updating());

    try {
        /*
         * add the patient if it's a new one; update it if it's locked
         */
        data = manager.getSampleNeonatal().getPatient();
        if (data.getId() == null) {
            PatientService.get().validate(data);
            data = PatientService.get().add(data);
            manager.getSampleNeonatal().setPatientId(data.getId());
            manager.getSampleNeonatal().setPatient(data);
        } else if (isPatientLocked) {
            PatientService.get().validate(data);
            data = PatientService.get().update(data);
            manager.getSampleNeonatal().setPatient(data);
            isPatientLocked = false;
        }

        /*
         * add the next of kin if it's a new one; update it if it's locked
         */
        data = manager.getSampleNeonatal().getNextOfKin();
        if (data.getId() == null) {
            PatientService.get().validate(data);
            data = PatientService.get().add(data);
            manager.getSampleNeonatal().setNextOfKinId(data.getId());
            manager.getSampleNeonatal().setNextOfKin(data);
        } else if (isNextOfKinLocked) {
            PatientService.get().validate(data);
            data = PatientService.get().update(data);
            manager.getSampleNeonatal().setNextOfKin(data);
            isNextOfKinLocked = false;
        }
    } catch (ValidationErrorsList e) {
        /*
         * for display
         */
        accession = manager.getSample().getAccessionNumber();
        if (accession == null)
            accession = 0;

        /*
         * new FormErrorExceptions are created to prepend accession number
         * to the messages of FormErrorExceptions returned by patient
         * validation; other exceptions are shown as is
         */
        e1 = new ValidationErrorsList();
        prefix = Messages.get().sample_accessionPrefix(accession);
        for (Exception ex : e.getErrorList()) {
            if (ex instanceof FormErrorException)
                e1.add(new FormErrorException(DataBaseUtil.concatWithSeparator(prefix, " ", ex.getMessage())));
            else
                e1.add(ex);
        }

        showErrors(e1);
        return;
    } catch (Exception e) {
        if (isState(ADD))
            Window.alert("commitAdd(): " + e.getMessage());
        else
            Window.alert("commitUpdate(): " + e.getMessage());
        logger.log(Level.SEVERE, e.getMessage(), e);
        clearStatus();
        return;
    }

    if (commitUpdateCall == null) {
        commitUpdateCall = new AsyncCallbackUI<SampleManager1>() {
            public void success(SampleManager1 result) {
                Integer id;

                manager = result;
                /*
                 * if either a new sample or a quick entered one was fully
                 * logged in, create an event log to record that
                 */
                if (isFullLogin) {
                    try {
                        id = DictionaryCache.getIdBySystemName("log_type_sample_login");
                        EventLogService.get().add(id, Messages.get().sample_login(), Constants.table().SAMPLE,
                                manager.getSample().getId(), Constants.dictionary().LOG_LEVEL_INFO, null);
                        isFullLogin = false;
                    } catch (Exception e) {
                        Window.alert(e.getMessage());
                        logger.log(Level.SEVERE, e.getMessage(), e);
                        clearStatus();
                        return;
                    }
                }
                evaluateEdit();
                setData();
                setState(DISPLAY);
                fireDataChange();
                clearStatus();

                /*
                 * the cache and scriptlets are cleared only if the
                 * add/update succeeds because otherwise, they can't be used
                 * by any tabs if the user wants to change any data
                 */
                cache = null;
                clearScriptlets();
            }

            public void validationErrors(ValidationErrorsList e) {
                showErrors(e);
                if (!e.hasErrors() && (e.hasWarnings() || e.hasCautions()) && !ignoreWarning)
                    if (Window.confirm(getWarnings(e.getErrorList(), true)))
                        commitUpdate(true);
            }

            public void failure(Throwable e) {
                if (state == ADD)
                    Window.alert("commitAdd(): " + e.getMessage());
                else
                    Window.alert("commitUpdate(): " + e.getMessage());
                logger.log(Level.SEVERE, e.getMessage(), e);
                clearStatus();
            }
        };
    }

    SampleService1.get().update(manager, ignoreWarning, commitUpdateCall);
}

From source file:org.openelis.modules.order1.client.InternalOrderScreenUI.java

License:Open Source License

/**
 * Shows a list of warnings in the form of a confirm dialog. Specific
 * screens need to override the commitWithWarnings() method to catch the
 * user's response./*www  . ja v  a  2 s  .  co  m*/
 */
private void showWarningsDialog(ValidationErrorsList warnings) {
    String warningText = "There are warnings on the screen:" + "\n";

    for (Exception ex : warnings.getErrorList()) {
        if (ex instanceof Warning)
            warningText += " * " + ex.getMessage() + "\n";
    }
    warningText += "\n" + "Press Ok to commit anyway or cancel to fix these warnings.";

    if (Window.confirm(warningText))
        commit(true);
}

From source file:org.openelis.modules.order1.client.SendoutOrderScreenUI.java

License:Open Source License

/**
 * Setup state and data change handles for every widget on the screen
 *///w w w.java  2  s.com
private void initialize() {
    ArrayList<Item<Integer>> model;
    ArrayList<Item<String>> smodel;
    ArrayList<DictionaryDO> list;
    Item<Integer> row;
    Item<String> srow;

    screen = this;

    //
    // button panel buttons
    //
    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            query.setEnabled(isState(QUERY, DEFAULT, DISPLAY) && userPermission.hasSelectPermission());
            if (isState(QUERY)) {
                query.lock();
                query.setPressed(true);
            }
        }
    });

    addShortcut(query, 'q', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            previous.setEnabled(isState(DISPLAY));
        }
    });

    addShortcut(previous, 'p', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            next.setEnabled(isState(DISPLAY));
        }
    });

    addShortcut(next, 'n', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            add.setEnabled(isState(ADD, DEFAULT, DISPLAY) && userPermission.hasAddPermission());
            if (isState(ADD)) {
                add.lock();
                add.setPressed(true);
            }
        }
    });

    addShortcut(add, 'a', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            update.setEnabled(isState(UPDATE, DISPLAY) && userPermission.hasUpdatePermission());
            if (isState(UPDATE)) {
                update.lock();
                update.setPressed(true);
            }
        }
    });

    addShortcut(update, 'u', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            commit.setEnabled(isState(QUERY, ADD, UPDATE));
        }
    });

    addShortcut(commit, 'm', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            abort.setEnabled(isState(QUERY, ADD, UPDATE));
        }
    });

    addShortcut(abort, 'o', CTRL);

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            optionsMenu.setEnabled(isState(DISPLAY));
            optionsButton.setEnabled(isState(DISPLAY));
            historyMenu.setEnabled(isState(DISPLAY));
        }
    });

    /*
     * option menu items
     */
    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            duplicate.setEnabled(isState(State.DISPLAY) && userPermission.hasAddPermission());
        }
    });
    duplicate.addCommand(new Command() {
        public void execute() {
            duplicate();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            shippingInfo.setEnabled(isState(State.DISPLAY));
        }
    });
    shippingInfo.addCommand(new Command() {
        public void execute() {
            shippingInfo();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            orderRequestForm.setEnabled(isState(State.DISPLAY));
        }
    });
    orderRequestForm.addCommand(new Command() {
        public void execute() {
            orderRequestForm();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            orderHistory.setEnabled(isState(DISPLAY));
        }
    });
    orderHistory.addCommand(new Command() {
        @Override
        public void execute() {
            orderHistory();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            orderOrganizationHistory.setEnabled(isState(DISPLAY));
        }
    });
    orderOrganizationHistory.addCommand(new Command() {
        @Override
        public void execute() {
            orderOrganizationHistory();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            orderItemHistory.setEnabled(isState(DISPLAY));
        }
    });
    orderItemHistory.addCommand(new Command() {
        @Override
        public void execute() {
            orderItemHistory();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            orderTestHistory.setEnabled(isState(DISPLAY));
        }
    });
    orderTestHistory.addCommand(new Command() {
        @Override
        public void execute() {
            orderTestHistory();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            orderContainerHistory.setEnabled(isState(DISPLAY));
        }
    });
    orderContainerHistory.addCommand(new Command() {
        @Override
        public void execute() {
            orderContainerHistory();
        }
    });

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            auxDataHistory.setEnabled(isState(DISPLAY));
        }
    });

    auxDataHistory.addCommand(new Command() {
        @Override
        public void execute() {
            auxDataHistory();
        }
    });

    //
    // screen fields
    //
    addScreenHandler(id, IOrderMeta.getId(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            id.setValue(getId());
        }

        public void onStateChange(StateChangeEvent event) {
            id.setEnabled(isState(QUERY));
            id.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? neededDays : zipCode;
        }
    });

    addScreenHandler(neededDays, IOrderMeta.getNeededInDays(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            neededDays.setValue(getNeededDays());
        }

        public void onValueChange(ValueChangeEvent<Integer> event) {
            setNeededDays(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            neededDays.setEnabled(isState(QUERY, ADD, UPDATE));
            neededDays.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? numberOfForms : id;
        }
    });

    addScreenHandler(numberOfForms, IOrderMeta.getNumberOfForms(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            numberOfForms.setValue(getNumberOfForms());
        }

        public void onValueChange(ValueChangeEvent<Integer> event) {
            setNumberOfForms(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            numberOfForms.setEnabled(isState(QUERY, ADD, UPDATE));
            numberOfForms.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? shipFrom : neededDays;
        }
    });

    addScreenHandler(shipFrom, IOrderMeta.getShipFromId(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            shipFrom.setValue(getShipFromId());
        }

        public void onValueChange(ValueChangeEvent<Integer> event) {
            setShipFromId(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            shipFrom.setEnabled(isState(QUERY, ADD, UPDATE));
            shipFrom.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? organizationId : numberOfForms;
        }
    });

    addScreenHandler(organizationId, IOrderMeta.getOrganizationId(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            organizationId.setValue(getOrganizationId());
        }

        public void onStateChange(StateChangeEvent event) {
            organizationId.setEnabled(isState(QUERY));
            organizationId.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? organizationName : shipFrom;
        }
    });

    addScreenHandler(organizationName, IOrderMeta.getOrganizationName(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            setOrganizationNameSelection();
        }

        public void onValueChange(ValueChangeEvent<Integer> event) {
            getOrganizationNameFromSelection();
        }

        public void onStateChange(StateChangeEvent event) {
            organizationName.setEnabled(isState(QUERY, ADD, UPDATE));
            organizationName.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? status : organizationId;
        }
    });

    organizationName.addGetMatchesHandler(new GetMatchesHandler() {
        public void onGetMatches(GetMatchesEvent event) {
            getOrganizationMatches(event.getMatch());
        }
    });

    addScreenHandler(status, IOrderMeta.getStatusId(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            status.setValue(getStatusId());
        }

        public void onValueChange(ValueChangeEvent<Integer> event) {
            setStatusId(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            Integer statusId;

            statusId = getStatusId();

            if (isState(QUERY)) {
                status.setEnabled(true);
                status.setQueryMode(true);
            } else if (isState(ADD, UPDATE)) {
                /*
                 * If adding or updating an order, the user should only
                 * change the status if it is not processed, recurring, or
                 * cancelled.
                 */
                status.setEnabled(!Constants.dictionary().ORDER_STATUS_PROCESSED.equals(statusId)
                        && !Constants.dictionary().ORDER_STATUS_RECURRING.equals(statusId)
                        && !Constants.dictionary().ORDER_STATUS_CANCELLED.equals(statusId));
                status.setQueryMode(false);
            } else {
                status.setEnabled(false);
                status.setQueryMode(false);
            }

            if (!status.isEnabled())
                return;

            for (Item<Integer> item : status.getModel()) {
                if (status.isQueryMode()) {
                    /*
                     * no options are to be disabled in Query state
                     */
                    item.setEnabled(true);
                    continue;
                }
                if (Constants.dictionary().ORDER_STATUS_PENDING.equals(item.getKey())
                        || Constants.dictionary().ORDER_STATUS_ON_HOLD.equals(item.getKey())
                        || Constants.dictionary().ORDER_STATUS_TEMPLATE.equals(item.getKey()))
                    item.setEnabled(true);
                else if (Constants.dictionary().ORDER_STATUS_PROCESSED.equals(item.getKey())
                        || Constants.dictionary().ORDER_STATUS_CANCELLED.equals(item.getKey()))
                    /*
                     * the options for "Processed" and "Cancelled" are only
                     * enabled for an existing order and only if it is
                     * pending or on hold
                     */
                    item.setEnabled(manager.getIorder().getId() != null
                            && (Constants.dictionary().ORDER_STATUS_PENDING.equals(statusId)
                                    || Constants.dictionary().ORDER_STATUS_ON_HOLD.equals(statusId)));
                else
                    item.setEnabled(false);
            }

        }

        public Widget onTab(boolean forward) {
            return forward ? organizationAttention : organizationName;
        }
    });

    addScreenHandler(organizationAttention, IOrderMeta.getOrganizationAttention(), new ScreenHandler<String>() {
        public void onDataChange(DataChangeEvent<String> event) {
            organizationAttention.setValue(getOrganizationAttention());
        }

        public void onValueChange(ValueChangeEvent<String> event) {
            setOrganizationAttention(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            organizationAttention.setEnabled(isState(QUERY, ADD, UPDATE));
            organizationAttention.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? orderedDate : status;
        }
    });

    addScreenHandler(orderedDate, IOrderMeta.getOrderedDate(), new ScreenHandler<Datetime>() {
        public void onDataChange(DataChangeEvent<Datetime> event) {
            orderedDate.setValue(getOrderedDate());
        }

        public void onValueChange(ValueChangeEvent<Datetime> event) {
            setOrderedDate(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            orderedDate.setEnabled(isState(QUERY, ADD, UPDATE));
            orderedDate.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? multipleUnit : organizationAttention;
        }
    });

    addScreenHandler(multipleUnit, IOrderMeta.getIorderOrganizationOrganizationAddressMultipleUnit(),
            new ScreenHandler<String>() {
                public void onDataChange(DataChangeEvent<String> event) {
                    multipleUnit.setValue(getMultipleUnit());
                }

                public void onStateChange(StateChangeEvent event) {
                    multipleUnit.setEnabled(isState(QUERY));
                    multipleUnit.setQueryMode(isState(QUERY));
                }

                public Widget onTab(boolean forward) {
                    return forward ? requestedBy : orderedDate;
                }
            });

    addScreenHandler(requestedBy, IOrderMeta.getRequestedBy(), new ScreenHandler<String>() {
        public void onDataChange(DataChangeEvent<String> event) {
            requestedBy.setValue(getRequestedBy());
        }

        public void onValueChange(ValueChangeEvent<String> event) {
            setRequestedBy(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            requestedBy.setEnabled(isState(QUERY, ADD, UPDATE));
            requestedBy.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? streetAddress : multipleUnit;
        }
    });

    addScreenHandler(streetAddress, IOrderMeta.getOrganizationAddressStreetAddress(),
            new ScreenHandler<String>() {
                public void onDataChange(DataChangeEvent<String> event) {
                    streetAddress.setValue(getStreetAddress());
                }

                public void onStateChange(StateChangeEvent event) {
                    streetAddress.setEnabled(isState(QUERY));
                    streetAddress.setQueryMode(isState(QUERY));
                }

                public Widget onTab(boolean forward) {
                    return forward ? costCenter : requestedBy;
                }
            });

    addScreenHandler(costCenter, IOrderMeta.getCostCenterId(), new ScreenHandler<Integer>() {
        public void onDataChange(DataChangeEvent<Integer> event) {
            costCenter.setValue(getCostCenterId());
        }

        public void onValueChange(ValueChangeEvent<Integer> event) {
            setCostCenterId(event.getValue());
        }

        public void onStateChange(StateChangeEvent event) {
            costCenter.setEnabled(isState(QUERY, ADD, UPDATE));
            costCenter.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? city : streetAddress;
        }
    });

    addScreenHandler(city, IOrderMeta.getOrganizationAddressCity(), new ScreenHandler<String>() {
        public void onDataChange(DataChangeEvent<String> event) {
            city.setValue(getCity());
        }

        public void onStateChange(StateChangeEvent event) {
            city.setEnabled(isState(QUERY));
            city.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? description : costCenter;
        }
    });

    addScreenHandler(description, IOrderMeta.getDescription(), new ScreenHandler<String>() {
        public void onDataChange(DataChangeEvent<String> event) {
            setDescriptionSelection();
        }

        public void onValueChange(ValueChangeEvent<String> event) {
            getDescriptionFromSelection();
        }

        public void onStateChange(StateChangeEvent event) {
            description.setEnabled(isState(QUERY, ADD, UPDATE));
            description.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? orgState : city;
        }
    });

    description.addGetMatchesHandler(new GetMatchesHandler() {
        public void onGetMatches(GetMatchesEvent event) {
            getDescriptionMatches(event.getMatch());
        }
    });

    addScreenHandler(orgState, IOrderMeta.getOrganizationAddressState(), new ScreenHandler<String>() {
        public void onDataChange(DataChangeEvent<String> event) {
            orgState.setValue(getState());
        }

        public void onStateChange(StateChangeEvent event) {
            orgState.setEnabled(isState(QUERY));
            orgState.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? zipCode : description;
        }
    });

    addScreenHandler(zipCode, IOrderMeta.getOrganizationAddressZipCode(), new ScreenHandler<String>() {
        public void onDataChange(DataChangeEvent<String> event) {
            zipCode.setValue(getZipCode());
        }

        public void onStateChange(StateChangeEvent event) {
            zipCode.setEnabled(isState(QUERY));
            zipCode.setQueryMode(isState(QUERY));
        }

        public Widget onTab(boolean forward) {
            return forward ? id : orgState;
        }
    });

    /*
     * tabs
     */
    tabPanel.setPopoutBrowser(OpenELIS.getBrowser());

    addScreenHandler(organizationTab, "organizationTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            organizationTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            organizationTab.setState(event.getState());
        }

        public Object getQuery() {
            return organizationTab.getQueryFields();
        }
    });

    addScreenHandler(auxDataTab, "auxDataTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            auxDataTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            auxDataTab.setState(event.getState());
        }

        public Object getQuery() {
            return auxDataTab.getQueryFields();
        }
    });

    /*
     * querying by this tab is allowed on this screen, but not on all
     * screens
     */
    auxDataTab.setCanQuery(true);

    addScreenHandler(testTab, "testTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            testTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            testTab.setState(event.getState());
        }

        public Object getQuery() {
            return testTab.getQueryFields();
        }
    });

    addScreenHandler(containerTab, "containerTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            containerTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            containerTab.setState(event.getState());
        }

        public Object getQuery() {
            return containerTab.getQueryFields();
        }
    });

    addScreenHandler(itemTab, "itemTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            itemTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            itemTab.setState(event.getState());
        }

        public Object getQuery() {
            return itemTab.getQueryFields();
        }
    });

    addScreenHandler(shippingNotesTab, "shippingNotesTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            shippingNotesTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            shippingNotesTab.setState(event.getState());
        }

        public Object getQuery() {
            return null;
        }
    });

    addScreenHandler(customerNotesTab, "customerNotesTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            customerNotesTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            customerNotesTab.setState(event.getState());
        }

        public Object getQuery() {
            return null;
        }
    });

    addScreenHandler(internalNotesTab, "internalNotesTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            internalNotesTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            internalNotesTab.setState(event.getState());
        }

        public Object getQuery() {
            return null;
        }
    });

    addScreenHandler(sampleNotesTab, "sampleNotesTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            sampleNotesTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            sampleNotesTab.setState(event.getState());
        }

        public Object getQuery() {
            return null;
        }
    });

    addScreenHandler(recurrenceTab, "recurrenceTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            recurrenceTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            recurrenceTab.setState(event.getState());
        }

        public Object getQuery() {
            return recurrenceTab.getQueryFields();
        }
    });

    addScreenHandler(fillTab, "fillTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            fillTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            fillTab.setState(event.getState());
        }
    });

    addScreenHandler(attachmentTab, "attachmentTab", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            attachmentTab.onDataChange();
        }

        public void onStateChange(StateChangeEvent event) {
            attachmentTab.setState(event.getState());
        }

        public Object getQuery() {
            return attachmentTab.getQueryFields();
        }
    });

    /*
     * querying by this tab is allowed on this screen, but not on all
     * screens
     */
    attachmentTab.setCanQuery(true);

    //
    // left hand navigation panel
    //
    nav = new ScreenNavigator<IdNameVO>(atozTable, atozNext, atozPrev) {
        public void executeQuery(final Query query) {
            QueryData field;

            setBusy(Messages.get().gen_querying());

            if (queryCall == null) {
                queryCall = new AsyncCallbackUI<ArrayList<IdNameVO>>() {
                    public void success(ArrayList<IdNameVO> result) {
                        clearStatus();
                        setQueryResult(result);
                    }

                    public void notFound() {
                        setQueryResult(null);
                        setState(DEFAULT);
                        setDone(Messages.get().gen_noRecordsFound());
                    }

                    public void lastPage() {
                        setQueryResult(null);
                        setError(Messages.get().gen_noMoreRecordInDir());
                    }

                    public void failure(Throwable error) {
                        setQueryResult(null);
                        Window.alert("Error: Send-out Order call query failed; " + error.getMessage());
                        setError(Messages.get().gen_queryFailed());
                    }
                };
            }
            /*
             * this screen should only query for send-out orders
             */
            field = new QueryData(IOrderMeta.getType(), QueryData.Type.STRING, Constants.iorder().SEND_OUT);
            query.setFields(field);
            query.setRowsPerPage(25);
            OrderService1.get().query(query, queryCall);
        }

        public boolean fetch(IdNameVO entry) {
            fetchById((entry == null) ? null : entry.getId());
            return true;
        }

        public ArrayList<Item<Integer>> getModel() {
            ArrayList<IdNameVO> result;
            ArrayList<Item<Integer>> model;
            Item<Integer> row;

            model = null;
            result = nav.getQueryResult();
            if (result != null) {
                model = new ArrayList<Item<Integer>>();
                for (IdNameVO entry : result) {
                    row = new Item<Integer>(2);
                    row.setKey(entry.getId());
                    row.setCell(0, entry.getId());
                    row.setCell(1, entry.getName());
                    model.add(row);
                }
            }
            return model;
        }
    };

    addStateChangeHandler(new StateChangeEvent.Handler() {
        public void onStateChange(StateChangeEvent event) {
            boolean enable;
            enable = isState(DEFAULT, DISPLAY) && userPermission.hasSelectPermission();
            atozButtons.setEnabled(enable);
            nav.enable(enable);
        }
    });

    atozButtons.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            Query query;
            QueryData field;

            field = new QueryData();
            field.setKey(IOrderMeta.getId());
            field.setQuery(((Button) event.getSource()).getAction());
            field.setType(QueryData.Type.INTEGER);

            query = new Query();
            query.setFields(field);
            nav.setQuery(query);
        }
    });

    bus.addHandler(AddTestEvent.getType(), new AddTestEvent.Handler() {
        public void onAddTest(AddTestEvent event) {
            switch (event.getAddType()) {
            case TEST:
                addTest(event.getId(), true, event.getIndex());
                break;
            case PANEL:
                addTest(event.getId(), false, event.getIndex());
                break;
            }
        }
    });

    bus.addHandler(RemoveTestEvent.getType(), new RemoveTestEvent.Handler() {
        public void onRemoveTest(RemoveTestEvent event) {
            removeTests(event.getIds());
        }
    });

    bus.addHandler(AddAuxGroupEvent.getType(), new AddAuxGroupEvent.Handler() {
        @Override
        public void onAddAuxGroup(AddAuxGroupEvent event) {
            IOrderReturnVO ret;
            ArrayList<Integer> ids;

            if (screen == event.getSource())
                return;

            ids = event.getGroupIds();
            if (ids != null && ids.size() > 0) {
                try {
                    ret = OrderService1.get().addAuxGroups(manager, ids);
                    manager = ret.getManager();
                    setData();
                    setState(state);
                    bus.fireEventFromSource(new AddAuxGroupEvent(ids), screen);
                    if (ret.getErrors() != null && ret.getErrors().size() > 0)
                        showErrors(ret.getErrors());
                    else
                        clearStatus();
                } catch (Exception e) {
                    Window.alert(e.getMessage());
                    logger.log(Level.SEVERE, e.getMessage(), e);
                }
            }
        }
    });

    bus.addHandler(RemoveAuxGroupEvent.getType(), new RemoveAuxGroupEvent.Handler() {
        @Override
        public void onRemoveAuxGroup(RemoveAuxGroupEvent event) {
            if (event.getGroupIds() != null && event.getGroupIds().size() > 0) {
                if (screen == event.getSource())
                    return;

                try {
                    manager = OrderService1.get().removeAuxGroups(manager, event.getGroupIds());
                    setData();
                    setState(state);
                    bus.fireEventFromSource(new RemoveAuxGroupEvent(event.getGroupIds()), screen);
                } catch (Exception e) {
                    Window.alert(e.getMessage());
                    logger.log(Level.SEVERE, e.getMessage(), e);
                }
            }
        }
    });

    bus.addHandler(AddRecurrenceEvent.getType(), new AddRecurrenceEvent.Handler() {
        public void onAddRecurrence(AddRecurrenceEvent event) {
            status.setEnabled(!Constants.dictionary().ORDER_STATUS_RECURRING.equals(getStatusId()));
            fireDataChange();
        }
    });

    bus.addHandler(DisplayAttachmentEvent.getType(), new DisplayAttachmentEvent.Handler() {
        @Override
        public void onDisplayAttachment(DisplayAttachmentEvent event) {
            displayAttachment(event.getId(), event.getIsSameWindow());
        }
    });

    window.addBeforeClosedHandler(new BeforeCloseHandler<WindowInt>() {
        public void onBeforeClosed(BeforeCloseEvent<WindowInt> event) {
            if (isState(ADD, UPDATE)) {
                event.cancel();
                setError(Messages.get().gen_mustCommitOrAbort());
            } else {
                /*
                 * make sure that all detached tabs are closed when the main
                 * screen is closed
                 */
                tabPanel.close();
            }
        }
    });

    // order status dropdown
    model = new ArrayList<Item<Integer>>();
    list = CategoryCache.getBySystemName("order_status");
    for (DictionaryDO d : list) {
        row = new Item<Integer>(d.getId(), d.getEntry());
        row.setEnabled("Y".equals(d.getIsActive()));
        model.add(row);
    }

    status.setModel(model);

    model = new ArrayList<Item<Integer>>();
    list = CategoryCache.getBySystemName("cost_centers");
    for (DictionaryDO d : list) {
        row = new Item<Integer>(d.getId(), d.getEntry());
        row.setEnabled("Y".equals(d.getIsActive()));
        model.add(row);
    }

    costCenter.setModel(model);

    model = new ArrayList<Item<Integer>>();
    list = CategoryCache.getBySystemName("laboratory_location");
    for (DictionaryDO d : list) {
        row = new Item<Integer>(d.getId(), d.getEntry());
        row.setEnabled("Y".equals(d.getIsActive()));
        model.add(row);
    }

    shipFrom.setModel(model);

    smodel = new ArrayList<Item<String>>();
    list = CategoryCache.getBySystemName("state");
    for (DictionaryDO d : list) {
        srow = new Item<String>(d.getEntry(), d.getEntry());
        srow.setEnabled("Y".equals(d.getIsActive()));
        smodel.add(srow);
    }

    orgState.setModel(smodel);

    /*
     * call for loading a default manager on the screen to create an order
     */
    addCall = new AsyncCallbackUI<IOrderManager1>() {
        public void success(IOrderManager1 result) {
            manager = result;
            cache = new HashMap<String, Object>();
            setData();
            setState(ADD);
            fireDataChange();
            neededDays.setFocus(true);
            setDone(Messages.get().gen_enterInformationPressCommit());
        }

        public void failure(Throwable error) {
            Window.alert(error.getMessage());
            logger.log(Level.SEVERE, error.getMessage(), error);
            clearStatus();
        }
    };

    /*
     * call for fetching and locking an order for update
     */
    fetchForUpdateCall = new AsyncCallbackUI<IOrderManager1>() {
        public void success(IOrderManager1 result) {
            manager = result;
            if (Constants.dictionary().ORDER_STATUS_CANCELLED.equals(manager.getIorder().getStatusId())) {
                Window.alert(Messages.get().order_cancelledOrderCantBeUpdated());
                try {
                    manager = OrderService1.get().unlock(manager.getIorder().getId(), elements);
                } catch (Exception e) {
                    Window.alert(e.getMessage());
                    logger.log(Level.SEVERE, e.getMessage() != null ? e.getMessage() : "null", e);
                }
                setData();
                setState(DISPLAY);
                fireDataChange();
            } else {
                try {
                    buildCache();
                } catch (Exception e) {
                    Window.alert(e.getMessage());
                    logger.log(Level.SEVERE, e.getMessage() != null ? e.getMessage() : "null", e);
                }
                setData();
                setState(UPDATE);
                fireDataChange();
                neededDays.setFocus(true);
            }
        }

        public void failure(Throwable e) {
            Window.alert(e.getMessage());
            logger.log(Level.SEVERE, e.getMessage() != null ? e.getMessage() : "null", e);
        }

        public void finish() {
            clearStatus();
        }
    };

    /*
     * call for adding/updating an order
     */
    updateCall = new AsyncCallbackUI<IOrderManager1>() {
        public void success(IOrderManager1 result) {
            manager = result;
            setData();
            setState(DISPLAY);
            fireDataChange();
            clearStatus();
            cache = null;
        }

        public void validationErrors(ValidationErrorsList e) {
            showErrors(e);
            if (!e.hasErrors() && e.hasWarnings()) {
                if (Window.confirm(getWarnings(e.getErrorList(), true)))
                    commitUpdate(true);
            }
        }

        public void failure(Throwable e) {
            if (isState(ADD))
                Window.alert("commitAdd(): " + e.getMessage());
            else
                Window.alert("commitUpdate(): " + e.getMessage());
            logger.log(Level.SEVERE, e.getMessage(), e);
            clearStatus();
        }
    };

    /*
     * call for unlocking an order
     */
    if (unlockCall == null) {
        unlockCall = new AsyncCallbackUI<IOrderManager1>() {
            public void success(IOrderManager1 result) {
                manager = result;
                setData();
                setState(DISPLAY);
                fireDataChange();
                setDone(Messages.get().gen_updateAborted());
            }

            public void failure(Throwable e) {
                Window.alert(e.getMessage());
                logger.log(Level.SEVERE, e.getMessage(), e);
                clearStatus();
            }
        };
    }

    /*
     * call for duplicating an order
     */
    duplicateCall = new AsyncCallbackUI<IOrderReturnVO>() {
        public void success(IOrderReturnVO result) {
            manager = result.getManager();
            if (result.getErrors().hasWarnings())
                Window.alert(getWarnings(result.getErrors().getErrorList(), false));
            if (!result.getErrors().hasWarnings() && result.getErrors().hasErrors())
                showErrors(result.getErrors());
            manager.getIorder().setParentIorderId(null);
            /*
             * the screen is in add state, so we need the cache here
             */
            try {
                buildCache();
            } catch (Exception ex) {
                Window.alert(ex.getMessage());
                logger.log(Level.SEVERE, ex.getMessage(), ex);
            }
            setData();
            setState(ADD);
            fireDataChange();
        }

        public void failure(Throwable e) {
            Window.alert(e.getMessage());
            logger.log(Level.SEVERE, e.getMessage(), e);
        }
    };
}

From source file:org.openelis.modules.order1.client.SendoutOrderScreenUI.java

License:Open Source License

private void commit(boolean ignoreWarning) {
    Validation validation;//from  w  w w .  jav  a  2 s . co m

    finishEditing();

    validation = validate();

    switch (validation.getStatus()) {
    case WARNINGS:
        /*
         * show the warnings and ask the user if the data should still
         * be committed; commit only if the user says yes
         */
        if (!Window.confirm(getWarnings(validation.getExceptions(), true)))
            return;
        break;
    case FLAGGED:
        /*
         * some part of the screen has some operation that needs to be
         * completed before committing the data
         */
        return;
    case ERRORS:
        setError(Messages.get().gen_correctErrors());
        return;
    }

    switch (super.state) {
    case QUERY:
        commitQuery();
        break;
    case ADD:
        commitUpdate(ignoreWarning);
        break;
    case UPDATE:
        commitUpdate(ignoreWarning);
        break;
    }
}

From source file:org.openelis.modules.order1.client.SendoutOrderScreenUI.java

License:Open Source License

@UiHandler("abort")
protected void abort(ClickEvent event) {
    finishEditing();// w w  w  .  jav a 2s .  co m
    clearErrors();
    setBusy(Messages.get().gen_cancelChanges());

    if (isState(QUERY)) {
        try {
            manager = null;
            setData();
            setState(DEFAULT);
            fireDataChange();
            setDone(Messages.get().gen_queryAborted());
        } catch (Exception e) {
            Window.alert(e.getMessage());
            logger.log(Level.SEVERE, e.getMessage(), e);
            clearStatus();
        }
    } else if (isState(ADD)) {
        if (!Window.confirm(Messages.get().order_abortWarning())) {
            setDone(Messages.get().gen_enterInformationPressCommit());
            return;
        }
        manager = null;
        setData();
        setState(DEFAULT);
        fireDataChange();
        setDone(Messages.get().gen_addAborted());
    } else if (isState(UPDATE)) {
        if (!Window.confirm(Messages.get().order_abortWarning())) {
            clearStatus();
            return;
        }
        OrderService1.get().unlock(manager.getIorder().getId(), elements, unlockCall);
    }
    cache = null;
}

From source file:org.openelis.modules.provider1.client.ProviderScreenUI.java

License:Open Source License

protected void commitUpdate(final boolean ignoreWarning) {
    if (isState(ADD))
        setBusy(Messages.get().gen_adding());
    else//from ww w.ja  v a2  s . c  o  m
        setBusy(Messages.get().gen_updating());

    if (updateCall == null) {
        updateCall = new AsyncCallbackUI<ProviderManager1>() {
            public void success(ProviderManager1 result) {
                manager = result;
                setData();
                setState(DISPLAY);
                fireDataChange();
                if (isState(ADD))
                    setDone(Messages.get().addingComplete());
                else
                    setDone(Messages.get().updatingComplete());
            }

            public void validationErrors(ValidationErrorsList e) {
                showErrors(e);
                if (!e.hasErrors() && e.hasWarnings() && !ignoreWarning) {
                    if (Window.confirm(getWarnings(e.getErrorList(), true)))
                        commitUpdate(true);
                }
            }

            public void failure(Throwable e) {
                if (isState(ADD))
                    Window.alert("commitAdd(): " + e.getMessage());
                else
                    Window.alert("commitUpdate(): " + e.getMessage());
                logger.log(Level.SEVERE, e.getMessage(), e);
                clearStatus();
            }
        };
    }

    ProviderService1.get().update(manager, updateCall);
}

From source file:org.openelis.modules.sample1.client.QAEventTabUI.java

License:Open Source License

private void initialize() {
    Item<Integer> row;//from w  ww  .  j a  v  a  2s .c o m
    ArrayList<Item<Integer>> model;
    ArrayList<DictionaryDO> list;

    screen = this;

    addScreenHandler(sampleQATable, "sampleQATable", new ScreenHandler<ArrayList<Row>>() {
        public void onDataChange(DataChangeEvent<ArrayList<Row>> event) {
            sampleQATable.setModel(getSampleQATableModel());
            showSampleBillableMessage();
        }

        public void onStateChange(StateChangeEvent event) {
            sampleQATable.setEnabled(true);
        }

        public Widget onTab(boolean forward) {
            return forward ? removeSampleQAButton : analysisQALookupButton;
        }
    });

    sampleQATable.addSelectionHandler(new SelectionHandler<Integer>() {
        public void onSelection(com.google.gwt.event.logical.shared.SelectionEvent<Integer> event) {
            removeSampleQAButton.setEnabled(isState(ADD, UPDATE));
        }
    });

    sampleQATable.addBeforeCellEditedHandler(new BeforeCellEditedHandler() {
        public void onBeforeCellEdited(BeforeCellEditedEvent event) {
            if (!isState(ADD, UPDATE) || !canChangeSampleQA())
                event.cancel();
        }
    });

    sampleQATable.addCellEditedHandler(new CellEditedHandler() {
        public void onCellUpdated(CellEditedEvent event) {
            int r, c;
            Object val;
            SampleQaEventViewDO data;

            r = event.getRow();
            c = event.getCol();
            val = sampleQATable.getValueAt(r, c);
            data = manager.qaEvent.get(r);

            if (!Window.confirm(Messages.get().gen_qaEventEditConfirm())) {
                switch (c) {
                case 1:
                    sampleQATable.setValueAt(r, c, data.getTypeId());
                    break;
                case 2:
                    sampleQATable.setValueAt(r, c, data.getIsBillable());
                    break;
                }
            } else {
                switch (c) {
                case 1:
                    data.setTypeId((Integer) val);
                    notifyQAChanged(null);
                    break;
                case 2:
                    data.setIsBillable((String) val);
                    showSampleBillableMessage();
                    break;
                }
            }
        }
    });

    sampleQATable.addRowDeletedHandler(new RowDeletedHandler() {
        public void onRowDeleted(RowDeletedEvent event) {
            manager.qaEvent.remove(event.getIndex());
            removeSampleQAButton.setEnabled(false);
            showSampleBillableMessage();
        }
    });

    addScreenHandler(removeSampleQAButton, "removeSampleQAButton", new ScreenHandler<Object>() {
        public void onStateChange(StateChangeEvent event) {
            removeSampleQAButton.setEnabled(isState(ADD, UPDATE) && sampleQATable.getSelectedRow() > -1);
        }

        public Widget onTab(boolean forward) {
            return forward ? sampleQALookupButton : sampleQATable;
        }
    });

    addScreenHandler(sampleQALookupButton, "sampleQALookupButton", new ScreenHandler<Object>() {
        public void onStateChange(StateChangeEvent event) {
            sampleQALookupButton.setEnabled(isState(ADD, UPDATE));
        }

        public Widget onTab(boolean forward) {
            return forward ? analysisQATable : removeSampleQAButton;
        }
    });

    addScreenHandler(analysisQATable, "analysisQATable", new ScreenHandler<ArrayList<Row>>() {
        public void onDataChange(DataChangeEvent<ArrayList<Row>> event) {
            analysisQATable.setModel(getAnalysisQATableModel());
            showAnalysisBillableMessage();
        }

        public void onStateChange(StateChangeEvent event) {
            analysisQATable.setEnabled(true);
        }

        public Widget onTab(boolean forward) {
            return forward ? removeAnalysisQAButton : sampleQALookupButton;
        }
    });

    analysisQATable.addSelectionHandler(new SelectionHandler<Integer>() {
        public void onSelection(com.google.gwt.event.logical.shared.SelectionEvent<Integer> event) {
            removeAnalysisQAButton.setEnabled(isState(ADD, UPDATE));
        }
    });

    analysisQATable.addBeforeCellEditedHandler(new BeforeCellEditedHandler() {
        public void onBeforeCellEdited(BeforeCellEditedEvent event) {
            if (!isState(ADD, UPDATE) || !canChangeAnalysisQA())
                event.cancel();
        }
    });

    analysisQATable.addCellEditedHandler(new CellEditedHandler() {
        public void onCellUpdated(CellEditedEvent event) {
            int r, c;
            Object val;
            AnalysisQaEventViewDO data;

            r = event.getRow();
            c = event.getCol();
            val = analysisQATable.getValueAt(r, c);
            data = manager.qaEvent.get(analysis, r);

            if (!Window.confirm(Messages.get().gen_qaEventEditConfirm())) {
                switch (c) {
                case 1:
                    analysisQATable.setValueAt(r, c, data.getTypeId());
                    break;
                case 2:
                    analysisQATable.setValueAt(r, c, data.getIsBillable());
                    break;
                }
            } else {
                switch (c) {
                case 1:
                    data.setTypeId((Integer) val);
                    notifyQAChanged(analysis.getId());
                    break;
                case 2:
                    data.setIsBillable((String) val);
                    showAnalysisBillableMessage();
                    break;
                }
            }
        }
    });

    analysisQATable.addRowDeletedHandler(new RowDeletedHandler() {
        public void onRowDeleted(RowDeletedEvent event) {
            manager.qaEvent.remove(analysis, event.getIndex());
            removeAnalysisQAButton.setEnabled(false);
            showAnalysisBillableMessage();
        }
    });

    addScreenHandler(removeAnalysisQAButton, "removeAnalysisQAButton", new ScreenHandler<Object>() {
        public void onStateChange(StateChangeEvent event) {
            removeAnalysisQAButton.setEnabled(isState(ADD, UPDATE) && analysisQATable.getSelectedRow() > -1);
        }

        public Widget onTab(boolean forward) {
            return forward ? analysisQALookupButton : analysisQATable;
        }
    });

    addScreenHandler(analysisQALookupButton, "analysisQALookupButton", new ScreenHandler<Object>() {
        public void onStateChange(StateChangeEvent event) {
            analysisQALookupButton.setEnabled(isState(ADD, UPDATE) && getTestId() != null);
        }

        public Widget onTab(boolean forward) {
            return forward ? sampleQATable : removeAnalysisQAButton;
        }
    });

    addScreenHandler(analysisBillableLabel, "analysisBillableLabel", new ScreenHandler<Object>() {
        public void onDataChange(DataChangeEvent<Object> event) {
            showAnalysisBillableMessage();
        }
    });

    addVisibleHandler(new VisibleEvent.Handler() {
        public void onVisibleOrInvisible(VisibleEvent event) {
            isVisible = event.isVisible();
            displayQAEvents();
        }
    });

    /*
     * handlers for the events fired by the screen containing this tab
     */
    parentBus.addHandler(SelectionEvent.getType(), new SelectionEvent.Handler() {
        public void onSelection(SelectionEvent event) {
            int i, count1, count2;
            String uid;
            SampleQaEventViewDO sqa;
            AnalysisQaEventViewDO aqa;
            Row row;

            switch (event.getSelectedType()) {
            case ANALYSIS:
                uid = event.getUid();
                break;
            default:
                uid = null;
                break;
            }

            if (uid != null)
                analysis = (AnalysisViewDO) manager.getObject(uid);
            else
                analysis = null;

            /*
             * compare sample qa events
             */
            count1 = sampleQATable.getRowCount();
            count2 = manager == null ? 0 : manager.qaEvent.count();

            if (count1 == count2) {
                for (i = 0; i < count1; i++) {
                    row = sampleQATable.getRowAt(i);
                    sqa = manager.qaEvent.get(i);
                    if (DataBaseUtil.isDifferent(sqa.getQaEventName(), row.getCell(0))
                            || DataBaseUtil.isDifferent(sqa.getTypeId(), row.getCell(1))
                            || DataBaseUtil.isDifferent(sqa.getIsBillable(), row.getCell(2))) {
                        redraw = true;
                        break;
                    }
                }
            } else {
                redraw = true;
            }

            if (!redraw) {
                count1 = analysisQATable.getRowCount();
                if (analysis != null) {
                    /*
                     * compare analysis qa events
                     */
                    count2 = manager.qaEvent.count(analysis);

                    if (count1 == count2) {
                        for (i = 0; i < count1; i++) {
                            row = analysisQATable.getRowAt(i);
                            aqa = manager.qaEvent.get(analysis, i);
                            if (DataBaseUtil.isDifferent(aqa.getQaEventName(), row.getCell(0))
                                    || DataBaseUtil.isDifferent(aqa.getTypeId(), row.getCell(1))
                                    || DataBaseUtil.isDifferent(aqa.getIsBillable(), row.getCell(2))) {
                                redraw = true;
                                break;
                            }
                        }
                    } else {
                        redraw = true;
                    }
                } else if (count1 > 0) {
                    /*
                     * if an analysis is not selected and the table for
                     * analysis qa events has some data then remove that
                     * data
                     */
                    redraw = true;
                }
            }
            setState(state);
            displayQAEvents();
        }
    });

    parentBus.addHandler(AnalysisChangeEvent.getType(), new AnalysisChangeEvent.Handler() {
        @Override
        public void onAnalysisChange(AnalysisChangeEvent event) {
            if (AnalysisChangeEvent.Action.STATUS_CHANGED.equals(event.getAction())
                    || AnalysisChangeEvent.Action.SECTION_CHANGED.equals(event.getAction())) {
                /*
                 * reevaluate the permissions for this section or status to
                 * enable or disable the widgets in the tab
                 */
                analysis = (AnalysisViewDO) manager.getObject(event.getUid());
                setState(state);
            }
        }
    });

    parentBus.addHandler(QAEventAddedEvent.getType(), new QAEventAddedEvent.Handler() {
        @Override
        public void onQAEventAdded(QAEventAddedEvent event) {
            redraw = true;
            analysis = (AnalysisViewDO) manager.getObject(event.getUid());
            displayQAEvents();
        }
    });

    parentBus.addHandler(QAEventRemovedEvent.getType(), new QAEventRemovedEvent.Handler() {
        @Override
        public void onQAEventRemoved(QAEventRemovedEvent event) {
            redraw = true;
            analysis = (AnalysisViewDO) manager.getObject(event.getUid());
            displayQAEvents();
        }
    });

    // qa event type dropdown
    model = new ArrayList<Item<Integer>>();
    list = CategoryCache.getBySystemName("qaevent_type");
    for (DictionaryDO d : list) {
        row = new Item<Integer>(d.getId(), d.getEntry());
        row.setEnabled("Y".equals(d.getIsActive()));
        model.add(row);
    }

    sampleQAType.setModel(model);
    analysisQAType.setModel(model);
}

From source file:org.openelis.modules.shipping.client.ShippingScreen.java

License:Open Source License

protected void update() {
    boolean ok;//from   ww w  . j av  a2  s  .  c  o m
    window.setBusy(Messages.get().lockForUpdate());

    try {
        ok = true;

        if (Constants.dictionary().SHIPPING_STATUS_PROCESSED.equals(manager.getShipping().getStatusId()))
            ok = Window.confirm(Messages.get().shippingStatusProcessed());
        else if (Constants.dictionary().SHIPPING_STATUS_SHIPPED.equals(manager.getShipping().getStatusId()))
            ok = Window.confirm(Messages.get().shippingStatusShipped());

        if (!ok) {
            manager = manager.abortUpdate();
            setState(State.DISPLAY);
            DataChangeEvent.fire(this);
            window.setDone(Messages.get().updateAborted());
            return;
        }

        manager = manager.fetchForUpdate();
        setState(State.UPDATE);
        setFocus(statusId);
        DataChangeEvent.fire(this);
        window.clearStatus();
    } catch (Exception e) {
        Window.alert(e.getMessage());
        window.clearStatus();
    }
}

From source file:org.openelis.modules.shipping.client.ShippingScreen.java

License:Open Source License

protected void abort() {
    if (state == State.QUERY) {
        setFocus(null);//from   w  w w. j  a  v  a  2 s.co m
        clearErrors();
        window.setBusy(Messages.get().cancelChanges());
        fetchById(null);
        window.setDone(Messages.get().queryAborted());
    } else if (state == State.ADD) {
        if (!openedFromMenu) {
            /*
             * If this screen was brought up from Fill Order screen then we
             * ask the user whether he or she is sure about aborting because
             * then no shipping record would be created for the orders sent
             * from that screen and there won't be any chance of creating a
             * shipping record for them in the future. If the user says no
             * then we don't do anything.
             */
            if (Window.confirm(Messages.get().abortNotCreateShippingRecord())) {
                /*
                 * fetchById(null) is called here to make sure that the
                 * screen doesn't have any data and is not in Add mode
                 * before window.close() is called because otherwise
                 * window.close() will prevent the window from being closed
                 * because of it being in Add mode
                 */
                fetchById(null);
                ActionEvent.fire(this, Action.ABORT, null);
                window.close();
            }
            return;
        }
        setFocus(null);
        clearErrors();
        window.setBusy(Messages.get().cancelChanges());
        fetchById(null);
        window.setDone(Messages.get().addAborted());
    } else if (state == State.UPDATE) {
        setFocus(null);
        clearErrors();
        window.setBusy(Messages.get().cancelChanges());
        try {
            manager = manager.abortUpdate();
            setState(State.DISPLAY);
            DataChangeEvent.fire(this);
        } catch (Exception e) {
            Window.alert(e.getMessage());
            fetchById(null);
        }
        window.setDone(Messages.get().updateAborted());
    } else {
        setFocus(null);
        clearErrors();
        window.clearStatus();
    }
}

From source file:org.openelis.modules.worksheetCompletion1.client.WorksheetCompletionScreenUI.java

License:Open Source License

private void commitTransfer(final boolean ignoreWarnings) {
    ArrayList<WorksheetAnalysisViewDO> waVDOs;

    finishEditing();//  ww w .ja  v  a2  s  . co  m
    setBusy(Messages.get().updating());

    waVDOs = worksheetItemTab.getTransferSelection();
    if (transferCall == null) {
        transferCall = new AsyncCallbackUI<WorksheetResultsTransferVO>() {
            public void success(WorksheetResultsTransferVO result) {
                ArrayList<SampleTestRequestVO> tests;

                sMansById.clear();
                if (result.getSampleManagers() != null && result.getSampleManagers().size() > 0) {
                    for (SampleManager1 sMan : result.getSampleManagers())
                        sMansById.put(sMan.getSample().getId(), sMan);

                    if (testReflexUtility == null) {
                        testReflexUtility = new TestReflexUtility1() {
                            @Override
                            public TestManager getTestManager(Integer testId) throws Exception {
                                return screen.getTestManager(testId);
                            }
                        };
                    }
                    try {
                        tests = testReflexUtility.getReflexTests(result.getSampleManagers(),
                                result.getReflexResultsList());
                        if (tests != null && tests.size() > 0) {
                            showPrepAndReflexTests(tests);
                        } else {
                            try {
                                SampleService1.get().update(result.getSampleManagers(), true);
                            } catch (ValidationErrorsList vel) {
                                showErrors(vel);
                                return;
                            } catch (Exception e) {
                                Window.alert(e.getMessage());
                                logger.log(Level.SEVERE, e.getMessage(), e);
                                return;
                            }
                            if (unlockReflexCall == null) {
                                unlockReflexCall = new AsyncCallbackUI<WorksheetManager1>() {
                                    public void success(WorksheetManager1 result) {
                                        manager = result;
                                        updateTransferMode = false;
                                        setData();
                                        setState(DISPLAY);
                                        fireDataChange();
                                        setDone(Messages.get().gen_updatingComplete());
                                    }

                                    public void failure(Throwable e) {
                                        Window.alert(e.getMessage());
                                        logger.log(Level.SEVERE, e.getMessage(), e);
                                        clearStatus();
                                    }
                                };
                            }

                            WorksheetService1.get().unlock(manager.getWorksheet().getId(), elements,
                                    unlockReflexCall);
                        }
                    } catch (Exception e) {
                        Window.alert(e.getMessage());
                        logger.log(Level.SEVERE, e.getMessage(), e);
                    }
                } else {
                    manager = result.getWorksheetManager();
                    updateTransferMode = false;
                    setData();
                    setState(DISPLAY);
                    fireDataChange();
                    setDone(Messages.get().gen_updatingComplete());
                }
            }

            public void validationErrors(ValidationErrorsList e) {
                showErrors(e);
                if (!e.hasErrors() && (e.hasWarnings() || e.hasCautions()) && !ignoreWarnings)
                    if (Window.confirm(getWarnings(e.getErrorList(), true)))
                        commitTransfer(true);
            }

            public void failure(Throwable e) {
                Window.alert("commitTransfer(): " + e.getMessage());
                logger.log(Level.SEVERE, e.getMessage(), e);
                clearStatus();
            }
        };
    }

    WorksheetService1.get().transferResults(manager, waVDOs, sampleMans, ignoreWarnings, transferCall);
}