home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / disk utilities / backup / backup_restore / backup_src_v3.20.lha / xpk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-06  |  20.9 KB  |  922 lines
  1. // xpk.c
  2. // 06 Dec 1996 11:25:20
  3.  
  4. #ifndef    BACKUP_INCLUDE
  5. #include "IncludeAll.c"
  6. #endif
  7. #include "Backup.h"
  8. #include <gadgets/NoteBook.h>
  9. #include "xpk.h"
  10. #include "Backup_Options.h"
  11. #include "Backup_proto.h"
  12. #include "BackupStrings.h"
  13.  
  14.  
  15. #define    PACKBUFFERSIZE    32768
  16. #define    INFOLINECOUNT    2
  17.  
  18.  
  19. #define    d(x)        ;
  20.  
  21. static UWORD ComputeX( UWORD value );
  22. static UWORD ComputeY( UWORD value );
  23. static BOOL FillPackersList(struct XpkPackerList *Packers);
  24. static void GOFitInfoText(const char *text, struct Gadget **GOGadgets, struct TextFont *InfoLineFont);
  25. static void GOGetPackModeInfo(struct Gadget **GOGadgets, const char *Packer, ULONG Mode);
  26. static void GetOldXPKOpt(const struct BackupOptions *Opt);
  27. static void SplitPackerName(const char *CompleteName, char *Packer, ULONG *Mode);
  28. static const char *GetXpkError(ULONG XpkError);
  29. static ULONG __saveds __asm XPKInFunc(register __a0 struct Hook *theHook,
  30.         register __a1 struct XpkIOMsg *Msg,
  31.         register __a2 APTR Dummy);
  32. static void GetPwdRender( void );
  33. static void CloseGetPwdWindow(void);
  34. static int PwdIDCMPHandler(void);
  35. static void __interrupt HandleGetPwdGadgetCallback(struct Hook *hook, struct Gadget *Gad, ULONG *Code);
  36. static int __interrupt HandleGetPwdGadget(struct Gadget *Gad, USHORT code, struct BackupOptions *Opt);
  37.  
  38.  
  39. // Variable aus Backup.c
  40. extern struct Window *aktWindow;
  41. extern struct TextFont *myFont;        // System Default Font
  42. extern struct TextFont *ScreenFont;
  43. extern struct TextFont PasswordFont;
  44. extern BPTR aktReadFileHandle;        // fh für Lese-File
  45. extern int readoffset;            // Offset innerhalb des aktuellen Lese-Buffers
  46. extern struct Buffer *AktReadBuffer;    // aktueller Lese-Buffer
  47. extern struct Disk ReadDisk;
  48. extern struct BackupOptions myOptions;
  49. extern unsigned long BytesProcessed;    // Anzahl Bytes
  50. extern struct PartitionInfo Root_pInfo;    // aktuelle Partition
  51.  
  52. // aus Backup_Window.c
  53. extern struct TextAttr PWDFONT;
  54. extern APTR vi;                // VisualInfo
  55. extern struct Screen *WBScreen;
  56.  
  57. // aus FileSelect.c
  58. extern struct Window *activeWindow;    // das gerade aktive Backup-Window
  59. extern BOOL HelpActive;            // Online-Hilfe ist aktiv
  60. extern BOOL GadgetHelp;            // V39-GadgetHelp ist verfügbar
  61. extern ULONG BackupHelpGroup;        // Help Group
  62.  
  63.  
  64. // globale Disk-Parameter
  65. extern struct BackupDevInfo globDrvDat;
  66.  
  67.  
  68. static ULONG              FontX, FontY;
  69. static UWORD                  OffX, OffY;
  70. static struct Window         *GetPwdWnd = NULL;
  71. static struct Gadget         *GetPwdGList = NULL;
  72. static struct Gadget         *GetPwdGadgets[GetPwd_CNT];
  73. static UWORD                  GetPwdWidth = 232;
  74. static UWORD                  GetPwdHeight = 80;
  75.  
  76. static struct BInputHandler *PackerSelectInput = NULL;
  77. static struct BInputHandler *PwdInput = NULL;
  78.  
  79. static MINLIST(GetPwdResourceList);
  80.  
  81. static struct GadgetShort *GetPwdGadgetShort;    // Tabelle für Tasten-Kürzel
  82.  
  83. struct MinList PackersList;
  84.  
  85. static char *PackInBuffer;
  86. static size_t PackInBufferSize;    // Größe von PackInBuffer
  87.  
  88.  
  89. static struct IntuiText GetPwdIText[] = { 1, 0, JAM1,108, 11, NULL, NULL, NULL };
  90.  
  91.  
  92. static UWORD GetPwdGTypes[] = {
  93.     STRING_KIND,
  94.     BUTTON_KIND,
  95.     BUTTON_KIND
  96. };
  97.  
  98. static struct NewGadget GetPwdNGad[] = {
  99.       3, 22, 226, 21,                     NULL, &PWDFONT, GD_PwdGadget, PLACETEXT_ABOVE, NULL, NULL,
  100.       3, 55,  85, 20,     (UBYTE *) MSG_OK_GAD,     NULL, GD_PwdOkGadget, PLACETEXT_IN, NULL, NULL,
  101.     144, 55,  85, 20, (UBYTE *) MSG_CANCEL_GAD,     NULL, GD_PwdCancelGadget, PLACETEXT_IN, NULL, NULL
  102. };
  103.  
  104. static ULONG GetPwdGTags[] = {
  105.         (STRINGA_ExitHelp), TRUE,
  106.         (GTST_MaxChars), XPK_PASSWORDLEN,
  107.         (GT_Underscore), '_',
  108.     (TAG_DONE),
  109.         (GT_Underscore), '_',
  110.     (TAG_DONE),
  111.         (GT_Underscore), '_',
  112.     (TAG_DONE)
  113. };
  114.  
  115.  
  116.  
  117. struct Library *XpkBase = NULL;
  118.  
  119. static struct XpkPackerList PackerList;
  120.  
  121. struct Gadget **XPKGOGadgets;
  122.  
  123. static ULONG CurrentPacker = 0;            // Index des aktuellen Packers
  124. static ULONG CurrentPackMode;            // Pack-Mode 0...100
  125. static BOOL  PackModeFixed = FALSE;
  126. BOOL  XPKEncrypt;
  127. static char  Password[XPK_PASSWORDLEN];
  128. static char  FinalPacker[XPK_PACKNAMELEN];    // Format: "ABCD.100"
  129.  
  130. static unsigned char *PackOutBuffer;
  131. static unsigned long PackOutBufferSize;
  132. static unsigned long MaxInLen;
  133.  
  134. static struct Hook GetPwdGadgetShortHook =
  135.     {
  136.     { NULL },
  137.     HookEntry,
  138.     (ULONG (*)()) HandleGetPwdGadgetCallback,
  139.     NULL,        // wird (struct BackupOptions *)
  140.     };
  141.  
  142. static struct BackupOptions *GetPwdOptions;
  143. static BOOL GetPwdResult;
  144.  
  145.  
  146. void InitXpk(void)
  147. {
  148.     NewList((struct List *) &PackersList);
  149.  
  150.     // kein Fehler wenn keine xpkmaster.library !!
  151.     XpkBase = OpenLibrary((STRPTR) XPKNAME, 0);
  152.  
  153.     if (XpkBase)
  154.         {
  155.         ULONG XpkError;
  156.  
  157.         XpkError = XpkQueryTags(XPK_PackersQuery, &PackerList,
  158.                 TAG_END);
  159.  
  160.         if (XpkError)
  161.             {
  162.             CleanupXpk();
  163.  
  164.             // wenn keine XPK-Libraries gefunden werden, kommt Fehler XPKERR_NOINFO
  165.             // dann wird kommentarlos die XPK-Unterstützung abgeschaltet.
  166.             if (XPKERR_NOINFO != XpkError)
  167.                 {
  168.                 // Fehler melden
  169.                 alarm("%s: XpkQueryTags: %s", __FUNC__, GetXpkError(XpkError));
  170.                 }
  171.             }
  172.         }
  173. }
  174.  
  175.  
  176. void CleanupXpk(void)
  177. {
  178.     if (PackOutBuffer)
  179.         {
  180.         free(PackOutBuffer);
  181.         PackOutBuffer = NULL;
  182.         PackOutBufferSize = 0;
  183.         }
  184.     if (PackInBuffer)
  185.         {
  186.         free(PackInBuffer);
  187.         PackInBuffer = NULL;
  188.         PackInBufferSize = 0;
  189.         }
  190.  
  191.     if (XpkBase)
  192.         CloseLibrary(XpkBase);
  193.     XpkBase = NULL;
  194. }
  195.  
  196.  
  197. BOOL GOInitXPKPacker(const struct BackupOptions *Opt)
  198. {
  199.     ASSERT_VALID(Opt);
  200.  
  201.     if (NULL == XpkBase)
  202.         return FALSE;
  203.  
  204.     if (!FillPackersList(&PackerList))
  205.         return FALSE;
  206.  
  207.     GetOldXPKOpt(Opt);
  208.  
  209.     return TRUE;
  210. }
  211.  
  212.  
  213. void GOSetupDefaultPacker(struct Gadget **GOGadgets, struct TextFont *InfoLineFont, const struct BackupOptions *Opt)
  214. {
  215.     ASSERT_VALID(Opt);
  216.     ASSERT_VALID(GOGadgets);
  217.     ASSERT_VALID(GOGadgets[GDX_NBXPKCompressorList]);
  218.     ASSERT_VALID(GOGadgets[GDX_GONoteBook]);
  219.  
  220.     GetOldXPKOpt(Opt);
  221.  
  222.     // Informationen für den Default-Packer anzeigen
  223.     GOGetPackerInfo(CurrentPacker, GOGadgets, InfoLineFont);
  224.  
  225.     // Default-Packer im ListView anzeigen
  226.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKCompressorList], GOGadgets[GDX_GONoteBook],
  227.         GTLV_Selected, CurrentPacker,
  228.         GTLV_MakeVisible, CurrentPacker,
  229.         TAG_END);
  230. }
  231.  
  232.  
  233. static UWORD ComputeX( UWORD value )
  234. {
  235.     return ((UWORD) ((value * FontX) / 65535));
  236. }
  237.  
  238.  
  239. static UWORD ComputeY( UWORD value )
  240. {
  241.     return ((UWORD) ((value * FontY) / 65535));
  242. }
  243.  
  244.  
  245. static BOOL FillPackersList(struct XpkPackerList *Packers)
  246. {
  247.     struct PackerNode *PackNode;
  248.     ULONG Count;
  249.  
  250.     ASSERT_VALID(Packers);
  251.  
  252.     // Liste zu Anfang leeren
  253.     while (PackNode = (struct PackerNode *) RemHead((struct List *) &PackersList))
  254.         {
  255.         free(PackNode);
  256.         }
  257.  
  258.     for (Count=0; Count<Packers->NumPackers; Count++)
  259.         {
  260.         long XpkError;
  261.  
  262.         PackNode = malloc(sizeof(struct PackerNode));
  263.         if (NULL == PackNode)
  264.             {
  265.             alarm(GetString(MSG_OUTOFMEMORY), __FUNC__, "PackNode", sizeof(struct PackerNode));
  266.             return FALSE;
  267.             }
  268.  
  269.         PackNode->pn_Node.ln_Type = NT_USER;
  270.         PackNode->pn_Node.ln_Pri = 0;
  271.         PackNode->PackerIndex = Count;
  272.         strcpy(PackNode->PackerName, PackerList.Packer[Count]);
  273.  
  274.         XpkError = XpkQueryTags(XPK_PackerQuery, &PackNode->Info,
  275.                 XPK_PackMethod, PackNode->PackerName,
  276.                 XPK_PackMode, 0,
  277.                 TAG_END);
  278.         if (XpkError)
  279.             {
  280.             alarm("%s: XpkQueryTags: %s", __FUNC__, GetXpkError(XpkError));
  281.             return FALSE;
  282.             }
  283.  
  284.         PackNode->pn_Node.ln_Name = PackNode->Info.Name;
  285.  
  286.         if (PackNode->Info.Flags & XPKIF_LOSSY)
  287.             {
  288.             // verlustbehaftete Kompression ist nicht brauchbar!
  289.             free(PackNode);
  290.             }
  291.         else
  292.             AddTail((struct List *) &PackersList, &PackNode->pn_Node);
  293.         }
  294.  
  295.     return TRUE;
  296. }
  297.  
  298.  
  299. void GOGetSelectedXPKPacker(struct BackupOptions *Opt)
  300. {
  301.     if (XpkBase)
  302.         {
  303.         sprintf(Opt->XPKPackerName, "%s.%d", PackerList.Packer[CurrentPacker],
  304.                 CurrentPackMode);
  305.         Opt->XPKEncrypt = XPKEncrypt;
  306.         }
  307.     else
  308.         strcpy(Opt->XPKPackerName, "");
  309. }
  310.  
  311.  
  312. void GOSetXPKPackMode(short code, struct Gadget **GOGadgets)
  313. {
  314.     CurrentPackMode = code;
  315.     if (GOGadgets)
  316.         GOGetPackModeInfo(GOGadgets, PackerList.Packer[CurrentPacker], code);
  317. }
  318.  
  319.  
  320. void GOGetPackerInfo(short code, struct Gadget **GOGadgets, struct TextFont *InfoLineFont)
  321. {
  322.     struct PackerNode *pNode;
  323.  
  324.     ASSERT_VALID(GOGadgets);
  325.     ASSERT_VALID(GOGadgets[GDX_GONoteBook]);
  326.  
  327.     for (pNode = (struct PackerNode *) PackersList.mlh_Head; code;
  328.         pNode = (struct PackerNode *) pNode->pn_Node.ln_Succ, code--);
  329.  
  330.     PackModeFixed = !(pNode->Info.Flags & XPKIF_MODES);
  331.     XPKEncrypt = (pNode->Info.Flags & XPKIF_NEEDPASSWD) != 0;
  332.  
  333.     CurrentPacker = pNode->PackerIndex;
  334.     if (NO_PACKMODE == CurrentPackMode || PackModeFixed)
  335.         CurrentPackMode = pNode->Info.DefMode;
  336.  
  337.     GOFitInfoText(pNode->Info.Description, GOGadgets, InfoLineFont);
  338.  
  339.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKLongName], GOGadgets[GDX_GONoteBook],
  340.         GTTX_Text, pNode->Info.LongName,
  341.         TAG_END);
  342.  
  343.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKEncrypt], GOGadgets[GDX_GONoteBook],
  344.         GA_Disabled, !(pNode->Info.Flags & XPKIF_ENCRYPTION) ||
  345.                 pNode->Info.Flags & XPKIF_NEEDPASSWD,
  346.         GTCB_Checked, XPKEncrypt,
  347.         TAG_END);
  348.  
  349.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKPassword], GOGadgets[GDX_GONoteBook],
  350.         GA_Disabled, !(pNode->Info.Flags & XPKIF_ENCRYPTION),
  351.         TAG_END);
  352.  
  353.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKMode], GOGadgets[GDX_GONoteBook],
  354.         GTSL_Level, CurrentPackMode,
  355.         GA_Disabled, PackModeFixed,
  356.         TAG_END);
  357.  
  358.     GOGetPackModeInfo(GOGadgets, pNode->PackerName, CurrentPackMode);
  359. }
  360.  
  361.  
  362. static void GOFitInfoText(const char *text, struct Gadget **GOGadgets, struct TextFont *InfoLineFont)
  363. {
  364.     static char pInfoString[INFOLINECOUNT][60];
  365.     struct RastPort TextRp;
  366.     struct TextExtent FitExt;
  367.     ULONG MaxLen, len;
  368.     short n;
  369.  
  370.     ASSERT_VALID(text);
  371.     ASSERT_VALID(GOGadgets);
  372.     ASSERT_VALID(GOGadgets[GDX_GONoteBook]);
  373.  
  374.     InitRastPort(&TextRp);
  375.     SetFont(&TextRp, InfoLineFont);
  376.  
  377.     memset(pInfoString, 0, sizeof(pInfoString));
  378.     text = stpblk(text);
  379.  
  380.     MaxLen = TextFit(&TextRp, (STRPTR) text, strlen(text), &FitExt, NULL,
  381.         1, GOGadgets[GDX_NBXPKInfoText1]->Width,
  382.         GOGadgets[GDX_NBXPKInfoText1]->Height);
  383.  
  384.     len = strlen(text);
  385.  
  386.     for (n=0; len && n < INFOLINECOUNT; n++)
  387.         {
  388.         ULONG CopyLen, Split = MaxLen;
  389.  
  390.         if (len < Split)
  391.             Split = 0;    // <text> ist kürzer als eine Zeile
  392.  
  393.         while (Split > 0)
  394.             {
  395.             if (isspace(text[Split]))
  396.                 {
  397.                 // Trennen am Leerzeichen
  398.                 CopyLen = min(Split, sizeof(pInfoString[n]) - 1);
  399.                 stccpy(pInfoString[n], text, CopyLen+1);
  400.                 text = stpblk(text + Split);
  401.                 break;
  402.                 }
  403.             else
  404.                 Split--;
  405.             }
  406.         if (0 == Split)
  407.             {
  408.             // keine Trennmöglichkeit gefunden
  409.             CopyLen = min(min(len, MaxLen), sizeof(pInfoString[n]) - 1);
  410.             stccpy(pInfoString[n], text, CopyLen+1);
  411.             text = stpblk(text + CopyLen);
  412.             }
  413.  
  414.         len = strlen(text);
  415.         }
  416.  
  417.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKInfoText1], GOGadgets[GDX_GONoteBook],
  418.         GTTX_Text, pInfoString[0],
  419.         TAG_END);
  420.     NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKInfoText2], GOGadgets[GDX_GONoteBook],
  421.         GTTX_Text, pInfoString[1],
  422.         TAG_END);
  423. }
  424.  
  425.  
  426. LONG __saveds __interrupt PackModeDispFunc(struct Gadget *Gad, WORD Level)
  427. {
  428.     GOGetPackModeInfo(XPKGOGadgets, PackerList.Packer[CurrentPacker], Level);
  429.  
  430.     return (LONG) Level;
  431. }
  432.  
  433.  
  434. static void GOGetPackModeInfo(struct Gadget **GOGadgets, const char *Packer, ULONG Mode)
  435. {
  436.     static char CFText[10];
  437.     struct XpkMode ModeInfo;
  438.     ULONG XpkError;
  439.  
  440.     ASSERT_VALID(GOGadgets);
  441.     ASSERT_VALID0(GOGadgets[GDX_GONoteBook]);
  442.  
  443.     if (XpkBase)
  444.         {
  445.         XpkError = XpkQueryTags(XPK_ModeQuery, &ModeInfo,
  446.                 XPK_PackMethod, Packer,
  447.                 XPK_PackMode, Mode,
  448.                 TAG_END);
  449.         if (XpkError)
  450.             {
  451.             alarm("%s: XpkQueryTags: %s", __FUNC__, GetXpkError(XpkError));
  452.             return;
  453.             }
  454.  
  455.         sprintf(CFText, "%3d.%01d", ModeInfo.Ratio/10, ModeInfo.Ratio % 10);
  456.  
  457.         if (GOGadgets[GDX_GONoteBook])
  458.             {
  459.             NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKModeName], GOGadgets[GDX_GONoteBook],
  460.                 GTTX_Text, ModeInfo.Description,
  461.                 TAG_END);
  462.             NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKPackRate], GOGadgets[GDX_GONoteBook],
  463.                 GTNM_Number, ModeInfo.PackSpeed,
  464.                 TAG_END);
  465.             NB_SetGadgetAttrs(GOGadgets[GDX_NBXPKUnpackRate], GOGadgets[GDX_GONoteBook],
  466.                 GTNM_Number, ModeInfo.UnpackSpeed,
  467.                 TAG_END);
  468.             NB_SetGadgetAttrs(GOGadgets[GDX_NBXPK_CF], GOGadgets[GDX_GONoteBook],
  469.                 GTTX_Text, CFText,
  470.                 TAG_END);
  471.             }
  472.         }
  473. }
  474.  
  475.  
  476. static const char *GetXpkError(ULONG XpkError)
  477. {
  478.     // XpkError ist < 0 !!!
  479.     return GetString(MSG_XPKERR_OK - XpkError);
  480. }
  481.  
  482.  
  483. static void GetOldXPKOpt(const struct BackupOptions *Opt)
  484. {
  485.     ULONG n;
  486.     char PackerName[6];
  487.     BOOL Found;
  488.  
  489.     ASSERT_VALID(Opt);
  490.  
  491.     stccpy(FinalPacker, Opt->XPKPackerName, sizeof(FinalPacker));
  492.     stccpy(Password, Opt->XPKPassword, sizeof(Password));
  493.     XPKEncrypt = Opt->XPKEncrypt;
  494.  
  495.     SplitPackerName(Opt->XPKPackerName, PackerName, &CurrentPackMode);
  496.  
  497.     for (n=0, Found=FALSE; n<PackerList.NumPackers; n++)
  498.         {
  499.         if (stricmp(PackerName, PackerList.Packer[n]) == 0)
  500.             {
  501.             CurrentPacker = n;
  502.             Found = TRUE;
  503.             break;
  504.             }
  505.         }
  506.  
  507.     if (!Found)
  508.         CurrentPackMode = NO_PACKER;
  509. }
  510.  
  511.  
  512. static void SplitPackerName(const char *CompleteName, char *Packer, ULONG *Mode)
  513. {
  514.     ULONG n;
  515.  
  516.     ASSERT_VALID(CompleteName);
  517.     ASSERT_VALID(Packer);
  518.     ASSERT_VALID(Mode);
  519.  
  520.     for (n=0; n<6 && CompleteName[n] && CompleteName[n] != '.';
  521.             n++)
  522.         Packer[n] = CompleteName[n];
  523.     Packer[n] = '\0';
  524.  
  525.     *Mode = 0;
  526.  
  527.  
  528.     while (*CompleteName && *CompleteName != '.')
  529.         CompleteName++;
  530.  
  531.     if ('.' == *CompleteName)
  532.         *Mode = atoi(++CompleteName);
  533. }
  534.  
  535.  
  536. // liefert die typische Kompressionsrate für den gewählten Packer in % (0...100)
  537. ULONG GetCompressionRatio(const char *Packer)
  538. {
  539.     char PackerName[6];
  540.     ULONG PackMode;
  541.     struct XpkMode ModeInfo;
  542.     ULONG XpkError;
  543.  
  544.     ASSERT_VALID(Packer);
  545.     ASSERT_VALID(XpkBase);
  546.  
  547.     SplitPackerName(Packer, PackerName, &PackMode);
  548.  
  549.     XpkError = XpkQueryTags(XPK_ModeQuery, &ModeInfo,
  550.             XPK_PackMethod, PackerName,
  551.             XPK_PackMode, PackMode,
  552.             TAG_END);
  553.     if (XpkError)
  554.         {
  555.         alarm("%s: XpkQueryTags: %s", __FUNC__, GetXpkError(XpkError));
  556.         return 100l;
  557.         }
  558.  
  559.     return (ULONG) (100l - (ModeInfo.Ratio / 10l));
  560. }
  561.  
  562.  
  563. BOOL XPKInitCompress(void)
  564. {
  565.     if (PackOutBuffer == NULL)
  566.         {
  567.         PackOutBufferSize = max(globDrvDat.CylSize, PACKBUFFERSIZE);
  568.         MaxInLen = (32 * (PackOutBufferSize - 2 * XPK_MARGIN)) / 33;
  569.         PackOutBuffer = (unsigned char *) calloc(PackOutBufferSize, 1);
  570.         }
  571.  
  572.     if (NULL == PackOutBuffer)
  573.         return FALSE;
  574.  
  575.     return TRUE;
  576. }
  577.  
  578.  
  579. void XPKCompressFile(struct NameField *info, size_t fsize)
  580. {
  581.     size_t ChunkLen, PackedLen;
  582.     struct Hook XPKInHook;
  583.     ULONG XPKError;
  584.     struct TagItem XpkInTags[2];
  585.  
  586.     ASSERT_VALID(info);
  587.  
  588.     if (NULL == XpkBase)
  589.         {
  590.         alarm(GetString(MSG_XPK_NOLIBRARY));
  591.         myabort(15);
  592.         }
  593.  
  594.     // Input für XPK festlegen
  595.     if (info->isPartition)
  596.         {
  597.         XPKInHook.h_Data = NULL;
  598.         XPKInHook.h_Entry = (unsigned long (*)()) XPKInFunc;
  599.  
  600.         XpkInTags[0].ti_Tag = XPK_InHook;
  601.         XpkInTags[0].ti_Data = (ULONG) &XPKInHook;
  602.         }
  603.     else
  604.         {
  605.         XpkInTags[0].ti_Tag = XPK_InFH;
  606.         XpkInTags[0].ti_Data = aktReadFileHandle;
  607.         }
  608.  
  609.     XpkInTags[1].ti_Tag = TAG_END;
  610.  
  611.     while (fsize)
  612.         {
  613.         ChunkLen = min(fsize, MaxInLen);
  614.  
  615.         XPKError = XpkPackTags(
  616.             XPK_InLen, ChunkLen,
  617.             XPK_ChunkSize, ChunkLen,
  618.             XPK_OutBuf, PackOutBuffer,
  619.             XPK_OutBufLen, PackOutBufferSize,
  620.             XPK_GetOutLen, &PackedLen,
  621.             XPK_PackMethod, myOptions.XPKPackerName,
  622.             XPK_StepDown, TRUE,
  623.             XPK_PassThru, TRUE,
  624.             XPK_Password, myOptions.XPKEncrypt ? myOptions.XPKPassword : NULL,
  625.             TAG_MORE, &XpkInTags,
  626.             TAG_END);
  627.  
  628.         if (XPKError)
  629.             {
  630.             alarm("%s: XpkPackTags: %s", __FUNC__, GetXpkError(XPKError));
  631.             break;
  632.             }
  633.  
  634.         BufferWrite(&info, PackOutBuffer, PackedLen);
  635.         fsize -= ChunkLen;
  636.  
  637.         BytesProcessed += ChunkLen;
  638.  
  639.         UpdateFileDisplay();    // update Byte & File Count
  640.         }
  641. }
  642.  
  643.  
  644. static ULONG __saveds __asm XPKInFunc(register __a0 struct Hook *theHook,
  645.         register __a1 struct XpkIOMsg *Msg,
  646.         register __a2 APTR Dummy)
  647. {
  648.     switch (Msg->Type)
  649.         {
  650.     case XIO_FREE:
  651.         d(printf("XIO_FREE Ptr=%08lx  Size=%ld\n", Msg->Ptr, Msg->Size);)
  652.         break;
  653.     case XIO_ABORT:
  654.         d(printf("XIO_ABORT Ptr=%08lx  Size=%ld\n", Msg->Ptr, Msg->Size);)
  655.         break;
  656.     case XIO_READ:
  657.         if (NULL == Msg->Ptr)
  658.             {
  659.             if (!PackInBuffer || Msg->Size > PackInBufferSize)
  660.                 {
  661.                 PackInBufferSize = Msg->Size;
  662.                 PackInBuffer = realloc(PackInBuffer, PackInBufferSize);
  663.                 if (NULL == PackInBuffer)
  664.                     {
  665.                     alarm(GetString(MSG_OUTOFMEMORY), __FUNC__, "PackInBuffer", PackInBufferSize);
  666.                     return -1L;
  667.                     }
  668.                 }
  669.             Msg->Ptr = PackInBuffer;
  670.             }
  671.  
  672.         d(printf("XIO_READ Ptr=%08lx  Size=%ld\n", Msg->Ptr, Msg->Size);)
  673.         if (Msg->Size != ReadPartition(&Root_pInfo, Msg->Size, Msg->Ptr))
  674.             return ~0l;
  675.         break;
  676.     default:
  677.         d(printf("Type=%ld\n", Msg->Type);)
  678.         break;
  679.         }
  680.  
  681.     return 0l;
  682. }
  683.  
  684.  
  685. static void GetPwdRender( void )
  686. {
  687.     struct IntuiText it;
  688.     UWORD    cnt;
  689.  
  690.     GetPwdIText[0].IText = (STRPTR) GetString(MSG_GETPASSWORD_GAD);
  691.  
  692.     for ( cnt = 0; cnt < GetPwd_TNUM; cnt++ )
  693.         {
  694.         it = GetPwdIText[cnt];
  695.         it.ITextFont = WBScreen->Font;
  696.         it.LeftEdge  = (GetPwdWnd->Width - IntuiTextLength( &it )) / 2;
  697.         it.TopEdge   = OffY + ComputeY( it.TopEdge ) - ( WBScreen->Font->ta_YSize / 2);
  698.  
  699.         PrintIText( GetPwdWnd->RPort, &it, 0, 0 );
  700.         }
  701. }
  702.  
  703.  
  704. // Paßwort für Verschlüsselung anfordern
  705. BOOL CheckPassword(struct BackupOptions *Opt)
  706. {
  707.     struct Gadget *g;
  708.     UWORD ww, wh;
  709.  
  710.     if (COMPRESS_XPK != Opt->bo_Compress || !Opt->XPKEncrypt || strlen(Opt->XPKPassword) > 0)
  711.         return TRUE;
  712.  
  713.     SignalUnIconifyMainWindow();
  714.  
  715.     GetPwdOptions = Opt;
  716.     GetPwdResult = FALSE;
  717.  
  718.     CreateGadgetShort(&GetPwdGadgetShort);
  719.  
  720.     CalcGadgetScale(WBScreen, ScreenFont, &FontX, &FontY, &OffX, &OffY, 8, 11);
  721.  
  722.     ww = ComputeX( GetPwdWidth );
  723.     wh = ComputeY( GetPwdHeight );
  724.  
  725.     g = CreateGadgetList(&GetPwdGList, GetPwd_CNT,
  726.             WBScreen->Font,
  727.             GetPwdGTypes,
  728.             GetPwdNGad,
  729.             GetPwdGadgets,
  730.             GetPwdGTags,
  731.             GetPwdGadgetShort,
  732.             &GetPwdResourceList,
  733.             FontX, FontY,
  734.             OffX, OffY
  735.             );
  736.     if (NULL == g)
  737.         {
  738.         alarm(GetString(MSG_CREATEGAD_FAILED), __FUNC__);
  739.         return FALSE;
  740.         }
  741.  
  742.     WindowBusy(aktWindow, TRUE);
  743.  
  744.     ww += OffX + aktWindow->WScreen->WBorRight;
  745.     wh += OffY + aktWindow->WScreen->WBorBottom;
  746.  
  747.     assert(ww > 20 && wh > 20);
  748.  
  749.     GetPwdWnd = OpenWindowTags( NULL,
  750.                 WA_Left,    aktWindow->WScreen->MouseX - ww/2,
  751.                 WA_Top,        aktWindow->WScreen->MouseY - wh/2,
  752.                 WA_Width,    ww,
  753.                 WA_Height,    wh,
  754.                 WA_IDCMP,    STRINGIDCMP|BUTTONIDCMP
  755.                     |IDCMP_GADGETDOWN|IDCMP_CLOSEWINDOW
  756.                     |IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW
  757.                     |IDCMP_MENUHELP|IDCMP_GADGETHELP
  758.                     |IDCMP_VANILLAKEY|IDCMP_RAWKEY,
  759.                 WA_Flags,    WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  760.                 WA_Gadgets,    GetPwdGList,
  761.                 WA_Title,    GetString(MSG_GETPWDWINDOW_TITLE),
  762.                 WA_PubScreen,    aktWindow->WScreen,
  763.                 WA_AutoAdjust,    TRUE,
  764.                 WA_HelpGroup,    BackupHelpGroup,
  765.                 WA_MenuHelp,    TRUE,
  766.                 WA_NewLookMenus, TRUE,
  767.                 TAG_DONE );
  768.  
  769.     if (NULL == GetPwdWnd)
  770.         {
  771.         WindowBusy(aktWindow, FALSE);
  772.         CloseGetPwdWindow();
  773.  
  774.         alarm(GetString(MSG_CANNOT_OPEN_WINDOW), __FUNC__, "GetPwdWnd");
  775.         return FALSE;
  776.         }
  777.  
  778.     GT_RefreshWindow( GetPwdWnd, NULL );
  779.     GetPwdRender();
  780.  
  781.     ActivateGadget(GetPwdGadgets[GDX_PwdGadget], GetPwdWnd, NULL);
  782.  
  783.     PwdInput = AddBInputHandler(1 << GetPwdWnd->UserPort->mp_SigBit, PwdIDCMPHandler);
  784.  
  785.     GetPwdGadgetShortHook.h_Data = Opt;
  786.  
  787.     do    {
  788.         eingabe(0l);
  789.         } while (GetPwdWnd);
  790.  
  791.     WindowBusy(aktWindow, FALSE);
  792.  
  793.     if (Opt->bo_Iconify)
  794.         IconifyMainWindow();        // aktWindow nach Paßwort-Abfrage wieder ikonifizieren
  795.  
  796.     return GetPwdResult;
  797. }
  798.  
  799.  
  800. static void CloseGetPwdWindow(void)
  801. {
  802.     RemBInputHandler(&PwdInput);
  803.  
  804.     SafeCloseWindow(&GetPwdWnd);
  805.     if (GetPwdGList)
  806.         {
  807.         FreeGadgets( GetPwdGList );
  808.         GetPwdGList = NULL;
  809.         }
  810.     FreeBResources(&GetPwdResourceList);
  811.     DestroyGadgetShort(&GetPwdGadgetShort);
  812. }
  813.  
  814.  
  815. static int PwdIDCMPHandler(void)
  816. {
  817.     struct IntuiMessage *msg;
  818.     long Result = 0;
  819.  
  820.     while (GetPwdWnd && (msg = GT_GetIMsg(GetPwdWnd->UserPort)) )
  821.         {
  822.         ULONG class;
  823.         USHORT code;
  824.         APTR Address;
  825.  
  826.         class = msg->Class;
  827.         code = msg->Code;
  828.         Address = msg->IAddress;
  829.  
  830.         GT_ReplyIMsg(msg);
  831.  
  832.         switch (class)
  833.             {
  834.         case IDCMP_ACTIVEWINDOW:
  835.             activeWindow = GetPwdWnd;
  836.             SetHelpPointer(activeWindow, HelpActive);
  837.             break;
  838.  
  839.         case IDCMP_GADGETHELP:
  840.             if (Address == NULL)
  841.                 {
  842.                 // Nicht über unserem Window
  843.                 }
  844.             else if (Address == GetPwdWnd)
  845.                 {
  846.                 // über dem Window
  847.                 CallHelp(HELPID_PWDWINDOW, TRUE);
  848.                 }
  849.             else
  850.                 CallHelp(((struct Gadget *) Address)->GadgetID, TRUE);
  851.             break;
  852.  
  853.         case IDCMP_GADGETUP:
  854.             Result = HandleGetPwdGadget((struct Gadget *) Address, code, GetPwdOptions);
  855.             break;
  856.  
  857.         case IDCMP_VANILLAKEY:
  858.             Result = HandleGadgetShort(GetPwdGadgetShort, GetPwdWnd, code, &GetPwdGadgetShortHook);
  859.             break;
  860.  
  861.         case IDCMP_RAWKEY:
  862.             if (GADCODE_HELP == code)
  863.                 ToggleHelp();
  864.             break;
  865.  
  866.         case IDCMP_REFRESHWINDOW:
  867.             // This handling is REQUIRED with GadTools.
  868.             GT_BeginRefresh(GetPwdWnd);
  869.             GT_EndRefresh(GetPwdWnd, TRUE);
  870.             break;
  871.             }
  872.         }
  873.     return Result;
  874. }
  875.  
  876.  
  877. static void __interrupt HandleGetPwdGadgetCallback(struct Hook *hook, struct Gadget *Gad, ULONG *Code)
  878. {
  879.     struct BackupOptions *Opt;
  880.  
  881.     Opt = (struct BackupOptions *) hook->h_Data;
  882.     HandleGetPwdGadget(Gad, (USHORT) *Code, Opt);
  883. }
  884.  
  885.  
  886. static int __interrupt HandleGetPwdGadget(struct Gadget *Gad, USHORT code, struct BackupOptions *Opt)
  887. {
  888.     int Result = Gad->GadgetID;
  889.  
  890.     switch (Gad->GadgetID)
  891.         {
  892.     case GD_PwdGadget:
  893.         switch (code)
  894.             {
  895.         case GADCODE_HELP:
  896.             ToggleHelp();
  897.             Result = 0;
  898.             break;
  899.         case 0:
  900.             GetPwdResult = TRUE;
  901.             stccpy(Opt->XPKPassword, GADSTRING(GetPwdGadgets[GDX_PwdGadget]),
  902.                 XPK_PASSWORDLEN);
  903.             CloseGetPwdWindow();
  904.             break;
  905.             }
  906.         break;
  907.  
  908.     case GD_PwdOkGadget:
  909.         GetPwdResult = TRUE;
  910.         stccpy(Opt->XPKPassword, GADSTRING(GetPwdGadgets[GDX_PwdGadget]),
  911.             XPK_PASSWORDLEN);
  912.         CloseGetPwdWindow();
  913.         break;
  914.  
  915.     case GD_PwdCancelGadget:
  916.         CloseGetPwdWindow();
  917.         break;
  918.         }
  919.  
  920.     return Result;
  921. }
  922.