Funktion zum Drucken von Textdateien



  • Ich brauch eine Funktion die eine Datei ausdruckt.
    Ich würde mich auch zufrieden geben, würde bei der Eingabeaufforderung der print Befehl funktionieren, tut er aber nicht.

    Also könnt ihr mir irgendwie helfen?



  • Tut mir leid,
    aber ich würde nochmal gerne um antwort bitten.



  • ShellExecute?



  • Vielen Dank



  • Ich habe ein Problem mit ShellExecute.

    Wie schaffe ich es zu Drucken, ohne dass ein momentan aktiviertes DOS-Programm nicht nach Windows switcht?
    Ich habe, also mein DOS Progg, von dem ich aus mein C++ Progg, das dann die Datei druckt, starten will. Jedoch minimiert sich nun immer das DOS-Progg, weil ein Dialog "Datei.txt wird gedruckt" für 1 Sekunde erscheint und das natürlich unter der Winapi.

    Was kann man da machen?



  • Hast du SW_HIDE mal ausprobiert - vielleicht ringt das etwas 🙄



  • Nee, das bringt nichts, da der Flag nicht für Dokumente gilt. Habe ich aber auch schon erfolglos ausprobiert.



  • Druckroutine zum Drucken des Inhalts eines Edit-Felds (den Drucken-Dialog kannste natürlich auch rausnehmen ;))

    /*----------------------------------------------
       POPPRNT.C -- Popup Editor Printing Functions
      ----------------------------------------------*/
    
    #include <windows.h>
    #include <commdlg.h>
    #include <string.h>
    #include "poppad.h"
    
    BOOL bUserAbort ;
    HWND hDlgPrint ;
    
    BOOL CALLBACK PrintDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
         {
         switch (msg)
              {
              case WM_INITDIALOG :
                   EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE,
                                                                MF_GRAYED) ;
                   return TRUE ;
    
              case WM_COMMAND :
                   bUserAbort = TRUE ;
                   EnableWindow (GetParent (hDlg), TRUE) ;
                   DestroyWindow (hDlg) ;
                   hDlgPrint = 0 ;
                   return TRUE ;
              }
         return FALSE ;
         }          
    
    BOOL CALLBACK AbortProc (HDC hPrinterDC, int iCode)
         {
         MSG msg ;
    
         while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
              {
              if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
                   {
                   TranslateMessage (&msg) ;
                   DispatchMessage (&msg) ;
                   }
              }
         return !bUserAbort ;
         }
    
    BOOL PopPrntPrintFile (HINSTANCE hInst, HWND hwnd, HWND hwndEdit, 
                                                       LPSTR szTitleName)
         {
         static DOCINFO  di = { sizeof (DOCINFO), "", NULL } ;
         static PRINTDLG pd ;
         BOOL            bSuccess ;
         LPCTSTR         pstrBuffer ;
         int             yChar, iCharsPerLine, iLinesPerPage, iTotalLines,
                         iTotalPages, iPage, iLine, iLineNum ;
         TEXTMETRIC      tm ;
         WORD            iColCopy, iNoiColCopy ;
    
         pd.lStructSize         = sizeof (PRINTDLG) ;
         pd.hwndOwner           = hwnd ;
         pd.hDevMode            = NULL ;
         pd.hDevNames           = NULL ;
         pd.hDC                 = NULL ;
         pd.Flags               = PD_ALLPAGES | PD_COLLATE | PD_RETURNDC ;
         pd.nFromPage           = 0 ;
         pd.nToPage             = 0 ;
         pd.nMinPage            = 0 ;
         pd.nMaxPage            = 0 ;
         pd.nCopies             = 1 ;
         pd.hInstance           = NULL ;
         pd.lCustData           = 0L ;
         pd.lpfnPrintHook       = NULL ;
         pd.lpfnSetupHook       = NULL ;
         pd.lpPrintTemplateName = NULL ;
         pd.lpSetupTemplateName = NULL ;
         pd.hPrintTemplate      = NULL ;
         pd.hSetupTemplate      = NULL ;
    
         if (!PrintDlg (&pd))
              return TRUE ;
    
         iTotalLines = (short) SendMessage (hwndEdit, EM_GETLINECOUNT, 0, 0L) ;
    
         if (iTotalLines == 0)
              return TRUE ;
    
         GetTextMetrics (pd.hDC, &tm) ;
         yChar = tm.tmHeight + tm.tmExternalLeading ;
    
         iCharsPerLine = GetDeviceCaps (pd.hDC, HORZRES) / tm.tmAveCharWidth ;
         iLinesPerPage = GetDeviceCaps (pd.hDC, VERTRES) / yChar ;
         iTotalPages   = (iTotalLines + iLinesPerPage - 1) / iLinesPerPage ;
    
         pstrBuffer = (LPCTSTR) HeapAlloc (GetProcessHeap (), 
    		                               HEAP_NO_SERIALIZE, iCharsPerLine + 1) ;
    
         EnableWindow (hwnd, FALSE) ;
    
         bSuccess   = TRUE ;
         bUserAbort = FALSE ;
    
         hDlgPrint = CreateDialog (hInst, (LPCTSTR) "PrintDlgBox", hwnd, PrintDlgProc) ;
         SetDlgItemText (hDlgPrint, IDD_FNAME, szTitleName) ;
    
         SetAbortProc (pd.hDC, AbortProc) ;
    
         GetWindowText (hwnd, (PTSTR) di.lpszDocName, sizeof (PTSTR)) ;
    
         if (StartDoc (pd.hDC, &di) > 0)
              {
              for (iColCopy = 0 ;
                   iColCopy < ((WORD) pd.Flags & PD_COLLATE ? pd.nCopies : 1) ;
                   iColCopy++)
                   {
                   for (iPage = 0 ; iPage < iTotalPages ; iPage++)
                        {
                        for (iNoiColCopy = 0 ;
                             iNoiColCopy < (pd.Flags & PD_COLLATE ? 1 : pd.nCopies) ;
                             iNoiColCopy++)
                             {
    
                             if (StartPage (pd.hDC) < 0)
                                  {
                                  bSuccess = FALSE ;
                                  break ;
                                  }
    
                             for (iLine = 0 ; iLine < iLinesPerPage ; iLine++)
                                  {
                                  iLineNum = iLinesPerPage * iPage + iLine ;
    
                                  if (iLineNum > iTotalLines)
                                       break ;
    
                                  *(int *) pstrBuffer = iCharsPerLine ;
    
                                  TextOut (pd.hDC, 0, yChar * iLine, pstrBuffer,
                                       (int) SendMessage (hwndEdit, EM_GETLINE,
                                       (WPARAM) iLineNum, (LPARAM) pstrBuffer)) ;
                                  }
    
                             if (EndPage (pd.hDC) < 0)
                                  {
                                  bSuccess = FALSE ;
                                  break ;
                                  }
    
                             if (bUserAbort)
                                  break ;
                             }
    
                        if (!bSuccess || bUserAbort)
                             break ;
                        }
    
                   if (!bSuccess || bUserAbort)
                        break ;
                   }
              }
         else
              bSuccess = FALSE ;
    
         if (bSuccess)
              EndDoc (pd.hDC) ;
    
         if (!bUserAbort)
              {
              EnableWindow (hwnd, TRUE) ;
              DestroyWindow (hDlgPrint) ;
              }
    
         HeapFree (GetProcessHeap (), 0, (LPVOID) pstrBuffer) ;
         DeleteDC (pd.hDC) ;
    
         return bSuccess && !bUserAbort ;
         }
    


  • Tut mir leid, aber irgendwie komm ich nicht klar damit.

    Könntet ihr mir sagen, welchen Code ich wie benutzen soll, oder zumindest eine WinMain Funktion schreiben, die das ganze aufruft.
    Ich habe einfach keine Ahnung von der WinAPI, tut mir leid!



  • Bitte Leute, kommt schon...
    Ich habe es die ganze Zeit versucht, aber ich checke den Code einfach nicht und die Zeit drückt. Diese scheiß Dokumentation hilft mir auch nicht weiter.



  • Grenz dein Problem mal ein 😉
    Was genau verstehst du am Code nicht oder wo hängst du gerade fest ?



  • Konnte mich in den letzten Tagen nicht melden, da es nun eh' zu spät ist. Verstanden habe ich irgendwie nicht, wie man es daraus schafft z.B. einen eigenen Text ausdruckt. Ist aber wie schon gesagt eh' zu spät.



  • Hi!
    weiß jemand, wie ich es schaffe, aufgrund dieser Druckroutine die von code_pilot angegeben wurde, eine Seitenzahl die sich mit jeder Seite addiert anzugeben?



  • noPeil schrieb:

    weiß jemand, wie ich es schaffe, aufgrund dieser Druckroutine die von code_pilot angegeben wurde, eine Seitenzahl die sich mit jeder Seite addiert anzugeben?

    Die aufgeführte Druckroutine sieht sauber aus, meine eigene ist sehr ähnlich. Die aufaddierte Seitenzahl ist mit einem Seitenzähler und einem zusätzlichen TextOut leicht einzufügen. Für die Ausgabe der nachfolgenden Druckzeilen sind dann natürlich Anpassungen erforderlich.



  • Danke! eigentlich hätt ich mir die frage ja sparen können 🙂
    TextOut und fertig!
    ein viel größeres problem ist das, auf jeder neuen Seite einen speziellen Kopf zu erstellen. dh. der text, der eh schon da steht muss quasi um die größe des Headers nach unten verschoben werden, um dann mit TextOut den Kopf zu schreiben.
    oder hat jemand eine bessere lösung, hat jemand schon mal so ein problem gehabt?

    Danke für eure antworten das hilft mir immer sehr, da ich nicht wirklich ein spezialist auf diesem Gebiet (WINAPI) bin.


  • Mod

    Was für ein Problem?
    So ist das eben beim drucken. Man "malt" eine ganze Seite... d.h. eben auch inkl. Überschrift.

    Ist doch nichts anderes als wenn Du ein Fenster für die Ausgabe mit WM_PAINT gestaltest. Auch da musst Du wissen, was Du wohin ausgibst.



  • Wer für Windows programmieren will, sollte als erstes die WINAPI beherrschen.
    Dazu gibt es den großen Petzold.
    Manche Sachen gehen danach mit der WinApi schneller und einfacher als mit dem ganzen Overhead von MFC und Co.
    Eine kleine API - DLL kann in jedes Programm eingebunden werden.



  • papa_multi schrieb:

    Wer für Windows programmieren will, sollte als erstes die WINAPI beherrschen.
    Dazu gibt es den großen Petzold.
    Manche Sachen gehen danach mit der WinApi schneller und einfacher als mit dem ganzen Overhead von MFC und Co.
    Eine kleine API - DLL kann in jedes Programm eingebunden werden.

    Und genau das scheint heute immer mehr zum Problem zu werden. Man lernt nicht mehr den einfachen Zugriff auf die WinApi in C und steht dann mit seinem Wissen von MFC und Co. irgendwann auf dem Schlauch. Hat der grosse Petzold auch schon gesagt.



  • anscheinend hab ich mich falsch ausgedrückt 🙂
    zum einen programmiere ich nur winapi c zum anderen weiß ich nicht mal was mfc ist, bzw will ich erstmal die finger davon lassen.
    um nochmals zu meinem problem zu kommen:
    ich habe einen text im editor stehen beispielsweise steht dort (bitte folgende "grafik" als eine seite vorstellen):

    -----------
    |HALLO
    |
    |
    |
    -----------
    soweit so gut, dies kann ich drucken, da gibt es keine probleme. nun möchte ich aber, dass auf jeder neuen seite ein spezieller "Header mit Dateninhalt" eingefügt wird, sodass es wie folgt aussieht:

    -----------
    |Header mit
    |Dateninhalt
    |
    |HALLO
    -----------

    im editor will ich den "Header mit Dateninhalt" nicht darstellen, sondern nur auf dem gedruckten blatt.
    Danke für eure antworten!


  • Mod

    DrawText des Headers
    DrawText des Inhaltes.

    Ist auf dem Bildschirm nicht anders als auf dem Drucker.


Log in to reply