中国DOS联盟

/////////////////////////////////////////////////////////////////////////////
//
//        A window class
//             PASS  BC++ 3.1
//        From CPP P633
//        Type by AW@ng
//
//             Form http://www.cn-dos.net/forum/
//            
/////////////////////////////////////////////////////////////////////////////


#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <dos.h>
#include <bios.h>
#include <stdio.h>

/////////////////////////////////////////////////////////////////////////////
//
//        Globe functions and data declare
//
/////////////////////////////////////////////////////////////////////////////



/* Text colors, first 7 can also be used to specify
   background color.
*/
const enum clr {black, blue, green, cyan, red, magenta,
                brown, lightgray, darkgray, lightblue,
                lightgreen, lightcyan, lightred,
                lightmagenta, yellow, white, blink=128};


char far *vid_mem;       //pointer to screen memory when in text mode


int  video_mode();
void goto_xy(int x, int y);
void set_v_ptr();
void write_char(int x, int y, char ch, int attrib);
void write_string(int x, int y, char *p, int attrib);


/////////////////////////////////////////////////////////////////////////////
//
//        End Globe declare
//
/////////////////////////////////////////////////////////////////////////////
//
//        Start globe function define
//
/////////////////////////////////////////////////////////////////////////////


//Return the current video mode
video_mode(void)
{
        union REGS r;

        r.h.ah = 15;

        return int86(0x10, &r, &r) & 255;
}


//Set video mode video_address
void set_v_ptr()
{
        int vmode;

        vmode = video_mode();
        if((vmode != 2) && (vmode != 3) && (vmode != 7))
        {
                cout << endl
                     << "Video must be in 80 column text mode"
                     << endl;

                exit( 1 );
        }

        //set proper address of video RAM
        if(vmode == 7)
        {
                vid_mem = (char *)0xB0000000;
        }
        else
        {
                vid_mem = (char *)0xB8000000;
        }
}



//Write character with specified attribute
void write_char(int x, int y, char ch, int attrib)
{
        char far *v;

        v = vid_mem;
        v += (y *160) + (x * 2);
        *v++ = ch;
        *v = attrib;
}


//Display string with specified attrib
void write_string(int x, int y, char *p, int attrib)
{
        register int i;
        char far *v;

        v = vid_mem;
        v += (y * 160) + (x * 2);

        for(i = y; *p ; i++)
        {
                *v++ = *p++;
                *v++ = attrib;
        }
}



//Send the cursor to the specified X, Y position
void goto_xy(int x, int y)
{
        union REGS r;

        r.h.ah = 2;
        r.h.dl = x;
        r.h.dh = y;
        r.h.bh = 0;

        int86(0x10, &r, &r);
}





/////////////////////////////////////////////////////////////////////////////
//
//        Start class declare
//
/////////////////////////////////////////////////////////////////////////////

class wintype
{
        int leftx;                   //define where window goes on the screen
        int upy;                     //upper left coordinate
        int rightx;
        int downy;                  //lower right coordinate

        int border;                        //if non-zero,border displayed
        int active;                  //non-zero if window is currently on screen
        char *title;                       //window title

        int curx, cury;              //current cursor location in window

        char *buf;                  //points to window's buffer

        char color;                  //window text color


        //private functions
        void save_screen();         //save screen so it can be restored
        void restore_screen();      //restore the original screen
        void draw_border();         //draw a window's border
        void display_title();       //display window title

    public:
        wintype(int lx, int uy,     //upper left
                int re, int ly,     //lower right
                int b = 1,          //non-zero for border
                char *mess = "");   //title message

        ~wintype()
        {
                winremove();
                delete buf;
        }


        void winput();              //display a window
        void winremove();           //remove a window
        int  winputs(char *s);      //write a string to the window
        int  winxy(int x, int y);   //go to X, Y relative to window
        void wingets(char *s);      //input a string from a window
        int  wingetche();           //input a character from a window
        void wincls();              //clears the window
        void wincleol();            //clears to end-of-line

        void setcolor(char c)   {color = c;                  }
        char getcolor()         {return color;               }
        void setbkcolor(char c) {color = (color | (c << 4)); }
        char getbkcolor()       {return (color >> 4) & 127;  }


        friend wintype &operator << (wintype &o, char *s);
        friend wintype &operator >> (wintype &o, char *s);
};

/////////////////////////////////////////////////////////////////////////////
//
//        End class declare
//
/////////////////////////////////////////////////////////////////////////////



