diff --git a/ReportImp/SeverinReports/FABA.png b/ReportImp/SeverinReports/FABA.png new file mode 100644 index 000000000..c73755cd0 Binary files /dev/null and b/ReportImp/SeverinReports/FABA.png differ diff --git a/ReportImp/SeverinReports/Invoicing/SettlementInvoiceCreation.cs b/ReportImp/SeverinReports/Invoicing/SettlementInvoiceCreation.cs new file mode 100644 index 000000000..f1b1a5410 --- /dev/null +++ b/ReportImp/SeverinReports/Invoicing/SettlementInvoiceCreation.cs @@ -0,0 +1,15 @@ +using BeWo.Data.Entities; +using BeWo.Service.Invoicing; +using BS.Shared.DataContracts; + +namespace SeverinReports.Invoicing +{ + + public class CustomSettlementInvoiceCreation : SettlementInvoiceCreation + { + public override bool CanCreateInvoiceTheOldWay(Settlement2DC si, CostBearer2SupportConcept c2s) + { + return false; + } + } +} diff --git a/ReportImp/SeverinReports/Logo Severin.png b/ReportImp/SeverinReports/Logo Severin.png new file mode 100644 index 000000000..98df252db Binary files /dev/null and b/ReportImp/SeverinReports/Logo Severin.png differ diff --git a/ReportImp/SeverinReports/Properties/Resources.Designer.cs b/ReportImp/SeverinReports/Properties/Resources.Designer.cs new file mode 100644 index 000000000..90a04ce74 --- /dev/null +++ b/ReportImp/SeverinReports/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Dieser Code wurde von einem Tool generiert. +// Laufzeitversion:4.0.30319.42000 +// +// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +// der Code erneut generiert wird. +// +//------------------------------------------------------------------------------ + +namespace SeverinReports.Properties { + using System; + + + /// + /// Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + /// + // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert + // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert. + // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen + // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SeverinReports.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Ãœberschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + /// Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/ReportImp/SeverinReports/Properties/Resources.resx b/ReportImp/SeverinReports/Properties/Resources.resx new file mode 100644 index 000000000..29dcb1b3a --- /dev/null +++ b/ReportImp/SeverinReports/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ReportImp/SeverinReports/SettlementReport2.Designer.cs b/ReportImp/SeverinReports/SettlementReport2.Designer.cs new file mode 100644 index 000000000..c89937958 --- /dev/null +++ b/ReportImp/SeverinReports/SettlementReport2.Designer.cs @@ -0,0 +1,1611 @@ +using BeWo.Report.ReportObjects; +namespace SeverinReports +{ + partial class Spitzabrechnung + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Spitzabrechnung)); + DevExpress.XtraReports.UI.XRSummary xrSummary1 = new DevExpress.XtraReports.UI.XRSummary(); + DevExpress.XtraReports.UI.XRWatermark xrWatermark1 = new DevExpress.XtraReports.UI.XRWatermark(); + this.Detail = new DevExpress.XtraReports.UI.DetailBand(); + this.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); + this.xrPictureBox1 = new DevExpress.XtraReports.UI.XRPictureBox(); + this.xrLabel8 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable1 = new DevExpress.XtraReports.UI.XRTable(); + this.rowErbrachteLeistung = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell22 = new DevExpress.XtraReports.UI.XRTableCell(); + this.ruleRateFactorNull = new DevExpress.XtraReports.UI.FormattingRule(); + this.xrLabel6 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable2 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow2 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow5 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell13 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow4 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell11 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow3 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell8 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow1 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow6 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow8 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow11 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell12 = new DevExpress.XtraReports.UI.XRTableCell(); + this.RecipientPostCodeAndTown = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel_RecipientStreet = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel_RecipientDivision = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel_RecipientContactPerson = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel1 = new DevExpress.XtraReports.UI.XRLabel(); + this.ReportFooter = new DevExpress.XtraReports.UI.ReportFooterBand(); + this.xrLabel10 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable3 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow20 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell16 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow7 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow9 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell6 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow21 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell18 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow22 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell29 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow23 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell30 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow24 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell31 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrLabel12 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblNotice = new DevExpress.XtraReports.UI.XRLabel(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.GroupHeader1 = new DevExpress.XtraReports.UI.GroupHeaderBand(); + this.fieldApprovedFLSWithFactor = new DevExpress.XtraReports.UI.CalculatedField(); + this.DetailReport = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail1 = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTable4 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow33 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell52 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell53 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupHeader2 = new DevExpress.XtraReports.UI.GroupHeaderBand(); + this.Zwischensumme = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.xrTable6 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow12 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell9 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell10 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow10 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell7 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupFooter1 = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.xrTable5 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow31 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell49 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell50 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow32 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell51 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow34 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell54 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell55 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow35 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell56 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell57 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow36 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell58 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow37 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell59 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell60 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow13 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell14 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow14 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell15 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow15 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell17 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow16 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell19 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow17 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell20 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrLabel7 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTableRow18 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell21 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow19 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell23 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow25 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell24 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell25 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell26 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell27 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell28 = new DevExpress.XtraReports.UI.XRTableCell(); + this.lblBankverbindung = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel11 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel14 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel15 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrPictureBox2 = new DevExpress.XtraReports.UI.XRPictureBox(); + this.xrLabel16 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTableRow26 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell32 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell33 = new DevExpress.XtraReports.UI.XRTableCell(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable4)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable6)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable5)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); + // + // Detail + // + this.Detail.HeightF = 0F; + this.Detail.Name = "Detail"; + this.Detail.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.Detail.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // ReportHeader + // + this.ReportHeader.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrPictureBox1}); + this.ReportHeader.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.ReportHeader.HeightF = 115.7083F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // xrPictureBox1 + // + this.xrPictureBox1.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrPictureBox1.ImageSource")); + this.xrPictureBox1.LocationFloat = new DevExpress.Utils.PointFloat(232.2917F, 5F); + this.xrPictureBox1.Name = "xrPictureBox1"; + this.xrPictureBox1.SizeF = new System.Drawing.SizeF(214.5833F, 100.5F); + this.xrPictureBox1.Sizing = DevExpress.XtraPrinting.ImageSizeMode.ZoomImage; + // + // xrLabel8 + // + this.xrLabel8.LocationFloat = new DevExpress.Utils.PointFloat(367.0001F, 215.5318F); + this.xrLabel8.Name = "xrLabel8"; + this.xrLabel8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel8.SizeF = new System.Drawing.SizeF(283F, 23F); + this.xrLabel8.StylePriority.UseTextAlignment = false; + this.xrLabel8.Text = "Köln, den [InvoiceDate!dd.MM.yyyy]"; + this.xrLabel8.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrLabel8.TextFormatString = "{0:dd.MM.yyyy}"; + // + // xrTable1 + // + this.xrTable1.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTable1.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 402.8651F); + this.xrTable1.Name = "xrTable1"; + this.xrTable1.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow25, + this.xrTableRow19, + this.xrTableRow18, + this.rowErbrachteLeistung, + this.xrTableRow26}); + this.xrTable1.SizeF = new System.Drawing.SizeF(650F, 85F); + this.xrTable1.StylePriority.UseBorderColor = false; + // + // rowErbrachteLeistung + // + this.rowErbrachteLeistung.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell22, + this.xrTableCell28}); + this.rowErbrachteLeistung.Name = "rowErbrachteLeistung"; + this.rowErbrachteLeistung.Weight = 0.085D; + // + // xrTableCell22 + // + this.xrTableCell22.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell22.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell22.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell22.Name = "xrTableCell22"; + this.xrTableCell22.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell22.StylePriority.UseBorderColor = false; + this.xrTableCell22.StylePriority.UseBorders = false; + this.xrTableCell22.StylePriority.UseFont = false; + this.xrTableCell22.Text = "Erbrachte Leistungen:"; + this.xrTableCell22.Weight = 1.6720503178074988D; + // + // ruleRateFactorNull + // + this.ruleRateFactorNull.Condition = "[RateFactorText2] == ?"; + this.ruleRateFactorNull.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.ruleRateFactorNull.Name = "ruleRateFactorNull"; + // + // xrLabel6 + // + this.xrLabel6.BackColor = System.Drawing.Color.Transparent; + this.xrLabel6.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 335.8651F); + this.xrLabel6.Multiline = true; + this.xrLabel6.Name = "xrLabel6"; + this.xrLabel6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel6.SizeF = new System.Drawing.SizeF(649.9998F, 57.46609F); + this.xrLabel6.StylePriority.UseBackColor = false; + this.xrLabel6.StylePriority.UseFont = false; + this.xrLabel6.Text = resources.GetString("xrLabel6.Text"); + // + // xrLabel5 + // + this.xrLabel5.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 313.8651F); + this.xrLabel5.Name = "xrLabel5"; + this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel5.SizeF = new System.Drawing.SizeF(317F, 17F); + this.xrLabel5.StylePriority.UseFont = false; + this.xrLabel5.Text = "Sehr geehrte Damen und Herren,"; + // + // xrLabel4 + // + this.xrLabel4.BackColor = System.Drawing.Color.Transparent; + this.xrLabel4.CanShrink = true; + this.xrLabel4.Font = new DevExpress.Drawing.DXFont("Verdana", 9.5F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 271.5318F); + this.xrLabel4.Multiline = true; + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(650F, 17F); + this.xrLabel4.StylePriority.UseBackColor = false; + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.Text = "[CustomerReferenceNumberAndDate]"; + this.xrLabel4.WordWrap = false; + // + // xrLabel3 + // + this.xrLabel3.BackColor = System.Drawing.Color.Transparent; + this.xrLabel3.CanShrink = true; + this.xrLabel3.Font = new DevExpress.Drawing.DXFont("Verdana", 9.5F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 255.5318F); + this.xrLabel3.Name = "xrLabel3"; + this.xrLabel3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel3.SizeF = new System.Drawing.SizeF(650F, 16F); + this.xrLabel3.StylePriority.UseBackColor = false; + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.Text = "Abrechnung Betreuungsleistungen für [Salutation2] [CustomerFirstName] [CustomerLa" + + "stName], geb. [CustomerBirthday!dd.MM.yyyy]"; + this.xrLabel3.WordWrap = false; + // + // xrLabel2 + // + this.xrLabel2.BackColor = System.Drawing.Color.Transparent; + this.xrLabel2.CanShrink = true; + this.xrLabel2.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 238.5318F); + this.xrLabel2.Name = "xrLabel2"; + this.xrLabel2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel2.SizeF = new System.Drawing.SizeF(363.5417F, 17F); + this.xrLabel2.StylePriority.UseBackColor = false; + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = "Rechnung Nr. [InvoiceNumber]"; + this.xrLabel2.WordWrap = false; + // + // xrTable2 + // + this.xrTable2.Font = new DevExpress.Drawing.DXFont("Verdana", 9F); + this.xrTable2.LocationFloat = new DevExpress.Utils.PointFloat(354.5001F, 0F); + this.xrTable2.Name = "xrTable2"; + this.xrTable2.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow2, + this.xrTableRow5, + this.xrTableRow4, + this.xrTableRow3, + this.xrTableRow1, + this.xrTableRow6, + this.xrTableRow8, + this.xrTableRow11, + this.xrTableRow13, + this.xrTableRow14, + this.xrTableRow15, + this.xrTableRow16, + this.xrTableRow17}); + this.xrTable2.SizeF = new System.Drawing.SizeF(295.5F, 194.8475F); + this.xrTable2.StylePriority.UseFont = false; + // + // xrTableRow2 + // + this.xrTableRow2.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell4}); + this.xrTableRow2.Name = "xrTableRow2"; + this.xrTableRow2.Weight = 0.12652159889050366D; + // + // xrTableCell4 + // + this.xrTableCell4.CanShrink = true; + this.xrTableCell4.Font = new DevExpress.Drawing.DXFont("Verdana", 9F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell4.Name = "xrTableCell4"; + this.xrTableCell4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell4.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell4.StylePriority.UseFont = false; + this.xrTableCell4.StylePriority.UseTextAlignment = false; + this.xrTableCell4.Text = "Severin soziale Dienstleistungen gGmbH"; + this.xrTableCell4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell4.Weight = 1D; + // + // xrTableRow5 + // + this.xrTableRow5.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell13}); + this.xrTableRow5.Name = "xrTableRow5"; + this.xrTableRow5.Weight = 0.12652159889050366D; + // + // xrTableCell13 + // + this.xrTableCell13.CanShrink = true; + this.xrTableCell13.Name = "xrTableCell13"; + this.xrTableCell13.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell13.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell13.StylePriority.UseFont = false; + this.xrTableCell13.StylePriority.UseTextAlignment = false; + this.xrTableCell13.Text = "Ambulant Betreutes Wohnen (BeWo)"; + this.xrTableCell13.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell13.Weight = 1D; + // + // xrTableRow4 + // + this.xrTableRow4.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell11}); + this.xrTableRow4.Name = "xrTableRow4"; + this.xrTableRow4.Weight = 0.12652160009349872D; + // + // xrTableCell11 + // + this.xrTableCell11.CanShrink = true; + this.xrTableCell11.Name = "xrTableCell11"; + this.xrTableCell11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell11.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell11.StylePriority.UseFont = false; + this.xrTableCell11.StylePriority.UseTextAlignment = false; + this.xrTableCell11.Text = "Fürstenbergstraße 29"; + this.xrTableCell11.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell11.Weight = 1D; + // + // xrTableRow3 + // + this.xrTableRow3.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell8}); + this.xrTableRow3.Name = "xrTableRow3"; + this.xrTableRow3.Weight = 0.12652159889050368D; + // + // xrTableCell8 + // + this.xrTableCell8.CanShrink = true; + this.xrTableCell8.Name = "xrTableCell8"; + this.xrTableCell8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell8.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell8.StylePriority.UseFont = false; + this.xrTableCell8.StylePriority.UseTextAlignment = false; + this.xrTableCell8.Text = "51065 Köln Mülheim"; + this.xrTableCell8.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell8.Weight = 1D; + // + // xrTableRow1 + // + this.xrTableRow1.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell1}); + this.xrTableRow1.Name = "xrTableRow1"; + this.xrTableRow1.Weight = 0.074424470512320387D; + // + // xrTableCell1 + // + this.xrTableCell1.Name = "xrTableCell1"; + this.xrTableCell1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell1.StylePriority.UseFont = false; + this.xrTableCell1.StylePriority.UseTextAlignment = false; + this.xrTableCell1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell1.Weight = 1D; + // + // xrTableRow6 + // + this.xrTableRow6.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell2}); + this.xrTableRow6.Name = "xrTableRow6"; + this.xrTableRow6.Weight = 0.12652160243933902D; + // + // xrTableCell2 + // + this.xrTableCell2.CanShrink = true; + this.xrTableCell2.Name = "xrTableCell2"; + this.xrTableCell2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell2.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrTableCell2.StylePriority.UseFont = false; + this.xrTableCell2.StylePriority.UseTextAlignment = false; + this.xrTableCell2.Text = "Tel. 0221 34664021"; + this.xrTableCell2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell2.Weight = 1D; + // + // xrTableRow8 + // + this.xrTableRow8.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell5}); + this.xrTableRow8.Name = "xrTableRow8"; + this.xrTableRow8.Weight = 0.11794387218291286D; + // + // xrTableCell5 + // + this.xrTableCell5.Name = "xrTableCell5"; + this.xrTableCell5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell5.StylePriority.UseTextAlignment = false; + this.xrTableCell5.Text = "Fax 0221 34664023"; + this.xrTableCell5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell5.Weight = 1D; + // + // xrTableRow11 + // + this.xrTableRow11.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell12}); + this.xrTableRow11.Name = "xrTableRow11"; + this.xrTableRow11.Weight = 0.11163670453541061D; + // + // xrTableCell12 + // + this.xrTableCell12.ForeColor = System.Drawing.Color.SlateBlue; + this.xrTableCell12.Multiline = true; + this.xrTableCell12.Name = "xrTableCell12"; + this.xrTableCell12.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell12.StylePriority.UseForeColor = false; + this.xrTableCell12.StylePriority.UseTextAlignment = false; + this.xrTableCell12.Text = "www.severin-ggmbh.de"; + this.xrTableCell12.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell12.TextFormatString = "GP-Nr.: {0}"; + this.xrTableCell12.Weight = 1D; + // + // RecipientPostCodeAndTown + // + this.RecipientPostCodeAndTown.CanShrink = true; + this.RecipientPostCodeAndTown.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.RecipientPostCodeAndTown.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 87.00005F); + this.RecipientPostCodeAndTown.Name = "RecipientPostCodeAndTown"; + this.RecipientPostCodeAndTown.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.RecipientPostCodeAndTown.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.RecipientPostCodeAndTown.SizeF = new System.Drawing.SizeF(292F, 17F); + this.RecipientPostCodeAndTown.StylePriority.UseFont = false; + this.RecipientPostCodeAndTown.Text = "[RecipientPostCodeAndTown]"; + // + // xrLabel_RecipientStreet + // + this.xrLabel_RecipientStreet.CanShrink = true; + this.xrLabel_RecipientStreet.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 70.00002F); + this.xrLabel_RecipientStreet.Name = "xrLabel_RecipientStreet"; + this.xrLabel_RecipientStreet.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel_RecipientStreet.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrLabel_RecipientStreet.SizeF = new System.Drawing.SizeF(292F, 17F); + this.xrLabel_RecipientStreet.StylePriority.UseFont = false; + this.xrLabel_RecipientStreet.Text = "[RecipientStreet]"; + // + // xrLabel_RecipientDivision + // + this.xrLabel_RecipientDivision.CanShrink = true; + this.xrLabel_RecipientDivision.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 53.00004F); + this.xrLabel_RecipientDivision.Name = "xrLabel_RecipientDivision"; + this.xrLabel_RecipientDivision.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel_RecipientDivision.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrLabel_RecipientDivision.SizeF = new System.Drawing.SizeF(292F, 17F); + this.xrLabel_RecipientDivision.StylePriority.UseFont = false; + this.xrLabel_RecipientDivision.Text = "[RecipientDivision]"; + // + // xrLabel_RecipientContactPerson + // + this.xrLabel_RecipientContactPerson.CanShrink = true; + this.xrLabel_RecipientContactPerson.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 36.00001F); + this.xrLabel_RecipientContactPerson.Name = "xrLabel_RecipientContactPerson"; + this.xrLabel_RecipientContactPerson.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel_RecipientContactPerson.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrLabel_RecipientContactPerson.SizeF = new System.Drawing.SizeF(292F, 17F); + this.xrLabel_RecipientContactPerson.StylePriority.UseFont = false; + this.xrLabel_RecipientContactPerson.Text = "[RecipientContactPerson]"; + // + // xrLabel1 + // + this.xrLabel1.CanShrink = true; + this.xrLabel1.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 19F); + this.xrLabel1.Name = "xrLabel1"; + this.xrLabel1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel1.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrLabel1.SizeF = new System.Drawing.SizeF(292F, 17F); + this.xrLabel1.StylePriority.UseFont = false; + this.xrLabel1.Text = "[RecipientOrganisation]"; + // + // ReportFooter + // + this.ReportFooter.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.lblBankverbindung, + this.xrLabel10, + this.xrTable3, + this.xrLabel12, + this.lblNotice}); + this.ReportFooter.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.ReportFooter.HeightF = 307.3531F; + this.ReportFooter.KeepTogether = true; + this.ReportFooter.Name = "ReportFooter"; + this.ReportFooter.StylePriority.UseFont = false; + // + // xrLabel10 + // + this.xrLabel10.LocationFloat = new DevExpress.Utils.PointFloat(0F, 220F); + this.xrLabel10.Name = "xrLabel10"; + this.xrLabel10.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel10.SizeF = new System.Drawing.SizeF(175F, 17F); + this.xrLabel10.StylePriority.UseFont = false; + this.xrLabel10.Text = "Mit freundlichen Grüßen"; + // + // xrTable3 + // + this.xrTable3.LocationFloat = new DevExpress.Utils.PointFloat(0F, 33F); + this.xrTable3.Name = "xrTable3"; + this.xrTable3.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow20, + this.xrTableRow7, + this.xrTableRow9, + this.xrTableRow21, + this.xrTableRow22, + this.xrTableRow23, + this.xrTableRow24}); + this.xrTable3.SizeF = new System.Drawing.SizeF(650F, 94F); + this.xrTable3.StylePriority.UseFont = false; + // + // xrTableRow20 + // + this.xrTableRow20.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell16}); + this.xrTableRow20.Name = "xrTableRow20"; + this.xrTableRow20.Weight = 0.38095238095238093D; + // + // xrTableCell16 + // + this.xrTableCell16.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Notice")}); + this.xrTableCell16.Name = "xrTableCell16"; + this.xrTableCell16.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell16.StylePriority.UsePadding = false; + this.xrTableCell16.Text = "xrTableCell1"; + this.xrTableCell16.Weight = 3D; + // + // xrTableRow7 + // + this.xrTableRow7.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell3}); + this.xrTableRow7.Name = "xrTableRow7"; + this.xrTableRow7.Weight = 0.23809523809523808D; + // + // xrTableCell3 + // + this.xrTableCell3.Name = "xrTableCell3"; + this.xrTableCell3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell3.StylePriority.UsePadding = false; + this.xrTableCell3.Weight = 3D; + // + // xrTableRow9 + // + this.xrTableRow9.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell6}); + this.xrTableRow9.Name = "xrTableRow9"; + this.xrTableRow9.Weight = 0.38095238095238088D; + // + // xrTableCell6 + // + this.xrTableCell6.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "FehlkontakteString")}); + this.xrTableCell6.Name = "xrTableCell6"; + this.xrTableCell6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell6.StylePriority.UsePadding = false; + this.xrTableCell6.Weight = 3D; + // + // xrTableRow21 + // + this.xrTableRow21.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell18}); + this.xrTableRow21.Name = "xrTableRow21"; + this.xrTableRow21.Weight = 0.23809523809523808D; + // + // xrTableCell18 + // + this.xrTableCell18.Name = "xrTableCell18"; + this.xrTableCell18.Weight = 3D; + // + // xrTableRow22 + // + this.xrTableRow22.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell29}); + this.xrTableRow22.Name = "xrTableRow22"; + this.xrTableRow22.Weight = 0.38095238095238088D; + // + // xrTableCell29 + // + this.xrTableCell29.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "AbsenceTimes")}); + this.xrTableCell29.Name = "xrTableCell29"; + this.xrTableCell29.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell29.StylePriority.UsePadding = false; + this.xrTableCell29.Text = "xrTableCell4"; + this.xrTableCell29.Weight = 3D; + // + // xrTableRow23 + // + this.xrTableRow23.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell30}); + this.xrTableRow23.Name = "xrTableRow23"; + this.xrTableRow23.Weight = 0.23809523809523803D; + // + // xrTableCell30 + // + this.xrTableCell30.Name = "xrTableCell30"; + this.xrTableCell30.Weight = 3D; + // + // xrTableRow24 + // + this.xrTableRow24.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell31}); + this.xrTableRow24.Name = "xrTableRow24"; + this.xrTableRow24.Weight = 0.38095238095238088D; + // + // xrTableCell31 + // + this.xrTableCell31.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "FinalSentence")}); + this.xrTableCell31.Name = "xrTableCell31"; + this.xrTableCell31.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell31.StylePriority.UsePadding = false; + this.xrTableCell31.Text = "xrTableCell8"; + this.xrTableCell31.Weight = 3D; + // + // xrLabel12 + // + this.xrLabel12.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "CreatorName")}); + this.xrLabel12.LocationFloat = new DevExpress.Utils.PointFloat(0F, 285F); + this.xrLabel12.Name = "xrLabel12"; + this.xrLabel12.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel12.SizeF = new System.Drawing.SizeF(225F, 17F); + this.xrLabel12.StylePriority.UseFont = false; + this.xrLabel12.TextFormatString = "i.A. {0}"; + // + // lblNotice + // + this.lblNotice.CanShrink = true; + this.lblNotice.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Italic); + this.lblNotice.LocationFloat = new DevExpress.Utils.PointFloat(0F, 7.999992F); + this.lblNotice.Name = "lblNotice"; + this.lblNotice.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblNotice.SizeF = new System.Drawing.SizeF(250F, 25F); + this.lblNotice.StylePriority.UseFont = false; + this.lblNotice.Text = "Abschließende Bemerkungen:"; + // + // topMarginBand1 + // + this.topMarginBand1.Name = "topMarginBand1"; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel16, + this.xrPictureBox2, + this.xrLabel15, + this.xrLabel14, + this.xrLabel11}); + this.bottomMarginBand1.HeightF = 102.6921F; + this.bottomMarginBand1.Name = "bottomMarginBand1"; + // + // GroupHeader1 + // + this.GroupHeader1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel7, + this.xrLabel1, + this.xrLabel_RecipientContactPerson, + this.xrLabel_RecipientDivision, + this.xrLabel_RecipientStreet, + this.RecipientPostCodeAndTown, + this.xrTable2, + this.xrLabel2, + this.xrLabel3, + this.xrLabel4, + this.xrLabel5, + this.xrLabel6, + this.xrTable1, + this.xrLabel8}); + this.GroupHeader1.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.GroupHeader1.HeightF = 487.8651F; + this.GroupHeader1.Name = "GroupHeader1"; + this.GroupHeader1.StylePriority.UseFont = false; + // + // fieldApprovedFLSWithFactor + // + this.fieldApprovedFLSWithFactor.Expression = "[ApprovedFLSTotal] * [RateFactor]"; + this.fieldApprovedFLSWithFactor.FieldType = DevExpress.XtraReports.UI.FieldType.Decimal; + this.fieldApprovedFLSWithFactor.Name = "fieldApprovedFLSWithFactor"; + // + // DetailReport + // + this.DetailReport.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail1, + this.GroupHeader2, + this.Zwischensumme}); + this.DetailReport.DataMember = "InvoiceItems"; + this.DetailReport.DataSource = this.bindingSource1; + this.DetailReport.Level = 0; + this.DetailReport.Name = "DetailReport"; + // + // Detail1 + // + this.Detail1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable4}); + this.Detail1.Font = new DevExpress.Drawing.DXFont("Verdana", 9.75F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.Detail1.HeightF = 17F; + this.Detail1.Name = "Detail1"; + this.Detail1.SortFields.AddRange(new DevExpress.XtraReports.UI.GroupField[] { + new DevExpress.XtraReports.UI.GroupField("PeriodStartDate", DevExpress.XtraReports.UI.XRColumnSortOrder.Ascending)}); + this.Detail1.StylePriority.UseFont = false; + // + // xrTable4 + // + this.xrTable4.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTable4.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable4.Name = "xrTable4"; + this.xrTable4.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow33}); + this.xrTable4.SizeF = new System.Drawing.SizeF(650F, 17F); + this.xrTable4.StylePriority.UseBorderColor = false; + // + // xrTableRow33 + // + this.xrTableRow33.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell52, + this.xrTableCell53}); + this.xrTableRow33.Name = "xrTableRow33"; + this.xrTableRow33.Weight = 0.085D; + // + // xrTableCell52 + // + this.xrTableCell52.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell52.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell52.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.AbrechnungsText")}); + this.xrTableCell52.Name = "xrTableCell52"; + this.xrTableCell52.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell52.StylePriority.UseBorderColor = false; + this.xrTableCell52.StylePriority.UseBorders = false; + this.xrTableCell52.StylePriority.UseFont = false; + this.xrTableCell52.Text = "abzüglich der geleisteten Abschlagszahlung:"; + this.xrTableCell52.Weight = 0.83602567232572123D; + // + // xrTableCell53 + // + this.xrTableCell53.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell53.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell53.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.GrossAmountTotal", "{0:c}")}); + this.xrTableCell53.Name = "xrTableCell53"; + this.xrTableCell53.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell53.StylePriority.UseBorderColor = false; + this.xrTableCell53.StylePriority.UseBorders = false; + this.xrTableCell53.StylePriority.UseFont = false; + this.xrTableCell53.StylePriority.UseTextAlignment = false; + this.xrTableCell53.Text = "xrTableCell10"; + this.xrTableCell53.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell53.Weight = 0.16397432767427886D; + // + // GroupHeader2 + // + this.GroupHeader2.BorderColor = System.Drawing.Color.Transparent; + this.GroupHeader2.Expanded = false; + this.GroupHeader2.GroupFields.AddRange(new DevExpress.XtraReports.UI.GroupField[] { + new DevExpress.XtraReports.UI.GroupField("RateFactor", DevExpress.XtraReports.UI.XRColumnSortOrder.Descending)}); + this.GroupHeader2.HeightF = 0F; + this.GroupHeader2.Name = "GroupHeader2"; + this.GroupHeader2.StylePriority.UseBorderColor = false; + // + // Zwischensumme + // + this.Zwischensumme.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable6}); + this.Zwischensumme.HeightF = 34F; + this.Zwischensumme.Name = "Zwischensumme"; + this.Zwischensumme.Visible = false; + // + // xrTable6 + // + this.xrTable6.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable6.Name = "xrTable6"; + this.xrTable6.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow12, + this.xrTableRow10}); + this.xrTable6.SizeF = new System.Drawing.SizeF(650F, 34F); + this.xrTable6.StylePriority.UseFont = false; + // + // xrTableRow12 + // + this.xrTableRow12.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell9, + this.xrTableCell10}); + this.xrTableRow12.Name = "xrTableRow12"; + this.xrTableRow12.Weight = 0.40476190476190466D; + // + // xrTableCell9 + // + this.xrTableCell9.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell9.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell9.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell9.Name = "xrTableCell9"; + this.xrTableCell9.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell9.StylePriority.UseBorderColor = false; + this.xrTableCell9.StylePriority.UseBorders = false; + this.xrTableCell9.StylePriority.UseFont = false; + this.xrTableCell9.StylePriority.UsePadding = false; + this.xrTableCell9.Text = "Zwischensumme [ItemDescription]:"; + this.xrTableCell9.Weight = 2.5080772986778848D; + // + // xrTableCell10 + // + this.xrTableCell10.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell10.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell10.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.GrossAmountTotal")}); + this.xrTableCell10.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell10.Name = "xrTableCell10"; + this.xrTableCell10.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell10.StylePriority.UseBorderColor = false; + this.xrTableCell10.StylePriority.UseBorders = false; + this.xrTableCell10.StylePriority.UseFont = false; + this.xrTableCell10.StylePriority.UsePadding = false; + this.xrTableCell10.StylePriority.UseTextAlignment = false; + xrSummary1.FormatString = "{0:c}"; + xrSummary1.Running = DevExpress.XtraReports.UI.SummaryRunning.Group; + this.xrTableCell10.Summary = xrSummary1; + this.xrTableCell10.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell10.Weight = 0.4919227013221153D; + // + // xrTableRow10 + // + this.xrTableRow10.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell7}); + this.xrTableRow10.Name = "xrTableRow10"; + this.xrTableRow10.Weight = 0.40476190476190466D; + // + // xrTableCell7 + // + this.xrTableCell7.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell7.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell7.Font = new DevExpress.Drawing.DXFont("Verdana", 9.75F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTableCell7.Name = "xrTableCell7"; + this.xrTableCell7.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell7.StylePriority.UseBorderColor = false; + this.xrTableCell7.StylePriority.UseBorders = false; + this.xrTableCell7.StylePriority.UseFont = false; + this.xrTableCell7.StylePriority.UsePadding = false; + this.xrTableCell7.Weight = 3D; + // + // GroupFooter1 + // + this.GroupFooter1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable5}); + this.GroupFooter1.Font = new DevExpress.Drawing.DXFont("Verdana", 9.75F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.GroupFooter1.HeightF = 115F; + this.GroupFooter1.Name = "GroupFooter1"; + this.GroupFooter1.StylePriority.UseFont = false; + // + // xrTable5 + // + this.xrTable5.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTable5.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable5.Name = "xrTable5"; + this.xrTable5.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow31, + this.xrTableRow32, + this.xrTableRow34, + this.xrTableRow35, + this.xrTableRow36, + this.xrTableRow37}); + this.xrTable5.SizeF = new System.Drawing.SizeF(650F, 115F); + this.xrTable5.StylePriority.UseBorderColor = false; + // + // xrTableRow31 + // + this.xrTableRow31.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell49, + this.xrTableCell50}); + this.xrTableRow31.Name = "xrTableRow31"; + this.xrTableRow31.Weight = 0.085D; + // + // xrTableCell49 + // + this.xrTableCell49.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell49.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell49.Name = "xrTableCell49"; + this.xrTableCell49.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell49.StylePriority.UseBorders = false; + this.xrTableCell49.StylePriority.UseFont = false; + this.xrTableCell49.StylePriority.UsePadding = false; + this.xrTableCell49.Text = "Gesamtforderung:"; + this.xrTableCell49.Weight = 0.836025672325721D; + // + // xrTableCell50 + // + this.xrTableCell50.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell50.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "AmountBillableTotal", "{0:c}")}); + this.xrTableCell50.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell50.Name = "xrTableCell50"; + this.xrTableCell50.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell50.StylePriority.UseBorders = false; + this.xrTableCell50.StylePriority.UseFont = false; + this.xrTableCell50.StylePriority.UsePadding = false; + this.xrTableCell50.StylePriority.UseTextAlignment = false; + this.xrTableCell50.Text = "xrTableCell9"; + this.xrTableCell50.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell50.Weight = 0.16397432767427886D; + // + // xrTableRow32 + // + this.xrTableRow32.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell51}); + this.xrTableRow32.Name = "xrTableRow32"; + this.xrTableRow32.Weight = 0.085D; + // + // xrTableCell51 + // + this.xrTableCell51.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell51.Name = "xrTableCell51"; + this.xrTableCell51.StylePriority.UseBorders = false; + this.xrTableCell51.Weight = 1D; + // + // xrTableRow34 + // + this.xrTableRow34.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell54, + this.xrTableCell55}); + this.xrTableRow34.Name = "xrTableRow34"; + this.xrTableRow34.Weight = 0.085D; + // + // xrTableCell54 + // + this.xrTableCell54.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell54.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell54.Name = "xrTableCell54"; + this.xrTableCell54.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell54.StylePriority.UseBorderColor = false; + this.xrTableCell54.StylePriority.UseBorders = false; + this.xrTableCell54.StylePriority.UseFont = false; + this.xrTableCell54.Text = "abzüglich der geleisteten Abschlagszahlung:"; + this.xrTableCell54.Weight = 0.83602576622596159D; + // + // xrTableCell55 + // + this.xrTableCell55.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell55.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell55.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "AmountAdvancedPayments", "{0:c}")}); + this.xrTableCell55.Name = "xrTableCell55"; + this.xrTableCell55.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell55.StylePriority.UseBorderColor = false; + this.xrTableCell55.StylePriority.UseBorders = false; + this.xrTableCell55.StylePriority.UseFont = false; + this.xrTableCell55.StylePriority.UseTextAlignment = false; + this.xrTableCell55.Text = "xrTableCell10"; + this.xrTableCell55.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell55.Weight = 0.16397423377403847D; + // + // xrTableRow35 + // + this.xrTableRow35.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell56, + this.xrTableCell57}); + this.xrTableRow35.Name = "xrTableRow35"; + this.xrTableRow35.Weight = 0.085D; + // + // xrTableCell56 + // + this.xrTableCell56.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell56.Name = "xrTableCell56"; + this.xrTableCell56.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell56.StylePriority.UseBorders = false; + this.xrTableCell56.StylePriority.UsePadding = false; + this.xrTableCell56.Text = "abzüglich Eigenanteil:"; + this.xrTableCell56.Weight = 0.83602586012620206D; + // + // xrTableCell57 + // + this.xrTableCell57.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell57.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Eigenbeteiligung", "{0:c}")}); + this.xrTableCell57.Name = "xrTableCell57"; + this.xrTableCell57.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell57.StylePriority.UseBorders = false; + this.xrTableCell57.StylePriority.UsePadding = false; + this.xrTableCell57.StylePriority.UseTextAlignment = false; + this.xrTableCell57.Text = "xrTableCell15"; + this.xrTableCell57.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell57.Weight = 0.16397413987379808D; + // + // xrTableRow36 + // + this.xrTableRow36.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell58}); + this.xrTableRow36.Name = "xrTableRow36"; + this.xrTableRow36.Weight = 0.085D; + // + // xrTableCell58 + // + this.xrTableCell58.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell58.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell58.Name = "xrTableCell58"; + this.xrTableCell58.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell58.StylePriority.UseBorderColor = false; + this.xrTableCell58.StylePriority.UseBorders = false; + this.xrTableCell58.Weight = 1D; + // + // xrTableRow37 + // + this.xrTableRow37.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell59, + this.xrTableCell60}); + this.xrTableRow37.Name = "xrTableRow37"; + this.xrTableRow37.Weight = 0.15D; + // + // xrTableCell59 + // + this.xrTableCell59.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell59.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell59.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell59.Name = "xrTableCell59"; + this.xrTableCell59.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell59.StylePriority.UseBorderColor = false; + this.xrTableCell59.StylePriority.UseBorders = false; + this.xrTableCell59.StylePriority.UseFont = false; + this.xrTableCell59.Text = "Restforderung:"; + this.xrTableCell59.Weight = 0.83602567232572123D; + // + // xrTableCell60 + // + this.xrTableCell60.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell60.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Claim", "{0:c}")}); + this.xrTableCell60.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell60.Name = "xrTableCell60"; + this.xrTableCell60.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell60.StylePriority.UseBorderColor = false; + this.xrTableCell60.StylePriority.UseBorders = false; + this.xrTableCell60.StylePriority.UseFont = false; + this.xrTableCell60.StylePriority.UseTextAlignment = false; + this.xrTableCell60.Text = "xrTableCell17"; + this.xrTableCell60.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell60.Weight = 0.16397432767427886D; + // + // xrTableRow13 + // + this.xrTableRow13.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell14}); + this.xrTableRow13.Name = "xrTableRow13"; + this.xrTableRow13.Weight = 0.11163670453541061D; + // + // xrTableCell14 + // + this.xrTableCell14.ForeColor = System.Drawing.Color.SlateBlue; + this.xrTableCell14.Multiline = true; + this.xrTableCell14.Name = "xrTableCell14"; + this.xrTableCell14.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell14.StylePriority.UseForeColor = false; + this.xrTableCell14.StylePriority.UseTextAlignment = false; + this.xrTableCell14.Text = "bewo@severin-ggmbh.de"; + this.xrTableCell14.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell14.Weight = 1D; + // + // xrTableRow14 + // + this.xrTableRow14.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell15}); + this.xrTableRow14.Name = "xrTableRow14"; + this.xrTableRow14.Weight = 0.074424474301754681D; + // + // xrTableCell15 + // + this.xrTableCell15.Multiline = true; + this.xrTableCell15.Name = "xrTableCell15"; + this.xrTableCell15.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell15.StylePriority.UseTextAlignment = false; + this.xrTableCell15.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell15.Weight = 1D; + // + // xrTableRow15 + // + this.xrTableRow15.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell17}); + this.xrTableRow15.Name = "xrTableRow15"; + this.xrTableRow15.Weight = 0.12652159889050368D; + // + // xrTableCell17 + // + this.xrTableCell17.Font = new DevExpress.Drawing.DXFont("Verdana", 9F, DevExpress.Drawing.DXFontStyle.Underline); + this.xrTableCell17.Multiline = true; + this.xrTableCell17.Name = "xrTableCell17"; + this.xrTableCell17.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell17.StylePriority.UseFont = false; + this.xrTableCell17.StylePriority.UseTextAlignment = false; + this.xrTableCell17.Text = "Ihr/e Ansprechpartner/in: [SenderContactPerson]"; + this.xrTableCell17.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell17.Weight = 1D; + // + // xrTableRow16 + // + this.xrTableRow16.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell19}); + this.xrTableRow16.Name = "xrTableRow16"; + this.xrTableRow16.Weight = 0.0744244721965134D; + // + // xrTableCell19 + // + this.xrTableCell19.Multiline = true; + this.xrTableCell19.Name = "xrTableCell19"; + this.xrTableCell19.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell19.StylePriority.UseTextAlignment = false; + this.xrTableCell19.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell19.Weight = 1D; + // + // xrTableRow17 + // + this.xrTableRow17.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell20}); + this.xrTableRow17.Name = "xrTableRow17"; + this.xrTableRow17.Weight = 0.12652161663468053D; + // + // xrTableCell20 + // + this.xrTableCell20.CanShrink = true; + this.xrTableCell20.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "BusinessPartnerId")}); + this.xrTableCell20.Font = new DevExpress.Drawing.DXFont("Verdana", 9F, ((DevExpress.Drawing.DXFontStyle)((DevExpress.Drawing.DXFontStyle.Bold | DevExpress.Drawing.DXFontStyle.Underline)))); + this.xrTableCell20.Multiline = true; + this.xrTableCell20.Name = "xrTableCell20"; + this.xrTableCell20.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell20.StylePriority.UseFont = false; + this.xrTableCell20.StylePriority.UseTextAlignment = false; + this.xrTableCell20.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + this.xrTableCell20.TextFormatString = "unser Zeichen: {0}"; + this.xrTableCell20.Weight = 1D; + // + // xrLabel7 + // + this.xrLabel7.BackColor = System.Drawing.Color.Transparent; + this.xrLabel7.Borders = DevExpress.XtraPrinting.BorderSide.Bottom; + this.xrLabel7.CanShrink = true; + this.xrLabel7.Font = new DevExpress.Drawing.DXFont("Verdana", 7F); + this.xrLabel7.LocationFloat = new DevExpress.Utils.PointFloat(0.0002909515F, 0F); + this.xrLabel7.Name = "xrLabel7"; + this.xrLabel7.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel7.SizeF = new System.Drawing.SizeF(249.9997F, 17F); + this.xrLabel7.StylePriority.UseBackColor = false; + this.xrLabel7.StylePriority.UseBorders = false; + this.xrLabel7.StylePriority.UseFont = false; + this.xrLabel7.StylePriority.UseTextAlignment = false; + this.xrLabel7.Text = "Severin gGmbH Fürstenbergstr.29 51065 Köln"; + this.xrLabel7.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrLabel7.WordWrap = false; + // + // xrTableRow18 + // + this.xrTableRow18.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell21, + this.xrTableCell27}); + this.xrTableRow18.Name = "xrTableRow18"; + this.xrTableRow18.Weight = 0.085D; + // + // xrTableCell21 + // + this.xrTableCell21.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell21.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell21.Multiline = true; + this.xrTableCell21.Name = "xrTableCell21"; + this.xrTableCell21.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell21.StylePriority.UseBorderColor = false; + this.xrTableCell21.StylePriority.UseBorders = false; + this.xrTableCell21.StylePriority.UseFont = false; + this.xrTableCell21.Weight = 1.6720503178074988D; + // + // xrTableRow19 + // + this.xrTableRow19.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell23, + this.xrTableCell26}); + this.xrTableRow19.Name = "xrTableRow19"; + this.xrTableRow19.Weight = 0.085D; + // + // xrTableCell23 + // + this.xrTableCell23.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell23.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell23.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell23.Multiline = true; + this.xrTableCell23.Name = "xrTableCell23"; + this.xrTableCell23.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell23.StylePriority.UseBorderColor = false; + this.xrTableCell23.StylePriority.UseBorders = false; + this.xrTableCell23.StylePriority.UseFont = false; + this.xrTableCell23.Text = "- zzgl. Faktor [RateFactorText2]:"; + this.xrTableCell23.Weight = 1.6720503178074988D; + // + // xrTableRow25 + // + this.xrTableRow25.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell24, + this.xrTableCell25}); + this.xrTableRow25.Name = "xrTableRow25"; + this.xrTableRow25.Weight = 0.085D; + // + // xrTableCell24 + // + this.xrTableCell24.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell24.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell24.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell24.Multiline = true; + this.xrTableCell24.Name = "xrTableCell24"; + this.xrTableCell24.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell24.StylePriority.UseBorderColor = false; + this.xrTableCell24.StylePriority.UseBorders = false; + this.xrTableCell24.StylePriority.UseFont = false; + this.xrTableCell24.Text = "Bewilligte Fachleistungsstunden (FLS) gesamt:"; + this.xrTableCell24.Weight = 1.6720503178074988D; + // + // xrTableCell25 + // + this.xrTableCell25.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell25.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell25.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ApprovedFLS")}); + this.xrTableCell25.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell25.Multiline = true; + this.xrTableCell25.Name = "xrTableCell25"; + this.xrTableCell25.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell25.StylePriority.UseBorderColor = false; + this.xrTableCell25.StylePriority.UseBorders = false; + this.xrTableCell25.StylePriority.UseFont = false; + this.xrTableCell25.StylePriority.UseTextAlignment = false; + this.xrTableCell25.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell25.Weight = 0.327949682192501D; + // + // xrTableCell26 + // + this.xrTableCell26.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell26.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell26.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ApprovedFLSWithFactor")}); + this.xrTableCell26.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell26.Multiline = true; + this.xrTableCell26.Name = "xrTableCell26"; + this.xrTableCell26.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell26.StylePriority.UseBorderColor = false; + this.xrTableCell26.StylePriority.UseBorders = false; + this.xrTableCell26.StylePriority.UseFont = false; + this.xrTableCell26.StylePriority.UseTextAlignment = false; + this.xrTableCell26.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + this.xrTableCell26.Weight = 0.327949682192501D; + // + // xrTableCell27 + // + this.xrTableCell27.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell27.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell27.Multiline = true; + this.xrTableCell27.Name = "xrTableCell27"; + this.xrTableCell27.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell27.StylePriority.UseBorderColor = false; + this.xrTableCell27.StylePriority.UseBorders = false; + this.xrTableCell27.StylePriority.UseFont = false; + this.xrTableCell27.Weight = 0.327949682192501D; + // + // xrTableCell28 + // + this.xrTableCell28.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell28.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell28.Multiline = true; + this.xrTableCell28.Name = "xrTableCell28"; + this.xrTableCell28.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell28.StylePriority.UseBorderColor = false; + this.xrTableCell28.StylePriority.UseBorders = false; + this.xrTableCell28.StylePriority.UseFont = false; + this.xrTableCell28.Weight = 0.327949682192501D; + // + // lblBankverbindung + // + this.lblBankverbindung.CanShrink = true; + this.lblBankverbindung.Font = new DevExpress.Drawing.DXFont("Verdana", 10F, DevExpress.Drawing.DXFontStyle.Bold); + this.lblBankverbindung.LocationFloat = new DevExpress.Utils.PointFloat(0F, 134.0995F); + this.lblBankverbindung.Multiline = true; + this.lblBankverbindung.Name = "lblBankverbindung"; + this.lblBankverbindung.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblBankverbindung.SizeF = new System.Drawing.SizeF(649.9999F, 69.98309F); + this.lblBankverbindung.StylePriority.UseFont = false; + this.lblBankverbindung.Text = "Sparkasse Köln.\r\nSeverin gGmbH\r\nIBAN: DE58 3705 0198 1933 6614 88\r\nBIC: COLSDE33X" + + "XX"; + // + // xrLabel11 + // + this.xrLabel11.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.xrLabel11.LocationFloat = new DevExpress.Utils.PointFloat(0.0002746582F, 0F); + this.xrLabel11.Multiline = true; + this.xrLabel11.Name = "xrLabel11"; + this.xrLabel11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel11.SizeF = new System.Drawing.SizeF(363.542F, 66.14831F); + this.xrLabel11.StylePriority.UseFont = false; + this.xrLabel11.Text = resources.GetString("xrLabel11.Text"); + // + // xrLabel14 + // + this.xrLabel14.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.xrLabel14.LocationFloat = new DevExpress.Utils.PointFloat(502.1253F, 26.15259F); + this.xrLabel14.Multiline = true; + this.xrLabel14.Name = "xrLabel14"; + this.xrLabel14.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel14.SizeF = new System.Drawing.SizeF(147.8753F, 39.99577F); + this.xrLabel14.StylePriority.UseFont = false; + this.xrLabel14.Text = "Handelsreg.-Nr: HRB 81520\r\n\r\nSteuer-Nr.: 218/5763/0921"; + // + // xrLabel15 + // + this.xrLabel15.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.xrLabel15.LocationFloat = new DevExpress.Utils.PointFloat(502.1253F, 0F); + this.xrLabel15.Multiline = true; + this.xrLabel15.Name = "xrLabel15"; + this.xrLabel15.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel15.SizeF = new System.Drawing.SizeF(87.87531F, 26.15259F); + this.xrLabel15.StylePriority.UseFont = false; + this.xrLabel15.Text = "Mitglied bei"; + // + // xrPictureBox2 + // + this.xrPictureBox2.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrPictureBox2.ImageSource")); + this.xrPictureBox2.LocationFloat = new DevExpress.Utils.PointFloat(590.0006F, 0F); + this.xrPictureBox2.Name = "xrPictureBox2"; + this.xrPictureBox2.SizeF = new System.Drawing.SizeF(60F, 24.5F); + this.xrPictureBox2.Sizing = DevExpress.XtraPrinting.ImageSizeMode.ZoomImage; + // + // xrLabel16 + // + this.xrLabel16.Font = new DevExpress.Drawing.DXFont("Arial", 8F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel16.LocationFloat = new DevExpress.Utils.PointFloat(0F, 66.14832F); + this.xrLabel16.Multiline = true; + this.xrLabel16.Name = "xrLabel16"; + this.xrLabel16.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel16.SizeF = new System.Drawing.SizeF(363.54F, 18F); + this.xrLabel16.StylePriority.UseFont = false; + this.xrLabel16.StylePriority.UseTextAlignment = false; + this.xrLabel16.Text = "Geschäftsführerin: Frau Sabine Fiedrich"; + this.xrLabel16.TextAlignment = DevExpress.XtraPrinting.TextAlignment.BottomLeft; + // + // xrTableRow26 + // + this.xrTableRow26.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell32, + this.xrTableCell33}); + this.xrTableRow26.Name = "xrTableRow26"; + this.xrTableRow26.Weight = 0.085D; + // + // xrTableCell32 + // + this.xrTableCell32.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell32.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell32.Multiline = true; + this.xrTableCell32.Name = "xrTableCell32"; + this.xrTableCell32.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell32.StylePriority.UseBorderColor = false; + this.xrTableCell32.StylePriority.UseBorders = false; + this.xrTableCell32.StylePriority.UseFont = false; + this.xrTableCell32.Weight = 1.6720503178074988D; + // + // xrTableCell33 + // + this.xrTableCell33.BorderColor = System.Drawing.SystemColors.ControlLight; + this.xrTableCell33.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell33.Multiline = true; + this.xrTableCell33.Name = "xrTableCell33"; + this.xrTableCell33.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell33.StylePriority.UseBorderColor = false; + this.xrTableCell33.StylePriority.UseBorders = false; + this.xrTableCell33.StylePriority.UseFont = false; + this.xrTableCell33.Weight = 0.327949682192501D; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.Settlement2RO); + // + // Spitzabrechnung + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.ReportHeader, + this.ReportFooter, + this.topMarginBand1, + this.bottomMarginBand1, + this.GroupHeader1, + this.DetailReport, + this.GroupFooter1}); + this.CalculatedFields.AddRange(new DevExpress.XtraReports.UI.CalculatedField[] { + this.fieldApprovedFLSWithFactor}); + this.DataSource = this.bindingSource1; + this.ExportOptions.PrintPreview.DefaultFileName = "Spitzabrechnung"; + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.ruleRateFactorNull}); + this.Margins = new DevExpress.Drawing.DXMargins(75F, 74F, 100F, 102.6921F); + this.PageHeight = 1169; + this.PageWidth = 827; + this.PaperKind = DevExpress.Drawing.Printing.DXPaperKind.A4; + this.Version = "23.2"; + xrWatermark1.Id = "Watermark1"; + this.Watermarks.Add(xrWatermark1); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable4)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable6)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable5)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); + + } + + #endregion + + private DevExpress.XtraReports.UI.DetailBand Detail; + private System.Windows.Forms.BindingSource bindingSource1; + private DevExpress.XtraReports.UI.ReportHeaderBand ReportHeader; + private DevExpress.XtraReports.UI.XRLabel xrLabel6; + private DevExpress.XtraReports.UI.XRLabel xrLabel5; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + private DevExpress.XtraReports.UI.XRTable xrTable2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell4; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow5; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell13; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell11; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell8; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow6; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow8; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell5; + private DevExpress.XtraReports.UI.XRLabel RecipientPostCodeAndTown; + private DevExpress.XtraReports.UI.XRLabel xrLabel_RecipientStreet; + private DevExpress.XtraReports.UI.XRLabel xrLabel_RecipientDivision; + private DevExpress.XtraReports.UI.XRLabel xrLabel_RecipientContactPerson; + private DevExpress.XtraReports.UI.XRLabel xrLabel1; + private DevExpress.XtraReports.UI.ReportFooterBand ReportFooter; + private DevExpress.XtraReports.UI.XRLabel lblNotice; + private DevExpress.XtraReports.UI.XRLabel xrLabel12; + private DevExpress.XtraReports.UI.XRTable xrTable1; + private DevExpress.XtraReports.UI.XRTableRow rowErbrachteLeistung; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell22; + private DevExpress.XtraReports.UI.XRTable xrTable3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow20; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell16; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow21; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell18; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow22; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell29; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow23; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell30; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow24; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell31; + private DevExpress.XtraReports.UI.XRLabel xrLabel10; + private DevExpress.XtraReports.UI.FormattingRule ruleRateFactorNull; + private DevExpress.XtraReports.UI.TopMarginBand topMarginBand1; + private DevExpress.XtraReports.UI.BottomMarginBand bottomMarginBand1; + private DevExpress.XtraReports.UI.XRLabel xrLabel8; + private DevExpress.XtraReports.UI.GroupHeaderBand GroupHeader1; + private DevExpress.XtraReports.UI.CalculatedField fieldApprovedFLSWithFactor; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport; + private DevExpress.XtraReports.UI.DetailBand Detail1; + private DevExpress.XtraReports.UI.XRTable xrTable4; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow33; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell52; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell53; + private DevExpress.XtraReports.UI.GroupFooterBand GroupFooter1; + private DevExpress.XtraReports.UI.XRTable xrTable5; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow31; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell49; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell50; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow32; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell51; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow34; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell54; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell55; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow35; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell56; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell57; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow36; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell58; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow37; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell59; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell60; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow7; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow9; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell6; + private DevExpress.XtraReports.UI.GroupHeaderBand GroupHeader2; + private DevExpress.XtraReports.UI.GroupFooterBand Zwischensumme; + private DevExpress.XtraReports.UI.XRTable xrTable6; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow12; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell9; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell10; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow10; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell7; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell12; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow13; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell14; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell15; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow15; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell17; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow16; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell19; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow17; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell20; + private DevExpress.XtraReports.UI.XRLabel xrLabel7; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow25; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell24; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow19; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell23; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow18; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell21; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell25; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell26; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell27; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell28; + private DevExpress.XtraReports.UI.XRLabel lblBankverbindung; + private DevExpress.XtraReports.UI.XRLabel xrLabel16; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox2; + private DevExpress.XtraReports.UI.XRLabel xrLabel15; + private DevExpress.XtraReports.UI.XRLabel xrLabel14; + private DevExpress.XtraReports.UI.XRLabel xrLabel11; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow26; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell32; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell33; + } +} \ No newline at end of file diff --git a/ReportImp/SeverinReports/SettlementReport2.cs b/ReportImp/SeverinReports/SettlementReport2.cs new file mode 100644 index 000000000..f9f00ac6a --- /dev/null +++ b/ReportImp/SeverinReports/SettlementReport2.cs @@ -0,0 +1,57 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using DevExpress.XtraReports.UI; +using BeWo.Report.ReportObjects; +using BeWo.Report; +using System.Text.RegularExpressions; +using BS.Shared.Extensions; + +namespace SeverinReports +{ + public partial class Spitzabrechnung : DevExpress.XtraReports.UI.XtraReport, IBeWoReport + { + public Spitzabrechnung() + { + InitializeComponent(); + } + + public void SetReportDataSource(Settlement2RO pRO) + { + if (String.IsNullOrEmpty(pRO.Notice)) + { + lblNotice.Visible = false; + } + + decimal rateFactor = 1; + + foreach (var ii in pRO.InvoiceItems) + { + if (ii.RateFactor.HasValue) + { + rateFactor = (100 + ii.RateFactor.Value) / 100; + } + + if (!pRO.FehlkontakteString.IsNullOrEmpty() && ii.RateFactor == 0) + { + Zwischensumme.Visible = true; + ii.AbrechnungsText = ii.AbrechnungsText.Replace("FLS", "Std."); + ii.ItemDescription = "Fehlkontakte"; + } + else if (ii.ItemDescription.IsNullOrEmpty()) + { + ii.ItemDescription = "Fachleistungsstunden"; + } + } + pRO.RateFactor = (double)rateFactor; + + if (!(pRO.Claim > 0)) + { + lblBankverbindung.Visible = false; + } + + this.bindingSource1.DataSource = pRO; + } + } +} diff --git a/ReportImp/SeverinReports/SettlementReport2.resx b/ReportImp/SeverinReports/SettlementReport2.resx new file mode 100644 index 000000000..cf056afb8 --- /dev/null +++ b/ReportImp/SeverinReports/SettlementReport2.resx @@ -0,0 +1,138 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + anbei sende ich Ihnen die unterschriebenen Nachweise über die im Rahmen des Betreuten Wohnens für [Salutation2] [CustomerFirstName] [CustomerLastName] erbrachten Leistungen zu. Nach unserer Berechnung ergeben sich für den Betreuungszeitraum [AccountingPeriod] hieraus: + + + + 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 + + + Severin gemeinnützige Gesellschaft für Inklusion, Beschäftigung, +Weiterbildung und Forschung für Menschen mit einer Behinderung +oder von einer Behinderung bedrohten Menschen nach SGB XII § 53 +Leistungen der Eingliederungshilfe mbH +IBAN: DE58 3705 0198 1933 6614 88, BIC: COLSDE33XXX + + + \ No newline at end of file diff --git a/ReportImp/SeverinReports/SeverinReports.csproj b/ReportImp/SeverinReports/SeverinReports.csproj index 1fca43d63..3b48fd256 100644 --- a/ReportImp/SeverinReports/SeverinReports.csproj +++ b/ReportImp/SeverinReports/SeverinReports.csproj @@ -106,19 +106,39 @@ + + + True + True + Resources.resx + Component ServicesOverviewReport.cs + + Component + + + SettlementReport2.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + ServicesOverviewReport.cs + + SettlementReport2.cs + Designer + @@ -129,6 +149,14 @@ {40D8B312-EA64-49E3-A31A-5E57ED4D5654} Report + + {094331c3-ecee-4c89-bbfd-4c9ded89f0ef} + Service + + + {2f50b83d-a3f0-4ec4-979a-3f9b7e3d8ed4} + Shared +