home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / window / omega2 / omio.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-25  |  10.3 KB  |  505 lines
  1. //
  2. // *************************************************************************
  3. // *                                                                       *
  4. // *    OMEGA C++ Windowing Class Library                                  *
  5. // *    =================================                                  *
  6. // *                                                                       *
  7. // *    Copyright 1991,92 Tom Clancy                                       *
  8. // *    Submitted to the public domain, April 1992                         *
  9. // *                                                                       *
  10. // *************************************************************************
  11. // *                                                                       *
  12. // *    IO Screen Prompt Methods                                           *
  13. // *                                                                       *
  14. // *************************************************************************
  15. //
  16.  
  17.  
  18. #include <string.h>
  19. #include <dos.h>
  20. #include <conio.h>
  21. #include "omio.hpp"
  22.  
  23. oIO::oIO() {
  24.   Done=FALSE;
  25.   Cursor=0;
  26.   InsertMode=ON;
  27.   Pointer=0;
  28.   IOFillchar=32;
  29.   Accepted=FALSE;
  30.   Canescape=TRUE;
  31.   Current=1;
  32.   Donekey=F10;
  33.   MessX=0;
  34.   MessY=0;
  35.   Nf=0;
  36.   Pfg=WHITE;
  37.   Pbk=BLUE;
  38.   Ffg=BLACK;
  39.   Fbk=LIGHTGRAY;
  40.   Cfg=WHITE;
  41.   Cbk=RED;
  42.   Mfg=WHITE;
  43.   Mbk=BLUE;
  44.   Fstartx=1;
  45.   UpperMode=TRUE;
  46. }
  47.  
  48. oIO::~oIO() {
  49.   register int i;
  50.   for(i=1; i<=Nf; i++) {
  51.     delete Field[i]->prompt;
  52.     delete Field[i]->message;
  53.     delete Field[i]->info;
  54.     delete Field[i];
  55.   }
  56. }
  57.  
  58. void oIO::setIO(int pfg, int pbk, int ffg, int fbk, int cfg, int cbk,
  59.         int mfg, int mbk, int messx, int messy) {
  60.  
  61.   Pfg=pfg;
  62.   Pbk=pbk;
  63.   Ffg=ffg;
  64.   Fbk=fbk;
  65.   Cfg=cfg;
  66.   Cbk=cbk;
  67.   Mfg=mfg;
  68.   Mbk=mbk;
  69.   MessX=messx;
  70.   MessY=messy;
  71. }
  72.  
  73. void oIO::addfield(int x, int y, int len, int nextf, int prevf, char *p, char *m) {
  74.  
  75.   Nf++;
  76.   if(Nf>255)
  77.     Nf=255;
  78.   else
  79.   if(numfields()<=255) {
  80.     Field[Nf] = new field;
  81.     Field[Nf]->message=new char[strlen(m)+1];
  82.     if(strlen(m))
  83.       strcpy(Field[Nf]->message,m);
  84.     else
  85.       Field[Nf]->message[0]='\0';
  86.     Field[Nf]->prompt=new char[strlen(p)+1];
  87.     if(strlen(p))
  88.       strcpy(Field[Nf]->prompt,p);
  89.     else
  90.       Field[Nf]->prompt[0]='\0';
  91.     Field[Nf]->info=new char[len+1];
  92.     Field[Nf]->info[0]='\0';
  93.     Field[Nf]->x=x;
  94.     Field[Nf]->y=y;
  95.     Field[Nf]->len=len;
  96.     Field[Nf]->next=nextf;
  97.     Field[Nf]->prev=prevf;
  98.     Field[Nf]->Ffg=Ffg;
  99.     Field[Nf]->Fbk=Fbk;
  100.   }
  101.  
  102. }
  103.  
  104. int  oIO::insertstr(char *s, char c, int pos) {
  105.  
  106.  register int i;
  107.  
  108.  if(UpperMode)
  109.    c=upcase(c);
  110.  
  111.  if(pos>=0 && pos<=strlen(s)) {
  112.    if(strlen(s) < Field[Current]->len) {
  113.      for(i=strlen(s); i>=pos; i--)
  114.        s[i+1]=s[i];
  115.        s[pos]=c;
  116.        return 1;
  117.    }
  118.    else
  119.      if(strlen(s)==Field[Current]->len) {
  120.        for(i=strlen(s)-1; i>=pos; i--)
  121.      s[i+1]=s[i];
  122.        s[pos]=c;
  123.        s[Field[Current]->len]='\0';
  124.        return 1;
  125.      }
  126.  }
  127.  return 0;
  128. }
  129.  
  130. int  oIO::overtpstr(char *s, char c, int pos) {
  131.  
  132.  if(UpperMode)
  133.    c=upcase(c);
  134.  
  135.  if(strlen(s))
  136.    if(pos<strlen(s)) {
  137.      s[pos]=c;
  138.      return 1;
  139.    }
  140.  return 0;
  141. }
  142.  
  143. int  oIO::deletestr(char *s, int pos) {
  144.  
  145.   register int i;
  146.   if(strlen(s)) {
  147.     if(pos>=0 && pos<=strlen(s)) {
  148.       for(i=pos; i<=strlen(s); i++)
  149.     s[i]=s[i+1];
  150.       return 1;
  151.     }
  152.   }
  153.   return 0;
  154. }
  155.  
  156.  
  157. void oIO::clearfield(int f) {
  158.   fillarea(Field[f]->x+strlen(Field[f]->prompt),Field[f]->y,Field[f]->x+strlen(Field[f]->prompt)+Field[f]->len-1,Field[f]->y,Field[f]->Ffg,Field[f]->Fbk,IOFillchar);
  159. }
  160.  
  161. void oIO::showfield(int f) {
  162.   clearfield(f);
  163.   if(strlen(Field[f]->info))
  164.     writeat(Fstartx,Field[f]->y,Field[f]->Ffg,Field[f]->Fbk,Field[f]->info);
  165. }
  166.  
  167. void oIO::goendstr() {
  168.   Cursor=Fstartx+strlen(Field[Current]->info);
  169.   if(Cursor>Fstartx+Field[Current]->len-1)
  170.     Cursor=Fstartx+Field[Current]->len-1;
  171.   Pointer=strlen(Field[Current]->info);
  172.   movexy(Cursor,Field[Current]->y);
  173.   if(InsertMode) linecursor();
  174.   else blockcursor();
  175. }
  176.  
  177. void oIO::gohomestr() {
  178.   Pointer=0;
  179.   Cursor=Fstartx;
  180.   movexy(Cursor,Field[Current]->y);
  181.   if(InsertMode) linecursor();
  182.   else blockcursor();
  183. }
  184.  
  185. int  oIO::withinIO() {
  186.   return (buttonx()>=Fstartx &&
  187.       buttonx()<=Fstartx+strlen(Field[Current]->info) &&
  188.       buttony()==Field[Current]->y);
  189. }
  190.  
  191. char *oIO::getfield(int fn) {
  192.   if(fn && fn<=Nf)
  193.     return Field[fn]->info;
  194.   else
  195.     return NULL;
  196. }
  197.  
  198. void oIO::setfield(char *s, int fn) {
  199.   delete Field[fn]->info;
  200.   Field[fn]->info=new char[strlen(s)+1];
  201.   strcpy(Field[fn]->info,s);
  202. }
  203.  
  204. char *oIO::getmessage(int mn) {
  205.   if(mn && mn<=Nf)
  206.     return Field[mn]->message;
  207.   else
  208.     return NULL;
  209. }
  210.  
  211. void oIO::display_message() {
  212.   if(strlen(Field[Current]->message))
  213.     writeat(MessX,MessY,Mfg,Mbk,Field[Current]->message);
  214.  
  215. }
  216.  
  217. void oIO::clear_message() {
  218.   if(strlen(Field[Current]->message))
  219.     clearline(MessY,MessX,MessX+strlen(Field[Current]->message),Mfg,getbkcolor());
  220. }
  221.  
  222. void oIO::display_field(int fn) {
  223.   if(fn && fn<=Nf) {
  224.     Cursor=Field[fn]->x+strlen(Field[fn]->prompt);
  225.     Fstartx=Cursor;
  226.     clearfield(fn);
  227.     writeat(Field[fn]->x,Field[fn]->y,Pfg,Pbk,Field[fn]->prompt);
  228.     if(strlen(Field[fn]->info))
  229.       writeat(Fstartx,Field[fn]->y,Field[fn]->Ffg,Field[fn]->Fbk,Field[fn]->info);
  230.     movexy(Cursor,Field[fn]->y);
  231.   }
  232. }
  233.  
  234. int  oIO::withinfield(int fn) {
  235.  
  236.   return (buttonx()>=Field[fn]->x &&
  237.       buttonx()<=Field[fn]->x+strlen(Field[fn]->prompt)+Field[fn]->len-1 &&
  238.       buttony()==Field[fn]->y);
  239. }
  240.  
  241. int  oIO::whichfield() {
  242.   register int i;
  243.   for(i=1; i<=Nf; i++)
  244.     if(withinfield(i)) return i;
  245.   return 0;
  246.  
  247. }
  248.  
  249. void oIO::initfieldinfo() {
  250.   register int i;
  251.   if(Nf)
  252.     for(i=1; i<=Nf; i++)
  253.       Field[i]->info[0]='\0';
  254. }
  255.  
  256. void oIO::display_form() {
  257.  
  258.   if(Nf) {
  259.     cursoroff();
  260.     Done=FALSE;
  261.     register int i;
  262.     for(i=1; i<=Nf; i++)
  263.       display_field(i);
  264.     display_message();
  265.     markcurrent();
  266.     goendstr();
  267.   }
  268. }
  269.  
  270. void oIO::display_info() {
  271.   display_form();
  272. }
  273.  
  274. void oIO::releasecurrent() {
  275.   setFfg(Ffg);
  276.   setFbk(Fbk);
  277.   display_field(Current);
  278. }
  279.  
  280. void oIO::markcurrent() {
  281.   setFfg(Cfg);
  282.   setFbk(Cbk);
  283.   display_field(Current);
  284. }
  285.  
  286. void oIO::gonextfield() {
  287.   int old=Current;
  288.   releasecurrent();
  289.   clear_message();
  290.   Current=Field[Current]->next;
  291.   if(Current<=0 || Current>Nf)
  292.     Current=old;
  293.   markcurrent();
  294.   if(Current!=old)
  295.     goendstr();
  296.   display_message();
  297. }
  298.  
  299. void oIO::goprevfield() {
  300.   int old=Current;
  301.   releasecurrent();
  302.   clear_message();
  303.   Current=Field[Current]->prev;
  304.   if(Current<=0 || Current>Nf)
  305.     Current=old;
  306.   markcurrent();
  307.   if(Current!=old)
  308.     goendstr();
  309.   display_message();
  310. }
  311.  
  312. void oIO::clearallfields() {
  313.   if(Nf) {
  314.     initfieldinfo();
  315.     register int i;
  316.     int old=Current;
  317.     cursoroff();
  318.     for(i=1; i<=Nf; i++) {
  319.       Current=i;
  320.       releasecurrent();
  321.     }
  322.     Current=old;
  323.     markcurrent();
  324.     goendstr();
  325.   }
  326. }
  327.  
  328. int  oIO::handle_mouse_event() {
  329.  
  330.   int w=whichfield();
  331.   if(w!=Current) {
  332.     if(w && w<=Nf) {
  333.       releasecurrent();
  334.       clear_message();
  335.       Current=w;
  336.       markcurrent();
  337.       goendstr();
  338.       display_message();
  339.       cursoron();
  340.       while(event());
  341.       return cmdSelectField;
  342.     }
  343.   }
  344.   else
  345.     if(withinIO()) {
  346.       markcurrent();
  347.       Cursor=buttonx();
  348.       if(Cursor<Fstartx)
  349.     Cursor=Fstartx;
  350.       Pointer=Cursor-Fstartx;
  351.       movexy(Cursor,buttony());
  352.       cursoron();
  353.       while(event());
  354.     }
  355.   return cmdNocmd;
  356. }
  357.  
  358. int  oIO::handle_key_event() {
  359.  
  360.  
  361.   int r=getkeycode();
  362.  
  363.   switch(r) {
  364.  
  365.     case Enter :
  366.       gonextfield();
  367.       return cmdNextField;
  368.       break;
  369.  
  370.     case ShiftTab :
  371.       goprevfield();
  372.       return cmdPrevField;
  373.       break;
  374.  
  375.     case DownArrow :
  376.       gonextfield();
  377.       return cmdNextField;
  378.       break;
  379.  
  380.     case UpArrow :
  381.       goprevfield();
  382.       return cmdPrevField;
  383.       break;
  384.  
  385.     case CtrlY :
  386.       Field[Current]->info[0]='\0';
  387.       display_field(Current);
  388.       markcurrent();
  389.       goendstr();
  390.       return cmdDeleteField;
  391.       break;
  392.  
  393.     case Escape :
  394.       if(Canescape) {
  395.     Accepted=FALSE;
  396.     Done=TRUE;
  397.     return cmdClose;
  398.       }
  399.       break;
  400.  
  401.     case BackSpace :
  402.       Pointer--;
  403.       if(Pointer<0)
  404.     Pointer=0;
  405.       int BS=deletestr(Field[Current]->info,Pointer);
  406.       if(Pointer+1<Field[Current]->len) {
  407.     Cursor--;
  408.     if(Cursor<Fstartx)
  409.       Cursor=Fstartx;
  410.       }
  411.       movexy(Cursor,Field[Current]->y);
  412.       if(BS)
  413.     showfield(Current);
  414.       return cmdKBHIT;
  415.       break;
  416.  
  417.     case Delete :
  418.       int D=deletestr(Field[Current]->info,Pointer);
  419.       if(D)
  420.     showfield(Current);
  421.       return cmdKBHIT;
  422.       break;
  423.  
  424.     case Home :
  425.       gohomestr();
  426.       return cmdKBHIT;
  427.       break;
  428.  
  429.     case End :
  430.       goendstr();
  431.       return cmdKBHIT;
  432.       break;
  433.  
  434.     case RightArrow :
  435.       if(Pointer<strlen(Field[Current]->info)) {
  436.     Cursor++;
  437.     Pointer++;
  438.     if(Cursor>Fstartx+Field[Current]->len-1) {
  439.       Pointer=strlen(Field[Current]->info);
  440.       Cursor=Fstartx+Field[Current]->len-1;
  441.     }
  442.     movexy(Cursor,Field[Current]->y);
  443.       }
  444.       return cmdRightArrow;
  445.       break;
  446.  
  447.     case LeftArrow :
  448.       Cursor--;
  449.       Pointer--;
  450.       if(Cursor<Fstartx) {
  451.     Cursor=Fstartx;
  452.     Pointer=0;
  453.       }
  454.       movexy(Cursor,Field[Current]->y);
  455.       return cmdLeftArrow;
  456.       break;
  457.  
  458.     case Insert :
  459.       InsertMode=!InsertMode;
  460.       if(InsertMode)
  461.     linecursor();
  462.       else
  463.     blockcursor();
  464.       return cmdKBHIT;
  465.       break;
  466.  
  467.     default :
  468.       if(Donekey==r) {
  469.     Accepted=TRUE;
  470.     Done=TRUE;
  471.     return cmdClose;
  472.       }
  473.       else {
  474.     if(istypeable(r)) {
  475.       char c=r;
  476.       int ok=0;
  477.       setlastevent(0);
  478.       if(InsertMode)
  479.         ok=insertstr(Field[Current]->info,c,Pointer);
  480.       else
  481.         ok=overtpstr(Field[Current]->info,c,Pointer);
  482.       if(ok) {
  483.         Pointer++;
  484.         Cursor++;
  485.         if(Cursor>Fstartx+Field[Current]->len-1) {
  486.           Pointer=strlen(Field[Current]->info);
  487.           Cursor=Fstartx+Field[Current]->len-1;
  488.         }
  489.         movexy(Cursor,Field[Current]->y);
  490.         showfield(Current);
  491.       }
  492.       return cmdKBHIT;
  493.     }
  494.       }
  495.       break;
  496.   }
  497.   return cmdNocmd;
  498. }
  499.  
  500. void oIO::goIO () {
  501.   while(getlastcmd()!=cmdClose) {
  502.     handle_events();
  503.   }
  504. }
  505.