Startpunkten

Stack_And_Queue/boolean.h

@@ -0,0 +1,6 @@
+#ifndef __BOOLEAN_H_
+
+#define __BOOLEAN_H_
+
+typedef int boolean;
+

Stack_And_Queue/huvud.cpp

@@ -0,0 +1,345 @@
+//#####################################################
+//		LAB 2 I PUMA
+//    CRILLE & ROBIN  971208
+//		LÄNKAD TEMPLATE LISTA
+//=====================================================
+
+#include "lista.cpp"
+#include "twindow.hpp"
+
+const int BUFFERSIZE = 100;	//för säkerinmatning
+const int MAXSIZE = 5;        //maximalt antal element
+const int SIST = 0;           //inmatning i listan
+const int FORST=!SIST;        //inmatning i listan
+const int FALSE=0;				//boolsk varabel
+const int TRUE=!FALSE;        //boolsk varabel
+
+const int BREDD = 9; 			//fönstrets bredd
+const int HOJD = 3;           //fönstrets höjd
+const int LEFT = 1;           //fönstrets Y-position
+const int TOP = 18;           //fönstrets X-position
+
+const int moveX = 0;          //fönsterflyttning X-led
+const int moveY = 5;          //fönsterflyttning Y-led
+
+//#####################################################
+// SÄKER INMATNING
+//		SER TILL ATT BARA HELTAL MATAS IN
+//=====================================================
+int mataIn()
+{
+	char buffer[BUFFERSIZE];
+	int f;
+	do
+	{
+		cin >> buffer;
+		if (strcmp(buffer,"0") == 0)
+			return 0;
+		else
+		{
+			f = atoi(buffer);
+			if (f!=0)
+				return f;
+			else
+				cout <<"Inget tal, forsok igen: ";
+		}
+	}while (!f);
+}
+//#####################################################
+//	SÄTTER IN ELEMENT I STACKEN
+//=====================================================
+void _push(stackClass <TWindow> &minStack)
+{
+	int position = FORST;
+	TWindow *newItem;
+	newItem = new TWindow(LEFT, TOP,(BREDD+LEFT),(HOJD+TOP),BLUE,WHITE);
+	if(minStack.length() < MAXSIZE)
+		if(newItem)
+		{
+			cout << "Skriv in element!";
+			cout << *newItem;
+			newItem->editText();
+			if(minStack.duplicate(*newItem))
+				cout <<"\nElementet finns redan.";
+			else
+				{
+				minStack.push(position, *newItem);
+				return;
+				}
+		}
+		else
+			cout <<"\nMinnet tog slut";
+	else
+		cout <<"Maximalt antal element i stacken";
+	getch();
+}
+//#####################################################
+//	SÄTTER IN ELEMENT I KÖN
+//=====================================================
+void _ins(queueClass <TWindow> &minQueue)
+{
+	TWindow *newItem;
+	int position = SIST;
+	newItem = new TWindow(LEFT, TOP,(BREDD+LEFT),(HOJD+TOP),BLUE,WHITE);
+	if(minQueue.length() < MAXSIZE)
+		if(newItem)
+		{
+			cout << "Skriv in element!";
+			cout << *newItem;
+			newItem->editText();
+			if(minQueue.duplicate(*newItem))
+				cout <<"\nElementet finns redan.";
+			else
+			{
+				minQueue.ins(position, *newItem);
+				return;
+			}
+		}
+		else
+			cout <<"\nMinnet tog slut";
+	else
+		cout <<"Maximalt antal element i kon";
+	getch();
+}
+//#####################################################
+//	TAR BORT ELEMENT I STACKEN
+//=====================================================
+void _pop(stackClass <TWindow> &minStack)
+{
+	if(!minStack.isEmpty())
+		minStack.pop();
+	else
+	{
+		cout <<"Stacken ar tom.";
+		getch();
+	}
+}
+//#####################################################
+//	TAR BORT ELEMENT I KÖN
+//=====================================================
+void _del(queueClass <TWindow> &minQueue)
+{
+	if(!minQueue.isEmpty())
+		minQueue.del();
+	else
+	{
+		cout <<"Kon ar tom.";
+		getch();
+	}
+}
+//#####################################################
+// VISAR ÖVERSTA ELEMENTET I STACKEN
+//=====================================================
+void _top(stackClass <TWindow> &minStack)
+{
+	if(!minStack.isEmpty())
+		minStack.top();
+	else
+		cout <<"Stacken ar tom.";
+	getch();
+}
+//#####################################################
+// VISAR ÖVERSTA ELEMENTET I KÖN
+//=====================================================
+void _getFront(queueClass <TWindow> &minQueue)
+{
+	if(!minQueue.isEmpty())
+		minQueue.getFront();
+	else
+		cout <<"Kon ar tom.";
+	getch();
+}
+//#####################################################
+//	VISAR ALLA ELEMENT I STACKEN
+//=====================================================
+void _stackDisplay(stackClass <TWindow> minStack)
+{
+	if(!minStack.isEmpty())
+	{
+		cout << "Elementen ar: \n";
+		minStack.display();
+	}
+	else
+		cout <<"Stacken ar tom";
+	getch();
+}
+//#####################################################
+//	VISAR ALLA ELEMENT I KÖN
+//=====================================================
+void _queueDisplay(queueClass <TWindow> minQueue)
+{
+	if(!minQueue.isEmpty())
+	{
+		cout << "Elementen ar: \n";
+		minQueue.display();
+	}
+	else
+		cout <<"Kon ar tom";
+	getch();
+}
+//#####################################################
+//	VISAR ANTALET ELEMENT I STACKEN
+//=====================================================
+void _stackAntal(stackClass <TWindow> minStack)
+{
+	int antalElement;
+	if(minStack.isEmpty())
+		cout <<"Stacken ar tom.";
+	else
+	{
+		antalElement=minStack.length();
+		cout<<"Det finns "<< antalElement<< " element i stacken";
+	}
+	getch();
+}
+//#####################################################
+//	VISAR ANTALET ELEMENT I KÖN
+//=====================================================
+void _queueAntal(queueClass <TWindow> minQueue)
+{
+	int antalElement;
+	if(minQueue.isEmpty())
+		cout <<"Kon ar tom.";
+	else
+	{
+		antalElement=minQueue.length();
+		cout<<"Det finns "<< antalElement<< " element i kon";
+	}
+	getch();
+}
+//#####################################################
+//	KOLLAR OM DET FINNS ELEMENT I STACEKN
+//=====================================================
+void _stackIsEmpty(stackClass <TWindow> minStack)
+{
+	if(minStack.isEmpty())
+		cout <<"Ja, stacken ar tom.";
+	else
+		cout <<"Nej, det finns element i stacken";
+	getch();
+}
+//#####################################################
+//	KOLLAR OM DET FINNS ELEMENT I KÖN
+//=====================================================
+void _queueIsEmpty(queueClass <TWindow> minQueue)
+{
+	if(minQueue.isEmpty())
+		cout <<"Ja, kon ar tom.";
+	else
+		cout <<"Nej, det finns element i kon";
+	getch();
+}
+//#####################################################
+// STACK-MENY
+//=====================================================
+void stackMenuItems()
+{
+	clrscr();
+	cout <<" Meny for stacken \n"
+		  <<" ---------------- \n\n"
+		  <<" 1. Lagg till ett element overst \n"
+		  <<" 2. Ta bort oversta elementet \n"
+		  <<" 3. Skriv ut oversta elementet \n"
+		  <<" 4. Skriv ut alla element \n"
+		  <<" 5. Hur många element finns det \n"
+		  <<" 6. Ar stacken tom? \n"
+		  <<" 0. Huvudmeny \n\n";
+}
+void stackMenu()
+{
+	stackClass<TWindow> minStack;
+	char val = TRUE;
+	do
+	{
+		stackMenuItems();
+		cin >> val;
+		switch (val)
+		{
+			case '1' : _push(minStack);break;
+			case '2' : _pop(minStack);break;
+			case '3' : _top(minStack);break;
+			case '4' : _stackDisplay(minStack);break;
+			case '5' : _stackAntal(minStack);break;
+			case '6' : _stackIsEmpty(minStack);break;
+			case '0' : ;break;
+			default : cout <<" Fel val.";
+		}
+	}while(val!='0');
+}
+//#####################################################
+// QUEUE-MENYN
+//=====================================================
+void queueMenuItems()
+{
+	clrscr();
+	cout <<" Meny for kon \n"
+		  <<" ---------------- \n\n"
+		  <<" 1. Lagg till ett element sist i kon \n"
+		  <<" 2. Ta bort forsta elementet \n"
+		  <<" 3. Skriv ut forsta elementet \n"
+		  <<" 4. Skriv ut alla element \n"
+		  <<" 5. Hur många element finns det? \n"
+		  <<" 6. Ar kon tom? \n"
+		  <<" 0. Huvudmeny \n\n";
+}
+void queueMenu()
+{
+	queueClass<TWindow> minQueue;
+	char val = TRUE;
+	do
+	{
+		queueMenuItems();
+		cin >> val;
+		switch (val)
+		{
+			case '1' : _ins(minQueue);break;
+			case '2' : _del(minQueue);break;
+			case '3' : _getFront(minQueue);break;
+			case '4' : _queueDisplay(minQueue);break;
+			case '5' : _queueAntal(minQueue);break;
+			case '6' : _queueIsEmpty(minQueue);break;
+			case '0' : ;break;
+			default : cout <<" Fel val.";
+		}
+	}while(val!='0');
+}
+//#####################################################
+// MAIN-MENU-ITEMS
+//=====================================================
+void mainMenuItems()
+{
+	clrscr();
+	TWindow justText;
+	justText.setText("Crille &Robin!");
+	cout << justText;
+	gotoxy(LEFT,TOP);
+	cout << " Continue...";
+	getch();
+	clrscr();
+	cout <<" Huvudmeny for lab 2 i PUMA. \n"
+		  <<" --------------------------- \n\n"
+		  <<" 1. Jobba med en stack. \n"
+		  <<" 2. Jobba med en ko. \n"
+		  <<" 0. Avsluta programmet. \n\n";
+
+}
+//#####################################################
+// MAINFUNCTION
+//=====================================================
+void main()
+{
+	char val = TRUE;
+	do
+	{
+		mainMenuItems();
+		cin >> val;
+		switch (val)
+		{
+			case '1' : stackMenu();break;
+			case '2' : queueMenu();break;
+			case '0' : cout <<" Programmet avslutat"<< endl;break;
+			default: cout <<" Fel val"<< endl;
+		}
+	}while (val != '0');
+}
+