//Construct a window.
wintype::wintype(int lx, int uy,
                 int rx, int ly,
                 int b,
                 char *mess     )
{
        if(lx < 0 ) lx = 0 ;
        if(rx > 79) rx = 79;
        if(uy < 0 ) uy = 0 ;
        if(ly > 24) ly = 24;

        leftx  = lx    ;
        upy    = uy    ;
        rightx = rx    ;
        downy  = ly    ;
        border = b     ;
        title  = mess  ;
        active = 0     ;
        curx = cury = 0;

        buf = new char[ 2 * (rightx - leftx + 1) * (downy - upy + 1) ];
        if( !buf )
        {
                cout << "\nAllocation window buffer error\n";
                exit( 1 );
        }

        color = white;
}


//Display a window
void wintype::winput()
{
        //get active window
        if( !active )                    //not currently in use
        {
                save_screen();      //save the current screen
                active = 1;         //set active flag
        }
        else
        {
                return;             //already on screen
        }

        if( border )
        {
                draw_border();
        }
        display_title();

        //position cursor in apper left corner
        goto_xy(leftx + curx + 1, upy + cury +1);
}


//Remove the window and restore prior screen contents.
void wintype::winremove()
{
        if(!active)        //con't remove a non-active window
        {
                return;
        }

        restore_screen();  //restore the original screen
        active = 0;        //restore_video
}


//Draw a border around the window
void wintype::draw_border()
{
        register int  i;
            char far *v;
            char far *t;

            v = vid_mem;
            t = v;

            for(i = leftx + 1; i < rightx; i++)
            {
            v += (upy * 160) + (i * 2);
            *v ++ = 196;
            *v = color;
            v = t;
            v += (downy * 160) + (i * 2);
            *v ++ = 196;
            *v = color;
            v = t;
            }

            for(i = upy + 1; i < downy; i++)
            {
            v += (i * 160) + (leftx * 2);
            *v ++ = 179;
            *v = color;
            v = t;
            v += (i * 160) + (rightx * 2);
            *v ++ = 179;
            *v = color;
            v = t;
            }

            //draw the corners
            write_char(leftx,  upy,   218, color);
            write_char(leftx,  downy, 192, color);
            write_char(rightx, upy,   191, color);
            write_char(rightx, downy, 217, color);
}


//Display the window's title
void wintype::display_title()
{
        register int x, len;

        x = leftx;
        len = strlen(title);
        len = (rightx - x- len)/2;
        if( len < 0 ) return;

        x = x + len +1;

        write_string(x, upy, title, color);
}


//Save screen so ti can be restored after window is removed
void wintype::save_screen()
{
        register int i, j    ;
            char far *v      ;
            char far *t      ;
            char *buf_ptr    ;


            buf_ptr = buf;
            v = vid_mem;
            for(i = upy; i < downy+1; i++)
            {
            for(j = leftx; j < rightx+1; j++)
            {
                t = (v + (i*160) + (j*2));
                *buf_ptr++ = *t++;
                *buf_ptr++ = *t;
                *(t - 1) = ' ';               //clear the window
            }
            }
}


//Restore a portion of the screen
void wintype::restore_screen()
{
        register int i, j    ;
            char far *v      ;
            char far *t      ;
            char *buf_ptr    ;


            buf_ptr = buf;                      //computer pointer to video RAM
            v = vid_mem;
            t = v;

            for(i = upy; i < downy+1; i++)
            {
            for(j = leftx; j < rightx+1; j++)
            {
                v = t;
                v += (i*160) + j*2;
                *v++ = *buf_ptr++;      //write the character
                *v = *buf_ptr++;        //write the attrib
            }
            }
}


//Write a string at the current cursor position win the specified window
int wintype::winputs(char *s)
{

        register int x, y;
            char far *v;


        //make sure window is active
        if ( !active )        return 0;


        x = curx + leftx + 1;
        y = cury + upy + 1;

        v = vid_mem;
        v += (y * 160) + (x * 2);

        for( ; *s; s++ )
        {
                if(y >= downy)
                {
                        return 1;
                }
                if(x >= rightx)
                {
                        return 1;
                }

                if(*s == '\n')
                {
                        y++;
                        x = leftx + 1;
                        v = vid_mem;
                        v += (y * 160) + (x * 2);;
                        cury++;
                        curx = 0;
                }
                else
                {
                        curx++;
                        x++;
                        *v++ = *s;
                        *v++ = color;
                }

                winxy(curx,cury);
        }

        return 1;
}


/* Postion cursor in a window at specified location
   Return 0 if out of range; non-zero otherwise.
*/
int wintype::winxy(int x, int y)
{
        if(x < 0 || x+leftx >= rightx-1)
        {
                return 0;
        }
        if(y < 0 || y+upy >= downy-1)
        {
                return 0;
        }

        curx = x;
        cury = y;
        goto_xy(leftx + x + 1, upy + y + 1);

        return 1;
}


