home *** CD-ROM | disk | FTP | other *** search
/ M.u.C.S. Disc 2000 / MUCS2000.iso / anwend / qed453 / src / prn_cfg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-04-11  |  17.1 KB  |  747 lines
  1. #include <gemx.h>
  2.  
  3. #include "global.h"
  4. #include "file.h"
  5. #include "options.h"
  6. #include "printer.h"
  7. #include "rsc.h"
  8. #include "wp-print.h"
  9.  
  10. /*
  11.  * aus cflib
  12. */
  13. extern void handle_mdial_msg(int *msg);
  14.  
  15. /*
  16.  * globale Variablen
  17. */
  18. PRN_CFG    *prn;
  19.  
  20. /*
  21.  * lokales
  22. */
  23. static int    gdos_device = 21;            /* Dev-Nummer 21 .. 30 */
  24. static char    gdos_name[80] = "";        /* Dev-Name */
  25. static int    fnt_anz;
  26. static bool    wp_config_read = FALSE;
  27.  
  28. #define CFGNAME    "pdlg.qed"            /* Name der Settings-Datei */
  29.  
  30. /* --------------------------------------------------------------------------- */
  31. bool open_printer(void)
  32. {
  33.     int    work_out[57];
  34.     int    i, p_xy[4];
  35.     bool    ret = FALSE;
  36.     
  37.     if (prn->use_pdlg)
  38.         prn->handle = v_opnprn(gl_phys_handle, prn->pdlg, work_out);
  39.     else
  40.     {
  41.         int    work_in[16];
  42.  
  43.         work_in[0] = gdos_device;
  44.         for (i=1; i < 10; i++)
  45.             work_in[i] = 1;
  46.         work_in[10] = 2;
  47.         for (i=11; i < 16; i++)
  48.             work_in[i] = 0;
  49.         v_opnwk(work_in, &prn->handle, work_out);
  50.     }
  51.     if (prn->handle)
  52.     {
  53.         fnt_anz = work_out[10] + vst_load_fonts(prn->handle, 0);
  54.     
  55.         prn->height = work_out[1];
  56.         p_xy[0] = 0;
  57.         p_xy[1] = 0;
  58.         p_xy[2] = work_out[0] - 1;
  59.         p_xy[3] = work_out[1] + 1;
  60.         vs_clip(prn->handle, TRUE, p_xy);
  61.         vswr_mode(prn->handle, MD_TRANS);
  62.         ret = TRUE;
  63.     }
  64.     return ret;
  65. }
  66.  
  67.  
  68. void close_printer(void)
  69. {
  70.     vst_unload_fonts(prn->handle, 0);
  71.     v_clswk(prn->handle);
  72. }
  73.  
  74.  
  75. static void get_fontname(int id, char *name)
  76. {
  77.     int    d;
  78.     
  79.     if (open_printer())
  80.     {
  81.         for (d = 1; d <= fnt_anz; d++)
  82.             if (vqt_name(prn->handle, d, name) == id)
  83.                 break;
  84.         close_printer();
  85.     }
  86.     else
  87.         strcpy(name, "???");
  88. }
  89.  
  90.  
  91. static bool sel_font(PRN_CFG *cfg)
  92. {
  93.     bool    ok = FALSE;
  94.     int    n_id, n_pts;
  95.     
  96.     n_id = cfg->font_id;
  97.     n_pts = cfg->font_pts;
  98.     
  99.     ok = do_fontsel((FS_M_XFSL|FS_M_MAGX), rsc_string(SELPFONTSTR), &n_id, &n_pts);
  100.     if (ok)
  101.     {
  102.         cfg->font_id = n_id;
  103.         cfg->font_pts = n_pts;
  104.         ok = TRUE;
  105.     }
  106.     else if (n_id == -1 && n_pts == -1)
  107.         note(1, 0, NOFSL);
  108.  
  109.     return ok;
  110. }
  111.  
  112. /* --------------------------------------------------------------------------- */
  113. /*
  114.  * WDIALOG
  115. */
  116.  
  117. /*
  118.  * Callbacks für Sub-Dialog
  119. */
  120. long cdecl init_qed_sub(PRN_SETTINGS *settings, PDLG_SUB *sub_dialog)
  121. {
  122.     OBJECT    *tree;
  123.     int        offset;
  124.     PRN_CFG    *cfg;
  125.     char        tmp[40];
  126.     
  127.     cfg = (PRN_CFG *)sub_dialog->private1;
  128.     tree = sub_dialog->tree;
  129.     offset = sub_dialog->index_offset;
  130.  
  131.     set_int(tree, PS_GFPTS + offset, cfg->font_pts);
  132.     get_fontname(cfg->font_id, tmp);
  133.     set_string(tree, PS_GFNAME + offset, tmp);
  134.  
  135.     set_state(tree, PS_ALL + offset, DISABLED, !cfg->ausdruck);
  136.     set_state(tree, PS_BLOCK + offset, DISABLED, (!cfg->ausdruck || !cfg->block));
  137.  
  138.     set_state(tree, PS_ALL + offset, SELECTED, !cfg->block);
  139.     set_state(tree, PS_BLOCK + offset, SELECTED, cfg->block);
  140.     
  141.     set_state(tree, PS_ZNUM + offset, SELECTED, cfg->num_zeilen);
  142.     set_state(tree, PS_SNUM + offset, SELECTED, cfg->num_seiten);
  143.     
  144.     set_int(tree, PS_RANDLEN + offset, cfg->rand_len);
  145.  
  146.     return 1;
  147. }
  148.  
  149. long cdecl do_qed_sub(PRN_SETTINGS *settings, PDLG_SUB *sub_dialog, short exit_obj)
  150. {
  151.     OBJECT    *tree;
  152.     int        offset;
  153.     PRN_CFG    *cfg;
  154.     
  155.     cfg = (PRN_CFG *)sub_dialog->private1;
  156.     tree = sub_dialog->tree;
  157.     offset = sub_dialog->index_offset;
  158.     switch (exit_obj - offset)
  159.     {
  160.         case PS_GFSEL :
  161.             if (sel_font(cfg))
  162.             {
  163.                 char    tmp[40];
  164.                 
  165.                 set_int(tree, PS_GFPTS + offset, cfg->font_pts);
  166.                 get_fontname(cfg->font_id, tmp);
  167.                 set_string(tree, PS_GFNAME + offset, tmp);
  168.                 redraw_obj(tree, PS_GFPTS + offset);
  169.                 redraw_obj(tree, PS_GFNAME + offset);
  170.             }
  171.             set_state(tree, exit_obj, SELECTED, FALSE);
  172.             redraw_obj(tree, exit_obj);
  173.             break;
  174.  
  175.         default:
  176.             break;
  177.     }
  178.     return 1;
  179. }
  180.  
  181. long cdecl reset_qed_sub(PRN_SETTINGS *settings, PDLG_SUB *sub_dialog)
  182. {
  183.     OBJECT    *tree;
  184.     int        offset;
  185.     PRN_CFG    *cfg;
  186.     
  187.     cfg = (PRN_CFG *)sub_dialog->private1;
  188.     tree = sub_dialog->tree;
  189.     offset = sub_dialog->index_offset;
  190.     
  191.     if (cfg->ausdruck)
  192.         cfg->block = get_state(tree, PS_BLOCK + offset, SELECTED);
  193.  
  194.     cfg->num_zeilen = get_state(tree, PS_ZNUM + offset, SELECTED);
  195.     cfg->num_seiten = get_state(tree, PS_SNUM + offset, SELECTED);
  196.     cfg->rand_len = get_int(tree, PS_RANDLEN + offset);
  197.  
  198.     return 1;
  199. }
  200.  
  201.  
  202. static bool pdlg_dial(PRN_CFG *cfg)
  203. {
  204.     PRN_DIALOG        *prn_dialog;
  205.     PRN_SETTINGS    *new;
  206.     int                d, button, ret, handle;
  207.     EVNT                ev;
  208.     OBJECT            *tree;
  209.     
  210.     new = malloc(sizeof(PRN_SETTINGS));
  211.     memcpy(new, cfg->pdlg, sizeof(PRN_SETTINGS));
  212.  
  213.     prn_dialog = pdlg_create(PDLG_3D);
  214.     if (prn_dialog)
  215.     {
  216.         PDLG_SUB    *sub = NULL;
  217.  
  218.         disable_menu();
  219.  
  220.         /* Unterdialog einhängen */
  221.         sub = malloc(sizeof(PDLG_SUB));
  222.         if (sub)
  223.         {
  224.             memset(sub, 0, sizeof(PDLG_SUB));
  225.             sub->sub_id = -1;
  226.             rsrc_gaddr(R_TREE, PRN_ICON, &tree);
  227.             sub->sub_icon = tree + 1;                /* Zeiger auf das Icon */
  228.             sub->sub_tree = printer_sub;            /* Zeiger auf den Unterdialog */
  229.             sub->init_dlg = init_qed_sub;            /* Initialisierungsfunktion */
  230.             sub->do_dlg = do_qed_sub;                /* Behandlungsfunktion */
  231.             sub->reset_dlg = reset_qed_sub;        /* Zurücksetzfunktion */
  232.  
  233.             sub->private1 = (long)cfg;
  234.  
  235.             pdlg_add_sub_dialogs(prn_dialog, sub);
  236.         }
  237.  
  238.         if (cfg->ausdruck)
  239.             handle = pdlg_open(prn_dialog, new, "qed", 0x0001, -1, -1);
  240.         else
  241.             handle = pdlg_open(prn_dialog, new, "qed", 0x0000, -1, -1);
  242.         do
  243.         {
  244.             ev.mwhich = (short)evnt_multi(MU_KEYBD|MU_MESAG|MU_BUTTON, 2, 1, 1, 
  245.                                                 0, 0, 0, 0, 0,    0, 0, 0, 0, 0,
  246.                                                 (int*)ev.msg, 0, 
  247.                                                 (int*)&ev.mx, (int*)&ev.my, 
  248.                                                 (int*)&ev.mbutton, 
  249.                                                 (int*)&ev.kstate,    (int*)&ev.key, 
  250.                                                 (int*)&ev.mclicks);
  251.             if (ev.mwhich & MU_MESAG)
  252.             {
  253.                 switch (ev.msg[0])
  254.                 {
  255.                     case WM_REDRAW :
  256.                     case WM_MOVED :
  257.                     case WM_SIZED:
  258.                         if (ev.msg[3] != handle)    /* für fremdes Fenster */
  259.                         {
  260.                             handle_mdial_msg((int *)ev.msg);
  261.                         }
  262.                         break;
  263.     
  264.                     case WM_BOTTOMED:                    /* nicht erlaubt! */
  265.                         break;
  266.                     
  267.                     case WM_TOPPED :
  268.                     case WM_NEWTOP :
  269.                     case WM_ONTOP :        
  270.                         ev.msg[0] = WM_TOPPED;        /* immer Druckerbox toppen! */
  271.                         ev.msg[3] = handle;
  272.                         break;
  273.                 }
  274.     
  275.             }
  276.             ret = pdlg_evnt(prn_dialog, new, &ev, &button);
  277.         } 
  278.         while (ret == 1);
  279.         
  280.         if (button == PDLG_OK)
  281.         {
  282.             memcpy(cfg->pdlg, new, sizeof(PRN_SETTINGS));
  283.             pdlg_use_settings(prn_dialog, new);
  284.         }
  285.  
  286.         pdlg_close(prn_dialog, &d, &d);
  287.  
  288.         if (sub)
  289.         {
  290.             pdlg_remove_sub_dialogs(prn_dialog);
  291.             free(sub);
  292.         }
  293.  
  294.         pdlg_delete(prn_dialog);
  295.         free(new);
  296.  
  297.         enable_menu();
  298.  
  299.         return (button == PDLG_OK);
  300.     }
  301.     return FALSE;
  302. }
  303.  
  304.  
  305. /* --------------------------------------------------------------------------- */
  306. /*
  307.  * qed-Dialog
  308. */
  309.  
  310. static void get_devinfo(int handle, int device, char *devname)
  311. {
  312.     if (gl_nvdi >= 0x300)
  313.     {
  314.         int    d;
  315.         char    s[80];
  316.  
  317.         vq_devinfo(handle, device, &d, s, devname);
  318.     }
  319.     else
  320.         sprintf(devname, "GDOS Printer %d", device);
  321. }
  322.  
  323. static bool get_gdos_device(void)
  324. {
  325.     if (gdos_device == 0 || gdos_name[0] == EOS)
  326.     {
  327.         int    work_in[16];
  328.         int    work_out[57];
  329.         int    i, handle;
  330.         
  331.         for (i=1; i < 10; i++)
  332.             work_in[i] = 1;
  333.         work_in[10] = 2;
  334.         for (i=11; i < 16; i++)
  335.             work_in[i] = 0;
  336.         for (i = 21; i < 31; i++)
  337.         {
  338.             work_in[0] = i;
  339.             v_opnwk(work_in, &handle, work_out);
  340.             if (handle > 0)
  341.             {
  342.                 gdos_device = i;
  343.                 get_devinfo(handle, i, gdos_name);
  344.                 v_clswk(handle);
  345.                 break;
  346.             }
  347.         }
  348.         gdos_name[32] = EOS;                /* mehr passt nicht in den G_STRING! */
  349.     }
  350.     return (gdos_device > 0);
  351. }
  352.  
  353.  
  354. static bool qed_cfg_dial(PRN_CFG *cfg)
  355. {
  356.     char        tmp[33];
  357.     int        antw, i;
  358.     bool        close = FALSE;
  359.     PATH        str = "";
  360.     MDIAL        *dial;
  361.     
  362.     /* GEMDOS */
  363.     switch (cfg->wp_mode)
  364.     {
  365.         case ELITE:
  366.             i = DICHTEELITE;
  367.             break;
  368.         case CONDENSED:
  369.             i = DICHTECOND;
  370.             break;
  371.         default:
  372.             i = DICHTEPICA;
  373.             break;
  374.     }
  375.     set_string(printer, DDICHTE, (char *)get_obspec(popups, i));
  376.     if (!wp_config_read && cfg->wp_treiber[0] != EOS)
  377.         wp_config_read = wp_load_cfgfile(cfg->wp_treiber);
  378.     if (wp_config_read)
  379.         wp_get_prnname(tmp, 25);
  380.     else
  381.         strcpy(tmp, rsc_string(NODEVSTR));
  382.  
  383.     set_state(printer, DNLQ, DISABLED, !wp_config_read);
  384.     set_state(printer, DDICHTE, DISABLED, !wp_config_read);
  385.     set_state(printer, DDICHTESTR, DISABLED, !wp_config_read);
  386.  
  387.     set_state(printer, DNLQ, SELECTED, cfg->wp_nlq);
  388.     set_string(printer, DTREIBNAME, tmp);
  389.     set_int(printer, DPLENGTH, cfg->wp_s_len);
  390.     set_int(printer, DPWIDTH, cfg->wp_z_len);
  391.  
  392.     /* GDOS */
  393.     if (gl_gdos && get_gdos_device())
  394.     {
  395.         set_string(printer, DDEVICE, gdos_name);
  396.         set_state(printer, DDEVICE, DISABLED, FALSE);
  397.         set_state(printer, DFONTSEL, DISABLED, FALSE);
  398.  
  399.         set_int(printer, DPTS, cfg->font_pts);
  400.         get_fontname(cfg->font_id, tmp);
  401.         set_string(printer, DFONT, tmp);
  402.     }
  403.     else
  404.     {
  405.         set_string(printer, DDEVICE, rsc_string(NODEVSTR));
  406.         set_state(printer, DDEVICE, DISABLED, TRUE);
  407.         set_state(printer, DFONTSEL, DISABLED, TRUE);
  408.         set_string(printer, DFONT, "--");
  409.         set_string(printer, DPTS, "--");
  410.     }
  411.  
  412.     dial = open_mdial(printer, DPLENGTH);
  413.     if (dial != NULL)
  414.     {
  415.         while (!close)
  416.         {
  417.             antw = do_mdial(dial) & 0x7fff;
  418.             switch (antw)
  419.             {
  420.                 case DFONTSEL:
  421.                     if (sel_font(cfg))
  422.                     {
  423.                         set_int(printer, DPTS, cfg->font_pts);
  424.                         get_fontname(cfg->font_id, tmp);
  425.                         set_string(printer, DFONT, tmp);
  426.                     }
  427.                     break;
  428.         
  429.                 case DTREIBER :
  430.                     if (select_single(cfg->wp_treiber, "*.cfg", rsc_string(TREIBERSTR)))
  431.                     {
  432.                         wp_config_read = wp_load_cfgfile(cfg->wp_treiber);
  433.                         if (wp_config_read)
  434.                             wp_get_prnname(str, 25);
  435.                         else
  436.                             strcpy(str, rsc_string(NODEVSTR));
  437.                         set_string(printer, DTREIBNAME, str);
  438.                         redraw_mdobj(dial, DTREIBNAME);
  439.                         set_state(printer, DNLQ, DISABLED, !wp_config_read);
  440.                         redraw_mdobj(dial, DNLQ);
  441.                         set_state(printer, DDICHTE, DISABLED, !wp_config_read);
  442.                         redraw_mdobj(dial, DDICHTE);
  443.                         set_state(printer, DDICHTESTR, DISABLED, !wp_config_read);
  444.                         redraw_mdobj(dial, DDICHTESTR);
  445.                     }
  446.                     set_state(printer, antw, SELECTED, FALSE);
  447.                     break;
  448.         
  449.                 case DDICHTESTR :
  450.                 case DDICHTE :
  451.                     if (antw == DDICHTE)
  452.                         i = handle_popup(printer, DDICHTE, popups, DICHTEPOP, POP_OPEN);
  453.                     else
  454.                         i = handle_popup(printer, DDICHTE, popups, DICHTEPOP, POP_CYCLE);
  455.                     if (i > 0)
  456.                         cfg->wp_mode = i - DICHTEPICA;
  457.                     break;
  458.         
  459.                 default:
  460.                     close = TRUE;
  461.                     break;
  462.             }
  463.             set_state(printer, antw, SELECTED, FALSE);
  464.             if (!close)
  465.                 redraw_mdobj(dial, antw);
  466.  
  467.         }
  468.         close_mdial(dial);
  469.         set_state(printer, antw, SELECTED, FALSE);
  470.         if (antw == DOK2)
  471.         {
  472.             cfg->wp_s_len = get_int(printer, DPLENGTH);
  473.             if (!cfg->wp_s_len)
  474.                 cfg->wp_s_len = 65;
  475.     
  476.             cfg->wp_z_len = get_int(printer, DPWIDTH);
  477.             if (!cfg->wp_z_len)
  478.                 cfg->wp_z_len = 80;
  479.     
  480.             cfg->wp_nlq = get_state(printer, DNLQ, SELECTED);
  481.             return TRUE;
  482.         }
  483.     }
  484.     return FALSE;
  485. }
  486.  
  487. static bool qed_start_dial(PRN_CFG *cfg)
  488. {
  489.     int    antw;
  490.     bool    start = FALSE;
  491.     
  492.     if (!wp_config_read && prn->wp_treiber[0] != EOS)
  493.         wp_config_read = wp_load_cfgfile(prn->wp_treiber);
  494.  
  495.     if (gl_gdos && (gdos_device == 0))
  496.         get_gdos_device();
  497.  
  498.     /* Allgemeine Parameter */
  499.     set_state(print, DZNUM, SELECTED, prn->num_zeilen);
  500.     set_state(print, DSNUM, SELECTED, prn->num_seiten);
  501.     set_state(print, DFEED, SELECTED, prn->vorschub);
  502.     set_state(print, DCHECK, SELECTED, prn->pruef_prn);
  503.     set_state(print, DALL, SELECTED, !prn->block);
  504.     set_state(print, DBLOCK, DISABLED, !prn->block);
  505.     set_state(print, DBLOCK, SELECTED, prn->block);
  506.     set_int(print, DRANDLEN, prn->rand_len);
  507.  
  508.     set_state(print, DGEMDOS, SELECTED, !prn->use_gdos);
  509.     set_state(print, DGDOS, SELECTED, prn->use_gdos);
  510.  
  511.     set_state(print, DGDOS, DISABLED, (gdos_device == 0));
  512.     set_state(print, DGDOS, SELECTED, ((gdos_device != 0) && (prn->use_gdos || !wp_config_read)));
  513.  
  514.     set_state(print, DGEMDOS, DISABLED, !wp_config_read);
  515.     set_state(print, DGEMDOS, SELECTED, (wp_config_read && !prn->use_gdos));
  516.  
  517.     set_state(print, DPRINT, DISABLED, (!wp_config_read && (gdos_device == 0)));
  518.     
  519.     antw = simple_mdial(print, DRANDLEN) & 0x7fff;
  520.     if ((antw == DOK1) || (antw == DPRINT))
  521.     {
  522.         prn->block = get_state(print, DBLOCK, SELECTED);
  523.         prn->use_gdos = get_state(print, DGDOS, SELECTED);
  524.         prn->num_zeilen = get_state(print, DZNUM, SELECTED);
  525.         prn->num_seiten = get_state(print, DSNUM, SELECTED);
  526.         prn->vorschub = get_state(print, DFEED, SELECTED);
  527.         prn->pruef_prn = get_state(print, DCHECK, SELECTED);
  528.         prn->rand_len = get_int(print, DRANDLEN);
  529.  
  530.         start = (antw == DPRINT);
  531.     }
  532.     return start;
  533. }
  534.  
  535. /* --------------------------------------------------------------------------- */
  536. /*
  537.  * Schnittstelle nach drau₧en
  538. */
  539. void prn_cfg_dial(void)
  540. {
  541.     bool        ok;
  542.     PRN_CFG    *new;
  543.     
  544.     prn->ausdruck = FALSE;                    /* Art des Dialogs: Konfig */
  545.     new = malloc(sizeof(PRN_CFG));
  546.     memcpy(new, prn, sizeof(PRN_CFG));
  547.     
  548.     if (prn->use_pdlg)
  549.         ok = pdlg_dial(new);
  550.     else
  551.         ok = qed_cfg_dial(new);
  552.     if (ok)
  553.     {
  554.         memcpy(prn, new, sizeof(PRN_CFG));
  555.     }
  556.     free(new);
  557. }
  558.  
  559. bool prn_start_dial(bool *block)
  560. {
  561.     bool    ok = FALSE;
  562.  
  563.     prn->ausdruck = TRUE;                    /* Art des Dialogs: Ausdruck */
  564.     if (block)
  565.         prn->block = *block;
  566.     else
  567.         prn->block = FALSE;
  568.  
  569.     if (prn->use_pdlg)
  570.     {
  571.         PRN_CFG    *new;
  572.         
  573.         prn->use_gdos = TRUE;
  574.         new = malloc(sizeof(PRN_CFG));
  575.         memcpy(new, prn, sizeof(PRN_CFG));
  576.         ok = pdlg_dial(new);
  577.         if (ok)
  578.             memcpy(prn, new, sizeof(PRN_CFG));
  579.         free(new);
  580.     }
  581.     else
  582.         ok = qed_start_dial(prn);
  583.  
  584.     if (block && ok)
  585.         *block = prn->block;
  586.  
  587.     return ok;
  588. }
  589.  
  590.  
  591. void prn_save_cfg(char *buffer)
  592. {
  593.     /* pdlg-Settings */
  594.     if (prn->pdlg != NULL)
  595.     {
  596.         char    *pdlg_file, *p;
  597.         FILE    *fd;
  598.                 
  599.         pdlg_file = strdup(buffer);
  600.         p = strrchr(pdlg_file, '\\');
  601.         if (p)
  602.             strcpy(p+1, CFGNAME);
  603.         else
  604.             strcpy(pdlg_file, CFGNAME);
  605.         fd = fopen(pdlg_file, "wb");
  606.         if (fd)
  607.         {
  608.             fwrite(prn->pdlg, 1, sizeof(PRN_SETTINGS), fd);
  609.             fclose(fd);
  610.         }
  611.         free(pdlg_file);
  612.     }    
  613.     /* sonstige Einstellungen */
  614.     write_cfg_bool("PrnCheck", prn->pruef_prn);
  615.     write_cfg_int("PrnDensity", prn->wp_mode);
  616.     write_cfg_str("PrnDriver", prn->wp_treiber);
  617.     write_cfg_int("PrnFontId", prn->font_id);
  618.     write_cfg_int("PrnFontSize", prn->font_pts);
  619.     write_cfg_bool("PrnFormfeed", prn->vorschub);
  620.     write_cfg_bool("PrnGdos", prn->use_gdos);
  621.     write_cfg_bool("PrnLineNumers", prn->num_zeilen);
  622.     write_cfg_int("PrnMarginLen", prn->rand_len);
  623.     write_cfg_bool("PrnNlq", prn->wp_nlq);
  624.     write_cfg_int("PrnPageHeight", prn->wp_s_len);
  625.     write_cfg_bool("PrnPageNumbers", prn->num_seiten);    
  626.     write_cfg_int("PrnPageWidth", prn->wp_z_len);
  627.     write_cfg_bool("PrnPdlg", prn->use_pdlg);
  628. }
  629.  
  630. bool prn_get_cfg(char *var, char *buffer)
  631. {
  632.     bool    ret = TRUE;
  633.  
  634.     if (var[0] != 'P')
  635.         ret = FALSE;
  636.  
  637.     else if (strcmp(var, "PrnCheck") == 0)
  638.         read_cfg_bool(buffer, &prn->pruef_prn);
  639.     else if(strcmp(var, "PrnDensity") == 0)
  640.         prn->wp_mode = atoi(buffer);
  641.     else if(strcmp(var, "PrnDriver") == 0)
  642.         read_cfg_str(buffer, prn->wp_treiber);
  643.     else if(strcmp(var, "PrnFontId") == 0)
  644.         prn->font_id = atoi(buffer);
  645.     else if(strcmp(var, "PrnFontSize") == 0)
  646.         prn->font_pts = atoi(buffer);
  647.     else if (strcmp(var, "PrnFormfeed") == 0)
  648.         read_cfg_bool(buffer, &prn->vorschub);
  649.     else if(strcmp(var, "PrnGdos") == 0)
  650.         read_cfg_bool(buffer, &prn->use_gdos);
  651.     else if (strcmp(var, "PrnLineNumers") == 0)
  652.         read_cfg_bool(buffer, &prn->num_zeilen);
  653.     else if (strcmp(var, "PrnMarginLen") == 0)
  654.         prn->rand_len = atoi(buffer);
  655.     else if(strcmp(var, "PrnNlq") == 0)
  656.         read_cfg_bool(buffer, &prn->wp_nlq);
  657.     else if(strcmp(var, "PrnPageHeight") == 0)
  658.         prn->wp_s_len = atoi(buffer);
  659.     else if (strcmp(var, "PrnPageNumbers") == 0)
  660.         read_cfg_bool(buffer, &prn->num_seiten);
  661.     else if(strcmp(var, "PrnPageWidth") == 0)
  662.         prn->wp_z_len = atoi(buffer);
  663.     else if(strcmp(var, "PrnPdlg") == 0)
  664.         read_cfg_bool(buffer, &prn->use_pdlg);
  665.  
  666.     /* Spezial-Fall: 'pdlg.qed' laden: in <buffer> ist der Pfad 'drin */
  667.     else if(strcmp(var, "PdlgRead") == 0)
  668.     {
  669.         char    *pdlg_file, *p;
  670.         FILE    *fd;
  671.                 
  672.         pdlg_file = strdup(buffer);
  673.         p = strrchr(pdlg_file, '\\');
  674.         strcpy(p+1, CFGNAME);
  675.         fd = fopen(pdlg_file, "rb");
  676.         if (fd)
  677.         {
  678.             fread(prn->pdlg, 1, sizeof(PRN_SETTINGS), fd);
  679.             fclose(fd);
  680.         }
  681.  
  682.         /* wenn kein WDIALOG da ist, auch nicht benutzen! */
  683.         if (!prn->pdlg_avail && prn->use_pdlg)
  684.             prn->use_pdlg = FALSE;
  685.  
  686.         free(pdlg_file);
  687.     }
  688.  
  689.     else
  690.         ret = FALSE;
  691.  
  692.     return ret;
  693. }
  694.  
  695.  
  696. void init_printer(void)
  697. {
  698.     prn = malloc(sizeof(PRN_CFG));
  699.     if (prn)
  700.     {
  701.         int    d, i;
  702.  
  703.         memset(prn, 0, sizeof(PRN_CFG));
  704.         prn->wp_s_len = 65;
  705.         prn->wp_z_len = 80;
  706.         prn->font_id = 1;
  707.         prn->font_pts = 10;    
  708.  
  709.         /* Ist WDialog installiert? */    
  710.         prn->pdlg_avail = (appl_xgetinfo(7, &i, &d, &d, &d) && ((i & 0x17) == 0x17));
  711.         if (prn->pdlg_avail)
  712.         {
  713.             PRN_DIALOG    *pd;
  714.     
  715.             /* Settings anlegen und default'en */
  716.             pd = pdlg_create(0);
  717.             if (pd)
  718.             {
  719.                 prn->pdlg = pdlg_new_settings(pd);
  720.                 pdlg_delete(pd);
  721.             }
  722.             else
  723.                 prn->pdlg_avail = FALSE;
  724.         }
  725.  
  726.         if (!prn->pdlg_avail)
  727.         {
  728.             /* damit die CFG erhalten bleibt! */
  729.             prn->pdlg = malloc(sizeof(PRN_SETTINGS));
  730.             memset(prn->pdlg, 0, sizeof(PRN_SETTINGS));
  731.         }
  732.     }
  733. }
  734.  
  735. void term_printer(void)
  736. {
  737.     if (prn)
  738.     {
  739.         if (prn->pdlg_avail)
  740.             pdlg_free_settings(prn->pdlg);
  741.         else
  742.             free(prn->pdlg);
  743.         free(prn);
  744.         prn = NULL;
  745.     }
  746. }
  747.