public WeatherRequestWWO(WeatherInput future, WeatherInput past = null, RefreshType reftype = RefreshType.FullRefresh)
{
m_info_future = future;
m_info_historical = past;
m_reftype = reftype;
m_weatherinfo = new WeatherNullPtr();//This is a NUll PTr Pattern so that there would always be a next actor and not a null pointer
}
/// <summary>
/// 更改名称
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void UpLabelToolStripMenuItem_Click(object sender, EventArgs e)
{
TreeListNode node = new TreeListNode();
RefreshType type = RefreshType.None;
if (treeList1.Focused)
{
if (treeList1.FocusedNode == null)
{
return;
}
node = treeList1.FocusedNode;
type = RefreshType.StaticLabel;
}
else
{
if (treeList2.FocusedNode == null)
{
return;
}
node = treeList2.FocusedNode;
type = RefreshType.DynamicLabel;
}
UpdateLabel update = new UpdateLabel(node.GetValue(0).ToString(), type);
update.MyRefreshEvent += new UpdateLabel.MyEvent(GetLabels);
update.Show();
Program.log.Error($"更改标签名{node.GetValue(0).ToString()}");
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.States))
{
}
if (type.HasFlag(RefreshType.Elements))
{
}
if (type.HasFlag(RefreshType.Animations))
{
}
if (type.HasFlag(RefreshType.Scopes))
{
}
if (type.HasFlag(RefreshType.Parameters))
{
}
if (type.HasFlag(RefreshType.Occasions))
{
}
if (type.HasFlag(RefreshType.CommonEvents))
{
}
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.Actors))
{
}
}
public RefreshLogObject(Uri serverUrl, string wellUid, string wellboreUid, string logObjectUid, RefreshType refreshType) : base(serverUrl)
{
WellUid = wellUid;
WellboreUid = wellboreUid;
LogObjectUid = logObjectUid;
RefreshType = refreshType;
}
public WeatherController(WeatherInput future, WeatherInput past = null, RefreshType reftype = RefreshType.FullRefresh)
{
m_info_future = future;
m_info_historical = past;
m_reftype = reftype;
BuildResponsibilityChain();
}
public UpdateLabel(string info, RefreshType refresh)
{
InitializeComponent();
index = int.Parse(info.Split(':').First());
textBox1.Text = info.Split(':').Last();
type = refresh;
}
public WeatherRequestZOWA(WeatherInput future, WeatherInput past = null, RefreshType reftype = RefreshType.FullRefresh)
{
m_info_future = future;
m_info_historical = past;
m_reftype = reftype;
m_weatherinfo = new WeatherNullPtr();
}
/// <summary>
/// TODO
/// </summary>
public TreeViewModel(RefreshType refreshType, HashSet <Severity> severities)
{
DataService dataService = DataService.Instance;
bool failed = false;
RaisePropertyChanged("SelectedKey");
switch (refreshType)
{
case RefreshType.Hard:
{
dataService.Refresh(true);
break;
}
case RefreshType.Soft:
{
dataService.Refresh(false);
break;
}
}
//failed = dataService.isFail();
this.Artifacts = new ObservableCollection <ArtifactViewModel>();
dataService.Severities = severities;
foreach (string key in dataService.RootElements)
{
Artifacts.Add(new ArtifactViewModel(key));
}
}
/// <summary>
/// Calls Refresh in Unity, and RefreshPaths in vfs. If called multiple times while already running, schedules itself again
/// </summary>
/// <param name="lifetime"></param>
/// <param name="refreshType"></param>
public Task Refresh(Lifetime lifetime, RefreshType refreshType)
{
myLocks.AssertMainThread();
if (myEditorProtocol.UnityModel.Value == null)
{
return(Task.CompletedTask);
}
if (!myBoundSettingsStore.GetValue((UnitySettings s) => s.AllowAutomaticRefreshInUnity) &&
refreshType == RefreshType.Normal)
{
return(Task.CompletedTask);
}
if (myRunningRefreshTask != null && !myRunningRefreshTask.IsCompleted)
{
// we may schedule secondary refresh here, which will start after first refresh and protocol reconnect
// we already do something like that in UnitTesting
myLogger.Verbose($"Refresh already running. Skip starting a new one.");
return(myRunningRefreshTask);
}
lifetime.OnTermination(() => myRunningRefreshTask = Task.CompletedTask);
myRunningRefreshTask = RefreshInternal(lifetime, refreshType);
return(myRunningRefreshTask);
}
private void calculate(LTPartnerData data, RefreshType type)
{
switch (type)
{
case RefreshType.Attribute:
attripower = AttributesManager.GetSelfAttributeCombatPower(data);
break;
case RefreshType.Skill:
skillper = AttributesManager.GetPartnerSkillPowerPer(data);
attripower = AttributesManager.GetSelfAttributeCombatPower(data);
break;
case RefreshType.EquipsuitSkill:
suitskillper = AttributesManager.GetEquipSuitPer(data);
attripower = AttributesManager.GetSelfAttributeCombatPower(data);
break;
case RefreshType.All:
attripower = AttributesManager.GetSelfAttributeCombatPower(data);
skillper = AttributesManager.GetPartnerSkillPowerPer(data);
suitskillper = AttributesManager.GetEquipSuitPer(data);
break;
default:
break;
}
curPower = (int)(attripower * (1 + skillper + suitskillper));
}
private async Task RefreshInternal(Lifetime lifetime, RefreshType refreshType)
{
var lifetimeDef = Lifetime.Define(lifetime);
myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Started");
mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime,
RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...")
.AsIndeterminate().AsNonCancelable());
try
{
try
{
var version = UnityVersion.Parse(myEditorProtocol.UnityModel.Value.UnityApplicationData.Value.ApplicationVersion);
if (version != null && version.Major < 2018)
{
using (mySolution.GetComponent <VfsListener>().PauseChanges())
{
await myEditorProtocol.UnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask();
}
}
else // it is a risk to pause vfs https://github.com/JetBrains/resharper-unity/issues/1601
{
await myEditorProtocol.UnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask();
}
}
catch (Exception e)
{
myLogger.Warn("connection usually brakes during refresh.", e);
}
finally
{
try
{
myLogger.Verbose(
$"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Finished");
var solution = mySolution.GetProtocolSolution();
var solFolder = mySolution.SolutionDirectory;
var list = new List <string> {
solFolder.FullPath
};
myLogger.Verbose($"RefreshPaths.StartAsTask Finished.");
await solution.GetFileSystemModel().RefreshPaths.Start(lifetimeDef.Lifetime, new RdRefreshRequest(list, true)).AsTask();
}
finally
{
myLogger.Verbose($"RefreshPaths.StartAsTask Finished.");
lifetimeDef.Terminate();
}
}
}
catch (Exception e)
{
myLogger.LogException(e);
}
finally
{
lifetimeDef.Terminate();
}
}
// If productGroupKey is non-empty, only those items that have their ProductGroupKey property equal
// to this value will be returned.
public ActiveItemTypeQuery(Datastore store, string productGroupKey, List <ItemTypeID> typeList, ShouldRefresh shouldRefresh, RefreshType refreshType = PlannerNameSpace.RefreshType.QueryForChangedItems)
: base(store)
{
TypeList = typeList;
m_productGroupKey = productGroupKey;
ShouldRefresh = shouldRefresh;
RefreshType = refreshType;
}
public AddLabel(RefreshType type = RefreshType.None, string text = null)
{
InitializeComponent();
comText = text;
Type = type;
label3.Text = "添加标签:\r\t一次添加多个标签,以回车分开,\r\t添加标签类请选择标签类型为动态或静态";
SetComboBox();
SetComboxType();
}
public SelectLabel(RefreshType type = RefreshType.None, string text = null)
{
InitializeComponent();
Type = type;
if (!string.IsNullOrEmpty(text))
{
labels = text.Split(',').ToList();
}
}
private RefreshType RefreshType;//委托方法
public ProblemTypeForm(IProblemEditFormReq iProblemEditFormReq, RefreshType RefreshType)
{
InitializeComponent();
this.iProblemEditFormReq = iProblemEditFormReq;
this.iProblemTypeFormReq = ImplProblemTypeFormReq.NewInstance();
this.RefreshType = RefreshType;
this.initView();
this.initData();
}
public void OnValueChanged(LTPartnerData data, bool isShow, RefreshType type)
{
perPower = curPower;
calculate(data, type);
add = curPower - perPower;
if (isShow && add != 0)
{
str = add >= 0 ? "+" : "";
MessageTemplateManager.ShowMessage(eMessageUIType.CombatPowerText, string.Format("{0},{1}{2}", curPower, str, add));
}
}
public static string ScriptRefresh(IEnumerable <TabularNamedObject> objects, RefreshType refreshType = RefreshType.Automatic)
{
if (objects.Count() == 1 && objects.First() is Model)
{
return(TOM.JsonScripter.ScriptRefresh((objects.First().MetadataObject as TOM.Model).Database, (TOM.RefreshType)refreshType));
}
else
{
return(TOM.JsonScripter.ScriptRefresh(objects.Where(o => o is Table || o is Partition).Select(o => o.MetadataObject).ToList(), (TOM.RefreshType)refreshType));
}
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.Classes))
{
}
if (type.HasFlag(RefreshType.Parameters))
{
}
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.Enemies))
{
}
if (type.HasFlag(RefreshType.Switches))
{
}
}
public HostItemQuery(Datastore store, List <ItemTypeID> typeList, List <string> groupMemberAliases, List <int> treeIDs,
AsyncObservableCollection <TrainItem> trains, ShouldRefresh isRefresh, RefreshType refreshType = RefreshType.QueryForChangedItems)
: base(store)
{
TypeList = typeList;
GroupMembers = groupMemberAliases;
TreeIDs = treeIDs;
Trains = trains;
ShouldRefresh = isRefresh;
RefreshType = refreshType;
}
internal static void Initialize(UcModBrowserKerbalStuff view)
{
View = view;
EventDistributor.AsyncTaskStarted += AsyncTaskStarted;
EventDistributor.AsyncTaskDone += AsyncTaskDone;
EventDistributor.LanguageChanged += LanguageChanged;
// Add your stuff to initialize here.
View.Model = model;
LastRefresh = RefreshType.New;
}
public void RefreshInactiveChannel(RefreshType refresh)
{
if (refresh == RefreshType.WithAccumulators)
{
proportionalPowerAccumulator = 0xFFFFFFFFFFFF;
}
busVoltage = 0xFFFF;
senseResistorVoltage = 0xFFFF;
averageBusVoltage = 0xFFFF;
senseResistorAverageVoltage = 0xFFFF;
proportionalPower = 0xFFFFFFF;
}
public Task Refresh(RefreshType force)
{
myLocks.AssertMainThread();
if (CurrentTask != null)
{
return(CurrentTask);
}
if (myEditorProtocol.UnityModel.Value == null)
{
return(new Task(() => {}));
}
if (!myBoundSettingsStore.GetValue((UnitySettings s) => s.AllowAutomaticRefreshInUnity) && force == RefreshType.Normal)
{
return(new Task(() => {}));
}
myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {force}");
var task = myEditorProtocol.UnityModel.Value.Refresh.StartAsTask(force);
CurrentTask = task;
var lifetimeDef = Lifetime.Define(myLifetime);
var solution = mySolution.GetProtocolSolution();
var solFolder = mySolution.SolutionFilePath.Directory;
mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime,
RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...").AsIndeterminate().AsNonCancelable());
task.ContinueWith(_ =>
{
mySolution.Locks.ExecuteOrQueueEx(lifetimeDef.Lifetime, "RefreshPaths", () =>
{
try
{
var list = new List <string> {
solFolder.FullPath
};
solution.GetFileSystemModel().RefreshPaths.Start(new RdRefreshRequest(list, true));
}
finally
{
CurrentTask = null;
lifetimeDef.Terminate();
}
});
});
return(task);
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.Elements))
{
}
if (type.HasFlag(RefreshType.Animations))
{
}
if (type.HasFlag(RefreshType.Parameters))
{
}
}
public void RefreshActiveChannel(RefreshType refresh)
{
// populate the registers with dummy data
var randomizer = EmulationManager.Instance.CurrentEmulation.RandomGenerator;
proportionalPower = SampleBusVoltage * SampleSenseResistorVoltage;
if (refresh == RefreshType.WithAccumulators)
{
proportionalPowerAccumulator += proportionalPower;
}
busVoltage = (ushort)(SampleBusVoltage + randomizer.Next(-20, 20));
senseResistorVoltage = (ushort)(SampleSenseResistorVoltage + randomizer.Next(-20, 20));
averageBusVoltage = GetAverage(vBusQueue, busVoltage);
senseResistorAverageVoltage = GetAverage(vSenseQueue, senseResistorVoltage);
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.States))
{
}
if (type.HasFlag(RefreshType.Elements))
{
}
if (type.HasFlag(RefreshType.EquipKinds))
{
}
}
private void RefreshChannels(RefreshType refresh)
{
for (int i = 0; i < ChannelCount; ++i)
{
if (channels[i].IsChannelDisabled.Value && !skipInactiveChannels.Value)
{
channels[i].RefreshInactiveChannel(refresh);
}
else if (!channels[i].IsChannelDisabled.Value)
{
channels[i].RefreshActiveChannel(refresh);
accumulatorCount += (refresh == RefreshType.WithAccumulators ? 1u : 0);
}
}
}
/// <summary>
/// 删除标签
/// </summary>
private void DelOneLabel()
{
RefreshType type = RefreshType.None;
if (treeList1.Focused && treeList1.FocusedNode != null)
{
DeleteShowMessage(treeList1);
type = RefreshType.StaticLabel;
}
else if (treeList2.Focused && treeList2.FocusedNode != null)
{
DeleteShowMessage(treeList2);
type = RefreshType.DynamicLabel;
}
GetLabels(type);
}
private int GetLabelType()
{
switch (comboBox_type.Text)
{
case "动态标签":
Type = RefreshType.DynamicLabel;
return(0);
case "静态标签":
Type = RefreshType.StaticLabel;
return(1);
default:
return(0);
}
}
protected bool AddRefreshDateFilterClause(ShouldRefresh shouldRefresh, RefreshType refreshType)
{
if (shouldRefresh == PlannerNameSpace.ShouldRefresh.Yes)
{
if (refreshType == PlannerNameSpace.RefreshType.QueryForChangedItems)
{
DateTime lastRefreshTime = TypeUtils.GetValueAsLocalTime(Planner.Instance.LastRefreshTime);
string lastRefreshDate = lastRefreshTime.ToShortDateString();
AddClause(Datastore.PropNameChangedDate, "equalsGreater", lastRefreshDate);
}
return(true);
}
else
{
return(false);
}
}
private void cbProblemType_SelectedIndexChanged(object sender, EventArgs e)
{
ProblemType type;
try { type = (ProblemType)this.cbProblemType.SelectedItem; }
catch
{
type = new ProblemType();
type.Name = this.TipEditType;
}
if (type.Name.Equals(this.TipEditType))
{
RefreshType RefreshType = new RefreshType(this.RefreshType);
ProblemTypeForm problemTypeForm = new ProblemTypeForm(this.iProblemEditFormReq, RefreshType);
problemTypeForm.ShowDialog();
}
}
/// <summary>
/// 获取标签集合加入选择标签栏
/// </summary>
public void GetLabels(RefreshType type)
{
AllLabels = new MyLabels();
switch (type)
{
case RefreshType.DynamicLabel:
SetDynamicLabel();
break;
case RefreshType.StaticLabel:
SetStaticLabel();
break;
case RefreshType.None:
SetDynamicLabel();
SetStaticLabel();
break;
}
}
public void RefreshGUI(RefreshType refresh, String str, IntPtr ptr)
{
if (ShuttingDown)
{
return;
}
switch (refresh)
{
case RefreshType.RefreshCloseDocument:
ShuttingDown = true;
break;
case RefreshType.RefreshSelection:
if (ptr != null && ptr.ToInt64() != 0)
{
UIForm form = UIForm.GetFromFixedId(ptr);
modelPropertiesForm.UpdateForForm(form);
modelObjectDescriptionForm.UpdateForView(form);
}
else
{
modelPropertiesForm.UpdateForForm(formBE);
modelObjectDescriptionForm.UpdateForView(formBE);
}
break;
case RefreshType.RefreshDocument:
TabText = formBE.get_title();
break;
case RefreshType.RefreshZoom:
modelNavigator.UpdateDisplay();
break;
case RefreshType.RefreshCloseEditor:
CloseEditorsForObject(str);
break;
}
}
public DataRule GetDataRule(string rulename, RefreshType rt)
{
switch (rt)
{
case RefreshType.OnlyCache:
return(FindDataRule(rulename));
case RefreshType.NoCache:
return(DataServices.LoadInfo(rulename));
default:
DataRule dr = FindDataRule(rulename);
if (dr == null)
{
dr = DataServices.LoadInfo(rulename);
AppendDataRule(dr);
}
return(dr);
}
}
private void AddLabelToolStripMenuItem_Click(object sender, EventArgs e)
{
string text = string.Empty;
RefreshType type = RefreshType.None;
if (treeList1.Focused && treeList1.FocusedNode.Level == 0)
{
text = treeList1.FocusedNode.GetValue(0).ToString();
type = RefreshType.StaticLabel;
}
else if (treeList2.Focused && treeList2.FocusedNode.Level == 0)
{
text = treeList2.FocusedNode.GetValue(0).ToString();
type = RefreshType.DynamicLabel;
}
AddLabel addLabel = new AddLabel(type, text);
addLabel.MyRefreshEvent += new AddLabel.MyEvent(GetLabels);
addLabel.Show();
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.States))
{
}
if (type.HasFlag(RefreshType.Elements))
{
}
if (type.HasFlag(RefreshType.Animations))
{
}
if (type.HasFlag(RefreshType.Skills))
{
}
if (type.HasFlag(RefreshType.Parameters))
{
}
if (type.HasFlag(RefreshType.Items))
{
}
if (type.HasFlag(RefreshType.Weapons))
{
}
if (type.HasFlag(RefreshType.Armors))
{
}
if (type.HasFlag(RefreshType.Switches))
{
}
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
if (type.HasFlag(RefreshType.States))
{
}
if (type.HasFlag(RefreshType.Elements))
{
}
if (type.HasFlag(RefreshType.Weapons))
{
}
if (type.HasFlag(RefreshType.Armors))
{
}
if (type.HasFlag(RefreshType.Skills))
{
}
}
private void ForwardRefreshToAllDocuments(RefreshType refresh, String str, IntPtr ptr)
{
foreach (ITabDocument document in contentTabControl.Documents)
if (document is IWorkbenchDocument)
(document as IWorkbenchDocument).RefreshGUI(refresh, str, ptr);
}
private void ForwardRefreshToActivDocument(RefreshType refresh, String str, IntPtr ptr)
{
if (contentTabControl.ActiveDocument is IWorkbenchDocument)
(contentTabControl.ActiveDocument as IWorkbenchDocument).RefreshGUI(refresh, str, ptr);
}
/// <summary>
/// Notifies all open database windows that objects of a given type need refreshed
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public static void DatabaseNotify(RefreshType type)
{
foreach (DatabaseWindow window in Windows.DatabaseForms)
window.NotifyRefresh(type);
}
public void RefreshGUI(RefreshType refresh, String str, IntPtr ptr)
{
if (IsDisposed || Disposing)
return;
SuspendLayout();
switch (refresh)
{
case RefreshType.RefreshCloseDocument:
{
ForwardRefreshToAllDocuments(refresh, str, ptr);
if (workbenchPhysicalOverviewForm != null)
{
workbenchPhysicalOverviewForm.ResetDocument(true);
workbenchPhysicalOverviewForm.Close();
workbenchPhysicalOverviewForm = null;
}
wbContext.flush_idle_tasks();
wbContext.close_document_finish();
break;
}
case RefreshType.RefreshNewDiagram:
{
BaseWindowsCanvasView canvas = BaseWindowsCanvasView.GetFromFixedId(ptr);
if (canvas != null)
{
// Open only diagrams which were open when this model was closed last time.
ModelDiagramForm modelDiagramForm = canvas.GetOwnerForm() as ModelDiagramForm;
if (modelDiagramForm != null && !modelDiagramForm.DiagramWrapper.is_closed())
DockDocument(modelDiagramForm, true, true);
}
break;
}
case RefreshType.RefreshNewModel: // A new model was loaded or created. Show UI.
ShowPhysicalOverviewForm(true);
// Let the backend create what is necessary.
wbContext.new_model_finish();
break;
case RefreshType.RefreshDocument:
case RefreshType.RefreshCloseEditor:
case RefreshType.RefreshOverviewNodeInfo:
ForwardRefreshToAllDocuments(refresh, str, ptr);
break;
case RefreshType.RefreshSchemaNoReload:
case RefreshType.RefreshSelection:
case RefreshType.RefreshZoom:
ForwardRefreshToActivDocument(refresh, str, ptr);
break;
case RefreshType.RefreshTimer:
UpdateTimer();
break;
case RefreshType.RefreshFinishEdits:
// Force all ongoing edits to be Commited (like in listview cells)
try
{
Control activeControl = ControlUtilities.GetLeafActiveControl(this);
if (activeControl != null)
{
if (activeControl.Parent is Aga.Controls.Tree.TreeViewAdv)
{
ActiveControl = null;
}
}
}
catch (Exception e)
{
Program.HandleException(e);
}
break;
case RefreshType.RefreshOverviewNodeChildren:
if (workbenchPhysicalOverviewForm != null)
workbenchPhysicalOverviewForm.RefreshGUI(refresh, str, ptr);
break;
}
ResumeLayout();
}
public void RefreshGUI(RefreshType refresh, String str, IntPtr ptr)
{
switch (refresh)
{
case RefreshType.RefreshSelection:
if (ptr != null && ptr.ToInt64() != 0)
{
UIForm form = UIForm.GetFromFixedId(ptr);
modelObjectDescriptionForm.UpdateForView(form);
}
else
modelObjectDescriptionForm.UpdateForView(null);
break;
case RefreshType.RefreshDocument:
UpdateTabText();
break;
case RefreshType.RefreshOverviewNodeChildren:
RefreshNodeChildren(new NodeIdWrapper(str));
break;
case RefreshType.RefreshOverviewNodeInfo:
RefreshNodeInfo(new NodeIdWrapper(str));
break;
case RefreshType.RefreshCloseEditor:
CloseEditorsForObject(str);
break;
}
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
public override void NotifyRefresh(RefreshType type)
{
}
public void RefreshDisplay(RefreshType refreshType)
{
if (lockBusy) return;
try
{
lockBusy = true;
Busy(true);
RefreshMenus(refreshType);
RefreshDatasources(refreshType);
RefreshFilter(refreshType);
ReGroupDataSets(refreshType);
RestoreCollapsed();
Busy(false);
}
catch (Exception ex)
{
log.Error(ex);
}
finally { lockBusy = false; }
}
void Refresh(RefreshType type)
{
try
{
TooltipManager.IsPaused = true;
System.Diagnostics.Debug.WriteLine("\r\nPivotGrid refresh started");
if (FocusedCell != null && FocusedCell.IsEditing)
EndEdit();
DateTime start = DateTime.Now;
if (type == RefreshType.BuildEndRefresh)
{
BuildAreasLayout();
}
if (type != RefreshType.RefreshByRows)
BuildColumnsArea();
if (type != RefreshType.RefreshByColumns)
BuildRowsArea();
BuildCellsArea();
BuildSplitters();
DateTime stop1 = DateTime.Now;
System.Diagnostics.Debug.WriteLine(" Building time: " + (stop1 - start).ToString());
if (m_LayoutProvider != null)
{
if (type != RefreshType.RefreshByRows)
{
DateTime stop2_1 = DateTime.Now;
InitializeColumnsArea(m_LayoutProvider);
DateTime stop2_2 = DateTime.Now;
System.Diagnostics.Debug.WriteLine(" InitializeColumnsArea time: " + (stop2_2 - stop2_1).ToString());
}
if (type != RefreshType.RefreshByColumns)
{
DateTime stop3_1 = DateTime.Now;
InitializeRowsArea(m_LayoutProvider);
DateTime stop3_2 = DateTime.Now;
System.Diagnostics.Debug.WriteLine(" InitializeRowsArea time: " + (stop3_2 - stop3_1).ToString());
}
DateTime stop4_1 = DateTime.Now;
InitializeCellsArea(m_LayoutProvider);
DateTime stop4_2 = DateTime.Now;
System.Diagnostics.Debug.WriteLine(" InitializeCellsArea time: " + (stop4_2 - stop4_1).ToString());
InitializeSplitters();
}
DateTime stop = DateTime.Now;
System.Diagnostics.Debug.WriteLine("PivotGrid refreshing time: " + (stop - start).ToString());
}
finally {
TooltipManager.IsPaused = false;
}
}
private void RefreshView(RefreshType refreshType)
{
if (refreshType == RefreshType.FacultiesOnly || refreshType == RefreshType.FullRefresh)
{
var faculties = _repo
.Faculties
.GetAllFaculties()
.OrderBy(f => f.SortingOrder)
.ToList();
FacultiesListView.DataSource = faculties;
FacultiesListView.Columns["FacultyId"].Visible = false;
FacultiesListView.Columns["SortingOrder"].Visible = false;
FacultiesListView.Columns["Name"].Width = (int)Math.Round((FacultiesListView.Width - 30) * 0.6);
FacultiesListView.Columns["ScheduleSigningTitle"].Width = (int)Math.Round((FacultiesListView.Width - 30) * 0.1);
FacultiesListView.Columns["DeanSigningSchedule"].Width = (int)Math.Round((FacultiesListView.Width - 30) * 0.1);
FacultiesListView.Columns["SessionSigningTitle"].Width = (int)Math.Round((FacultiesListView.Width - 30) * 0.1);
FacultiesListView.Columns["DeanSigningSessionSchedule"].Width = (int)Math.Round((FacultiesListView.Width - 30) * 0.1);
FacultiesListView.Columns["Letter"].Width = 30;
}
if (refreshType == RefreshType.GroupsOnly || refreshType == RefreshType.FullRefresh)
{
Faculty faculty = null;
if (FacultiesListView.SelectedCells.Count > 0)
{
faculty = ((List<Faculty>)FacultiesListView.DataSource)[FacultiesListView.SelectedCells[0].RowIndex];
}
if (faculty == null)
{
return;
}
var facultyGroups = _repo
.GroupsInFaculties
.GetFiltredGroupsInFaculty(gif => gif.Faculty.FacultyId == faculty.FacultyId)
.Select(gif => gif.StudentGroup)
.ToList();
GroupsView.DataSource = facultyGroups;
GroupsView.Columns["StudentGroupId"].Visible = false;
GroupsView.Columns["Name"].Width = GroupsView.Width - 50;
}
}
public void RefreshGUI(RefreshType refresh, String str, IntPtr ptr)
{
if (Closing)
return;
switch (refresh)
{
case RefreshType.RefreshCloseDocument:
Closing = true;
break;
case RefreshType.RefreshSelection:
if (ptr != null && ptr.ToInt64() != 0)
{
UIForm form = UIForm.GetFromFixedId(ptr);
modelPropertiesForm.UpdateForForm(form);
modelObjectDescriptionForm.UpdateForView(form);
}
else
{
modelPropertiesForm.UpdateForForm(formBE);
modelObjectDescriptionForm.UpdateForView(formBE);
}
break;
case RefreshType.RefreshDocument:
TabText = formBE.get_title();
break;
case RefreshType.RefreshZoom:
modelNavigator.UpdateDisplay();
break;
case RefreshType.RefreshCloseEditor:
CloseEditorsForObject(str);
break;
}
}
private void RefreshFilter(RefreshType refreshType)
{
if (refreshType.Equals(RefreshType.Full) || refreshType.Equals(RefreshType.View))
{
if (gridRelationDataSets.ContainsKey("GetDashboardProcessList"))
{
gridGroupingControl1.DataSource = gridRelationDataSets["GetDashboardProcessList"];
gridGroupingControl1.Engine.SourceListSet.Clear();
gridGroupingControl1.Engine.SourceListSet.Add("GetDashboardProcessList", gridRelationDataSets["GetDashboardProcessList"]);
}
}
if (dvProcesses != null)
{
if (!String.IsNullOrEmpty(filterView) && String.IsNullOrEmpty(filterStatus))
dvProcesses.RowFilter = filterView;
else if (String.IsNullOrEmpty(filterView) && !String.IsNullOrEmpty(filterStatus))
dvProcesses.RowFilter = filterStatus;
else if (!String.IsNullOrEmpty(filterView) && !String.IsNullOrEmpty(filterStatus))
dvProcesses.RowFilter = filterView + " AND " + filterStatus;
else
dvProcesses.RowFilter = String.Empty;
}
}
private void RefreshMenus(RefreshType refreshType)
{
if (refreshType.Equals(RefreshType.Full))
{
DataSet dsViewList = DashboardData.GetViewList();
BuildViewMenu(dsViewList);
if (filterSettings.Count == 0)
{
if (tsbView.Items.Count > 0)
tsbView.SelectedIndex = 0;
if (tsbGroup.Items.Count > 0)
tsbGroup.SelectedIndex = 0;
}
filterSettings.Clear();
filterSettings.Add("View", viewId);
filterSettings.Add("Group", tsbGroup.SelectedIndex);
tsbGroup.SelectedIndex = filterSettings["Group"];
}
}
private void RefreshView(RefreshType refreshType)
{
if (refreshType == RefreshType.FacultiesOnly || refreshType == RefreshType.FullRefresh)
{
var faculties = _repo
.GetAllFaculties()
.OrderBy(f => f.SortingOrder)
.ToList();
FacultiesListView.DataSource = faculties;
FacultiesListView.Columns["FacultyId"].Visible = false;
FacultiesListView.Columns["SortingOrder"].Visible = false;
FacultiesListView.Columns["Name"].Width = FacultiesListView.Width - 50;
FacultiesListView.Columns["Letter"].Width = 30;
}
if (refreshType == RefreshType.GroupsOnly || refreshType == RefreshType.FullRefresh)
{
var faculty = ((List<Faculty>)FacultiesListView.DataSource)[FacultiesListView.SelectedCells[0].RowIndex];
if (faculty == null)
{
return;
}
var facultyGroups = _repo
.GetFiltredGroupsInFaculty(gif => gif.Faculty.FacultyId == faculty.FacultyId)
.Select(gif => gif.StudentGroup)
.ToList();
GroupsView.DataSource = facultyGroups;
GroupsView.Columns["StudentGroupId"].Visible = false;
GroupsView.Columns["Name"].Width = GroupsView.Width - 50;
}
}
public PSAction() {
this.sortRankField = "0";
this.launchNewWindowField = false;
this.clientActionField = true;
this.supportsMultiSelectField = false;
this.refreshHintField = RefreshType.none;
}
public void InvokeRefresh(RefreshType refreshType)
{
try
{
if (InvokeRequired)
{
delInvokeRefresh d = new delInvokeRefresh(RefreshDisplay);
this.BeginInvoke(d, refreshType);
}
else
{
RefreshDisplay(refreshType);
}
}
catch (Exception ex)
{
log.Error(ex);
}
}
static void fsw_Changed(object sender, FileSystemEventArgs e)
{
LastUpdateTime = System.DateTime.Now.Ticks;
RefreshType = AutoF5Lib.RefreshType.Page;
}
private void ReGroupDataSets(RefreshType refreshType)
{
if (refreshType.Equals(RefreshType.Full) || refreshType.Equals(RefreshType.View))
try
{
////Specify relations in grouping engine
gridRelationDescriptors.Clear();
gridGroupingControl1.TableDescriptor.Relations.Clear();
foreach (DashboardView view in Config.Views.Values)
{
//-------------------------------------------------
//Uncomment this line for child views
//-------------------------------------------------
AddGridRelationDescriptor(view);
}
foreach (DashboardView view in Config.Views.Values)
{
if (gridRelationDescriptors.ContainsKey(view.Alias))
{
foreach (string hiddenField in view.HiddenFields)
{
gridRelationDescriptors[view.Alias].ChildTableDescriptor.VisibleColumns.Remove(hiddenField);
}
}
}
if (tsbGroup.SelectedItem != null)
GroupColumn(tsbGroup.SelectedItem.ToString());
gridGroupingControl1.TableDescriptor.VisibleColumns.Clear();
foreach (DataColumn col in gridRelationDataSets["GetDashboardProcessList"].Table.Columns)
gridGroupingControl1.TableDescriptor.VisibleColumns.Add(col.ColumnName);
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove(tsbGroup.SelectedItem.ToString());
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("ActivityId");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("ProcessId");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Schedule Name");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Description");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Total");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Success");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Failed");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("SLA");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("ViewId");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Expected Start Time");
gridGroupingControl1.TableDescriptor.VisibleColumns.Remove("Expected Completion Time");
gridGroupingControl1.TopLevelGroupOptions.ShowFilterBar = true;
GridColumnDescriptorCollection descColl = gridGroupingControl1.TableDescriptor.Columns;
foreach (GridColumnDescriptor desc in descColl)
desc.AllowFilter = true;
}
catch (Exception ex)
{
log.Error(ex);
}
}
private void RefreshList(RefreshType rt, int key, UserInfo user)
{
lock (this)//进程间互斥,防止在刷新时修改集合
{
switch (rt)
{
case RefreshType.Add:
{
Log.Write(user.IP, "Update start");
if (!this.Disposing)
{
RefreshMethod call = delegate()
{
ListViewItem li = listViewHistoryUser.Items.Insert(0, user.IP.ToString());
li.SubItems.Add(new ListViewItem.ListViewSubItem(li, DateTime.Now.ToString()));
li.SubItems.Add(new ListViewItem.ListViewSubItem(li, "Update start"));
};
listViewHistoryUser.Invoke(call);
}
ConnectedUsers.Add(key, user);//刷新history user
break;
}
case RefreshType.Remove:
{
if (ConnectedUsers.ContainsKey(key))
{
Log.Write(ConnectedUsers[key].IP, "Update finish");//在还没有登入时会出错
if (!this.Disposing)
{
RefreshMethod call = delegate()
{
ListViewItem li = listViewHistoryUser.Items.Insert(0, ConnectedUsers[key].IP.ToString());
li.SubItems.Add(new ListViewItem.ListViewSubItem(li, DateTime.Now.ToString()));
li.SubItems.Add(new ListViewItem.ListViewSubItem(li, "Update finish"));
};
listViewHistoryUser.Invoke(call);
}
ConnectedUsers.Remove(key);
}
break;
}
case RefreshType.Refresh:
break;
}
if (!this.Disposing)//正在中止线程
{
RefreshMethod call = delegate()
{
listViewActiveUser.Items.Clear();
IEnumerator ie = ConnectedUsers.GetEnumerator();
while (ie.MoveNext())
{
UserInfo ui = ((DictionaryEntry)ie.Current).Value as UserInfo;
ListViewItem li = listViewActiveUser.Items.Add(ui.IP.ToString());
li.SubItems.Add(new ListViewItem.ListViewSubItem(li, ui.ConnectTime.ToString()));
}
};
listViewActiveUser.Invoke(call);//终止线程时调用会产生死锁
}
}
}
public EcoleLoadedEventArgs(RefreshType change)
{
RefreshType = change;
}
/// <summary>
/// Refreshes objects by type flag
/// </summary>
/// <param name="type">Flag for type of object to refresh</param>
/// <exception cref="NotImplementedException">Thrown when method is not overridden.</exception>
/// <remarks>This methods is to be overridden in inherited classes.</remarks>
/// <exception cref="System.NotImplementedException">Thrown when method is not overridden in inherited class</exception>
public virtual void NotifyRefresh(RefreshType type)
{
throw new NotImplementedException("Method needs to be overridden in inherited classes.");
}
private void RefreshDatasources(RefreshType refreshType)
{
try
{
if (refreshType.Equals(RefreshType.Full) || refreshType.Equals(RefreshType.Data))
{
gridRelationDataSets.Clear();
DataView dv = ((DataSet)DashboardData.GetDashboard(dtPicker.Value, 1)).Tables[0].DefaultView;
//failsafe
if (dv == null || dv.Table.Rows.Count == 0)
dv = ((DataSet)DashboardData.GetDashboard(dtPicker.Value, 1)).Tables[0].DefaultView;
gridRelationDataSets.Add("GetDashboardProcessList", dv);
dvProcesses = dv;
}
}
catch (Exception ex)
{
log.Error(ex);
}
}