Stack_And_Queue/keycode.h

@@ -0,0 +1,12 @@
+#ifndef __KEYCODE_H
+
+#define __KEYCODE_H
+
+const int LeftTop 		= 201;
+
+const int RightTop		= 187;
+
+const int RightBottom 		= 188;
+
+const int LeftBottom		= 200;
+

Stack_And_Queue/lista.cpp

@@ -0,0 +1,177 @@
+//#####################################################
+// LISTA.CPP
+//=====================================================
+
+#include <stddef.h>				//för NULL
+#include <assert.h>				//för assert()
+#include <iostream.h>			//för in-ut matning
+#include <conio.h>				//för getch();
+#include <string.h>        	//för säker inmatning
+#include <stdlib.h>				//för atoi()
+#include "stack.cpp"
+#include "queue.cpp"
+
+template <class T>
+class listClass
+{
+	public:
+		listClass();
+		~listClass();
+		int listIsEmpty();
+		int listLength();
+		int newDuplicate(T newItem);
+		T retrive(int position);
+		void listInsert(int position, T newItem);
+		void listDel();
+		void listDisplay();
+		void listAntal();
+	private:
+		struct listNode
+		{
+			T listContent;
+			listNode* next;
+		};
+		typedef struct listNode listNode;
+		typedef struct listNode* ptrType;
+		ptrType head;
+		int size;
+};
+//#####################################################
+// CONSTRUCTOR
+// SÄTTER LISTSTORLEKEN TILL NOLL & HEAD TILL NULL
+//		pre: TRUE
+//		post: en lista har skapats
+//=====================================================
+template <class T>
+listClass<T>::listClass():size(0), head(NULL)
+{
+}
+//#####################################################
+// DESTRUCTOR
+// FÖRSTÖR LISTAN, ANROPAS AUTOMATISKT VID AVSLUT
+//		pre: TRUE
+//		post: listan har raderats
+//=====================================================
+template <class T>
+listClass<T>::~listClass()
+{
+}
+//#####################################################
+// KOLLAR OM LISTAN ÄR TOM
+//		pre: TRUE
+//		post: TRUE om listan är tom
+//		post: FALSE om listan inte är tom
+//=====================================================
+template <class T>
+int listClass<T>::listIsEmpty()
+{
+	return int (size == 0);
+}
+//#####################################################
+// RETURNERAR ANTALET ELEMENT I LISTAN
+//		pre: TRUE
+//		post: antalet element i listan är returnerade
+//=====================================================
+template <class T>
+int listClass<T>::listLength()
+{
+	return size;
+}
+//#####################################################
+// LÄGGER TILL ETT NYTT ELEMENT I LISTAN
+//		pre: minne fanns för att skapa fönstret
+//    pre: att maximalt antal element inte finns
+//    pre: att listelementet inte finns
+//    post: listan har ett nytt element
+//=====================================================
+template <class T>
+void listClass<T>::listInsert(int position, T newItem)
+{
+	size++;
+	ptrType newPtr = new listNode,cur;
+	if(position == FORST)
+	{
+		newPtr -> listContent = newItem;
+		newPtr ->next = head;
+		head = newPtr;
+	}
+	else
+	{
+		if(size == 1)
+		{
+			newPtr -> listContent = newItem;
+			newPtr ->next = head;
+			head = newPtr;
+		}
+		else
+		{
+			for(cur=head ; cur!=NULL ; cur=cur->next)
+				if(cur->next == NULL)
+				{
+					newPtr -> listContent = newItem;
+					cur->next = newPtr;
+					newPtr->next = NULL;
+				}
+			delete cur;
+			cur = NULL;
+		}
+	}
+}
+//#####################################################
+// TAR BORT ELEMENT I LISTAN
+//    pre: att det finns en lista
+//		post: ett elementet har tagits bort
+//=====================================================
+template <class T>
+void listClass<T>::listDel()
+{
+	ptrType cur=head;
+	size--;
+	head = head -> next;
+	cur -> next = NULL;
+	delete cur;
+	cur = NULL;
+}
+//#####################################################
+// SKRIVER UT LISTAN PÅ SKÄRMEN
+//		pre: att det finns en lista
+//		post: listan har skrivits ut
+//=====================================================
+template <class T>
+void listClass<T>::listDisplay()
+{
+	TWindow ruta;
+	for(ptrType cur = head ; cur != NULL ; cur = cur->next)
+	{
+		ruta=cur->listContent;
+		cout << ruta;
+		ruta.move(moveX,moveY);
+	}
+}
+//#####################################################
+// KOLLAR OM ETT ELEMENT FINNS
+//		pre: att det finns en lista
+//		post: TRUE om elementet redan finns
+//		post: FALSE om elementet inte redan finns
+//=====================================================
+template <class T>
+int listClass<T>::newDuplicate(T newItem)
+{
+	ptrType cur;
+	for(cur=head ; cur != NULL ; cur = cur->next)
+		if(cur->listContent == newItem)
+			return TRUE;
+	return FALSE;
+}
+//#####################################################
+// HÄMTAR ÖVERSTA ELEMENTET
+//		pre: att det finns en lista
+//		post: det översta elementet har returnerats
+//=====================================================
+template <class T>
+T listClass<T>::retrive(int position)
+{
+	ptrType cur=head;
+	for(int i=0 ; i<position-1 ; i++)
+		cur=cur->next;
+	return (cur->listContent);

Stack_And_Queue/queue.cpp

@@ -0,0 +1,119 @@
+//#####################################################
+// QUEUE.CPP
+//=====================================================
+
+template <class T>
+class queueClass
+{
+	public:
+		queueClass();
+		~queueClass();
+		int length();
+		int duplicate(T newItem);
+		void ins(int position, T newItem);
+		void del();
+		int isEmpty();
+		void getFront();
+		void display();
+	private:
+		listClass<TWindow>minLista;
+		typedef struct queueNode* ptrType;
+		ptrType head;
+		int size;
+};
+
+//#####################################################
+// CONSTRUCTOR
+// SÄTTER KÖSTORLEKEN TILL NOLL & HEAD TILL NULL
+//		pre: TRUE
+//		post: en kö har skapats
+//=====================================================
+template <class T>
+queueClass<T>::queueClass():size(0), head(NULL)
+{
+}
+//#####################################################
+// DESTRUCTOR
+// FÖRSTÖR KÖN, ANROPAS AUTOMATISKT VID AVSLUT
+//		pre: att det finns en kö
+//		post: kön har raderats
+//=====================================================
+template <class T>
+queueClass<T>::~queueClass()
+{
+}
+//#####################################################
+// RETURNERAR ANTALET ELEMENT I KÖN
+//		pre: TRUE
+//		post: antalet element i kön är returnerade
+//=====================================================
+template <class T>
+int queueClass<T>::length()
+{
+	return (minLista.listLength());
+}
+//#####################################################
+// KOLLAR OM ETT ELEMENT FINNS
+//		pre: att det finns en kö
+//		post: TRUE om elementet redan finns
+//		post: FALSE om elementet inte redan finns
+//=====================================================
+template <class T>
+int queueClass<T>::duplicate(T newItem)
+{
+	return (minLista.newDuplicate(newItem));
+}
+//#####################################################
+// LÄGGER TILL ETT NYTT ELEMENT I KÖN
+//		pre: minne fanns för att skapa fönstret
+//    pre: att maximalt antal element inte finns
+//    pre: att köelementet inte finns
+//    post: kön har ett nytt element
+//=====================================================
+template <class T>
+void queueClass<T>::ins(int position, T newItem)
+{
+	minLista.listInsert(position, newItem);
+}
+//#####################################################
+// TAR BORT ELEMENT I LISTAN
+//    pre: att det finns en kö
+//		post: översta elementet har tagits bort
+//=====================================================
+template <class T>
+void queueClass<T>::del()
+{
+	minLista.listDel();
+}
+//#####################################################
+// KOLLAR OM KÖN ÄR TOM
+//		pre: TRUE
+//		post: TRUE om kön är tom
+//		post: FALSE om kön inte är tom
+//=====================================================
+template <class T>
+int queueClass<T>::isEmpty()
+{
+	return (minLista.listIsEmpty());
+}
+//#####################################################
+// SKRIVER UT ÖVERSTA ELEMENTET
+//		pre: att det finns en kö
+//		post: översta elementet har skrivits ut
+//=====================================================
+template <class T>
+void queueClass<T>::getFront()
+{
+	TWindow ruta;
+	ruta=minLista.retrive(FORST);
+	cout << ruta;
+	ruta.move(moveX,moveY);
+}
+//#####################################################
+// SKRIVER UT KÖN PÅ SKÄRMEN
+//		pre: att det finns en kö
+//		post: kön har skrivits ut
+//=====================================================
+template <class T>
+void queueClass<T>::display()
+{

Stack_And_Queue/stack.cpp

@@ -0,0 +1,118 @@
+//#####################################################
+// STACK.CPP
+//=====================================================
+
+template <class T>
+class stackClass
+{
+	public:
+		stackClass();
+		~stackClass();
+		int length();
+		int duplicate(T newItem);
+		void push(int position, T newItem);
+		void pop();
+		void top();
+		void display();
+		int isEmpty();
+	private:
+		listClass<TWindow>minLista;
+		typedef struct stackNode* ptrType;
+		ptrType head;
+		int size;
+};
+//#####################################################
+// CONSTRUCTOR
+// SÄTTER STACKSTORLEKEN TILL NOLL OCH HEAD TILL NULL
+//		pre: TRUE
+//		post: en stack har skapats
+//=====================================================
+template <class T>
+stackClass<T>::stackClass():size(0), head(NULL)
+{
+}
+//#####################################################
+// DESTRUCTOR
+// FÖRSTÖR STACKEN, ANROPAS AUTOMATISKT VID AVSLUT
+//		pre: TRUE
+//		post: stacken har raderats
+//=====================================================
+template <class T>
+stackClass<T>::~stackClass()
+{
+}
+//#####################################################
+// RETURNERAR ANTALET ELEMENT I STACKEN
+//		pre: TRUE
+//		post: antalet element i stacken är returnerade
+//=====================================================
+template <class T>
+int stackClass<T>::length()
+{
+	return (minLista.listLength());
+}
+//#####################################################
+// KOLLAR OM ETT ELEMENT FINNS
+//		pre: att det finns en stack
+//		post: TRUE om elementet redan finns
+//		post: FALSE om elementet inte redan finns
+//=====================================================
+template <class T>
+int stackClass<T>::duplicate(T newItem)
+{
+	return(minLista.newDuplicate(newItem));
+}
+//#####################################################
+// LÄGGER TILL ETT NYTT ELEMENT I STACKEN
+//		pre: minne fanns för att skapa fönstret
+//    pre: att maximalt antal element inte finns
+//    pre: att elementet inte redan finns
+//    post: stacken har ett nytt element
+//=====================================================
+template <class T>
+void stackClass<T>::push(int position, T newItem)
+{
+	minLista.listInsert(position, newItem);
+}
+//#####################################################
+// TAR BORT ELEMENT I STACKEN
+//    pre: att det finns en stack
+//		post: elementet har tagits bort
+//=====================================================
+template <class T>
+void stackClass<T>::pop()
+{
+	minLista.listDel();
+}
+//#####################################################
+// SKRIVER UT ÖVERSTA ELEMENTET
+//		pre: att det finns en stack
+//		post: elementet har skrivits ut
+//=====================================================
+template <class T>
+void stackClass<T>::top()
+{
+	TWindow ruta;
+	ruta=minLista.retrive(FORST);
+	cout << ruta;
+	ruta.move(moveX,moveY);
+}
+//#####################################################
+// SKRIVER UT STACKEN PÅ SKÄRMEN
+//		pre: att det finns en stack
+//		post: stacken har skrivits ut
+//=====================================================
+template <class T>
+void stackClass<T>::display()
+{
+	minLista.listDisplay();
+}
+//#####################################################
+// KOLLAR OM STACKEN ÄR TOM
+//		pre: TRUE
+//		post: TRUE om stacken är tom
+//		post: FALSE om stacken inte är tom
+//=====================================================
+template <class T>
+int stackClass<T>::isEmpty()
+{

Stack_And_Queue/twindow.cpp

@@ -0,0 +1,203 @@
+#include <dos.h>
+#include <conio.h>
+#include <bios.h>
+#include <string.h>
+#include <ctype.h>
+#include "twindow.hpp"
+
+const int MAXX=80;
+const int MAXY=25;
+const int MINX=0;
+const int MINY=0;
+class Display
+{
+	public:
+		typedef unsigned far* ScreenPtr;
+		static void drawChar(unsigned x,unsigned y, char c, unsigned fg, unsigned bg);
+};
+void Display::drawChar(unsigned x,unsigned y, char c, unsigned fg, unsigned bg)
+{
+	ScreenPtr display = (ScreenPtr)MK_FP(0xB800,0x0);
+	display[y*80+x] = (((bg<<4)|fg)<<8)|(c & 255);
+}
+//=============================================================================
+// default constructor: skapar fönstret med vissa koordinater och färger
+//-----------------------------------------------------------------------------
+TWindow::TWindow()
+{
+	Left=69;Right=78;Bottom=4;Top=1;background=BLUE;foreground=WHITE;
+	text=NULL;
+}
+//=============================================================================
+// constructor: skapar fönstret med vissa koordinater och färger
+//-----------------------------------------------------------------------------
+TWindow::TWindow(unsigned left,unsigned top,unsigned right ,unsigned bottom, DColor bg, DColor fg):
+Left(left),Right(right),Bottom(bottom),Top(top),background(bg), foreground(fg)
+{
+	theState = 0;//FALSE;
+	text=NULL;
+}
+
+//=============================================================================
+// destructor: förstör fönstret
+//-----------------------------------------------------------------------------
+TWindow::~TWindow()
+{
+	if(isVisible())
+		hide();
+}
+
+//=============================================================================
+// hide: gömmer fönstret
+//-----------------------------------------------------------------------------
+void TWindow::hide()
+{
+	erase();
+}
+//=============================================================================
+// show: visar fönstret
+//-----------------------------------------------------------------------------
+void TWindow::display()
+{
+	draw();
+	if(text)
+		showText();
+}
+
+//=============================================================================
+// draw: ritar upp fönstret
+//-----------------------------------------------------------------------------
+void TWindow::draw()
+{
+	theState = 1;//;TRUE;
+	for(int j= Top; j< Bottom; j++ )
+		for(int i=Left; i< Right ; i++ )
+		{
+			Display::drawChar(i,j,' ',foreground,background);
+		}
+	drawBorder();
+}
+
+//=============================================================================
+// erase: ritar över fönstret med svart
+//-----------------------------------------------------------------------------
+void TWindow::erase()
+{
+	for(int j= Top; j<= Bottom; j++ )
+		for(int i=Left; i<= Right ; i++ )
+			Display::drawChar(i,j,' ',BLACK,BLACK);
+	theState = 0;//FALSE;
+}
+
+//=============================================================================
+// drewBorder: ritar ramen runt fönstret
+//-----------------------------------------------------------------------------
+void TWindow::drawBorder()
+{
+	for(int i=Left+1; i< Right; i++)Display::drawChar(i	,Top		  , HLine		, foreground, background);
+	for(    i=Left+1; i< Right; i++)Display::drawChar(i	,Bottom		, HLine		, foreground, background);
+	for(    i=Top+1;  i< Bottom; i++)Display::drawChar(Left	,i		, VLine		, foreground, background);
+	for(    i=Top+1;  i< Bottom; i++)Display::drawChar(Right	,i		, VLine		, foreground, background);
+	Display::drawChar(Left	,Top		, LeftTop		, foreground, background);
+	Display::drawChar(Right	,Top		,RightTop		, foreground, background);
+	Display::drawChar(Right	,Bottom	,RightBottom, foreground, background);
+	Display::drawChar(Left	,Bottom	, LeftBottom, foreground, background);
+}
+void TWindow::move(unsigned relX, unsigned relY)
+{
+	Left=Left+relX;
+	Right=Right+relX;
+	Top=Top+relY;
+	Bottom=Bottom+relY;
+}
+void TWindow::moveAbs(unsigned x, unsigned y)
+{
+	unsigned width=Right-Left;
+	unsigned height=Bottom-Top;
+	Left=x;
+	Right=x+width;
+	Top=y;
+	Bottom=y+height;
+}
+
+void TWindow::setText(char* txt)
+{
+	text=new char[strlen(txt)];
+	strcpy(text, txt);
+}
+void TWindow::showText()
+{
+	int x=Left+1,y=Top+1;
+	for(int i=0;i<strlen(text);i++)
+	{
+		Display::drawChar(x, y, text[i], foreground, background);
+		if(++x>=Right)
+		{
+			x=Left+1;
+			y++;
+		}
+	}
+}
+void TWindow::editText()
+{
+	int i=0;
+	delete text;
+	int size=(Right-Left-1)*(Bottom-Top-1);
+	text=new char[size];
+	text[0]='\0';
+	char* buffer=new char[size];
+	while(((buffer[i]=bioskey(0))!=ENTER)&&(i<size))
+	{
+		if(buffer[i]==BACK)
+		{
+			text[i-1]='\0';
+			if(--i<0)i=0;
+			draw();
+			showText();
+		}
+		else if(buffer[i]==ESC)
+		{
+			delete text;
+			text=NULL;
+			draw();
+			return;
+		}
+		else if(isalnum(buffer[i])||buffer[i]==' ')
+		{
+			text[i]=buffer[i];
+			text[i+1]='\0';
+			showText();
+			i++;
+		}
+	}
+}
+TWindow& TWindow::operator=(TWindow& t)
+{
+	delete text;
+	text=new char[strlen(t.text)];
+	strcpy(text, t.text);
+	return *this;
+}
+boolean TWindow::operator==(TWindow& t)
+{
+	return strcmp(t.text, text)==0;
+}
+boolean TWindow::operator<(TWindow& t)
+{
+	return strcmp(text, t.text)<0;
+}
+boolean TWindow::operator>(TWindow& t)
+{
+	return strcmp(text, t.text)>0;
+}
+ostream& operator<<(ostream& o, TWindow& t)
+{
+	t.display();
+	return o;
+}
+istream& operator>>(istream&i, TWindow& t)
+{
+	t.editText();
+	return i;
+}
+

Stack_And_Queue/twindow.hpp

@@ -0,0 +1,39 @@
+#ifndef __TWINDOW__H
+#define __TWINDOW__H
+#include "keycode.h"
+#include "boolean.h"
+#include <iostream.h>
+typedef  unsigned char DColor;
+class TWindow
+{
+	public:
+		TWindow();
+		TWindow(unsigned left,unsigned top,unsigned right ,unsigned bottom, DColor bg, DColor fg);
+		~TWindow();
+		boolean isVisible() {return theState;}
+		void hide();
+		void display();
+		void move(unsigned nX, unsigned nY);
+		void TWindow::moveAbs(unsigned x, unsigned y);
+		void setText(char* txt);
+		void editText();
+		char* getText(){return text;};
+      void setColor(unsigned char col){background=col;};
+		TWindow& operator=(TWindow& t);
+		boolean operator==(TWindow& t);
+		boolean operator<(TWindow& t);
+      boolean operator>(TWindow& t);
+	private:
+		char* text;
+		DColor   background, foreground;
+		boolean    theState;
+		unsigned Left,Top, Right,Bottom;
+		void draw();
+		void erase();
+		void drawBorder();
+		void showText();
+};
+ostream& operator<<(ostream& o, TWindow& t);
+istream& operator>>(istream&i, TWindow& t);
+#endif
+