public override void AfterConstruction()
{
base.AfterConstruction();
StartAt = "00:00";
EndAt = "00:00";
ExpenseType = Session.GetObjectByKey <ExpenseType>((((ExpenseType)ValueManager.GetValueManager <Dictionary <string, object> >("Values").Value["SalaryExpense"])).Oid);
}
static void AddSystemConfigurationToValueManager(XafApplication application, ITypeInfo type)
{
var os = application.CreateObjectSpace();
IValueManager <Dictionary <string, object> > valueManager = ValueManager.GetValueManager <Dictionary <string, object> >("Values");
if (valueManager.CanManageValue)
{
valueManager.Value = null;
}
var systemConfig = os.FindObject(type.Type, null);
if (systemConfig != null)
{
Dictionary <string, object> values = new Dictionary <string, object>();
foreach (var property in type.Members.Where(x => x.IsProperty))
{
values.Add(property.Name, property.GetValue(systemConfig));
}
valueManager = ValueManager.GetValueManager <Dictionary <string, object> >("Values");
if (valueManager.CanManageValue)
{
valueManager.Value = values;
}
}
}
protected override void Redraw(ImageManager imgManager)
{
if (!ValueManager.IsChanged(ID.Top) && !ValueManager.IsChanged(ID.Bot) && !ForceUpdate)
{
return;
}
ImageRenderer render = new ImageRenderer(imgManager.GetImageObject(DefaultImage, DeckType));
string top = ValueManager[ID.Top];
string bot = ValueManager[ID.Bot];
if (((top == KorrySettings.TopState && !KorrySettings.ShowTopNonZero) || (KorrySettings.ShowTopNonZero && ValueNonZero(top))) && !string.IsNullOrEmpty(KorrySettings.TopImage))
{
render.DrawImage(imgManager.GetImageObject(KorrySettings.TopImage, DeckType), KorrySettings.GetRectangleTop());
}
string testValue = bot;
if (KorrySettings.UseOnlyTopAddr)
{
testValue = top;
}
if (((testValue == KorrySettings.BotState && !KorrySettings.ShowBotNonZero) || (KorrySettings.ShowBotNonZero && ValueNonZero(testValue))) && !string.IsNullOrEmpty(KorrySettings.BotImage))
{
render.DrawImage(imgManager.GetImageObject(KorrySettings.BotImage, DeckType), KorrySettings.GetRectangleBot());
}
DrawImage = render.RenderImage64();
IsRawImage = true;
NeedRedraw = true;
render.Dispose();
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
// Disable version
if (this.CurrentDBVersion != new Version("0.0.0.0"))
{
return;
}
//
IObjectSpace os = ObjectSpace;
Session ssn = ((ObjectSpace)os).Session;
// "Наша" организация (она там одна)
crmUserParty.CurrentUserParty = ValueManager.GetValueManager <crmUserParty>("UserParty");
XPQuery <crmUserParty> userParties = new XPQuery <crmUserParty>(ssn);
var queryUP = (from userParty in userParties
select userParty).ToList <crmUserParty>();
foreach (var up in queryUP)
{
crmUserParty.CurrentUserParty.Value = (crmUserParty)up;
break;
}
// Исправление CashFlowRgister
CashFlowFormed(ssn);
os.CommitChanges();
// Исправление статусов заявок
RepairRequestRestSum(ssn);
os.CommitChanges();
}
internal sealed override void InitValueManager()
{
if (IsConcrete)
{
_valueManager = ValueManager.Create(this);
}
}
protected override void OnActivated()
{
controller = Application.MainWindow.GetController <FeatureCenterNotificationsController>();
controller.defaultProvider.NotificationTypesInfo.Add(XafTypesInfo.Instance.FindTypeInfo(typeof(TaskWithNotifications)));
controller.notificationController.Active["ShowNotifications"] = true;;
ValueManager.GetValueManager <Boolean?>("IsCustomNotificationInitialize").Value = true;
}
public override void Register(ImageManager imgManager, IPCManager ipcManager)
{
base.Register(imgManager, ipcManager);
RenderDefaultImage(imgManager);
ValueManager.RegisterValue(ID.Bot, KorrySettings.AddressBot);
}
private void Awake()
{
if (instance != null)
{
return;
}
instance = this;
}
public override void Update(ImageManager imgManager)
{
base.Update(imgManager);
RenderDefaultImage(imgManager);
NeedRedraw = true;
ValueManager.UpdateValueAddress(ID.Bot, KorrySettings.AddressBot);
}
public virtual void Register(ImageManager imgManager, IPCManager ipcManager)
{
SetInitialization();
ValueManager.RegisterManager(ipcManager);
imgManager.AddImage(DefaultImage, DeckType);
imgManager.AddImage(ErrorImage, DeckType);
}
internal sealed override void TryMakeConcrete()
{
if (!IsConcrete && !_isConcrete.HasValue)
{
_isConcrete = true;
Debug.Assert(_valueManager == null);
_valueManager = ValueManager.EnsureConcrete(this);
}
}
public override bool OnButtonUp(IPCManager ipcManager, long tick)
{
if (BaseSettings.SwitchOnCurrentValue)
{
ValueManager.SetVariable(ID.SwitchState, ValueManager[ID.ControlState]);
}
return(base.OnButtonUp(ipcManager, tick));
}
public override void Deregister(ImageManager imgManager)
{
base.Deregister(imgManager);
if (TextSettings.HasIndication)
{
imgManager.RemoveImage(TextSettings.IndicationImage, DeckType);
}
ValueManager.DeregisterValue(ID.ControlState);
}
public override void CustomizeTypesInfo(ITypesInfo typesInfo)
{
base.CustomizeTypesInfo(typesInfo);
CalculatedPersistentAliasHelper.CustomizeTypesInfo(typesInfo);
IValueManager <string> valueManager = ValueManager.GetValueManager <string>("FullName");
if (valueManager.CanManageValue)
{
valueManager.Value = "concat(FirstName, ' ', LastName)";
}
}
public virtual void UpdateActionValues()
{
if (!SwitchSettings.SwitchOnCurrentValue && IsActionReadable(SwitchSettings.ActionType) && IPCTools.IsReadAddress(SwitchSettings.AddressAction))
{
if (!ValueManager.ContainsValue(ID.SwitchState))
{
ValueManager.RegisterValue(ID.SwitchState, SwitchSettings.AddressAction);
}
else
{
ValueManager.UpdateValueAddress(ID.SwitchState, SwitchSettings.AddressAction);
}
ValueManager.RemoveVariable(ID.SwitchState);
}
else
{
if (ValueManager.ContainsValue(ID.SwitchState))
{
ValueManager.DeregisterValue(ID.SwitchState);
}
if (!ValueManager.ContainsVariable(ID.ControlState) && InitializationTest()) // SWITCH ONLY
{
ValueManager.SetVariable(ID.SwitchState, SwitchSettings.SwitchOffState);
}
}
if (IsActionReadable(SwitchSettings.ActionTypeLong) && IPCTools.IsReadAddress(SwitchSettings.AddressActionLong))
{
if (!ValueManager.ContainsValue(ID.SwitchStateLong) && SwitchSettings.HasLongPress)
{
ValueManager.RegisterValue(ID.SwitchStateLong, SwitchSettings.AddressActionLong);
}
else if (ValueManager.ContainsValue(ID.SwitchStateLong))
{
ValueManager.DeregisterValue(ID.SwitchStateLong);
}
ValueManager.RemoveVariable(ID.SwitchStateLong);
}
else
{
if (ValueManager.ContainsValue(ID.SwitchStateLong))
{
ValueManager.DeregisterValue(ID.SwitchStateLong);
}
if (!ValueManager.ContainsVariable(ID.ControlState) && SwitchSettings.HasLongPress)
{
ValueManager.SetVariable(ID.SwitchStateLong, SwitchSettings.SwitchOffStateLong);
}
}
}
private void Awake()
{
DontDestroyOnLoad(gameObject);
if (!Instance)
{
Instance = this;
}
else
{
DestroyImmediate(this.gameObject);
}
}
protected override void OnActivated()
{
base.OnActivated();
this.View.ControlsCreated += View_ControlsCreated;
if (IEventControllerResourceManager.Resources == null)
{
IEventControllerResourceManager.Resources = ValueManager.GetValueManager <List <object> >("SchedulerControllerResourceManager");
IEventControllerResourceManager.Resources.Value = new List <object>();
}
}
public override void Register(ImageManager imgManager, IPCManager ipcManager)
{
base.Register(imgManager, ipcManager);
imgManager.AddImage(DisplaySettings.OnImage, DeckType);
imgManager.AddImage(DisplaySettings.OffImage, DeckType);
if (DisplaySettings.HasIndication)
{
imgManager.AddImage(DisplaySettings.IndicationImage, DeckType);
}
ValueManager.RegisterValue(ID.ControlState, DisplaySettings.Address);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
ValueManager myScript = (ValueManager)target;
EditorGUILayout.HelpBox("Test of duplicates and missing values are only possible ingame.", MessageType.Info);
if (GUILayout.Button("Test duplicate/missing"))
{
myScript.testForDuplicatesAndMissingValues();
}
}
public LocalProcess(LocalSession session, ProcessInfo processInfo, int processID, IRemoteServerProcess process) : base()
{
_session = session;
_process = process;
_processID = processID;
_processInfo = processInfo;
_streamManager = new LocalStreamManager((IStreamManager)_process);
_internalProcess = (ServerProcess)_session._internalSession.StartProcess(new ProcessInfo(_session._internalSession.SessionInfo));
_session._server.OnCacheCleared += new CacheClearedEvent(CacheCleared);
_session._server.OnCacheClearing += new CacheClearedEvent(CacheClearing);
CacheCleared(_session._server);
_valueManager = new ValueManager(_internalProcess, this);
}
void ApplicationOnSetupComplete(object sender, EventArgs eventArgs)
{
lock (_lockObject) {
if (_instanceModelApplicationCreatorManager == null)
{
_instanceModelApplicationCreatorManager = ValueManager.GetValueManager <ModelApplicationCreator>("instanceModelApplicationCreatorManager");
}
if (_instanceModelApplicationCreatorManager.Value == null)
{
_instanceModelApplicationCreatorManager.Value = ((ModelApplicationBase)Application.Model).CreatorInstance;
}
}
}
public override void Update(ImageManager imgManager)
{
base.Update(imgManager);
RenderImages(imgManager);
NeedRedraw = true;
if (DrawBox != TextSettings.DrawBox)
{
TextSettings.ResetRectText();
DrawBox = TextSettings.DrawBox;
UpdateSettingsModel = true;
}
ValueManager.UpdateValueAddress(ID.ControlState, Address);
}
public string GetParameterValue(int id)
{
if (_isEditable)
{
if (Parameters[id].ValueType == ValueManager.ValueTypes.Sm)
{
return(ValueManager.ConvertToSm(Parameters[id].Value));
}
if (Parameters[id].ValueType == ValueManager.ValueTypes.Pt)
{
return(ValueManager.ConvertToPt(Parameters[id].Value));
}
}
return(Parameters[id].Value);
}
void Awake()
{
#region 나자신의 싱글톤 객체를 만들어서 할당한다.
if (나자신 == null)
{
나자신 = this;
}
else
{
Debug.LogError("싱글톤 사용해야합니다. 오류가 발행하기 쉽습니다. ValueManager 클래스의 Awake()를 수정하세요.");
}
#endregion
awaked = true;
}
private void NewObjectAction_Executing(object sender, CancelEventArgs e)
{
if (ValueManager.GetValueManager <Dictionary <string, object> >("Values").Value["SalaryExpense"] == null)
{
MessageOptions options = new MessageOptions();
options.Duration = 2000;
options.Message = "Salries expense type not added to system setup";
options.Type = InformationType.Error;
options.Web.Position = InformationPosition.Top;
options.Win.Caption = "Error";
options.Win.Type = WinMessageType.Flyout;
Application.ShowViewStrategy.ShowMessage(options);
e.Cancel = true;
}
}
public override void Register(ImageManager imgManager, IPCManager ipcManager)
{
base.Register(imgManager, ipcManager);
if (TextSettings.HasIndication)
{
imgManager.AddImage(TextSettings.IndicationImage, DeckType);
}
if (TextSettings.DrawBox)
{
RenderImages(imgManager);
}
ValueManager.RegisterValue(ID.ControlState, Address);
}
protected override void OnActivated()
{
base.OnActivated();
this.View.ControlsCreated += View_ControlsCreated;
if (SchedulerControllerResourceManager.Resources == null)
{
SchedulerControllerResourceManager.Resources = ValueManager.GetValueManager <List <object> >("SchedulerControllerResourceManager");
SchedulerControllerResourceManager.Resources.Value = new List <object>();
}
if (SchedulerControllerResourceManager.ActiveViewType == null)
{
SchedulerControllerResourceManager.ActiveViewType = ValueManager.GetValueManager <SchedulerViewType>("SchedulerControllerSchedulerViewType");
SchedulerControllerResourceManager.ActiveViewType.Value = DevExpress.XtraScheduler.SchedulerViewType.Agenda;
}
}
protected override void Redraw(ImageManager imgManager)
{
if (!ValueManager.IsChanged(ID.ControlState) && !ForceUpdate)
{
return;
}
string lastImage = DrawImage;
string currentValue = ValueManager[ID.ControlState];
if (Settings.OnState == currentValue || Settings.OffState == currentValue)
{
if (Settings.OnState == currentValue)
{
DrawImage = Settings.OnImage;
}
else
{
DrawImage = Settings.OffImage;
}
}
else if (Settings.HasIndication)
{
if (Settings.IndicationValueAny || Settings.IndicationValue == currentValue)
{
DrawImage = Settings.IndicationImage;
}
else
{
DrawImage = Settings.ErrorImage;
}
}
else
{
DrawImage = Settings.ErrorImage;
}
if (lastImage != DrawImage || ForceUpdate)
{
NeedRedraw = true;
}
}
public virtual void DeregisterAction()
{
if (ValueManager.ContainsValue(ID.SwitchState))
{
ValueManager.DeregisterValue(ID.SwitchState);
}
if (ValueManager.ContainsVariable(ID.SwitchState))
{
ValueManager.RemoveVariable(ID.SwitchState);
}
if (ValueManager.ContainsValue(ID.SwitchStateLong))
{
ValueManager.DeregisterValue(ID.SwitchStateLong);
}
if (ValueManager.ContainsVariable(ID.SwitchStateLong))
{
ValueManager.RemoveVariable(ID.SwitchStateLong);
}
}
public virtual void RegisterAction()
{
if (!BaseSettings.SwitchOnCurrentValue && IsActionReadable(BaseSettings.ActionType) && IPCTools.IsReadAddress(BaseSettings.AddressAction))
{
ValueManager.RegisterValue(ID.SwitchState, BaseSettings.AddressAction);
}
else if (!BaseSettings.SwitchOnCurrentValue)
{
ValueManager.SetVariable(ID.SwitchState, BaseSettings.SwitchOffState);
}
if (BaseSettings.HasLongPress && !BaseSettings.SwitchOnCurrentValue && IsActionReadable(BaseSettings.ActionTypeLong) && IPCTools.IsReadAddress(BaseSettings.AddressActionLong))
{
ValueManager.RegisterValue(ID.SwitchStateLong, BaseSettings.AddressActionLong);
}
else if (BaseSettings.HasLongPress && !BaseSettings.SwitchOnCurrentValue)
{
ValueManager.SetVariable(ID.SwitchStateLong, BaseSettings.SwitchOffStateLong);
}
}
