void UpdatePanels()
{
var controller = EditorForm.Instance.WorkspaceController as WorkspaceControllerForForm;
var documentWindows = controller.GetDockWindowsRecursive();
var selectedWindow = controller.SelectedDocumentWindow;
//no update for some windows
if (selectedWindow != null)
{
if (selectedWindow.OpenAsSettings)
{
return;
}
if (selectedWindow.Document != null && selectedWindow.Document.SpecialMode == "ProjectSettingsUserMode")
{
return;
}
}
//remove old
foreach (PanelData panel in panels.ToArray())
{
if (!documentWindows.Contains(panel.documentWindow))
{
RemovePanel(panel);
}
}
//create new
if (selectedWindow != null && GetPanel(selectedWindow) == null)
{
CreatePanel(selectedWindow, true);
}
//activate
{
bool setToNull = true;
if (selectedWindow != null)
{
PanelData panel = GetPanel(selectedWindow);
if (panel != null)
{
SelectedPanel = panel;
setToNull = false;
}
}
if (setToNull)
{
SelectedPanel = null;
}
}
}
protected override void OnHide(GUnit unit, PanelData panel)
{
var preloadPanelData = panel as UIPreloadTestPanelData;
foreach (var preloadItem in preloadPanelData.preloadItemList)
{
preloadItem.Despawn();
}
preloadPanelData.preloadItemList.Clear();
}
protected override void OnShow(GUnit unit, PanelData panel, params object[] args)
{
var preloadPanelData = panel as UIPreloadTestPanelData;
var asset = AssetProcess.Get <GameObject>("Prefabs/UI/PreloadItem");
for (var i = 0; i < 10; i++)
{
var preloadItem = asset.Spawn();
preloadItem.transform.SetParent(preloadPanelData.grid.transform);
}
}
public void AddPanel(OSCPanel panel, float minimalSize, float size = 0.5f)
{
var data = new PanelData();
data.Panel = panel;
data.MinimumSizePixel = minimalSize;
data.Size = size;
_storedPanelData.Add(data);
var fullSize = 0f;
foreach (var storedData in _storedPanelData)
{
fullSize += storedData.Size;
}
if (fullSize > 1f)
{
foreach (var storedData in _storedPanelData)
{
storedData.Size = 1f / _storedPanelData.Count;
}
}
if (_storedPanelData.Count < 2)
{
return;
}
_splitters.Clear();
_selectedSplitter = null;
Splitter previouSplitter = null;
foreach (var storedData in _storedPanelData)
{
if (previouSplitter != null)
{
previouSplitter.SecondPanel = storedData.Panel;
previouSplitter.SecondData = storedData;
_splitters.Add(previouSplitter);
}
previouSplitter = new Splitter()
{
FirstPanel = storedData.Panel,
FirstData = storedData
};
}
LoadData();
}
public override UIPanelBase.PanelData GetPanelData()
{
PanelData pd = base.GetPanelData();
pd.JumpData = new PanelJumpData();
pd.JumpData.Tabs = new int[2];
pd.JumpData.Tabs[0] = (int)memActiveFirstTab;
pd.JumpData.Tabs[1] = mActiveSecondTab;
pd.JumpData.Param = selectMallItemId;
pd.JumpData.ExtParam = purchaseNum;
return(pd);
}
public override UIPanelBase.PanelData GetPanelData()
{
PanelData data = base.GetPanelData();
data.JumpData = new PanelJumpData();
data.JumpData.Tabs = new int[2];
data.JumpData.Tabs[0] = (int)selectfTabID;
data.JumpData.Tabs[1] = (int)selectsTabID;
data.JumpData.Param = (uint)selectExchangeId;
data.JumpData.ExtParam = (uint)exchangeNum;
return(data);
}
public override UIPanelBase.PanelData GetPanelData()
{
PanelData pd = base.GetPanelData();
pd.JumpData = new PanelJumpData();
pd.JumpData.Tabs = new int[2];
pd.JumpData.Tabs[0] = (int)activeStore;
pd.JumpData.Tabs[1] = activeTabId;
pd.JumpData.Param = selectMallItemId;
pd.JumpData.ExtParam = purchaseNum;
return(pd);
}
/// <summary>
/// 创建面板，请求资源管理器
/// </summary>
/// <param name="type"></param>
public void CreatePanel(string path, int weight, LuaFunction func = null)
{
string name = Path.GetFileNameWithoutExtension(path);
if (uiList.GetValue(path) != null)
{
return;
}
AssetWidget uiWidget = new AssetWidget(path, weight, (ao) =>
{
var prefab = ao.GetAsset <GameObject>();
if (prefab == null)
{
Debug.LogError(string.Format("Panel load error: no panel founded! {0}, {1}", ao.assetPath, name));
return;
}
GameObject go = Instantiate(prefab) as GameObject;
go.name = name;
go.layer = LayerMask.NameToLayer("UI");
go.transform.SetParent(FindParent().transform, false);
go.transform.localScale = Vector3.one;
go.transform.localPosition = Vector3.zero;
LuaBehaviour behaviour = go.transform.GetOrAddComponent <LuaBehaviour>();
behaviour.OnInit();
PanelData panelData;
try
{
panelData = poolManager.Get <PanelData>();
}
catch
{
panelData = new PanelData();
}
panelData.Name = name;
panelData.Weight = weight;
panelData.PanelObject = go;
panelData.behaviour = behaviour;
uiList.Put(name, panelData);
uiShowList.Add(name);
if (func != null)
{
func.Call(go);
}
_curShowPanel = name;
_curDepth++;
panelData.AddOrder(_curDepth);
Debug.LogWarning("CreatePanel::>> " + name + " " + prefab);
});
panelLoader.LoadAsset(uiWidget);
}
private void processJSON(int i, string rt)
{
try
{
PanelData tempPanel = new PanelData();
int poz = 1;
string[] temp = rt.Split(',');
foreach (string index in temp)
{
string[] item = index.Split(':');
item[1] = item[1].Replace("\"", string.Empty).Trim();
switch (poz)
{
case 2:
tempPanel.title = item[1];
break;
case 3:
tempPanel.price = Convert.ToDecimal(item[1]);
break;
case 4:
tempPanel.description = item[1];
break;
case 6:
tempPanel.sellerID = item[1];
break;
case 8:
tempPanel.seller = item[1];
break;
case 10:
tempPanel.pictureURL = item[1];
break;
}
poz++;
}
if (tempPanel.title != null && tempPanel.description != null)
{
pnlData.Add(tempPanel);
adaugaLaPoz(i, tempPanel);
}
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
void Show(GUnit unit, PanelData panelData, PanelParamData paramData)
{
panelData.gameObject.SetActive(true);
OnShow(unit, panelData, paramData.paramsList.ToArray());
if (panelData.AnimationType == UIAnimationType.Animation)
{
panelData.AnimationProcessor?.Play(UIConstant.OPEN_TWEEN_NAME);
}
else if (panelData.AnimationType == UIAnimationType.Tween)
{
panelData.TweenProcessor?.Play(UIConstant.OPEN_TWEEN_NAME);
}
}
/// <summary>
/// Panel変更イベントを登録する
/// </summary>
private void SetPanelEvent(Vector2I OldPos, Vector2I NewPos)
{
if (OldPos != Vector2I.InvalidPos)
{
PanelData panel = GridHelper.GetPanel(OldPos.X, OldPos.Y);
panel._OnReportPanelChange -= pOnReportPanelChange;
}
if (NewPos != Vector2I.InvalidPos)
{
PanelData panel = GridHelper.GetPanel(NewPos.X, NewPos.Y);
panel._OnReportPanelChange += pOnReportPanelChange;
}
}
protected override void InitData()
{
PanelID = PanelID.Main;
PrePanelID = PanelID.Invalid;
PanelData = new PanelData(
PanelType.Normal,
PanelColliderMode.Image,
PanelNavigationMode.Navigation,
PanelPopupMode.HideOther,
//进入主界面后,清空导航栈
true
);
}
protected override void OnCreatePanelControl(PanelData panel)
{
base.OnCreatePanelControl(panel);
var component = panel.documentWindow.Document.ResultComponent;
//var component = panel.documentWindow.ObjectOfWindow as Component;
//if( panel.documentWindow.LoadedResource != null )
// component = panel.documentWindow.GetDocumentObject() as Component;
if (component != null)
{
var browser = new ContentBrowser(); // documentObject as Component );
if (sharedOptions != null)
{
browser.Options = sharedOptions;
}
else
{
Config_Load(browser);
sharedOptions = browser.Options;
}
browser.Mode = ContentBrowser.ModeEnum.Objects;
browser.CanSelectObjectSettings = true;
browser.Options.FilteringModeButton = false;
browser.Options.DisplayPropertiesSortFilesBy = false;
browser.Options.DisplayPropertiesOpenButton = false;
browser.TreeViewBorderDraw = BorderSides.Top;
browser.ListViewBorderDraw = BorderSides.Top;
browser.MultiSelect = true;
//!!!!было до redesign
//browser.ItemAfterSelect += ContentBrowser_ItemAfterSelect;
//browser.ItemAfterChoose += ContentBrowser_ItemAfterChoose;
browser.Init(panel.documentWindow, component, /*null,*/ null);
panel.control = browser;
panel.control.Dock = DockStyle.Fill;
Controls.Add(panel.control);
browser.ItemAfterSelect += Browser_ItemAfterSelect;
SelectItemsOfSelectedObjects(panel.documentWindow);
}
else
{
panel.control = new UserControl();
panel.control.Dock = DockStyle.Fill;
Controls.Add(panel.control);
}
}
public override void SetPanelData(PanelData aPanelData)
{
GamePanelData pd = aPanelData as GamePanelData;
if (pd == null)
{
Debug.Log("GamePanelData is null");
return;
}
currenLevelData = pd.CurrentLevel;
SetUpLevel();
}
public override PanelData GetPanelData()
{
PanelData pd = new PanelData()
{
PID = PanelId,
Data = cacheData,
JumpData = new PanelJumpData()
{
Tabs = new int[] { (int)m_curMode }
},
};
return(pd);
}
void RemovePanel(PanelData panel)
{
if (SelectedPanel == panel)
{
SelectedPanel = null;
}
var control = panel.control;
control.Parent.Controls.Remove(control);
control.Dispose();
panels.Remove(panel);
}
public static PanelData GetPanel(int X, int Y)
{
foreach (TaskData tData in FloorManager.TaskDataList.Values)
{
if (tData is PanelData)
{
PanelData panel = tData as PanelData;
if (panel.X == X && panel.Y == Y)
{
return(panel);
}
}
}
return(null);
}
static PanelData FindExistingPanelData(Guid pluginId, Guid tabId)
{
if (m_existing_panels != null)
{
for (int i = 0; i < m_existing_panels.Count; i++)
{
PanelData pd = m_existing_panels[i];
if (pd != null && pd.PlugInId == pluginId && pd.PanelType.GUID == tabId)
{
return(pd);
}
}
}
return(null);
}
static IWin32Window FindOrCreatePanel(Guid pluginId, Guid tabId)
{
PanelData data = FindExistingPanelData(pluginId, tabId);
if (data == null)
{
return(null);
}
if (data.Panel == null)
{
data.Panel = System.Activator.CreateInstance(data.PanelType) as IWin32Window;
}
return(data.Panel);
}
void RemovePanel(PanelData panel)
{
//!!!!так?
if (SelectedPanel == panel)
{
SelectedPanel = null;
}
var control = panel.control;
control.Parent.Controls.Remove(control);
control.Dispose();
panels.Remove(panel);
panelByDocumentWindow.Remove(panel.documentWindow);
}
static int OnVisiblePanelCallback(Guid pluginId, Guid tabId, uint state)
{
PanelData data = FindExistingPanelData(pluginId, tabId);
if (data == null)
{
return(0);
}
System.Windows.Forms.Control panel = data.Panel as System.Windows.Forms.Control;
if (panel == null)
{
return(0);
}
panel.Visible = (state != 0);
return(1);
}
/// <summary>
/// 关闭面板
/// </summary>
/// <param name="name"></param>
public void ClosePanel(string name)
{
uiShowList.Remove(name);
PanelData panelObj = uiList.GetValue(name);
if (panelObj != null)
{
if (_curShowPanel == name)
{
_curDepth--;
}
panelObj.ResetOrder();
panelObj.behaviour.OnClose();
poolManager.Release <PanelData>(panelObj);
}
}
public void LoadInstalledPanel(PanelTypes panelType, PanelDatabase sourceDatabase)
{
var variation = variationList.Where(m => m.Item1 == panelType && m.Item2 == sourceDatabase.Provider).FirstOrDefault();
if (variation != null)
{
PanelType = variation.Item1;
CurrentPanel = variation.Item4;
PanelData = variation.Item3;
PanelData.LoadConnectionString(sourceDatabase.ConnectionString());
}
else
{
throw new Exception(String.Format("Panel not supported: {0} - {1}", panelType, sourceDatabase.Provider));
}
}
// ********************************************************************
// ********************************************************************
#region Panel Methods
// ********************************************************************
protected override void _Initialise(PanelData _data)
{
DialoguePanelData castData = _data as DialoguePanelData;
if (castData != null)
{
LogManager.Log("DialoguePanel _Initialise with conversation " + castData.conversation.name,
LogCategory.UI,
LogSeverity.LOG,
"Dialogue",
gameObject);
m_currentConversation = castData.conversation;
}
m_previousCursor = InputManager.cursor;
Events.Raise(new ChangeCursorEvent("TalkingCursor"));
m_player = ReInput.players.GetPlayer(0);
}
public void SelectObjects(object[] objects) // SettingsLevel2Window.PanelData settingsPanel )
{
if (EditorAPI.ClosingApplication)
{
return;
}
//if( settingsPanel != null )
if (objects.Length != 0)
{
//find cached panel
PanelData panel = GetPanel(objects); // settingsPanel );
bool isAlreadySelected = panel != null && SelectedPanel == panel;
if (!isAlreadySelected)
{
if (panel != null)
{
//move to last position (best priority)
panels.Remove(panel);
panels.Add(panel);
}
//create new panel
if (panel == null)
{
//remove cached
while (panels.Count >= maxCachedCount)
{
RemovePanel(panels[0]);
}
panel = CreatePanel(objects, true);
//panel = CreatePanel( settingsPanel, true );
}
SelectedPanel = panel;
}
}
else
{
SelectedPanel = null;
}
}
public PanelData Open <T>(UILayer layer = UILayer.Common, Action <T> callback = null) where T : UIBasePanel
{
string panelName = typeof(T).ToString();
if (_allPanelData.TryGetValue(panelName, out var data))
{
if (data.handle.IsDone)
{
data.panel.gameObject.SetActive(true);
data.panel.transform.SetAsLastSibling();
callback?.Invoke((T)data.panel);
}
return(data);
}
PanelData panelData = new PanelData();
_allPanelData.Add(panelName, panelData);
panelData.layer = layer;
panelData.name = panelName;
foreach (var ignoreName in _ignoreClosePanelList)
{
if (panelName == ignoreName)
{
panelData.IgnoreClose = true;
break;
}
}
panelData.handle = ResManager.Instance.Instantiate(panelName, panelGo =>
{
panelGo.name = panelName;
panelGo.transform.SetParent(_allPanelParentDict[layer], false);
T uiPanel = panelGo.GetComponent <T>();
panelData.panel = uiPanel;
callback?.Invoke(uiPanel);
});
return(panelData);
}
PanelData CreatePanel(DocumentWindow documentWindow, bool willSelected)
{
PanelData panel = new PanelData();
panel.documentWindow = documentWindow;
panels.Add(panel);
panelByDocumentWindow.Add(panel.documentWindow, panel);
//create control
OnCreatePanelControl(panel);
if (!willSelected && panel.control != null)
{
panel.control.Visible = false;
panel.control.Enabled = false;
}
return(panel);
}
PanelData CreatePanel(DocumentWindow document, object[] key, bool willSelected)
{
PanelData panel = new PanelData();
panels.Add(panel);
panel.selectedObjects = key;
panel.CreateAndAddPanel(this);
//hide
if (!willSelected && panel.layoutPanel != null)
{
panel.layoutPanel.Visible = false;
panel.layoutPanel.Enabled = false;
}
SettingsProvider.Create(document, panel.selectedObjects, panel.layoutPanel, null, true);
return(panel);
}
/// <summary>
/// You typically register your panel class in your plug-in's OnLoad function.
/// This informs Rhino of the existence of your panel class
/// </summary>
/// <param name="plugin">Plug-in this panel is associated with</param>
/// <param name="panelType">
/// Class type to construct when a panel is shown. Currently only types
/// that implement the IWin32Window interface are supported. The requirements
/// for the class are that it has a parameterless constructor and have a
/// GuidAttribute applied with a unique Guid
/// </param>
/// <param name="caption"></param>
/// <param name="icon">Use a 32bit depth icon in order to get proper transparency</param>
public static void RegisterPanel(Rhino.PlugIns.PlugIn plugin, Type panelType, string caption, System.Drawing.Icon icon)
{
if (!typeof(IWin32Window).IsAssignableFrom(panelType))
{
throw new ArgumentException("panelType must implement IWin32Window interface", "panelType");
}
System.Reflection.ConstructorInfo constructor = panelType.GetConstructor(System.Type.EmptyTypes);
if (!panelType.IsPublic || constructor == null)
{
throw new ArgumentException("panelType must be a public class and have a parameterless constructor", "panelType");
}
object[] attr = panelType.GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), false);
if (attr.Length != 1)
{
throw new ArgumentException("panelType must have a GuidAttribute", "panelType");
}
if (m_existing_panels == null)
{
m_existing_panels = new List <PanelData>();
}
// make sure the type is not already registered
for (int i = 0; i < m_existing_panels.Count; i++)
{
var pd = m_existing_panels[i];
if (pd != null && pd.PlugInId == plugin.Id && pd.PanelType == panelType)
{
return;
}
}
PanelData panel_data = new PanelData();
panel_data.PlugInId = plugin.Id;
panel_data.PanelType = panelType;
m_existing_panels.Add(panel_data);
m_create_panel_callback = OnCreatePanelCallback;
m_visible_panel_callback = OnVisiblePanelCallback;
UnsafeNativeMethods.RHC_RegisterTabbedDockBar(caption, panelType.GUID, plugin.Id, icon.Handle, m_create_panel_callback, m_visible_panel_callback);
}
UIPanelBase CreateUI(PanelData panelData)
{
//先尝试找到Component类型，接着直接在资源对象上附上组件，这样以后在实例化时，无需再装配组件。
if (!panelData.EnsureComponent())
{ //确认组件类型是否正确
return(null);
}
GameObject prefab = panelData.panelResObject;
//Type t = Type.GetType(panelData.componentName);
//if (t == null)
//{
// Debug.LogErrorFormat("UIManager::CreateUI:找不到名为{0}的组件类型", panelData.componentName);
// return null;
//}
//if (!t.IsSubclassOf(typeof(UIPanelBase)))
//{
// Debug.LogErrorFormat("UIManager::CreateUI:名为{0}的组件类型不是一个UIPanelBase类型", panelData.componentName);
// return null;
//}
//if (prefab.GetComponent(t) == null)
// prefab.AddComponent(t);
GameObject instance = GameObject.Instantiate(prefab, _rootCanvasTrans);
Transform trans = instance.transform;
trans.localPosition = Vector3.zero;
trans.localRotation = Quaternion.identity;
trans.localScale = Vector3.one;
GameObjectUtils.SetLayerRecursively(trans, LayerManager.GetLayerInt(LayerManager.Layer.Internal_UI));
UIPanelBase panel = instance.GetComponent <UIPanelBase>();
if (panel == null)
{
Debug.LogErrorFormat("UIManager::CreateUI:名为{0}的组件类型不是一个UIPanelBase类型", panelData.componentName);
return(null);
}
return(panel);
}
//based on stock solar panel sun tracking code
private void updatePanelRotation(PanelData pd)
{
//vector from pivot to sun
Vector3 vector = pd.pivotTransform.InverseTransformPoint (sunTransform.position);
//finding angle to turn towards based on direction of vector on a single axis
float y = Mathf.Atan2 (vector.x, vector.z) * 57.29578f;
//lerp towards destination rotation by trackingSpeed amount
Quaternion to = pd.pivotTransform.rotation * Quaternion.Euler (0f, y, 0f);
pd.pivotTransform.rotation = Quaternion.Lerp (pd.pivotTransform.rotation, to, TimeWarp.deltaTime * this.trackingSpeed);
}
private void updatePanelPower(PanelData pd)
{
if(!isOccludedByPart(pd.rayCastTransform))
{
Vector3 normalized = (sunTransform.position - pd.rayCastTransform.position).normalized;
float sunAOA = Mathf.Clamp (Vector3.Dot (pd.rayCastTransform.forward, normalized), 0f, 1f);
float distMult = (float)(vessel.solarFlux / PhysicsGlobals.SolarLuminosityAtHome);
if(distMult==0 && FlightGlobals.currentMainBody!=null)//vessel.solarFlux == 0, so occluded by a planetary body
{
occluderName = FlightGlobals.currentMainBody.name;//just guessing..but might be occluded by the body we are orbiting?
}
float efficMult = temperatureEfficCurve.Evaluate ((float)part.temperature);
float panelEnergy = resourceAmount * TimeWarp.fixedDeltaTime * sunAOA * distMult * efficMult;
energyFlow += panelEnergy;
}
}
//loads transforms from model given the transform names specified in config
//TODO rework to remove the lists, no need to keep names afterwards
private void findTransforms()
{
panelData.Clear();
if(pivotNames.Count!=suncatcherNames.Count)
{
print ("pivot and suncatcher names length not equal, error!");
return;
}
PanelData pd;
String pn, sn;
Transform t1, t2;
int length = pivotNames.Count;//lists -should- be the same size, or there will be problems
for(int i = 0; i < length; i++)
{
pn = pivotNames[i];
sn = suncatcherNames[i];
t1 = part.FindModelTransform(pn);
t2 = part.FindModelTransform(sn);
if(t1==null || t2==null)
{
print ("null transform found for names.. "+pn+" :: "+sn);
continue;
}
pd = new PanelData();
pd.pivotTransform = t1;
pd.rayCastTransform = t2;
pd.angle = 0;
pd.defaultOrientation = new Quaternion(t1.localRotation.x, t1.localRotation.y, t1.localRotation.z, t1.localRotation.w);//set a copy of original rotation, to restore when panels are retracted
panelData.Add (pd);
}
if(windBreakTransformName!=null && windBreakTransformName.Length>0)
{
t1 = part.FindModelTransform(windBreakTransformName);
if(t1!=null)
{
windBreakTransform = t1;
}
}
if(windBreakTransform==null && panelData.Count>0)
{
windBreakTransform = panelData[0].pivotTransform;
}//else it will use default vessel transform
}
private void findTransforms()
{
panelData.Clear();
String[] suncatcherNames = rayTransforms.Split(',');
String[] pivotNames = pivotTransforms.Split(',');
if (pivotNames.Length != suncatcherNames.Length)
{
print("pivot and suncatcher names length not equal, error!");
return;
}
PanelData pd;
String pn, sn;
Transform t1, t2;
int length = pivotNames.Length;//lists -should- be the same size, or there will be problems
for (int i = 0; i < length; i++)
{
pn = pivotNames[i].Trim();
sn = suncatcherNames[i].Trim();
t1 = part.FindModelTransform(pn);
t2 = part.FindModelTransform(sn);
if (t1 == null || t2 == null)
{
print("null transform found for solar panel pivot/suncather names names.. " + pn + " :: " + sn + " :: " + t1 + " ::" + t2);
continue;
}
pd = new PanelData();
pd.pivotTransform = t1;
pd.rayCastTransform = t2;
pd.defaultOrientation = pd.pivotTransform.localRotation;
panelData.Add(pd);
}
if (windBreakTransformName != null && windBreakTransformName.Length > 0)
{
t1 = part.FindModelTransform(windBreakTransformName);
if (t1 != null)
{
windBreakTransform = t1;
}
}
if (windBreakTransform == null && panelData.Count > 0)
{
windBreakTransform = panelData[0].pivotTransform;
}//else it will use default vessel transform
}
/// <summary>
/// You typically register your panel class in your plug-in's OnLoad function.
/// This informs Rhino of the existence of your panel class
/// </summary>
/// <param name="plugin">Plug-in this panel is associated with</param>
/// <param name="panelType">
/// Class type to construct when a panel is shown. Currently only types
/// that implement the IWin32Window interface are supported. The requirements
/// for the class are that it has a parameterless constructor and have a
/// GuidAttribute applied with a unique Guid
/// </param>
/// <param name="caption"></param>
/// <param name="icon">Use a 32bit depth icon in order to get proper transparency</param>
public static void RegisterPanel(Rhino.PlugIns.PlugIn plugin, Type panelType, string caption, System.Drawing.Icon icon)
{
if (!typeof(IWin32Window).IsAssignableFrom(panelType))
throw new ArgumentException("panelType must implement IWin32Window interface", "panelType");
System.Reflection.ConstructorInfo constructor = panelType.GetConstructor(System.Type.EmptyTypes);
if (!panelType.IsPublic || constructor == null)
throw new ArgumentException("panelType must be a public class and have a parameterless constructor", "panelType");
object[] attr = panelType.GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), false);
if (attr.Length != 1)
throw new ArgumentException("panelType must have a GuidAttribute", "panelType");
if (m_existing_panels == null)
m_existing_panels = new List<PanelData>();
// make sure the type is not already registered
for (int i = 0; i < m_existing_panels.Count; i++)
{
var pd = m_existing_panels[i];
if (pd != null && pd.PlugInId == plugin.Id && pd.PanelType == panelType)
return;
}
PanelData panel_data = new PanelData();
panel_data.PlugInId = plugin.Id;
panel_data.PanelType = panelType;
m_existing_panels.Add(panel_data);
m_create_panel_callback = OnCreatePanelCallback;
m_visible_panel_callback = OnVisiblePanelCallback;
UnsafeNativeMethods.RHC_RegisterTabbedDockBar(caption, panelType.GUID, plugin.Id, icon.Handle, m_create_panel_callback, m_visible_panel_callback);
}
