KOMPLETTES PROGRAMM: Datenverwaltung
//////////////////////////////////////////////
// Bildschirm-Steuerung
// fuer Dateiverwaltung
// mit drop-down menu
// für Datenverwaltungsprogramm
// MENU.c
#include <conio.h>
#include <string.h>
#include <process.h> // exit()
#include "func.h"
#define TRUE 1
#define U_ARRO 72 // Up-arrow key
#define D_ARRO 80 // Down-arrow key
#define MENU_WIDTH 15 // width of menu
#define MAX_ITEMS 7 // number of menu items
char *menu_item[MAX_ITEMS] = // menu item names
{
" Anzeigen ",
" Anhaengen ",
" Suchen ",
" Speichern ",
" neueDatei ",
" reorganize",
" Quit "
};
////////////////////////////
// Prototypen
void display_menu(void);
void draw_box(int left, int top, int width, int height);
char get_code(void);
void menu_action(char *item_name);
int vpos; // position of active item on menu (0 at top)
int ret; // return-value
///////////////////////////////////////////////////////////////////
// main()
// gets key-press from user, changes selected item, takes action
int main(void) {
textbackground(BLUE); // clear screen to blue
clrscr();
_setcursortype(0); // remove cursor
while(TRUE) {
//--------------------------
display_menu(); // display the menu
// -------------------------
switch ( get_code() ) { // get key press from user
case U_ARRO:
if (vpos > 0) vpos -= 1;
else vpos = MAX_ITEMS -1;
break;
case D_ARRO:
vpos = (vpos < MAX_ITEMS-1) ? ++vpos : 0;
break;
case '\r': // perform menu action
menu_action( menu_item[vpos] ); // arg is item name
break;
} // end switch
} // end while
} // end main()
/////////////////////////////////////////////////////////
// FUNKTIONEN
// display_menu()
// displays box and menu items, highlights active item
void display_menu() {
int j;
textbackground(WHITE); // black on white
textcolor(BLACK);
//--------------------
draw_box(1, 2, MENU_WIDTH+1, MAX_ITEMS+2); // draw the box
//----------------------
for(j = 0; j < MAX_ITEMS; j++) { // for each menu item
if(j == vpos) { // if active item,
textbackground(LIGHTBLUE);
textcolor(WHITE);
}
gotoxy(3, j + 3); // display item name
cputs( menu_item[j] );
textbackground(WHITE); // restore background
textcolor(BLACK);
}
} // end display_menu()
//////////////////////////////////////////////////////////////////////
// draws a box with a single line around it
void draw_box(int left, int top, int width, int height) {
int j;
char string[81]; // utility string
// define box-size window
window(left, top, left+width-1, top+height-1);
clrscr(); // clear window to background color
// now add line so chars on bottom line won't cause scroll
window(left, top, left+width-1, top+height);
// draw top and bottom lines, with corners
for(j=1; jganzer Bildschirm
textbackground(BLUE); // Hintergrund auf BLAU setzen
clrscr(); // BS loeschen
}
//----------------------------------------------------------------------
if( strcmp(item_name, " Anzeigen ") == 0) {
loeschen(); // erst Vektor im RAM leeren
ret = lesen(); // ret -> Anzahl der gelesenen Elemente
anzeigen(ret);
clrscr();
window(0,0, 80,25); // window->ganzer Bildschirm
textbackground(BLUE); // Hintergrund auf BLAU setzen
clrscr(); // BS löschen
}
//---------------------------------------------------------------------------
if( strcmp(item_name, " Suchen ") == 0) {
loeschen();
ret=lesen();
suchen(ret);
clrscr();
window(0,0, 80,25); // window->ganzer Bildschirm
textbackground(BLUE); // Hintergrund auf BLAU setzen
clrscr(); // BS löschen
}
//----------------------------------------------------------------------
if( strcmp(item_name, " Speichern ") == 0) {
if (i>0)
ret = speichern(i); // i -> Anzahl der zu speichernden Elemente
clrscr();
window(0,0, 80,25); // window->ganzer Bildschirm
textbackground(BLUE); // Hintergrund auf BLAU setzen
clrscr(); // BS loeschen
}
//---------------------------------------------------------------------------
if( strcmp(item_name, " neueDatei ") == 0 ) {
ret = dateiname();
clrscr();
window(0,0, 80,25); // window->ganzer Bildschirm
textbackground(BLUE); // Hintergrund auf BLAU setzen
clrscr(); // BS loeschen
}
// ----------------------------------------------------------------------------
if( strcmp(item_name, " reorganize") == 0 ) {
ret = reorg();
clrscr();
window(0,0, 80,25); // window->ganzer Bildschirm
textbackground(BLUE); // Hintergrund auf BLAU setzen
clrscr(); // BS loeschen
}
// ----------------------------------------------------------------------------
if( strcmp(item_name, " Quit ") == 0 ) {
//speichern(i);
_setcursortype(_NORMALCURSOR); // restore cursor
exit(0); // exit to DOS
}
} // end menu_action
///////////////////////////////////////////////////////////////////////
// FUNC.h
///////////////////////////////////////////////////////
// FUNC.h
// Header-Datei
// (externe Variablen und Prototypen der Funktionen)
#define MAX 50
extern char datei[];
extern int i;
// ------------------------------------
// Prototypen der Funktionen
// ------------------------------------
void linebox (void);
int append (int);
int speichern(int);
int loeschen (void);
int lesen (void);
int suchen (int);
int anzeigen (int);
int dateiname(void);
int reorg (void);
/////////////////////////////////////////////////777
// FUNC.c
// Funktions-Definitionen
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include "func.h"
// -- Definition der verwendeten globalen Datentypen:
// -- STRUCT, Vektor von structs, Dateiname
struct Texte {
char suchbegriff [80];
char beschreibung[512];
char literatur [80];
char anzahl;
char deleted;
};
struct Texte vek[MAX]; // Vektor aus MAX struct-Elementen
char datei[20] ="c://dbtest.txt";
int i;
// -----------------------------------------
// FUNKTIONEN
// -----------------------------------------
////////////////////////////////////////////
// APPEND
// Datensaetze anfuegen:
// einlesen aus Datei
// und speichern
int append(int i) {
int neu=0;
if (i == -1) i=0; // Weil -1 heisst: Datei ist nicht vorhanden
while(1) { // Neue Datensätze einlesen von Console
linebox();
gotoxy(15,1);
textcolor(RED);
cprintf(" < %s : %i >",datei, i+1);
textcolor(BLUE);
gotoxy(2,2);
cputs("Begriff: ");
gets(vek[i].suchbegriff);
if ( strlen ( vek[i].suchbegriff ) < 1) { // Fertig mit einlesen
break;
}
gotoxy(2,5);
cputs("Beschreibung: ");
gets(vek[i].beschreibung);
gotoxy(2,8);
cputs("Literatur: ");
gets(vek[i].literatur);
vek[i].deleted=' ';
neu++; // Es wurde ein neuer Datensatz eingegeben
i++;
}
if (neu) speichern(i);
return i; // Neue Gesamtzahl
}
//////////////////////////////////////////////
// struct in Datei speichern
int speichern(int i) {
FILE *fp;
fp = fopen(datei,"w");
linebox();
if (fp == NULL) {
gotoxy(5,5);
textcolor(RED);
cprintf("Datei konnte nicht gespeichert werden!");
textcolor(BLACK);
getch();
return -1;
}
// Datensätze schreiben
vek[0].anzahl = i-1; // Aktuelle Anzahl der Elemente
// im ersten Element speichern
fwrite(vek, sizeof(struct Texte), i, fp);
fclose(fp);
gotoxy(15,1);
textcolor(RED);
cprintf(" < %s >",datei);
textcolor(BLUE);
gotoxy(5,3);
cprintf("%i Datensaetze gespeichert...",i);
gotoxy(20,16);
cputs(" < TASTE > ");
getch();
return i;
}
//////////////////////////////////////////////////
// Vektor im RAM loeschen
int loeschen( ) {
int j = 0;
while( j < MAX ) {
strcpy( vek[j].suchbegriff, "");
strcpy( vek[j].beschreibung, "");
strcpy( vek[j].literatur, "");
vek[j].anzahl=0;
vek[j].deleted=' ';
j++;
}
return j;
}
///////////////////////////////////////////////////
// Datei oeffnen und lesen
int lesen( ) {
FILE * fp;
fp = fopen( datei, "r" ); // Zum Lesen öffnen
if (fp == NULL)
return -1;
fread(vek, sizeof(struct Texte), 1, fp); // Erstes Element holen
i = vek[0].anzahl + 1;
rewind(fp); // an den Anfang gehen
i = fread(vek, sizeof(struct Texte), i, fp); // strukturiertes Lesen
fclose(fp);
return i; // Anzahl gelesener Datensaetze
}
///////////////////////////////////////////////
// Bildschirmausgabe:
// Datensätze anzeigen / loeschen / wiederherstellen
int anzeigen(int i) {
int j = 0;
int c;
int neu=0; // gibt an, ob Datensätze gespeichert werden müssen
while( j < i ) {
clrscr();
linebox();
if (vek[j].deleted == 'l') {
gotoxy(2,4);
cprintf("Datensatz %i geloescht!", j+1);
gotoxy(2,5);
textcolor(RED);
cprintf("Wiederherstellen => r");
if((c=getch()) !='r') {
j++;
continue;
}
else { ////////// Datensatz wiederherstellen ////////////
clrscr();
linebox();
gotoxy(2,2);
cprintf("Datensatz %i wiederhergestellt!", j+1);
vek[j].deleted=' ';
neu++;
}
}
gotoxy(11,1);
textcolor(RED);
if (j+1 == i)
cprintf (" < LETZTER DATENSATZ: %i > ", j+1);
else
cprintf(" < %s, %i von %i > ",datei, j+1, i);
gotoxy(2,3);
textcolor(BLACK);
cputs("Begriff:\n");
textcolor(BLUE);
gotoxy(2,4);
cputs(vek[j].suchbegriff);
gotoxy(2,6);
textcolor(BLACK);
cputs("Beschreibung:\n");
gotoxy(2,7);
textcolor(BLUE);
cputs(vek[j].beschreibung);
gotoxy(2,10);
textcolor(BLACK);
cputs("Literatur:\n");
gotoxy(2,11);
textcolor(BLUE);
cputs(vek[j].literatur);
gotoxy(15,16);
textcolor(RED);
cputs(" < loeschen => l > ");
///////////////////////////////////////////////////////////
if((c=getch())== 'l') {
clrscr();
linebox();
gotoxy(10,4);
cprintf("Datensatz %i wurde soeben geloescht...", j+1);
getch();
neu++;
vek[j].deleted=c; // gelöscht !!!!!!!!!
}
///////////////////////////////////////////////////////////
j++;
}
if (neu) speichern(j);
return j;
}
/////////////////////////////////////////////////
// Neue Datei anlegen
int dateiname(void) {
char datei_neu[8];
linebox();
gotoxy(15,1);
textcolor(RED);
cprintf(" < %s >",datei);
gotoxy(20,16);
cputs(" < TASTE > ");
textcolor(BLACK);
gotoxy(3,3);
cputs("Neuer Dateiname: ");
gets(datei_neu);
if (strlen(datei_neu) > 0 ) {
strcpy(datei , datei_neu);
i = 0;
return 1;
}
return 0;
}
/////////////////////////////////////////////
// int suchen ()
// sucht einen String in einem Datensatzfeld
int suchen (int i) {
char such[20];
int j=0, k=0, l=0, found=-1;
linebox();
gotoxy(10,2);
cputs("Bitte Suchstring eingeben: ");
gotoxy(2,3);
gets(such);
while(j < i) { // Alle Datensätze durchgehen und vergleichen
found = -1, k=0, l=0;
while( vek[j].suchbegriff[k] != '\0') {
while((vek[j].suchbegriff[k++] == such[l]) && such[l++] !='\0') {
if (found == -1) found = j;
}
if (found > 0) {
clrscr();
linebox();
gotoxy(13,1);
textcolor(RED);
cprintf(" < Datensatz Nr. %i > ", j+1);
textcolor(BLACK);
gotoxy(2,2);
cputs("Begriff: ");
cputs(vek[j].suchbegriff);
gotoxy(15,16);
textcolor(RED);
cputs("< WEITER ? >");
textcolor(BLACK);
getch();
}
j++;
}
}
return found;
}
//////////////////////////////////////////////
// Datei reorganisieren
// Gelöschte Datensaetze dauerhaft entfernen
int reorg() {
FILE *fp;
int j=0,k=0;
struct Texte vek2[MAX]; // Vektor aus struct-Elementen
clrscr();
linebox();
for(j=0; j < i; j++) {
//cprintf("%i\n",k);
if(vek[j].deleted != 'l') {
vek2[k++] = vek[j];
}
}
vek2[0].anzahl = k-1;
fp = fopen(datei,"w");
fwrite(vek2, sizeof(struct Texte), k, fp); // Komprimierte Datei speichern
fclose(fp);
loeschen(); // Vektor im Speicher loeschen
gotoxy(10,1);
textcolor(RED);
cprintf(" < Datenbank reorganisiert: %i Saetze> ", k);
textcolor(BLACK);
getch();
return k;
}