// Copyright (C) 2010 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.gerrit.client.changes;
import com.google.gerrit.client.Gerrit;
import com.google.gerrit.common.PageLinks;
import com.google.gerrit.common.data.ChangeDetail;
import com.google.gerrit.reviewdb.client.AccountGeneralPreferences;
import com.google.gerrit.reviewdb.client.PatchSet;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.KeyPressEvent;
import com.google.gwt.event.logical.shared.OpenEvent;
import com.google.gwt.event.logical.shared.OpenHandler;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.DisclosurePanel;
import com.google.gwt.user.client.ui.FlowPanel;
import com.google.gwtexpui.globalkey.client.GlobalKey;
import com.google.gwtexpui.globalkey.client.KeyCommand;
import com.google.gwtexpui.globalkey.client.KeyCommandSet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Composite that displays the patch sets of a change. This composite ensures
* that keyboard navigation to each changed file in all patch sets is possible.
*/
public class PatchSetsBlock extends Composite {
private final Map<PatchSet.Id, PatchSetComplexDisclosurePanel> patchSetPanels =
new HashMap<>();
private final FlowPanel body;
private HandlerRegistration regNavigation;
private List<PatchSetComplexDisclosurePanel> patchSetPanelsList;
/**
* the patch set id of the patch set for which is the keyboard navigation is
* currently enabled
*/
private PatchSet.Id activePatchSetId;
/** the patch set id of the current (latest) patch set */
private PatchSet.Id currentPatchSetId;
/** Patch sets on this change, in order. */
private List<PatchSet> patchSets;
PatchSetsBlock() {
body = new FlowPanel();
initWidget(body);
}
/** Adds UI elements for each patch set of the given change to this composite. */
public void display(final ChangeDetail detail, final PatchSet.Id diffBaseId) {
clear();
final PatchSet currps = detail.getCurrentPatchSet();
currentPatchSetId = currps.getId();
patchSets = detail.getPatchSets();
if (Gerrit.isSignedIn()) {
final AccountGeneralPreferences p =
Gerrit.getUserAccount().getGeneralPreferences();
if (p.isReversePatchSetOrder()) {
Collections.reverse(patchSets);
}
}
patchSetPanelsList = new ArrayList<>();
for (final PatchSet ps : patchSets) {
final PatchSetComplexDisclosurePanel p =
new PatchSetComplexDisclosurePanel(ps, ps == currps,
detail.hasDraftComments(ps.getId()));
if (diffBaseId != null) {
p.setDiffBaseId(diffBaseId);
if (ps == currps) {
p.refresh();
}
}
add(p);
patchSetPanelsList.add(p);
}
}
private void clear() {
setRegisterKeys(false);
body.clear();
patchSetPanels.clear();
}
public void refresh(final PatchSet.Id diffBaseId) {
if (patchSetPanelsList != null) {
for (final PatchSetComplexDisclosurePanel p : patchSetPanelsList) {
p.setDiffBaseId(diffBaseId);
if (p.isOpen()) {
p.refresh();
}
}
}
}
/**
* Adds the given patch set panel to this composite and ensures that handler
* to activate / deactivate keyboard navigation for the patch set panel are
* registered.
*/
private void add(final PatchSetComplexDisclosurePanel patchSetPanel) {
body.add(patchSetPanel);
final PatchSet.Id id = patchSetPanel.getPatchSet().getId();
ActivationHandler activationHandler = new ActivationHandler(id);
patchSetPanel.addOpenHandler(activationHandler);
patchSetPanel.addClickHandler(activationHandler);
patchSetPanels.put(id, patchSetPanel);
}
public void setRegisterKeys(final boolean on) {
if (on) {
KeyCommandSet keysNavigation =
new KeyCommandSet(Gerrit.C.sectionNavigation());
keysNavigation.add(new PreviousPatchSetKeyCommand(0, 'p', Util.C
.previousPatchSet()));
keysNavigation.add(new NextPatchSetKeyCommand(0, 'n', Util.C
.nextPatchSet()));
regNavigation = GlobalKey.add(this, keysNavigation);
if (activePatchSetId != null) {
activate(activePatchSetId);
} else {
activate(currentPatchSetId);
}
} else {
if (regNavigation != null) {
regNavigation.removeHandler();
regNavigation = null;
}
deactivate();
}
}
@Override
protected void onUnload() {
setRegisterKeys(false);
super.onUnload();
}
/**
* Activates keyboard navigation for the patch set panel that displays the
* patch set with the given patch set id.
* The keyboard navigation for the previously active patch set panel is
* automatically deactivated.
* This method also ensures that the current row is only highlighted in the
* table of the active patch set panel.
*/
public void activate(final PatchSet.Id patchSetId) {
if (indexOf(patchSetId) != -1) {
if (!patchSetId.equals(activePatchSetId)) {
deactivate();
PatchSetComplexDisclosurePanel patchSetPanel =
patchSetPanels.get(patchSetId);
patchSetPanel.setActive(true);
patchSetPanel.setOpen(true);
activePatchSetId = patchSetId;
}
} else {
Gerrit.display(PageLinks.toChange(patchSetId.getParentKey()));
}
}
/** Deactivates the keyboard navigation for the currently active patch set panel. */
private void deactivate() {
if (activePatchSetId != null) {
PatchSetComplexDisclosurePanel patchSetPanel =
patchSetPanels.get(activePatchSetId);
patchSetPanel.setActive(false);
activePatchSetId = null;
}
}
public PatchSet getCurrentPatchSet() {
PatchSetComplexDisclosurePanel patchSetPanel =
patchSetPanels.get(currentPatchSetId);
if (patchSetPanel != null) {
return patchSetPanel.getPatchSet();
} else {
return null;
}
}
private int indexOf(PatchSet.Id id) {
for (int i = 0; i < patchSets.size(); i++) {
if (patchSets.get(i).getId().equals(id)) {
return i;
}
}
return -1;
}
private class ActivationHandler implements OpenHandler<DisclosurePanel>,
ClickHandler {
private final PatchSet.Id patchSetId;
ActivationHandler(PatchSet.Id patchSetId) {
this.patchSetId = patchSetId;
}
@Override
public void onOpen(OpenEvent<DisclosurePanel> event) {
// when a patch set panel is opened by the user
// it should automatically become active
PatchSetComplexDisclosurePanel patchSetPanel =
patchSetPanels.get(patchSetId);
patchSetPanel.refresh();
activate(patchSetId);
}
@Override
public void onClick(ClickEvent event) {
// when a user clicks on a patch table the corresponding
// patch set panel should automatically become active
activate(patchSetId);
}
}
public class PreviousPatchSetKeyCommand extends KeyCommand {
public PreviousPatchSetKeyCommand(int mask, char key, String help) {
super(mask, key, help);
}
@Override
public void onKeyPress(final KeyPressEvent event) {
int index = indexOf(activePatchSetId) - 1;
if (0 <= index) {
activate(patchSets.get(index).getId());
}
}
}
public class NextPatchSetKeyCommand extends KeyCommand {
public NextPatchSetKeyCommand(int mask, char key, String help) {
super(mask, key, help);
}
@Override
public void onKeyPress(final KeyPressEvent event) {
int index = indexOf(activePatchSetId) + 1;
if (index < patchSets.size()) {
activate(patchSets.get(index).getId());
}
}
}
}