//read a string from a window
void wintype::wingets(char *s)
{
        char ch, *temp;

        temp = s;

        for(;;)
        {
                ch = wingetche();

                switch(ch)
                {
                        case '\r' :
                                {
                                        *s = '\0';
                                        return ;
                                }

                        case '\b' :
                                if(s > temp)
                                {
                                        s--;
                                        curx--;

                                        if(curx < 0)
                                        {
                                                curx = 0;
                                        }

                                        winxy(curx, cury);
                                        write_char(leftx + curx + 1, upy + cury +1, ' ', color);
                                }
                                break;

                        default :
                                {
                                        *s = ch;
                                        s++;
                                }
                }
        }
}



/* Input a keystroke inside a window
   Returns full 16 bit keyboard code.
*/
wintype::wingetche()
{
        union inkey
        {
                char ch[2];
                int  i;
        } c;
        union REGS r;


        if( !active ) return 0;


        winxy(curx, cury);

        r.h.ah = 0;
        c.i = int86(0x16, &r, &r);

        if( c.ch[0] )
        {
                switch( c.ch[0] )
                {
                        case '\r' :
                        {
                                break;
                        }

                        case '\b' :
                        {
                                break;
                        }

                        default:
                                {
                                        if( curx + leftx < rightx -1 )
                                                {
                                                        write_char(leftx + curx +1,
                                                                   upy + cury +1,
                                                                   c.ch[0],
                                                                   color           );
                                                        curx++;
                                                }
                                }
                }
        }

        if(cury < 0) cury = 0;
        if(cury + upy > downy -2)
                {
                        cury--;
                        winxy(curx, cury);
                }

        return c.i;
}


//Clear a window
void wintype::wincls()
{
        register int i, j;
        char far *v, far *t;

        v = vid_mem;
        t = v;

        for(i = upy +1; i < downy; i++)
                for(j = leftx + 1; j < rightx; j++)
                        {
                                v = t;
                                v += (i * 160) + (j * 2);
                                *v++ = ' ';
                                *v = color;
                        }

        curx = 0;
        cury = 0;
}


//Clear to end of line
void wintype::wincleol()
{
        register int i, x, y;


        x = curx;
        y = cury;
        winxy(curx, cury);

        for(i = curx; i < rightx; i++)
                {
                        winputs(" ");
                }

        winxy(x, y);
}


//Output to a window
wintype &operator << (wintype &o, char *s)
{
        o.winputs(s);
        return o;
}


//Input from a window
wintype &operator >> (wintype &o, char *s)
{
        o.wingets(s);
        return o;
}



/////////////////////////////////////////////////////////////////////////////
//
//   Main program here
//
/////////////////////////////////////////////////////////////////////////////
main()
{
        char s[80];



        set_v_ptr();                //set the video memory pointer


        wintype w1(1, 10, 20, 20, 1, "My window #1");
        wintype w2(40, 1, 60, 20, 1, "My window #2");
        wintype w3(40, 5, 60, 20, 2, "My window #3");


        w1.winput();
        w2.winput();

        w1.setcolor(blue);
        w2.setcolor(green);
        w3.setcolor(red);
        getch();

        w1.winremove();
        w2.winremove();
        getch();

        w1.winput();
        w2.winput();
        w3.winput();
        getch();


        w1.winremove();
        getch();

        w3.winremove();
        getch();

        w2.winremove();
        getch();



        w1.winput();
        w2.winput();
        getch();

        w1 >> s;
        w1.winxy( 0, 0 );
        getch();

        w1.winputs("Hi there\n");
        w1.winputs("Windows is fan");
        w1 << "\n";
        w1 >> s;
        w1 << "This \nis " << "a test" << "\n";
        w2 << "this is a test";
        w2.winxy(3, 4);
        w2 << "at location 3,4";
        w1 << "This is anther test for you to see\n";
        w1 >> s;

        w3.winput();
        w3 >> s;
        w3.winremove();
        getch();


        w1.winxy(0, 0);
        w1.setcolor(red);
        w1.setbkcolor(cyan);
        w1.winputs("PROMPT:");
        w1.setcolor(white);
        w1.setbkcolor(black);
        w1 >> s;

        w2.winxy(0, 4);
        w2.setcolor(yellow);
        w2.setbkcolor(green);
        w2.winputs(s);
        w2 >> s;

        w2.wincls();
        w1.winxy(5, 0);
        w1.wincleol();
        w2 >> s;

        w1.winremove();
        w2.winremove();
        w1.winput();

       
                w1 >> s;


        return 0;
}