/// <summary>
///
/// </summary>
/// <param name="renderer"></param>
/// <param name="keyAttribute"></param>
protected void OutputMultiRenderer(Object [] renderers, string keyAttribute, bool isClerkingServices)
{
Response.Clear();
if (renderers.Length > 0)
{
bool contentTypeSet = false;
IEnumerator i = renderers.GetEnumerator();
while (i.MoveNext())
{
IBaseRenderer renderer = (IBaseRenderer)i.Current;
if (renderer == null)
{
continue;
}
if (!contentTypeSet)
{
Response.AddHeader("Content-Disposition", "attachment;filename=\"" + renderer.GetFileName() + "\"");
Response.ContentType = renderer.GetMimeType();
contentTypeSet = true;
}
Response.Write(renderer.Render(keyAttribute));
}
if (isClerkingServices)
{
Response.Write("Clerking Services=Yes\n");
}
}
Response.End(); // required or sometimes will show inline
}
public GroupBaseRenderer(Renderer renderer, GroupItem groupItem, IBaseRenderer parent)
{
Renderer = renderer;
GroupItem = groupItem;
GroupItem.PropertyChanged += new PropertyChangedEventHandler(container_PropertyChanged);
Parent = parent;
}
/// <summary>
///
/// </summary>
/// <param name="renderer"></param>
/// <param name="keyAttribute"></param>
protected void OutputRenderer(IBaseRenderer renderer, string keyAttribute)
{
Response.Clear();
Response.AddHeader("Content-Disposition", "attachment;filename=\"" + renderer.GetFileName() + "\"");
Response.ContentType = renderer.GetMimeType();
Response.Write(renderer.Render(keyAttribute));
Response.End(); // required or sometimes will show inline
}
public SolidFillRenderer(Renderer renderer, SolidFill fill, IBaseRenderer parent)
: base(renderer, fill, parent)
{
_renderer = renderer;
_fill = fill;
_fill.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(fill_PropertyChanged);
_path = new GraphicsPath();
}
public VarRenderer(Renderer renderer, Variable variable, IBaseRenderer parent)
{
Debug.Assert(renderer != null);
Debug.Assert(variable != null);
_variable = variable;
_variable.PropertyChanged += new PropertyChangedEventHandler(_node_PropertyChanged);
_renderer = renderer;
Parent = parent;
}
public CaseRenderer(Renderer renderer, Case caseNode, IBaseRenderer parent)
{
Debug.Assert(renderer != null && caseNode != null);
_caseNode = caseNode;
_caseNode.PropertyChanged += new PropertyChangedEventHandler(_caseNode_PropertyChanged);
_caseNode.Nodes.ItemAdded += new EventHandler<ItemEventArgs<ThemeNode>>(Nodes_ItemAdded);
_caseNode.Nodes.ItemRemoved += new EventHandler<ItemEventArgs<ThemeNode>>(Nodes_ItemRemoved);
foreach (var child in _caseNode.Nodes)
AddHandler(child);
_renderer = renderer;
Parent = parent;
}
//private FeatureVariableResolver _resolver;
public LinearCalibrationRenderer(Renderer renderer, LinearCalibration linearCalibration, IBaseRenderer parent)
: base(renderer, linearCalibration, parent)
{
_linearCalibration = linearCalibration;
_linearCalibration.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_linearCalibration_PropertyChanged);
}
protected void Page_Load(object sender, EventArgs e)
{
this.RequirePermission(Affinity.RolePermission.SubmitOrders);
string id = NoNull.GetString(Request["id"]);
string keyAttribute = NoNull.GetString(Request["key"], "sp_id");
string format = NoNull.GetString(Request["format"], "hash");
string exportformat = "PFT";
if (!format.Equals("entire"))
{
Affinity.Request r = new Affinity.Request(this.phreezer);
r.Load(id);
// make sure this user has permission to make updates to this order
if (!r.Order.CanRead(this.GetAccount()))
{
this.Crash(300, "Permission denied.");
}
IBaseRenderer renderer = null;
// depending on the format requested, get the correct renderer object
switch (format)
{
case "entire":
break;
case "xml":
exportformat = "Generic XML";
renderer = new XmlRenderer(r, this.GetSystemSettings());
break;
case "rei":
exportformat = "REI XML";
renderer = new XmlREIRenderer(r, this.GetSystemSettings());
break;
case "change":
exportformat = "PFT (Changes Only)";
renderer = new PFTChangeRenderer(r, this.GetSystemSettings());
break;
case "TPS":
exportformat = "TPS";
renderer = new TPSServicePFTRenderer(r, this.GetSystemSettings());
break;
//case "special":
// renderer = new XmlSpecialRenderer(r, this.GetSystemSettings());
// break;
default:
renderer = new PFTRenderer(r, this.GetSystemSettings());
break;
}
Affinity.ExportLog exportlog = new Affinity.ExportLog(this.phreezer);
Affinity.Account account = this.GetAccount();
exportlog.AccountID = account.Id;
exportlog.OrderID = r.OrderId;
exportlog.RequestID = r.Id;
exportlog.ExportFormat = exportformat;
exportlog.Insert();
// output the results of the renderer
OutputRenderer(renderer, keyAttribute);
}
else
{
Affinity.RequestTypes rts = new Affinity.RequestTypes(this.phreezer);
Affinity.RequestTypeCriteria rtc = new Affinity.RequestTypeCriteria();
rtc.IsActive = 1;
rts.Query(rtc);
Object [] renderers = new Object[rts.Count];
IEnumerator i = rts.GetEnumerator();
int j = 0;
bool isClerkingServices = false;
Affinity.Account account = this.GetAccount();
exportformat = "Entire Order";
while (i.MoveNext())
{
Affinity.RequestType rt = (Affinity.RequestType)i.Current;
Affinity.Order order = new Affinity.Order(this.phreezer);
order.Load(id);
Affinity.RequestCriteria rc = new Affinity.RequestCriteria();
rc.RequestTypeCode = rt.Code;
order.GetOrderRequests(rc);
Affinity.Requests reqs = order.GetOrderRequests(rc);
Affinity.Request r = null;
if (reqs.Count > 0)
{
r = (Affinity.Request)reqs[0];
if (rt.Code.Equals("ClerkingRequest"))
{
isClerkingServices = true;
}
IBaseRenderer renderer = new PFTRenderer(r, this.GetSystemSettings());
renderers[j] = renderer;
j++;
}
if (r != null)
{
Affinity.ExportLog exportlog = new Affinity.ExportLog(this.phreezer);
exportlog.AccountID = account.Id;
exportlog.OrderID = r.OrderId;
exportlog.RequestID = r.Id;
exportlog.ExportFormat = exportformat;
exportlog.Insert();
}
}
OutputMultiRenderer(renderers, keyAttribute, isClerkingServices);
}
}
public MarkerRenderer(Renderer renderer, Marker marker, IBaseRenderer parent)
: base(renderer, marker, parent)
{
_marker = marker;
_marker.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_marker_PropertyChanged);
}
public ContainerNodeRenderer(Renderer renderer, ContainerNode node, IBaseRenderer parent)
: base(renderer, node, parent)
{
_containerNode = node;
_containerNode.PropertyChanged += _containerNode_PropertyChanged;
}
public WindowRenderer(Renderer renderer, Window window, IBaseRenderer parent)
: base(renderer, window, parent)
{
_window = window;
_window.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_window_PropertyChanged);
}
internal IEnumerable<IBaseRenderer> GetRenderers(ContainerNode _containerNode, IBaseRenderer parent)
{
var nodes = _containerNode.Nodes;
for (int i = nodes.Count - 1; i >= 0; i--)
{
var child = nodes[i];
var childStyle = child as Style;
if(childStyle != null)
foreach(var childSubRenderer in GetRenderers(childStyle, parent))
yield return childSubRenderer;
var renderer = child.Renderer ?? (child.Renderer = CreateRenderer(child, null, parent));
if (renderer != null)
yield return renderer;
}
}
//internal void InitializeRenderer(ThemeNode node, ExpressionContext context)
//{
// if (node.Renderer == null)
// node.Renderer = CreateRenderer(node, context);
// if (node is Text)
// {
// var text = (Text)node;
// if (text.LabelBox != null && text.LabelBox.Renderer == null)
// text.LabelBox.Renderer = CreateRenderer(text.LabelBox, context);
// }
//}
internal IBaseRenderer CreateRenderer(ThemeNode node, ExpressionContext context, IBaseRenderer parent)
{
if (node is Group)
return new LayerGroupRenderer(this, (Group)node, parent);
if (node is Layer)
return new LayerRenderer(this, (Layer)node, parent);
if (node is Case)
return new CaseRenderer(this, (Case)node, parent);
if (node is LinearCalibration)
return new LinearCalibrationRenderer(this, (LinearCalibration)node, parent);
if (node is Marker)
return new MarkerRenderer(this, (Marker)node, parent);
if (node is PointExtractor)
return new PointExtractorRenderer(this, (PointExtractor)node, parent);
if (node is Stroke)
return new StrokeRenderer(this, (Stroke)node, parent);
if (node is Text)
return new TextRenderer(this, (Text)node, parent);
if (node is VerticesEnumerator)
return new VerticesEnumeratorRenderer(this, (VerticesEnumerator)node, parent);
if (node is SolidFill)
return new SolidFillRenderer(this, (SolidFill)node, parent);
if (node is LineStyle)
return new LineStyleRenderer(this, (LineStyle)node, parent);
if (node is Style)
return null;
if (node is Window)
return new WindowRenderer(this, (Window)node, parent);
if (node is ContainerNode)
return new ContainerNodeRenderer(this, (ContainerNode)node, parent);
if (node is Variable)
return new VarRenderer(this, (Variable)node, parent);
if (node is Run)
return new MacroExecuter(this, (Run)node, context, parent);
Debug.Fail("No renderer");
return null;
}
public TextRenderer(Renderer renderer, Text text, IBaseRenderer parent)
: base(renderer, text, parent)
{
_text = text;
_text.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_text_PropertyChanged);
}
public VerticesEnumeratorRenderer(Renderer renderer, VerticesEnumerator verticesEnumerator, IBaseRenderer parent)
:base(renderer, verticesEnumerator, parent)
{
_verticesEnumerator = verticesEnumerator;
_verticesEnumerator.PropertyChanged += new PropertyChangedEventHandler(_verticesEnumerator_PropertyChanged);
}
private void PrintDetailInternal(ReportPageEventArgs rpea, DataNavigator nav)
{
Rectangle sectionRect;
base.PrintDetail(null, rpea);
// no loop if there is no data
if (!nav.HasMoreData)
{
rpea.PrintPageEventArgs.HasMorePages = false;
return;
}
ITableContainer tableContainer = base.CurrentSection.Items[0] as ITableContainer;
IBaseRenderer r = PrintRendererFactory.CreateRenderer(base.CurrentSection.Items[0], nav, base.SinglePage, base.Layout, CurrentSection);
if (r != null)
{
// r.Render(tableContainer,rpea,Evaluator);
}
// branch to render table's etc
if (tableContainer != null)
{
tableContainer.DataNavigator = nav;
tableContainer.Parent = base.CurrentSection;
if (rpea.SinglePage.PageNumber == 1)
{
tableContainer.StartLayoutAt(base.Sections[2]);
}
else
{
tableContainer.StartLayoutAt(base.Sections[0]);
}
base.RenderTable(base.CurrentSection, tableContainer, rpea);
this.ReportDocument.DetailsDone = true;
}
else
{
// first element
if (base.SinglePage.PageNumber == 1)
{
this.dataNavigator.MoveNext();
}
do
{
ISimpleContainer simpleContainer = base.CurrentSection.Items[0] as ISimpleContainer;
if (simpleContainer != null)
{
nav.Fill(simpleContainer.Items);
}
else
{
nav.Fill(base.CurrentSection.Items);
}
sectionRect = new Rectangle(rpea.PrintPageEventArgs.MarginBounds.Left,
base.CurrentSection.SectionOffset,
rpea.PrintPageEventArgs.MarginBounds.Width,
base.CurrentSection.Size.Height);
if (PrintHelper.IsPageFull(sectionRect, base.SectionBounds))
{
PerformPageBreak(rpea);
return;
}
Point currentPosition = base.RenderItems(rpea);
if (nav.CurrentRow < nav.Count - 1)
{
if (base.CurrentSection.PageBreakAfter)
{
PerformPageBreak(rpea);
return;
}
}
base.CurrentSection.SectionOffset = currentPosition.Y;
rpea.LocationAfterDraw = new Point(rpea.LocationAfterDraw.X,
currentPosition.Y);
}while (nav.MoveNext());
this.ReportDocument.DetailsDone = true;
}
rpea.LocationAfterDraw = new Point(rpea.LocationAfterDraw.X, rpea.LocationAfterDraw.Y + 5);
if (!PrintHelper.IsRoomForFooter(base.SectionBounds, rpea.LocationAfterDraw))
{
AbstractRenderer.PageBreak(rpea);
}
}
public PointExtractorRenderer(Renderer renderer, PointExtractor pointExtractor, IBaseRenderer parent)
: base(renderer, pointExtractor, parent)
{
_pointExtractor = pointExtractor;
_pointExtractor.PropertyChanged += new PropertyChangedEventHandler(_pointExtractor_PropertyChanged);
}
public LayerGroupRenderer(Renderer renderer, Group group, IBaseRenderer parent)
: base(renderer, group, parent)
{
}
public LayerRenderer(Renderer renderer, Layer layer, IBaseRenderer parent)
: base(renderer, layer, parent)
{
_layer = layer;
}
