Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » Editor de Texto en C

C/Visual C - Editor de Texto en C

Volver
Nuevo Tema
<<>>
 
Vista:

Editor de Texto en C

Publicado por Laura (2 intervenciones) el 19/06/2003 23:10:34
Estoy desarrollando un Editor de texto en el modo grafico de turbo C++, y necesito alguna orientacion sobre como realizar el "scroll" (funcion de las barras de desplazamiento) si el manejo del texto se hace a traves de estructuras de datos con nodos encadenados en memoria, la duda es como hacer que el cada linea que se va escribiendo sea almacenada en disco y en la ram para evitar que se agote la memoria con el uso del modo grafico y de los nodos creados dinamicamente.
Cualquier ayuda se la voy a agradecer!!!!!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Implementación de scroll y manejo de texto en un editor de texto en Turbo C++

Publicado por Alejandro (1286 intervenciones) el 04/07/2025 00:21:06
Para desarrollar un editor de texto en Turbo C++ que maneje el desplazamiento (scroll) y almacene el texto tanto en memoria como en disco, puedes seguir estos pasos. Utilizaremos una estructura de datos basada en nodos encadenados para almacenar las líneas de texto y implementaremos la funcionalidad de desplazamiento.

1. Estructura de datos



Primero, define una estructura para representar cada línea de texto. Puedes usar una lista enlazada para almacenar las líneas:

1
2
3
4
5
6
struct Line {
    char *text;          // Puntero a la línea de texto
    struct Line *next;   // Puntero a la siguiente línea
};
 
Line *head = nullptr; // Cabeza de la lista enlazada

2. Funciones para manejar el texto



a. Agregar línea



Crea una función para agregar una nueva línea a la lista:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void addLine(constchar *newText) {
    Line *newLine = new Line;
    newLine->text = new char[strlen(newText) + 1];
    strcpy(newLine->text, newText);
    newLine->next = nullptr;
 
    if (head == nullptr) {
        head = newLine;
    } else {
        Line *current = head;
        while (current->next != nullptr) {
            current = current->next;
        }
        current->next = newLine;
    }
}

b. Guardar en disco



Crea una función para guardar el texto en un archivo:

1
2
3
4
5
6
7
8
9
10
11
void saveToFile(const char *filename) {
    FILE *file = fopen(filename, "w");
    if (file) {
        Line *current = head;
        while (current != nullptr) {
            fprintf(file, "%s\n", current->text);
            current = current->next;
        }
        fclose(file);
    }
}

3. Implementar scroll



Para implementar el desplazamiento, necesitarás manejar la visualización de las líneas en la pantalla. Puedes usar las funciones de Turbo C++ para dibujar en modo gráfico.

a. Mostrar texto



Crea una función para mostrar las líneas en la pantalla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void displayText(int startLine, int maxLines) {
    int y = 0; // Coordenada Y para dibujar
    Line *current = head;
    int lineCount = 0;
 
    while (current != nullptr && lineCount < startLine + maxLines) {
        if (lineCount >= startLine) {
            outtextxy(10, y, current->text); // Dibuja la línea en la posición Y
            y += 15; // Incrementa la posición Y para la siguiente línea
        }
        current = current->next;
        lineCount++;
    }
}

b. Manejar el scroll



Puedes implementar el desplazamiento utilizando las teclas de dirección o las teclas de página. Aquí hay un ejemplo básico:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void scrollText(int &startLine, int maxLines) {
    char ch;
    while (true) {
        if (kbhit()) {
            ch = getch();
            if (ch == 72) { // Flecha arriba
                if (startLine > 0) startLine--;
            } else if (ch == 80) { // Flecha abajo
                startLine++;
            } else if (ch == 27) { // Esc para salir
                break;
            }
            cleardevice(); // Limpia la pantalla
            displayText(startLine, maxLines); // Muestra el texto
        }
    }
}

4. Cargar texto desde disco



Para cargar el texto desde un archivo al iniciar el editor, puedes crear una función que lea el archivo y llene la lista enlazada:

1
2
3
4
5
6
7
8
9
10
11
void loadFromFile(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (file) {
        char buffer[256];
        while (fgets(buffer, sizeof(buffer), file)) {
            buffer[strcspn(buffer, "\n")] = 0; // Eliminar el salto de línea
            addLine(buffer);
        }
        fclose(file);
    }
}

5. Consideraciones finales



- Gestión de memoria: Asegúrate de liberar la memoria de las líneas cuando ya no las necesites para evitar fugas de memoria.
- Optimización: Si el archivo de texto es muy grande, considera implementar un sistema de paginación para cargar solo las líneas necesarias en memoria.
- Interfaz gráfica: Asegúrate de que la interfaz gráfica sea intuitiva y fácil de usar.

Con estos pasos, deberías poder implementar un editor de texto básico en Turbo C++ que maneje el desplazamiento y almacene el texto en memoria y en disco. ¡Buena suerte, Laura!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar