/// <summary>
/// Build cursor definition.
/// </summary>
/// <param name="link"></param>
/// <returns></returns>
internal CursorDefinition BuildCursorDefinition()
{
CursorDefinition cursorDefinition = BuildCursorDefinition(DataSourceReference.DataSourceDefinition,
DataSourceViewDefinition.DbKey, DataSourceViewDefinition.RecordsOrder, true, BuildFields(DataSourceViewDefinition.DbKey),
DataSourceViewDefinition.TaskDataSource.Access);
return(cursorDefinition);
}
/// <summary>
/// build cursor using CursorDefinition
/// </summary>
/// <param name="cursorDefinition"></param>
/// <returns></returns>
private RuntimeCursor Build(CursorDefinition cursorDefinition)
{
RuntimeCursor runtimeCursor = new RuntimeCursor();
runtimeCursor.ID = idGenerator.GenerateId();
runtimeCursor.CursorDefinition = cursorDefinition;
runtimeCursor.RuntimeCursorData = BuildRuntimeCursorData(runtimeCursor.CursorDefinition);
return(runtimeCursor);
}
protected string GetExpression(string expression)
{
CursorDefinition definition = (CursorDefinition)_parser.ParseCursorDefinition(expression);
definition.Capabilities = CursorCapability.Navigable;
definition.CursorType = DAE.CursorType.Dynamic;
definition.Isolation = CursorIsolation.Browse;
return(new D4TextEmitter().Emit(definition));
}
/// <summary>
/// calculate insert flag
/// </summary>
/// <param name="cursorDefinition"></param>
protected virtual void CalculateInsertFlag(CursorDefinition cursorDefinition)
{
if (DataSourceViewDefinition.CanInsert)
{
cursorDefinition.SetFlag(CursorProperties.Insert);
}
else
{
cursorDefinition.ClearFlag(CursorProperties.Insert);
}
}
protected virtual void UpdateCursor(CursorDefinition cursor)
{
lock (this)
{
_cursor?.Dispose();
_cursor = cursor.Create().SubscribeWithState(cursor.Hotspot, (image, pos) =>
{
//TODO Can't use CursorMode.Auto, because it doesn't work on Linux yet.
//(See: https://forum.unity3d.com/threads/cursor-setcursor-does-not-work-in-editor.476617/)
UECursor.SetCursor(image, pos, CursorMode.ForceSoftware);
});
}
}
public ICssValue Convert(StringSource source)
{
var cursor = default(ICssValue);
var definitions = new List <ICssValue>();
while (!source.IsDone)
{
var definition = new CursorDefinition();
definition.Source = source.ParseImageSource();
var c = source.SkipSpacesAndComments();
if (definition.Source != null)
{
var x = source.ParseNumber();
c = source.SkipSpacesAndComments();
var y = source.ParseNumber();
c = source.SkipSpacesAndComments();
if (x.HasValue != y.HasValue || c != Symbols.Comma)
{
break;
}
source.SkipCurrentAndSpaces();
if (x.HasValue)
{
var xp = new Length(x.Value, Length.Unit.None);
var yp = new Length(y.Value, Length.Unit.None);
definition.Position = new Point(xp, yp);
}
definitions.Add(definition);
}
else
{
cursor = source.ParseConstant(Map.SystemCursors);
if (cursor != null)
{
return(new Cursor(definitions.ToArray(), cursor));
}
break;
}
}
return(null);
}
/// <summary>
/// build runtime cursor data
/// </summary>
/// <param name="cursorDefinition"></param>
/// <returns></returns>
private RuntimeCursorData BuildRuntimeCursorData(CursorDefinition cursorDefinition)
{
RuntimeCursorData cursorData = new RuntimeCursorData();
cursorData.CurrentValues = new FieldValues();
cursorData.OldValues = new FieldValues();
for (int i = 0; i < cursorDefinition.FieldsDefinition.Count; i++)
{
//TODO: set storage type
cursorData.CurrentValues.Add(new FieldValue());
cursorData.OldValues.Add(new FieldValue());
}
//TODO: locates
return(cursorData);
}
protected PlanNode EmitBrowseVariantNode(Plan plan, int originIndex, bool forward, bool inclusive)
{
Schema.Order originOrder = new Schema.Order();
for (int index = 0; index <= originIndex; index++)
{
originOrder.Columns.Add(new Schema.OrderColumn(Order.Columns[index].Column, Order.Columns[index].Ascending, Order.Columns[index].IncludeNils));
}
Schema.IRowType origin = new Schema.RowType(originOrder.Columns, Keywords.Origin);
//plan.PushCursorContext(new CursorContext(CursorType, CursorCapabilities & ~(CursorCapability.BackwardsNavigable | CursorCapability.Bookmarkable | CursorCapability.Searchable | CursorCapability.Countable), CursorIsolation));
//try
//{
plan.EnterRowContext();
try
{
plan.Symbols.Push(new Symbol(String.Empty, origin));
try
{
var cursorExpression = EmitBrowseVariantExpression(originOrder, origin, originIndex, forward, inclusive);
var cursorDefinition =
new CursorDefinition
(
cursorExpression,
CursorCapabilities & ~(CursorCapability.BackwardsNavigable | CursorCapability.Bookmarkable | CursorCapability.Searchable | CursorCapability.Countable),
CursorIsolation,
CursorType
);
var resultNode = Compiler.Compile(plan, cursorDefinition, true);
return(resultNode.ExtractNode <TableNode>());
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
//}
//finally
//{
// plan.PopCursorContext();
//}
}
/// <summary>
/// Build cursor definition.
/// </summary>
/// <param name="link"></param>
/// <returns></returns>
internal CursorDefinition BuildCursorDefinition(DataSourceDefinition dataSourceDefinition, DBKey dbKey, Order order, bool keyCheckNeeded, List <DBField> dbFields, Access access)
{
CursorDefinition cursorDefinition = new CursorDefinition();
cursorDefinition.DataSourceDefinition = dataSourceDefinition;
cursorDefinition.Key = dbKey;
cursorDefinition.FieldsDefinition = dbFields;
cursorDefinition.IsFieldUpdated = new List <bool>();
cursorDefinition.DifferentialUpdate = new List <bool>();
for (int i = 0; i < cursorDefinition.FieldsDefinition.Count; i++)
{
//rt_prpr_fldlist_in_vew - different from C++ but it seems more logical
cursorDefinition.IsFieldUpdated.Add(false);
cursorDefinition.DifferentialUpdate.Add(false);
}
cursorDefinition.Direction = order;
cursorDefinition.CursorMode = CursorMode.Online;
//check for non interactive
// : CursorMode.Batch;
if (keyCheckNeeded)
{
cursorDefinition.SetFlag(CursorProperties.KeyCheck);
}
//TODO:batch tsk_crsr_prpr
cursorDefinition.SetFlag(CursorProperties.StartPos);
//TODO:locate tsk_crsr_prpr
//crsr->dir = CTX->ctl_tsk_.tskr->range_dir;
//TODO:
//if CTX->ctl_tsk_.tsk_rt->TransMode != TRANS_MODE_NONE
if (access == Access.Write)
{
CalculateInsertFlag(cursorDefinition);
ClaculateDeleteFlag(cursorDefinition);
cursorDefinition.SetFlag(CursorProperties.Update);
}
return(cursorDefinition);
}
protected override string InternalGetExpression()
{
Expression expression = GetSeedExpression();
OrderExpression saveOrderExpression = expression as OrderExpression;
BrowseExpression saveBrowseExpression = expression as BrowseExpression;
if (saveOrderExpression != null)
{
expression = saveOrderExpression.Expression;
}
if (saveBrowseExpression != null)
{
expression = saveBrowseExpression.Expression;
}
// Eat irrelevant browse and order operators
OrderExpression orderExpression = null;
BrowseExpression browseExpression = null;
while (((orderExpression = expression as OrderExpression) != null) || ((browseExpression = expression as BrowseExpression) != null))
{
if (orderExpression != null)
{
expression = orderExpression.Expression;
orderExpression = null;
}
if (browseExpression != null)
{
expression = browseExpression.Expression;
browseExpression = null;
}
}
if (IsMasterSetup() && _writeWhereClause)
{
expression = MergeRestrictCondition
(
expression,
GetMasterDetailCondition(DetailKey)
);
}
if (_filter != String.Empty)
{
expression = MergeRestrictCondition
(
expression,
_parser.ParseExpression(_filter)
);
}
if (IsAdorned())
{
AdornExpression adornExpression = new AdornExpression();
adornExpression.Expression = expression;
adornExpression.Expressions.AddRange(_columns);
adornExpression.Constraints.AddRange(_constraints);
adornExpression.Orders.AddRange(_orders);
adornExpression.Keys.AddRange(_keys);
expression = adornExpression;
}
if (_orderDefinition != null)
{
if (_useBrowse)
{
browseExpression = new Language.D4.BrowseExpression();
browseExpression.Expression = expression;
browseExpression.Columns.AddRange(_orderDefinition.Columns);
expression = browseExpression;
}
else
{
orderExpression = new Language.D4.OrderExpression();
orderExpression.Expression = expression;
orderExpression.Columns.AddRange(_orderDefinition.Columns);
expression = orderExpression;
}
}
else if (_order != null)
{
if (_useBrowse)
{
browseExpression = new BrowseExpression();
foreach (Schema.OrderColumn column in _order.Columns)
{
if (column.IsDefaultSort)
{
browseExpression.Columns.Add(new OrderColumnDefinition(column.Column.Name, column.Ascending, column.IncludeNils));
}
else
{
browseExpression.Columns.Add(new OrderColumnDefinition(column.Column.Name, column.Ascending, column.IncludeNils, column.Sort.EmitDefinition(EmitMode.ForCopy)));
}
}
browseExpression.Expression = expression;
expression = browseExpression;
}
else
{
orderExpression = new OrderExpression();
foreach (Schema.OrderColumn column in _order.Columns)
{
if (column.IsDefaultSort)
{
orderExpression.Columns.Add(new OrderColumnDefinition(column.Column.Name, column.Ascending, column.IncludeNils));
}
else
{
orderExpression.Columns.Add(new OrderColumnDefinition(column.Column.Name, column.Ascending, column.IncludeNils, column.Sort.EmitDefinition(EmitMode.ForCopy)));
}
}
orderExpression.Expression = expression;
expression = orderExpression;
}
}
else
{
if (saveOrderExpression != null)
{
saveOrderExpression.Expression = expression;
expression = saveOrderExpression;
}
else if (saveBrowseExpression != null)
{
saveBrowseExpression.Expression = expression;
expression = saveBrowseExpression;
}
}
CursorDefinition cursorExpression = new CursorDefinition(expression);
cursorExpression.Isolation = _requestedIsolation;
cursorExpression.Capabilities = _requestedCapabilities;
cursorExpression.SpecifiesType = true;
cursorExpression.CursorType = _cursorType;
return(new D4TextEmitter().Emit(cursorExpression));
}
public override void ExplicitVisit(CursorDefinition fragment)
{
_fragments.Add(fragment);
}
/// <summary>
/// build cursor using DataSourceDefinition
/// </summary>
/// <param name="dataSourceDefinition"></param>
/// <returns></returns>
internal RuntimeCursor Build(DataSourceDefinition dataSourceDefinition, Access access)
{
CursorDefinition cursorDefinition = BuildCursorDefinition(dataSourceDefinition, null, Order.Ascending, false, dataSourceDefinition.Fields, access);
return(Build(cursorDefinition));
}
/// <summary>
/// calculate value of the delete flag
/// </summary>
/// <param name="cursorDefinition"></param>
protected override void ClaculateDeleteFlag(CursorDefinition cursorDefinition)
{
cursorDefinition.SetFlag(CursorProperties.Delete);
}
public override void Visit(CursorDefinition node) { this.action(node); }
protected virtual void CalculateLinkFlag(CursorDefinition cursorDefinition)
{
cursorDefinition.SetFlag(CursorProperties.CursorLink);
}
/// <summary>
/// calculate delete flag
/// </summary>
/// <param name="cursorDefinition"></param>
protected virtual void ClaculateDeleteFlag(CursorDefinition cursorDefinition)
{
cursorDefinition.ClearFlag(CursorProperties.Delete);
}
protected override void CalculateLinkFlag(CursorDefinition cursorDefinition)
{
//main view is not link
}
/// <summary>
/// build cursor
/// </summary>
/// <param name="link"></param>
/// <returns></returns>
internal RuntimeCursor Build(RuntimeReadOnlyView view)
{
CursorDefinition cursorDefinition = BuildCursorDefinition();
return(Build(cursorDefinition));
}
/// <summary>
/// claculate value of the inset flag
/// </summary>
/// <param name="cursorDefinition"></param>
protected override void CalculateInsertFlag(CursorDefinition cursorDefinition)
{
cursorDefinition.SetFlag(CursorProperties.Insert);
}