Probleme beim Drucken von DGV-Inhalt

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Probleme beim Drucken von DGV-Inhalt

    Mahlzeit.
    So langsam muss ich auch die Drucken-Thematik in meinem Programm mal angehen. Ich dachte mir, ich bastel'
    was, womit man jedes beliebige DGV ausdrucken kann. (Ja, extra DGV-Inhalt und nicht DataTable - ich erweitere das später
    um eine Vorabauswahl für Spalten und Rows)

    Ich muss zugeben, das ganze Gedöns mit dem Drucken (alles muss "gemalt" werden, neue Seite erstellen etc.) ist für mich komplexer als die ganze
    Datenverarbeitungs-Sachen die ich inzwischen betreibe.. :S

    Die Druckvorschau sieht soweit schon ganz ordentlich aus, allerdings:

    - schießen manche "Zellinhalte" (FormattedValue.ToString) über die Rectangles hinaus, obwohl ich die per MeasureString ausgemessen habe
    - ich hab's hinbekommen, dass wenn die Header erstellt werden, er weitere Seiten erstellt und die restlichen Header dahin verteilt. Außerdem
    erstelle ich für jeden Header direkt die entsprechenden Zellinhalte mit.
    Was passiert jetzt aber, wenn die Zeilen mehr werden, als es die Seite zu lässt? Hier müsste wieder eine neue Seite erstellt werden und die Header von der 1.
    wieder mit angedruckt werden.

    - ich will mir nen eigenen PrintPreview-Dialog bauen, dazu hab ich erstmal nen einfachen Dialog, da das PrintPreviewControl drauf gezogen und
    2 Radiobuttons erstellt für die Einstellung Hochformat/Querformat. Dazu ein entsprechendes Handling geschrieben:

    VB.NET-Quellcode

    1. Private Sub rbtn_CheckedChanged(sender As Object, e As EventArgs) Handles rbtnHochformat.CheckedChanged,
    2. rbtnQuerformat.CheckedChanged
    3. If rbtnHochformat.Checked Then
    4. Me.PrintPreviewControl1.Document.DefaultPageSettings.Landscape = False
    5. Else
    6. Me.PrintPreviewControl1.Document.DefaultPageSettings.Landscape = True
    7. End If
    8. End Sub


    Da tut sich allerdings nix, wenn ich die Radiobuttons anklicke (also die Ansicht ändert sich im PrintPreview nicht).
    Ich hätte gedacht, dass sich dort die Ansicht ändert und auch die Seiten "neu erstellt" werden. Denn im Querformat hätte man ja z.B. mehr Platz für die Header.
    Könnt ihr mir sagen, wie ich das am besten anstelle?

    Anbei mein bisheriger Print-Code (erstmal nur Druckvorschau, Rest kommt später wenn das alles passt):

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Drawing, System.Drawing.Printing
    3. Public Module Print
    5. Private WithEvents _PrintDoc As PrintDocument
    6. Private _dgv As DataGridView
    7. Private _myfont As Font = New Font("Arial", 11, FontStyle.Regular)
    8. Private _activeColIndex As Integer
    9. Private _totalWidth As Integer
    10. Private _penGray As New Pen(Brushes.LightGray, 0.5)
    12. 'TODO: Abfangen, wenn Headertext im DGV mehrzeilig angezeigt wird (ist dann soll er auch mehrzeilig gedruckt werden
    14. Public Sub PrintDgv(DocumentName As String, dgv As DataGridView)
    15. _PrintDoc = New PrintDocument With {.DocumentName = DocumentName}
    16. _dgv = dgv
    17. _activeColIndex = 0
    18. _totalWidth = 0
    19. Using dlgPreview As New dlgPrintPreview
    20. 'dlgPreview.WindowState = FormWindowState.Maximized
    21. dlgPreview.PrintPreviewControl1.Document = _PrintDoc
    22. dlgPreview.ShowDialog()
    23. End Using
    24. End Sub
    26. Private Sub PrintDoc_PrintPage(sender As Object, e As PrintPageEventArgs) Handles _PrintDoc.PrintPage
    27. Dim g = e.Graphics
    28. Dim margin = _PrintDoc.DefaultPageSettings.Margins
    29. Dim X = margin.Left
    30. Dim Y = margin.Top
    31. Dim drawText As Action(Of String, Integer, Integer) = Sub(s, dx, dy) g.DrawString(s, _myfont, Brushes.Black, X + dx, Y + dy)
    32. drawText(_PrintDoc.DocumentName, 0, 0) 'Titel
    33. Y += 30
    34. Dim kvpOfColsAndMaxWidth = GetVisibleColAndMaxWidth(g)
    35. Dim maxPrintWidth = _PrintDoc.DefaultPageSettings.PaperSize.Width - _PrintDoc.DefaultPageSettings.Margins.Right 'die maximale Breite nach rechts
    36. For Each colAndMaxWidth In kvpOfColsAndMaxWidth
    37. If colAndMaxWidth.Key.Index < _activeColIndex Then Continue For
    38. If _totalWidth + colAndMaxWidth.Value > maxPrintWidth Then 'wenn die Breite überschritten würde, dann hier abbrechen und nach return mit der Col weitermachen
    39. If Not e.HasMorePages Then e.HasMorePages = True
    40. _activeColIndex = colAndMaxWidth.Key.Index
    41. _totalWidth = 0 'totalWidth muss für eine neue Seite natürlich zurückgesetzt werden
    42. Return
    43. End If
    44. DrawHeader(g, X, Y, _totalWidth, colAndMaxWidth)
    45. DrawFormattedValue(g, X, Y, _totalWidth, colAndMaxWidth)
    46. _totalWidth += colAndMaxWidth.Value
    47. Next
    48. If e.HasMorePages Then e.HasMorePages = False
    49. End Sub
    51. ''' <summary>Speichert alle sichtbaren DGV-Columns, sowie die maximale Schriftbreite der Spalte (oder HeaderCell-Breite, falls größer) in einem Dictionary</summary>
    52. Private Function GetVisibleColAndMaxWidth(g As Graphics) As Dictionary(Of DataGridViewColumn, Integer)
    53. Dim dic As New Dictionary(Of DataGridViewColumn, Integer)
    54. For i = 0 To _dgv.ColumnsX.Where(Function(col) col.Visible).Count - 1
    55. Dim colIndex = i
    56. 'Dim maxCellWidth = _dgv.RowsX.Select(Function(rw) rw.Cells(colIndex).Size.Width).Max
    57. Dim maxCellContentWidth = g.MeasureString(_dgv.RowsX.Select(Function(rw) rw.Cells(colIndex).FormattedValue.ToString).Max, _myfont) 'TODO: klappt noch nicht zu 100%
    58. Dim colWidth = _dgv.Columns(i).Width
    59. If colWidth > maxCellContentWidth.Width Then
    60. dic.Add(_dgv.Columns(colIndex), colWidth)
    61. Else
    62. dic.Add(_dgv.Columns(colIndex), CInt(maxCellContentWidth.Width))
    63. End If
    64. Next
    65. Return dic
    66. End Function
    68. Private Sub DrawHeader(g As Graphics, x As Integer, y As Integer, totalWidth As Integer, colAndMaxWidth As KeyValuePair(Of DataGridViewColumn, Integer))
    69. Dim drawHeaderText As Action(Of String, Integer) = Sub(s, dx) g.DrawString(s, _myfont, Brushes.Black, x + dx, y + 5)
    70. g.FillRectangle(Brushes.LightGray, x + totalWidth, y, colAndMaxWidth.Value, 30)
    71. drawHeaderText(colAndMaxWidth.Key.HeaderText, totalWidth)
    72. End Sub
    74. Private Sub DrawFormattedValue(g As Graphics, x As Integer, y As Integer, totalWidth As Integer, colAndMaxWidth As KeyValuePair(Of DataGridViewColumn, Integer))
    75. Dim drawRowText As Action(Of String, Integer, Integer) = Sub(s, dx, dy) g.DrawString(s, _myfont, Brushes.Black, x + dx, y + dy)
    76. Dim rowPos = 35
    77. For Each rw In _dgv.RowsX
    78. Dim formattedValue = rw.Cells(colAndMaxWidth.Key.Index).FormattedValue.ToString
    79. If formattedValue = "True" Then formattedValue = "Ja"
    80. If formattedValue = "False" Then formattedValue = "Nein"
    81. drawRowText(formattedValue, totalWidth, rowPos)
    82. g.DrawRectangle(_penGray, x + totalWidth, y + rowPos, colAndMaxWidth.Value, 30) 'x,x + rowPos - 5, totalWidth + colAndMaxWidth.Value, x + rowPos - 5) 'zu weit rechts, teilweise unterschiedlich lang
    83. rowPos += 30
    84. Next
    85. End Sub
    87. End Module


    PS: Ich hab mich ein bisschen an dem Code von diesem Thread bedient, allerdings muss es bei mir flexibel sein, da sich die Spalten ja auch je nach DGV ändern ;) : vb-paradise.de/index.php/Threa…ostID=1173341#post1173341

    "Na, wie ist das Wetter bei dir?"
    "Caps Lock."
    "Hä?"
    "Shift ohne Ende!" :thumbsup:

    Jo, die Idee, ein DGV as is zu drucken kam mir auch, und ob man davon ein Tut machen sollte.
    aber grad keine Zeit.

    ich hab übrigens den Code aus dem anderen Thread noch weiterentwickelt:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private Sub PrintDocument1_PrintPage(sender As Object, e As Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage
    2. Dim g = e.Graphics
    3. Dim margin = PrintDocument1.DefaultPageSettings.Margins
    4. Dim X = margin.Left
    5. Dim Y = margin.Top
    6. Dim drawText As Action(Of String, Integer) = Sub(s, dx) g.DrawString(s, myfont, Brushes.Black, X + dx, Y)
    7. If _pageNr = 0 Then
    8. Y += 240 : drawText("Auftragsnummer" & vbTab & vbTab & ":", 10)
    9. Y += 20 : drawText("Bauvorhaben" & vbTab & vbTab & ":", 10)
    10. End If
    11. Y += 80
    12. DrawColumnHeaders(g, Y)
    13. Y += 35
    14. e.HasMorePages = True
    15. Try
    16. For i = _printRow To bsFkAuftragsdetail.Count - 1
    17. Dim row = bsFkAuftragsdetail.At(Of AuftragsdetailRow)(i)
    18. Dim sUnprinted = If(row.IsLeistungNull, "", row.Leistung.Substring(_printedLeistungChars))
    19. If sUnprinted = "" Then sUnprinted = " "
    20. Dim layoutRect = e.MarginBounds
    21. layoutRect.Offset(X + 60, Y - margin.Top)
    22. layoutRect.Width = 380
    23. layoutRect.Height -= Y
    24. Dim charactersfitted, linesfilled As Integer
    25. Dim sz = g.MeasureString(sUnprinted, myfont, layoutRect.Size, _strformat, charactersfitted, linesfilled)
    26. If charactersfitted = 0 Then Return
    27. If _printedLeistungChars = 0 Then
    28. 'neu angefangene row: auch die anderen Werte eintragen
    29. If Not row.IsPosNull Then drawText(CStr(row.Pos), 17)
    30. If Not row.IsMengeNull Then drawText(Format(row.Menge, "N2"), 465)
    31. If Not row.IsEinheitNull Then drawText(Format(row.Einheit), 535)
    32. If Not row.IsEinzelpreisNull Then drawText(Format(row.Einzelpreis, "C2"), 603)
    33. If Not row.IsGesamtpreisNull Then drawText(Format(row.Gesamtpreis, "C2"), 668)
    34. End If
    36. Dim sPrint = sUnprinted.Substring(0, charactersfitted)
    37. g.DrawString(sPrint, myfont, Brushes.Black, layoutRect, _strformat)
    38. _printedLeistungChars += charactersfitted
    40. Dim hoehe = CInt(sz.Height) + 6
    41. DrawGridlines(g, Y, hoehe)
    42. If charactersfitted < sUnprinted.Length Then Return
    43. _printRow += 1
    44. _printedLeistungChars = 0
    45. Y += hoehe
    46. Next
    47. e.HasMorePages = False
    48. Finally
    49. _pageNr += 1
    50. g.DrawString(String.Format(" - Seite {0} -", _pageNr), myfont, Brushes.LightGray, 380, 1130)
    51. End Try
    52. End Sub
    54. Private Sub DrawColumnHeaders(g As Graphics, y As Integer)
    55. Dim X = PrintDocument1.DefaultPageSettings.Margins.Left
    56. g.FillRectangle(Brushes.LightGray, X + 10, y, 40, 30)
    57. g.FillRectangle(Brushes.LightGray, X + 52, y, 400, 30)
    58. g.FillRectangle(Brushes.LightGray, X + 454, y, 65, 30)
    59. g.FillRectangle(Brushes.LightGray, X + 521, y, 55, 30)
    60. g.FillRectangle(Brushes.LightGray, X + 578, y, 80, 30)
    61. g.FillRectangle(Brushes.LightGray, X + 660, y, 80, 30)
    62. Dim drawText As Action(Of String, Integer) = Sub(s, dx) g.DrawString(s, myfont, Brushes.Black, X + dx, y + 5)
    63. drawText("Pos.", 15)
    64. drawText("Leistung", 240)
    65. drawText("Menge", 462)
    66. drawText("Einheit", 524)
    67. drawText("EP [€]", 600)
    68. drawText("GP [€]", 685)
    69. End Sub
    71. Private Sub DrawGridlines(g As Graphics, y As Integer, hoehe As Integer)
    72. Dim X = PrintDocument1.DefaultPageSettings.Margins.Left
    73. Dim dy = hoehe
    74. y -= 5
    75. g.DrawLine(_pnGray, X + 51, y, X + 51, y + dy)
    76. g.DrawLine(_pnGray, X + 453, y, X + 453, y + dy)
    77. g.DrawLine(_pnGray, X + 520, y, X + 520, y + dy)
    78. g.DrawLine(_pnGray, X + 582, y, X + 582, y + dy)
    79. g.DrawLine(_pnGray, X + 664, y, X + 664, y + dy)
    80. g.DrawLine(_pnGray, X + 10, y + dy, X + 739, y + dy)
    81. End Sub
    82. End Class

    Es kommt nun nicht mehr vor, dass er aus der Print-Schleife rausspringt, um in der nächsten Zeile weiterzumachen.
    Sondern wenn er rausspringt, machter immer auf der nächsten Seite mit der rausgesprungenen Zeile weiter.
    Es wird nämlich nun der Rest-Platz auf der Seite gemessen - und wenn der zu niedrig ist für nichtmal eine Zeile - dann auf nächster Seite weiter (erster Return).
    Also er geht mit der aktuellen Row auf die nächste Seite, wenn er entweder garnichts drucken konnte, oder nicht alles unterbringen konnte.

    Für deinen allgemeinen Ansatz brauchst du was komplizierteres als ein einfaches KeyValuePair je Spalte.
    Da brauchste ein Objekt, was die Spaltenbreite und auch die bisher gedruckten Zeichen sich merkt.
    In meim Code fährt das ja im Form herum (_printedLeistungChars) - das geeeeht, weils ist die einzige problematische Spalte, aber nicht schön.
    Beim generisschen Ansatz müssen alle Zellen so (also mit Vermessung und LayoutRect) gedruckt werden, und die höchste Zelle gibt dann die Gesamt-Zeilen-Höhe vor.
    Jo, das mit dem Seitenvorschub wird bisserl komplizierter, weil man muss erst alle Zell-Texte vermessen, und dann gucken, welche Höhe man noch drucken kann. und danach erst tatsächlich drucken.
    (Bzw. wenn die erste Zelle die Begrenzung erreicht, dann kann man abbrechen, weil damit ist die LayoutRect-Höhe aller anderen Zellen auch geklärt.)

    Ich würd auch nicht versuchen per Code die Spaltenbreiten festzulegen, sondern das soll der User am DGV machen, und das wird dann proportional auf die PrintMargins übertragen.


    warum ein eigener PrintPreview-Dialog?
    Ich find den vorhandenen sehr gut - der zeigt, wie die Seiten aussehen werden.
    Für Einstellungen der DruckParameter nimmt man den PrintDialog (dassis ein anderer).
    Dann muss man nur dafür sorgen, dass der PrintPreviewDialog dasselbe PrintDocument bekommt, an dem der PrintDialog seine Einstellungen vorgenommen hat.
    Am einfachsten bringt man das auf dem (Main-)Form unter - Dialoge in Modulen zu instanzieren ist ungeschickt, weil da geht alles verloren, wenn man sie schliesst.

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „ErfinderDesRades“ ()

    tragl schrieb:

    Ich hab mich ein bisschen an dem Code von diesem Thread bedient
    Fang hier an:
    Drucken mehrseitiger Dokumente
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    tragl schrieb:

    Da tut sich allerdings nix
    Du musst danach DeinPrintPreviewControl.InvalidatePreview aufrufen.
    Ansonsten tl;dr, daher: Man kann doch von einem Control ein Bild machen und dieses als Bild (ggf. gestückelt) an das Document übergeben - AFAIR.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    ErfinderDesRades schrieb:

    Da brauchste ein Objekt, was die Spaltenbreite und auch die bisher gedruckten Zeichen sich merkt.

    ne, für die Spaltenüberschriften nicht. Er soll ja nicht die Spaltenbeschriftung mittendrin abschneiden und auf der neuen Seite fortsetzen, sondern den kompletten Text als neue Spalte auf die neue Seite - das funzt ja auch.

    ErfinderDesRades schrieb:

    Ich würd auch nicht versuchen per Code die Spaltenbreiten festzulegen, sondern das soll der User am DGV machen, und das wird dann proportional auf die PrintMargins übertragen.

    jain. wenn der User die soweit zusammengeschoben hat, dass Text abgeschnitten wird, dann würde der auch beim Drucken abgeschnitten. Deshalb wollte ich mir mit Dim maxCellContentWidth = g.MeasureString(_dgv.RowsX.Select(Function(rw) rw.Cells(colIndex).FormattedValue.ToString).Max, _myfont) die quasi breiteste Zelle holen.
    Muss ich mal debuggen, warum das nicht überall klappt.

    ErfinderDesRades schrieb:

    warum ein eigener PrintPreview-Dialog?

    Damit ich eigene Buttons etc. hinzufügen kann.

    RodFromGermany schrieb:

    Fang hier an:
    #
    Den Thread hab ich schon im Blick. Hab gestern erstmal mit dem "Groben" angefangen und bin halt auf die genannten Probleme gestoßen. ICh hab noch n altes Projekt von dir gefunden "Tabelle drucken",
    das hab ich gestern mal runtergeladen und acker ich die Tage mal durch

    VaporiZed schrieb:

    Du musst danach DeinPrintPreviewControl.InvalidatePreview aufrufen.

    Danke dafür. Hab ich eingebaut. Es wird was aktualisiert, allerdings erscheint danach nur noch der Überschriftstext, ansonsten ist die Seite blank (die ganzen Tabellen-Sachen fehlen)


    ErfinderDesRades schrieb:

    Beim generisschen Ansatz müssen alle Zellen so (also mit Vermessung und LayoutRect) gedruckt werden, und die höchste Zelle gibt dann die Gesamt-Zeilen-Höhe vor.

    Ich hab grad noch die Idee, dass ich ja die gesamtanzahl an DGV-Rows mit entspr. Höhe addieren kann - außerdem kenne ich ja die Gesamthöhe der PrintPage, damit sollte sich doch was machen lassen.
    "Na, wie ist das Wetter bei dir?"
    "Caps Lock."
    "Hä?"
    "Shift ohne Ende!" :thumbsup:

    Sooo, nach langem Tüfteln hab ich eine bisher gut funktionierende Lösung gebastelt.
    Der Code ist sicher an einigen Stellen verbesserungsbedürftig:

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Drawing, System.Drawing.Printing
    3. Public Module Print
    5. Private WithEvents _PrintDoc As PrintDocument
    6. Private _dgv As DataGridView
    7. Private _myfont As Font = New Font("Arial", 11, FontStyle.Regular)
    8. Private _penGray As New Pen(Brushes.LightGray, 0.5)
    9. Private _headerHeight As Integer = 30
    10. Private _rowHeight As Integer = 20
    11. Private _UsedWidth As Integer
    12. Private _UsedHeight As Integer
    13. Private _startColIndex As Integer = 0
    14. Private _activeColIndex As Integer = 0
    15. Private _interruptColIndex As Integer = 0
    16. Private _printedMaxColIndex As Integer = 0
    17. Private _activeRowIndex As Integer = 0
    18. Private _hasRowInterruption As Boolean = False
    19. Private _hasColInterruption As Boolean = False
    20. Private _pageCounter As Integer = 1
    22. 'TODO: Abfangen, wenn Headertext mehrzeilig ist dann soll er auch mehrzeilig gedruckt werden
    24. Public Sub PrintDgv(DocumentName As String, dgv As DataGridView)
    25. _PrintDoc = New PrintDocument With {.DocumentName = DocumentName}
    26. _dgv = dgv
    27. Using dlgPreview As New dlgPrintPreview
    28. dlgPreview.WindowState = FormWindowState.Maximized
    29. dlgPreview.PrintPreviewControl1.Document = _PrintDoc
    30. dlgPreview.nudHorizontal.Value = 1
    31. dlgPreview.nudVertical.Value = 1
    32. dlgPreview.ShowDialog()
    33. End Using
    34. End Sub
    36. Private Sub PrintDoc_PrintPage(sender As Object, e As PrintPageEventArgs) Handles _PrintDoc.PrintPage
    37. Dim g = e.Graphics
    38. Dim margin = _PrintDoc.DefaultPageSettings.Margins
    39. margin.Left = 30
    40. margin.Right = 30
    41. margin.Top = 30
    42. margin.Bottom = 30
    43. Dim X = margin.Left
    44. Dim Y = margin.Top
    45. g.DrawString($"{_PrintDoc.DocumentName} | Seite: {_pageCounter}", _myfont, Brushes.Black, X, Y) 'Überschrift
    46. Y += 30 'etwas Platz schaffen zu den Spaltenköpfen
    47. Dim kvpOfColsAndMaxWidth = GetVisibleColAndMaxWidth() 'Spalten und deren maximale Breiten holen 'TODO: klappt nicht einwandfrei, Text steht teilweise trotzdem über
    48. Dim maxPrintWidth = If(_PrintDoc.DefaultPageSettings.Landscape, _PrintDoc.DefaultPageSettings.PaperSize.Height, _PrintDoc.DefaultPageSettings.PaperSize.Width) - margin.Right - margin.Left 'die maximale Breite je nach Orientierung
    49. If e.HasMorePages Then e.HasMorePages = False 'wenn weiter unten weitere Seiten gefordert wurden, dann hier zurücksetzen - sonst Endlosschleife
    50. 'Columns
    51. If _hasRowInterruption Then
    52. _startColIndex = _printedMaxColIndex + 1
    53. _activeColIndex = _printedMaxColIndex + 1
    54. Else
    55. _startColIndex = If(_hasColInterruption, _interruptColIndex, 0)
    56. _activeColIndex = If(_hasColInterruption, _interruptColIndex, 0)
    57. End If
    58. For iCol = _activeColIndex To _dgv.Columns.Count - 1
    59. If Not _hasRowInterruption Then _hasColInterruption = False 'solange wie es Row-Unterbrechungen gibt muss/soll er die Spaltenköpfe auf jeder Seite neu malen 'TODO: Einstellbar machen?
    60. _activeColIndex = iCol
    61. Dim colIsVisible = kvpOfColsAndMaxWidth.Any(Function(kvp) kvp.Key.Index = _activeColIndex)
    62. If Not colIsVisible Then Continue For 'wenn die Spalte im DGV nicht sichtbar ist, dann überspringen
    63. Dim colAndMaxWidth = kvpOfColsAndMaxWidth.First(Function(kvp) kvp.Key.Index = _activeColIndex) 'passendes KVP raussuchen
    64. If _UsedWidth + colAndMaxWidth.Value > maxPrintWidth Then 'überschreiten die Spaltenköpfe die Seitenbreite, dann Abbruch und erstmal Rows eintragen
    65. _hasColInterruption = True
    66. _interruptColIndex = _activeColIndex 'Abbruch-Spaltenindex merken
    67. Exit For
    68. End If
    69. DrawHeader(g, X, Y, _UsedWidth, colAndMaxWidth) 'Spaltenkopf zeichnen
    70. _UsedWidth += colAndMaxWidth.Value
    71. Next
    72. _UsedHeight = Y + _headerHeight + 5 'etwas Platz zwischen Spaltenköpfe und Rows schaffen
    73. _UsedWidth = 0 'Benutzte Breite zurücksetzen, damit die Rows nun wieder von ganz links an gemalt werden
    74. 'Rows
    75. Dim toColIndex = If(_hasColInterruption, _activeColIndex - 1, _activeColIndex) 'Wenn ein Abbruch wegen Überbreite (Spalten) erfolgt, dann activeColIndex-1, sonst wird bei den Rows 1 Spalteninhalt zuviel gemalt.
    76. DrawRows(g, X, _startColIndex, toColIndex, kvpOfColsAndMaxWidth) 'die zugehörigen Row-Inhalte der bisher gemalten Spaltenköpfe
    77. If _hasRowInterruption Then
    78. e.HasMorePages = True
    79. _pageCounter += 1
    80. Return
    81. Else
    82. _printedMaxColIndex = toColIndex 'Wenn kein Row-Abbruch mehr kommt, dann hier den Max-Index der bisher gemalten Spaltenköpfe merken
    83. End If
    84. If _hasColInterruption Then
    85. e.HasMorePages = True
    86. _pageCounter += 1
    87. Return
    88. End If
    89. If e.HasMorePages Then e.HasMorePages = False
    90. End Sub
    92. Private Sub DrawRows(g As Graphics, X As Integer, startCol As Integer, endCol As Integer, kvpOfColsAndMaxWidth As Dictionary(Of DataGridViewColumn, Integer))
    93. Dim margin = _PrintDoc.DefaultPageSettings.Margins
    94. Dim maxPrintHeight = If(_PrintDoc.DefaultPageSettings.Landscape, _PrintDoc.DefaultPageSettings.PaperSize.Width, _PrintDoc.DefaultPageSettings.PaperSize.Height) - margin.Bottom 'die maximale Höhe
    95. For iRow = 0 To _dgv.Rows.Count - 1
    96. If _UsedHeight + _rowHeight > maxPrintHeight Then
    97. _hasRowInterruption = True
    98. Exit For
    99. End If
    100. If Not _hasRowInterruption Then _activeRowIndex = iRow
    101. If iRow <> _activeRowIndex Then Continue For
    102. _hasRowInterruption = False
    103. Dim rw = _dgv.Rows(_activeRowIndex)
    104. For iCol = startCol To endCol
    105. Dim colIndex = iCol
    106. Dim colIsVisible = kvpOfColsAndMaxWidth.Any(Function(kvp) kvp.Key.Index = colIndex)
    107. If Not colIsVisible Then Continue For
    108. Dim colAndMaxWidth = kvpOfColsAndMaxWidth.First(Function(kvp) kvp.Key.Index = colIndex)
    109. Dim formattedValue = rw.Cells(iCol).FormattedValue.ToString
    110. If formattedValue = "True" Then formattedValue = "Ja"
    111. If formattedValue = "False" Then formattedValue = "Nein"
    112. g.DrawString(formattedValue, _myfont, Brushes.Black, X + _UsedWidth, _UsedHeight + 1)
    113. g.DrawRectangle(_penGray, X + _UsedWidth, _UsedHeight, colAndMaxWidth.Value, _rowHeight)
    114. _UsedWidth += colAndMaxWidth.Value
    115. Next
    116. _UsedWidth = 0
    117. _UsedHeight += _rowHeight
    118. Next
    119. End Sub
    121. Private Sub DrawHeader(g As Graphics, x As Integer, y As Integer, totalWidth As Integer, colAndMaxWidth As KeyValuePair(Of DataGridViewColumn, Integer))
    122. Dim drawHeaderText As Action(Of String, Integer) = Sub(s, dx) g.DrawString(s, _myfont, Brushes.Black, x + dx, y + 5)
    123. g.FillRectangle(Brushes.LightGray, x + totalWidth, y, colAndMaxWidth.Value, _headerHeight)
    124. drawHeaderText(colAndMaxWidth.Key.HeaderText, totalWidth)
    125. End Sub
    127. ''' <summary>Speichert alle sichtbaren DGV-Columns, sowie die maximale Schriftbreite der Spalte (oder HeaderCell-Breite, falls größer) in einem Dictionary</summary>
    128. Private Function GetVisibleColAndMaxWidth() As Dictionary(Of DataGridViewColumn, Integer)
    129. Dim dic As New Dictionary(Of DataGridViewColumn, Integer)
    130. Dim g = _dgv.CreateGraphics
    131. For i = 0 To _dgv.ColumnsX.Where(Function(col) col.Visible).Count - 1
    132. Dim colIndex = i
    133. Dim maxCellContentWidth = g.MeasureString(_dgv.RowsX.Select(Function(rw) rw.Cells(colIndex).FormattedValue.ToString).Max, _myfont) 'TODO: klappt noch nicht zu 100%
    134. Dim colWidth = _dgv.Columns(i).Width
    135. If colWidth > maxCellContentWidth.Width Then
    136. dic.Add(_dgv.Columns(colIndex), colWidth)
    137. Else
    138. dic.Add(_dgv.Columns(colIndex), CInt(maxCellContentWidth.Width))
    139. End If
    140. Next
    141. Return dic
    142. End Function
    144. End Module


    Ich hab' noch das Problem, dass er mir die maximalen Spaltenbreiten (bzw. maximale Textlänge) nicht korrekt ausgibt - teilweise steht Text über die Linien hinaus.
    Ansonsten @ErfinderDesRades wäre das denke ich schonmal ein guter Ansatz für's allgemeine Drucken eines DataGridViews.

    Wenn mir jemand einen Tipp gibt, wie ich das mit der Textlänge hinbekomme, dann kann ich mir das noch erweitern, dass nur bestimmte (ausgewählte) Spalten und Rows gedruckt werden.
    Ich bastel' dann die Tage mal an meinem eigenen PrintPreviewDialog weiter und verschöner den noch etwas. :thumbup:

    Edit: Mit dem längsten Inhalt hab ich rausgefunden. Ich dachte ich könnte den längsten String mit .Max rausfinden, ging aber nicht. Hab mir ne kleine Function gebastelt, die mir den längsten String zurück gibt,
    den vermesse ich dann mit g.MeasureString:

    VB.NET-Quellcode

    1. ''' <summary>Speichert alle sichtbaren DGV-Columns, sowie die maximale Schriftbreite der Spalte (oder HeaderCell-Breite, falls größer) in einem Dictionary</summary>
    2. Private Function GetVisibleColAndMaxWidth() As Dictionary(Of DataGridViewColumn, Integer)
    3. Dim dic As New Dictionary(Of DataGridViewColumn, Integer)
    4. Dim g = _dgv.CreateGraphics
    5. For i = 0 To _dgv.ColumnsX.Where(Function(col) col.Visible).Count - 1
    6. Dim colIndex = i
    7. Dim ht = _dgv.Columns(colIndex).HeaderText
    8. Dim CellContent = _dgv.RowsX.Select(Function(rw) rw.Cells(colIndex).FormattedValue.ToString).ToArray
    9. Dim maxCellContentWidth = g.MeasureString(GetLongestString(CellContent), _myfont).ToSize.Width 'TODO: klappt noch nicht zu 100%
    10. Dim colWidth = g.MeasureString(_dgv.Columns(i).HeaderText, _myfont).ToSize.Width
    11. If colWidth > maxCellContentWidth Then
    12. dic.Add(_dgv.Columns(colIndex), colWidth + 5)
    13. Else
    14. dic.Add(_dgv.Columns(colIndex), maxCellContentWidth + 5)
    15. End If
    16. Next
    17. Return dic
    18. End Function
    20. Private Function GetLongestString(SomeStrings As String()) As String
    21. Dim longest = ""
    22. For Each str In SomeStrings
    23. If str.Length > longest.Length Then longest = str
    24. Next
    25. Return longest
    26. End Function


    "Na, wie ist das Wetter bei dir?"
    "Caps Lock."
    "Hä?"
    "Shift ohne Ende!" :thumbsup:

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „tragl“ ()

    @tragl GetLongestString() funktioniert nicht, weil "iii" hat mehr Buchstaben als "mm", ist aber kürzer.
    Du musst den breitesten gedruckten Text ermitteln, sieh vielleicht mal hier rein: Drucken mehrseitiger Dokumente
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    tragl schrieb:

    - ich hab's hinbekommen, dass wenn die Header erstellt werden, er weitere Seiten erstellt und die restlichen Header dahin verteilt. Außerdem erstelle ich für jeden Header direkt die entsprechenden Zellinhalte mit.
    Was passiert jetzt aber, wenn die Zeilen mehr werden, als es die Seite zu lässt? Hier müsste wieder eine neue Seite erstellt werden und die Header von der 1. wieder mit angedruckt werden.
    ich hab noch nicht das Druck-Konzept verstanden:
    Mir scheint, du willst eine zweite Seite ausdrucken, wenn die Tabelle breiter ist als die Druck-Seite? (Zeilenhöhe konstant, Spaltenbreite variabel)?
    In dem anderen Thread war ja Konzept, dass alle Spalten auf die Seiten-Breite passen, und wenn Zell-Texte zu lang werden, werden sie umgebrochen (also Spaltenbreite konstant, Zeilenhöhe variabel).

    ErfinderDesRades schrieb:

    ich hab noch nicht das Druck-Konzept verstanden:


    ist beides variabel. Wenn die Header breiter sind, als die Seite dann druckt er erst alles auf die 1. Seite. Passen die Rows zu den Headern der 1. Seite nicht drauf, dann macht er ne neue Seite mit den gleichen Headern und macht
    die Rows dort weiter. Erst wenn die Rows dann abgeschlossen sind, macht er mit den Headern auf einer weiteren Seite weiter. Ich guck' mal dass ich nen kleines Testprojekt baue..

    @RodFromGermany: Also muss ich statt der Buchstabenanzahl jeden String mit g.MeasureString vermessen und da den längsten zurück geben?
    "Na, wie ist das Wetter bei dir?"
    "Caps Lock."
    "Hä?"
    "Shift ohne Ende!" :thumbsup:

    Also in deim Konzept geben die SpaltenHeader die Breiten vor, und der Druck muss sich dem in beide Dimensionen anpassen?
    Also wenn die Header zu breit sind einen "Seitenumbruch" nach rechts vollführen?
    Und wenn der Zellentext zu lang ist einen Zeilumbruch in der Zeile
    Und natürlich wenn die Seite voll ist auf de(r/n) nächsten Seite(n) weitermachen (klassischer Seitenumbruch)?

    Jo, versuchma dein Konzept detailliert auszuformulieren (oder habichs nu bereits richtig begriffen?), im Zusammenhang mit deim Testprojekt.

    @ErfinderDesRades:

    Hier mal ein Mini-Testprojekt - ich denke da sollte alles aufgeklärt werden :)

    ErfinderDesRades schrieb:

    Und wenn der Zellentext zu lang ist einen Zeilumbruch in der Zeile
    Und natürlich wenn die Seite voll ist auf de(r/n) nächsten Seite(n) weitermachen (klassischer Seitenumbruch)?


    Ja, so in etwa kommt das hin. Mit zu langem Zellentext hab ich noch nix zu tun, das wäre eine Extra-Wurst die man einbauen müsste.
    Bei mir geht das aktuell nur so:

    Wenn die Header zu Breit sind für eine Seite -> nächste Seite (nach rechts) und da weitermalen
    Wenn die Rows zu hoch sind für die Seite -> nächste Seite (nach unten), die gleichen Header wie auf der 1. Seite und da mit den restlichen Rows weitermachen
    Dateien

    • dgvprint01.zip

      (20,94 kB, 76 mal heruntergeladen, zuletzt: )
    "Na, wie ist das Wetter bei dir?"
    "Caps Lock."
    "Hä?"
    "Shift ohne Ende!" :thumbsup:

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „tragl“ ()

    tragl schrieb:

    Also muss ich statt der Buchstabenanzahl jeden String mit g.MeasureString vermessen und da den längsten zurück geben?
    Ja.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!