// Copyright (C) 2015 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.api;
import com.google.gerrit.client.GerritUiExtensionPoint;
import com.google.gerrit.client.rpc.Natives;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsArray;
import com.google.gwt.dom.client.Element;
import com.google.gwt.user.client.ui.FlowPanel;
import com.google.gwt.user.client.ui.SimplePanel;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ExtensionPanel extends FlowPanel {
private static final Logger logger = Logger.getLogger(ExtensionPanel.class.getName());
private final GerritUiExtensionPoint extensionPoint;
private final List<Context> contexts;
public ExtensionPanel(GerritUiExtensionPoint extensionPoint) {
this(extensionPoint, new ArrayList<String>());
}
public ExtensionPanel(GerritUiExtensionPoint extensionPoint, List<String> panelNames) {
this.extensionPoint = extensionPoint;
this.contexts = create(panelNames);
}
private List<Context> create(List<String> panelNames) {
List<Context> contexts = new ArrayList<>();
for (Definition def : getOrderedDefs(panelNames)) {
SimplePanel p = new SimplePanel();
add(p);
contexts.add(Context.create(def, p));
}
return contexts;
}
private List<Definition> getOrderedDefs(List<String> panelNames) {
if (panelNames == null) {
panelNames = Collections.emptyList();
}
Map<String, List<Definition>> defsOrderedByName = new LinkedHashMap<>();
for (String name : panelNames) {
defsOrderedByName.put(name, new ArrayList<Definition>());
}
for (Definition def : Natives.asList(Definition.get(extensionPoint.name()))) {
addDef(def, defsOrderedByName);
}
List<Definition> orderedDefs = new ArrayList<>();
for (List<Definition> defList : defsOrderedByName.values()) {
orderedDefs.addAll(defList);
}
return orderedDefs;
}
private static void addDef(Definition def, Map<String, List<Definition>> defsOrderedByName) {
String panelName = def.getPanelName();
if (panelName.equals(def.getPluginName() + ".undefined")) {
/* Handle a partially undefined panel name from the
javascript layer by generating a random panel name.
This maintains support for panels that do not provide a name. */
panelName =
def.getPluginName() + "." + Long.toHexString(Double.doubleToLongBits(Math.random()));
}
if (defsOrderedByName.containsKey(panelName)) {
defsOrderedByName.get(panelName).add(def);
} else if (defsOrderedByName.containsKey(def.getPluginName())) {
defsOrderedByName.get(def.getPluginName()).add(def);
} else {
defsOrderedByName.put(panelName, Collections.singletonList(def));
}
}
public void put(GerritUiExtensionPoint.Key key, String value) {
for (Context ctx : contexts) {
ctx.put(key.name(), value);
}
}
public void putInt(GerritUiExtensionPoint.Key key, int value) {
for (Context ctx : contexts) {
ctx.putInt(key.name(), value);
}
}
public void putBoolean(GerritUiExtensionPoint.Key key, boolean value) {
for (Context ctx : contexts) {
ctx.putBoolean(key.name(), value);
}
}
public void putObject(GerritUiExtensionPoint.Key key, JavaScriptObject value) {
for (Context ctx : contexts) {
ctx.putObject(key.name(), value);
}
}
@Override
protected void onLoad() {
super.onLoad();
for (Context ctx : contexts) {
try {
ctx.onLoad();
} catch (RuntimeException e) {
logger.log(
Level.SEVERE,
"Failed to load extension panel for extension point "
+ extensionPoint.name()
+ " from plugin "
+ ctx.getPluginName()
+ ": "
+ e.getMessage());
}
}
}
@Override
protected void onUnload() {
super.onUnload();
for (Context ctx : contexts) {
for (JavaScriptObject u : Natives.asList(ctx.unload())) {
ApiGlue.invoke(u);
}
}
}
static class Definition extends JavaScriptObject {
static final JavaScriptObject TYPE = init();
private static native JavaScriptObject init() /*-{
function PanelDefinition(n, c, x) {
this.pluginName = n;
this.onLoad = c;
this.name = x;
};
return PanelDefinition;
}-*/;
static native JsArray<Definition> get(String i) /*-{ return $wnd.Gerrit.panels[i] || [] }-*/;
protected Definition() {}
public final native String getPanelName() /*-{ return this.pluginName + "." + this.name; }-*/;
public final native String getPluginName() /*-{ return this.pluginName; }-*/;
}
static class Context extends JavaScriptObject {
static final Context create(Definition def, SimplePanel panel) {
return create(TYPE, def, panel.getElement());
}
final native void onLoad() /*-{ this._d.onLoad(this) }-*/;
final native JsArray<JavaScriptObject> unload() /*-{ return this._u }-*/;
final native String getPluginName() /*-{ return this._d.pluginName; }-*/;
final native void put(String k, String v) /*-{ this.p[k] = v; }-*/;
final native void putInt(String k, int v) /*-{ this.p[k] = v; }-*/;
final native void putBoolean(String k, boolean v) /*-{ this.p[k] = v; }-*/;
final native void putObject(String k, JavaScriptObject v) /*-{ this.p[k] = v; }-*/;
private static native Context create(JavaScriptObject T, Definition d, Element e)
/*-{ return new T(d,e) }-*/ ;
private static final JavaScriptObject TYPE = init();
private static native JavaScriptObject init() /*-{
var T = function(d,e) {
this._d = d;
this._u = [];
this.body = e;
this.p = {};
};
T.prototype = {
onUnload: function(f){this._u.push(f)},
};
return T;
}-*/;
protected Context() {}
}
}