int main() {
char* fichero_existente = "/FICHEROS/lectura/leer_escritura_varios_tamanyos256";
char* fichero_no_existente = "/FICHEROS/lectura/leer_escritura_varios_tamanyos64";
//Montar disco.
printf("abrir_fichero_exista_noexista -> Montando el disco en la particion /FICHEROS/lectura con discoFS\n");
if(montar("disco", "lectura", "discoFS") < 0) {
printf("abrir_fichero_exista_noexista -> Error al montar particion lectura en disco con discoFS.\n");
}
//Abrir ficheros
int fd64 = abrir(fichero_no_existente, T_FICHERO);
if(fd64 < 0) {
printf("abrir_fichero_exista_noexista: Error al abrir fichero origen %s\n", fichero_no_existente);
return -1;
}
int fd256 = abrir(fichero_existente, T_FICHERO);
if(fd256 < 0) {
printf("abrir_fichero_exista_noexista: Error al abrir fichero origen %s\n", fichero_existente);
return -1;
}
printf("abrir_fichero_exista_noexista -> %s -> fd = %d", fichero_no_existente, fd64);
printf("abrir_fichero_exista_noexista -> %s -> fd = %d", fichero_existente, fd256);
//Mostrar ficheros.
char buffer[TAM_BUFFER + 1];
int leidos;
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd256, buffer, TAM_BUFFER);
int leidos256 = leidos;
while(leidos > 0) {
printf("%s",buffer);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd256, buffer, TAM_BUFFER);
leidos256 += leidos;
}
printf("Leidos(%s): %d\n", fichero_existente, leidos256);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd64, buffer, TAM_BUFFER);
int leidos64 = leidos;
while(leidos > 0) {
printf("%s",buffer);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd64, buffer, TAM_BUFFER);
leidos64 += leidos;
}
printf("Leidos(%s): %d\n", fichero_no_existente, leidos64);
//Cerrar ficheros
cerrar(fd64);
cerrar(fd256);
return 0;
}
void main(void)
{
struct dado info[5];
char op;
do {
clrscr();
printf("MENU PRINCIPAL\n");
printf("--------------\n");
printf("1. Inserir dados\n");
printf("2. Visualizar dados\n");
printf("3. Ler arquivo\n");
printf("4. Gravar arquivo\n");
printf("5. Sair\n");
op=getch();
if (op=='1') {
inserir(info);
} else if (op=='2') {
exibir(info);
} else if (op=='3') {
clrscr();
if (abrir(info)) {
printf("Arquivo aberto com sucesso!");
}
getch();
} else if (op=='4') {
clrscr();
if (salvar(info)) {
printf("Arquivo salvo com sucesso!");
}
getch();
}
} while (op!='5');
}
void main(){
flujo = 0;
abrir();
leer();
cerrar();
printf("buffer leido: %s \n", databuffer);
system("pause");
while(flujo == 0){
intentos = 10;
clearScreen();
copy_from_buffer_to_local();
rellena_cadenaRevelada(); //rellenar con guiones
implementar_mouse();
imprimeAbecedario();
if(game_over == 0){
printf("se acabaron los intentos \n");
printf("llegaste a formar: %s\n", cadenaRevelada);
//flujo = 1;
}
printf("volver a jugar? (presiona ENTER)\n");
printf("salir de la aplicacion? (presiona ESC)\n");
teclaLetra();
}
system("pause");
}
int main() {
/*
ESCRITURA FICHEROS
*/
//Abrir fichero.
int fd512 = abrir("/FICHEROS/lectura/fichero_mul_child512", T_FICHERO);
printf("escribir_fichero_mul_child(%d) -> fd = %d", obtener_id_proceso(), fd512);
if(fd512 < 0) {
printf("escribir_fichero_mul_child(%d) -> Error al abrir fichero origen fichero_mul_child512\n", obtener_id_proceso());
return -1;
}
//Llenar bloque.
char buffer512[512];
char letra = (char) ('A' + obtener_id_proceso());
llenar_bloque(letra, buffer512, 512);
//Escribir bloque.
int escritos512 = escribir(fd512, buffer512, 512);
printf("escribir_fichero_mul_child(%d) -> Escritos(512%c): %d\n", obtener_id_proceso(), letra, escritos512);
//Cerrar fichero.
cerrar(fd512);
/*
SINCRONIZADO DISCOFS
*/
printf("escribir_fichero_mul_child(%d) -> Sincronizando el volumen montado en /FICHEROS/lectura\n", obtener_id_proceso());
if(sincronizar("lectura") < 0) {
printf("escribir_fichero_mul_child(%d) -> Error al sincronizar el volumen\n", obtener_id_proceso());
}
return 0;
}
int main(){
char bloque[TAM_BLOQUE];
int fd_cdrom;
int ret;
int num=0;
printf("mostrar el cdrom por pantalla");
/* abrir fichero origen */
fd_cdrom = abrir ("/DISPOSITIVOS/cdrom",0);
if (0 > fd_cdrom) {
printf("copiar_disco: Error al abrir el cdrom\n");
return (-1);
}
/* mostra cdrom por pantalla */
printf("mostrar_disco: leyendo bloque %d\n\n\n",num);
ret = leer(fd_cdrom,bloque,TAM_BLOQUE);
while (0 < ret) {
printf("%s",bloque);
num=num+1;
printf("\n\nmostrar_disco: leyendo bloque %d\n\n\n",num);
ret = leer(fd_cdrom,bloque,TAM_BLOQUE);
}
/* cerrar cdrom */
cerrar (fd_cdrom);
return (0);
}
//----------------------
main()
{
menu();
int quant;
criar();
do
{
printf ("Informe o numero de identificação da peça: ");
scanf ("%d",&quant);
fflush(stdin);
if (quant == 0) {system ("cls");break;}
reg.id= quant;
fflush(stdin);
printf ("Informe a descrição da peça: ");
gets (reg.desc);
fflush(stdin);
printf ("Informe o fabricante: ");
gets (reg.fabricante);
fflush(stdin);
printf ("Informe o ano de fabricação: ");
scanf ("%d",®.ano);
fflush(stdin);
printf ("Informe o Preço Unitario: ");
scanf ("%d",®.preco);
fflush(stdin);
printf ("Informea quantidade disponivel: ");
scanf ("%d",®.quantidade);
fflush(stdin);
printf ("----------------------------------------\n");
getch ();
system ("cls");
menu();
fwrite (®,sizeof(reg),1,arquivo);
}
while (quant != 0);
fechar();
abrir();
int fab_2009=0,mais_1000=0,somatorio=0,cara=0,barata;
barata= reg.preco;
while (fread(®,sizeof(reg),1,arquivo))
{
if (reg.ano == 2009) {++fab_2009;}
if (reg.preco > 1000) {++mais_1000;}
if (((reg.id % 2)== 1) || (reg.preco > 30)) {somatorio= somatorio + reg.preco;}
if (reg.preco > cara) {cara= reg.preco;}
if (reg.preco < barata) {barata= reg.preco;}
}
fechar();
printf ("- Foram fabricadas %d peças em 2009\n\n",fab_2009);
printf ("- Contem %d peças mais caras que 1000 reias\n\n",mais_1000);
printf ("- A soma dos preços de peças com 'Id' impar\n\n");
printf ("ou mais caro que 30 reais é %d\n\n",somatorio);
printf ("- %d é o presço mais caro\n\n",cara);
printf ("- %d é o preço mais barato\n\n",barata);
getch ();
}
int main(){
char bloque[1025];
int fd_disco;
int ret;
int num_bloque=0;
int error_encontrado = 0;
int id_actual = obtener_id_proceso();
printf("Comprobando lectura por bloques (%d)\n", id_actual);
/* limpiar el bloque */
for(ret = 0; ret < 1024; ret ++){
bloque[ret] = 'n';
}
bloque[1024] = '\0';
/* abrir fichero origen */
fd_disco = abrir ("/DISPOSITIVOS/disco",0);
if (0 > fd_disco) {
printf("test_bloque_cdrom(%d): Error al abrir el cdrom\n", id_actual);
printf("### Result: Fail\n");
return (-1);
}
/* mostra cdrom por pantalla */
printf("test_disco_cdrom (%d) leyendo bloque %d\n", id_actual, num_bloque);
ret = leer(fd_disco, bloque, 1024);
error_encontrado = comprobar_valores(bloque, num_bloque);
while ((0 < ret) && !error_encontrado) {
fprintf(stdout, "{%s}FIN\n", bloque);
num_bloque++;
printf("test_disco_cdrom (%d) leyendo bloque %d\n", id_actual, num_bloque);
ret = leer(fd_disco, bloque, 1024);
if(ret > 0){
error_encontrado = comprobar_valores(bloque, num_bloque);
}
}
printf("Bloque final: %d, error_encontrado: %d\n", num_bloque, error_encontrado);
/* El Ãltimo bloque leido no deberÃa sobrepasar la imagen. */
if(num_bloque != 10){
printf("### Result: Fail\n");
}else{
if(!error_encontrado){
printf("### Result: OK\n");
}else{
printf("### Result: Fail\n");
}
}
/* cerrar cdrom */
cerrar (fd_disco);
return (0);
}
int main ()
{
char* arg_list[] = {
"SublimeText", NULL
};
abrir ("SublimeText", arg_list);
return 0;
}
principal::principal(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::principal)
{
ui->setupUi(this);
connect(ui->actionAbrir, SIGNAL(triggered()), this, SLOT(abrir()));
connect(ui->actionSalvar, SIGNAL(triggered()), this, SLOT(salvar()));
connect(ui->actionSair, SIGNAL(triggered()), this, SLOT(sair()));
}
void USART2_IRQHandler(void) {
static char t[2];
static uint16_t cnt = 0; // this counter is used to determine the string length
char *comando;
char *argumento;
t[1] = '\0';
// check if the USART2 receive interrupt flag was set
if (USART_GetITStatus(USART2, USART_IT_RXNE )) {
t[0] = USART2 ->DR; // the character from the USART1 data register is saved in t
/* check if the received character is not the LF character (used to determine end of string)
* or the if the maximum string length has been been reached
*/
if ((t[0] != '\n') && (cnt < MAX_STRLEN)) {
if ((t[0] >= 'a' && t[0] <= 'z') || (t[0] >= 'A' && t[0] <= 'Z')
|| (t[0] >= '0' && t[0] <= '9') || t[0] == ' ') {
USART_puts(USART2, t);
if (received_string[cnt] == '\0') {
received_string[cnt + 1] = '\0';
}
received_string[cnt] = t[0];
cnt++;
} else if (t[0] == 0x7f) {
if (cnt > 0) {
cnt--;
received_string[cnt] = '\0';
USART_puts(USART2, "\b \b");
}
}
} else if (t[0] == '\n') { // otherwise reset the character counter and print the received string
cnt = 0;
USART_puts(USART2, "\n");
comando = strtok(received_string, " ");
argumento = strtok(NULL, " ");
if (strcmp(comando, "cadastrar") == 0) {
cadastrar(argumento);
} else if (strcmp(comando, "listar") == 0) {
listar();
} else if (strcmp(comando, "resetar") == 0) {
resetarRegistros();
} else if (strcmp(comando, "abrir") == 0) {
abrir(argumento, 1);
} else {
USART_puts(USART2, "Comando desconhecido!");
}
USART_puts(USART2, "\n");
USART_puts(USART2, ">");
received_string[0] = '\0';
}
}
}
int main(){
int fd_disco = -1;
int ret = -1;
int comparador;
char bufferL[1025];
char bufferE[1025];
memset(bufferE, 'a', 1024);
bufferE[1024] = '\0';
bufferL[1024] = '\0';
/* abrir fichero disco */
fd_disco = abrir ("/DISPOSITIVOS/disco", 0);
if (0 > fd_disco) {
printf("test_e2_2_leer_bloque: Error al abrir el disco \n");
printf("### Result: Fail\n");
return (-1);
}
ret = leer(fd_disco, bufferL, 1024);
if ( 0 > ret){
printf("test_e2_2_leer_bloque: Error al leer del disco \n");
printf("### Result: Fail\n");
return (-1);
}
mostrarBuffer(bufferE);
mostrarBuffer(bufferL);
/* comparamos datos extraidos */
comparador = strcmp(bufferE, bufferL);
if(comparador != 0)
{
printf("test_e2_2_leer_bloque: Datos en el disco no encontrados \n");
printf("### Result: Fail\n");
return -1;
}
printf("### Result: OK\n");
return 0;
}
int main(){
char origen[MAX_STRING];
char buffer[TAM_BUFFER];
int escritos;
int ret;
int fd_origen;
printf("Montando el disco en la particion /FICHEROS/lectura con discoFS\n");
ret=montar("disco", "lectura", "discoFS");
if (0 > ret) {
printf("escribir_fichero: Error al montar particion lectura en disco con discoFS\n");
}
/* obtener los nombre de los ficheros */
printf("Introduzca el fichero destino EJ: /FICHEROS/lectura/datos:");
scanf("%s",origen);
/* abrir fichero origen */
fd_origen = abrir (origen,T_FICHERO);
if (0 > fd_origen) {
printf("escribir_fichero: Error al abrir fichero destino %s\n", origen);
return (-1);
}
llenar_bloque('A', buffer);
escritos = escribir(fd_origen,buffer,TAM_BUFFER);
printf("%d\n", escritos);
cerrar(fd_origen);
return (0);
}
int main(){
char origen[MAX_STRING];
char destino[MAX_STRING];
char buffer[TAM_BUFFER];
int fd_origen, fd_destino;
int leidos, escritos;
int ret;
/* montar debugfs */
printf("Montando la depuracion en la particion /FICHEROS/proc con debugFS\n");
ret=montar("", "proc", "debugFS");
if (0 > ret) {
printf("mostrar_fichero: Error al montar particion de depuracion con debugFS\n");
return (-1);
}
/* montar cdrom */
printf("Montando el cdrom en la particion /FICHEROS/lectura con cdromFS\n");
ret=montar("cdrom","lectura", "cdromFS");
if (0 > ret) {
printf("Copiar_fichero: Error al montar particion lectura en cdrom con cdromFS\n");
return (-1);
}
/* montar disco */
printf("Montando el disco en la particion /FICHEROS/escritura con discoFS\n");
ret=montar("disco","escritura", "discoFS");
if (0 > ret) {
printf("Copiar_fichero: Error al montar particion escritura en disco con discoFS\n");
return (-1);
}
/* obtener los nombre de los ficheros */
printf("Introduzca el fichero origen EJ: /FICHEROS/lectura/datos:");
scanf("%s",origen);
printf("Introduzca el fichero destino EJ: /FICHEROS/escritura/resultado:");
scanf("%s",destino);
/* abrir fichero origen */
fd_origen = abrir (origen, T_FICHERO);
if (0 > fd_origen) {
printf("Copiar_fichero: Error al abrir fichero origen %s\n", origen);
return (-1);
}
/* abrir fichero destino */
fd_destino = abrir (destino, T_FICHERO);
if (0 > fd_destino) {
printf("Copiar_fichero: Error al abrir fichero destino %s\n", destino);
return (-1);
}
/* copiar origen en destino */
leidos = leer(fd_origen,buffer,TAM_BUFFER);
while (0 < leidos) {
escritos = escribir(fd_destino,buffer,leidos);
if (leidos != escritos) {
printf("Copiar_fichero: Error al escribir fichero destino %s\n", destino);
return (-1);
}
leidos = leer(fd_origen,buffer,TAM_BUFFER);
}
/* cerrar fichero origen */
cerrar (fd_origen);
/* cerrar fichero destino */
cerrar (fd_destino);
/* sincronizar las escrituras */
printf("Escribiendo los cambios de la particion /FICHEROS/escritura en el disco\n");
sincronizar("escritura");
return 0;
}
int main(){
int retDebug;
int fd_origen = -1;
int fd_disco = -1;
int leidos = -1;
int seek = 0;
//PUEDE NECESITAR CAMBIO EN FUNCION DEL NUMERO DE DESCRIPTOR Y DEL NUMERO DE DISPOSITIVO
char cadenaDescFichero[200] = "DESCFICHERO:\tID=2, tipo=0, inodo=-1, montaje=-1, Dispositivo=3\n";
//char cadenaDescFichero[200] = "DESCFICHERO:\tID=2, tipo=0, inodo=-1, montaje=-1, Dispositivo=2\n";
char buffer[1024];
char *encontrado = NULL;
buffer[1023] = '\0';
/* montar debugfs */
//printf("Montando la depuracion en la particion /FICHEROS/proc con debugFS\n");
retDebug=montar("", "proc", "debugFS");
if (0 > retDebug) {
printf("test_e2_1_abrir_disco: Error al montar particion de depuracion con debugFS\n");
printf("### Result: Fail\n");
return (-1);
}
/* abrir fichero disco */
fd_disco = abrir ("/DISPOSITIVOS/disco", 0);
if (0 > fd_disco) {
printf("test_e2_1_abrir_disco: Error al abrir el disco \n");
printf("### Result: Fail\n");
return (-1);
}
/* abrir fichero tabla de descriptores (tabla_procesos) */
fd_origen = abrir ("/FICHEROS/proc/tabla_procesos", T_FICHERO);
if (0 > fd_origen) {
printf("test_e2_1_abrir_disco: Error al abrir fichero tabla_descriptores \n");
printf("### Result: Fail\n");
return (-1);
}
/*leemos la tabla de descriptores*/
bzero(buffer, 1023);
seek = 0;
leidos = leer(fd_origen,buffer,1023);
while (0 < leidos && leidos != 1023) {
seek += leidos;
leidos = leer(fd_origen,&(buffer[seek]),1023-seek);
}
printf("%s\n\n\n", buffer); //Falla con ficheros de imagen que tengan archivos de tamaño mayor que un bloque
cerrar(fd_origen);
cerrar(fd_disco);
/*buscamos datos en la tabla de descriptores*/
encontrado = strstr(buffer, cadenaDescFichero);
if(encontrado == NULL)
{
printf("test_e2_1_abrir_disco: Datos en la tabla de descriptores no encontrados \n");
printf("### Result: Fail\n");
return -1;
}
printf("### Result: OK\n");
return 0;
}
int sys_ejecutar ( char* arch, char* args[] ) {
int i, fd, idx_codigo, idx_dato;
pcb* nueva_tarea;
dword funcion;
char* dato = (char*)alocar (11);
char* archivo = arch + recuperar_base ();
char** args1 = (char**) (((int)args) + recuperar_base() );
char* argu;
if ( args1 != NULL ) {
i = 0;
imprimir ( "Mostrando argumentos:\n" );
while ( args1[i] != NULL ) {
argu = (char*) ( ((int)args1[i]) + recuperar_base () );
imprimir ( "args[%d] = <%s>\n", i, argu );
i++;
}
for (i = 0; i < 12 && archivo [i] != '\0'; i++) {
dato [i] = archivo [i];
}
} else {
imprimir ( "No se recibieron argumentos en ejecutar\n" );
}
imprimir_cadena ( "Abriendo: <" );
imprimir_cadena ( archivo );
imprimir_cadena ( " - " );
imprimir_cadena ( dato );
imprimir_cadena ( ">\n" );
fd = abrir ( archivo );
funcion = (dword) sys_alocar ( tarea_actual->archivos [fd].ed.tamanio +
TAMANIO_PILA_USUARIO );
if ( funcion == NULL ) {
return -1;
}
if ( fd == ERROR ) {
return -1;
} else {
idx_codigo = siguiente_indice_gdt ();
setear_desc_seg ( SEG_CODIGO, funcion, &_gdt->descriptores[idx_codigo],
0xFFFFF );
// tarea_actual->archivos [fd].ed.tamanio );
idx_dato = siguiente_indice_gdt ();
setear_desc_seg ( SEG_DATOS, funcion, &_gdt->descriptores[idx_dato],
0xFFFFF );
// tarea_actual->archivos [fd].ed.tamanio +
// TAMANIO_PILA_USUARIO );
leer_archivo (fd, (void*)funcion, tarea_actual->archivos [fd].ed.tamanio);
nueva_tarea = crear_tarea ((handler_tarea)funcion);
//nueva_tarea->dato = archivo;
//nueva_tarea->dato = arch;
nueva_tarea->dato = dato;
nueva_tarea->tarea->eip = 0x00;
nueva_tarea->tarea->cs = 8 * idx_codigo;
nueva_tarea->tarea->ds = 8 * idx_dato;
nueva_tarea->tarea->es = nueva_tarea->tarea->ds;
nueva_tarea->tarea->fs = nueva_tarea->tarea->ds;
nueva_tarea->tarea->gs = nueva_tarea->tarea->ds;
nueva_tarea->selector_ds = nueva_tarea->tarea->ds >> 3;
/*
nueva_tarea->tarea->esp = funcion + TAMANIO_PILA_USUARIO +
tarea_actual->archivos [fd].ed.tamanio;
nueva_tarea->tarea->ss = nueva_tarea->tarea->ds;
nueva_tarea->tarea->ss0 = nueva_tarea->tarea->ds;
nueva_tarea->tarea->ss1 = nueva_tarea->tarea->ds;
nueva_tarea->tarea->ss2 = nueva_tarea->tarea->ds;
*/
/*
imprimir_cadena ("poniendo en ejecucion a ");
imprimir_cadena (dato);
imprimir_cadena ("\n");
*/
agregar (nueva_tarea);
//cerrar ( fd );
}
return nueva_tarea->pid;
}
void VentanaPrincipal::crearAcciones()
{
accionCompilar = new QAction(QIcon(":/imagenes/compile.png"), tr("Compilar"), this);
accionCompilar->setStatusTip("Compilar archivo actual");
connect(accionCompilar, SIGNAL(triggered()), this, SLOT(compilar()));
accionNuevo = new QAction(QIcon(":/imagenes/new.png"), tr("Nuevo"), this);
accionNuevo->setShortcuts(QKeySequence::New);
accionNuevo->setStatusTip(tr("Crear un nuevo archivo"));
connect(accionNuevo, SIGNAL(triggered()), this, SLOT(nuevoArchivo()));
accionAbrir = new QAction(QIcon(":/imagenes/open.png"), tr("Abrir..."), this);
accionAbrir->setShortcuts(QKeySequence::Open);
accionAbrir->setStatusTip(tr("Abrir un archivo existente"));
connect(accionAbrir, SIGNAL(triggered()), this, SLOT(abrir()));
accionGuardar = new QAction(QIcon(":/imagenes/save.png"), tr("Guardar"), this);
accionGuardar->setShortcuts(QKeySequence::Save);
accionGuardar->setStatusTip(tr("Guardar cambios del archivo"));
connect(accionGuardar, SIGNAL(triggered()), this, SLOT(guardar()));
accionGuardarComo = new QAction(tr("Guardar como..."), this);
accionGuardarComo->setShortcuts(QKeySequence::SaveAs);
accionGuardarComo->setStatusTip(tr("Guardar archivo con un nuevo nombre"));
connect(accionGuardarComo, SIGNAL(triggered()), this, SLOT(guardarComo()));
accionSalir = new QAction(tr("Salir"), this);
accionSalir->setShortcuts(QKeySequence::Quit);
accionSalir->setStatusTip(tr("Salir de la aplicacion"));
connect(accionSalir, SIGNAL(triggered()), this, SLOT(close()));
accionCortar = new QAction(QIcon(":/imagenes/cut.png"), tr("Cortar"), this);
accionCortar->setShortcuts(QKeySequence::Cut);
accionCortar->setStatusTip(tr("Cortar el contenido seleccionado al portapapeles"));
connect(accionCortar, SIGNAL(triggered()), editorTexto, SLOT(cut()));
accionCopiar = new QAction(QIcon(":/imagenes/copy.png"), tr("Copiar"), this);
accionCopiar->setShortcuts(QKeySequence::Copy);
accionCopiar->setStatusTip(tr("Copiar el contenido seleccionado al portapapeles"));
connect(accionCopiar, SIGNAL(triggered()), editorTexto, SLOT(copy()));
accionPegar = new QAction(QIcon(":/imagenes/paste.png"), tr("Pegar"), this);
accionPegar->setShortcuts(QKeySequence::Paste);
accionPegar->setStatusTip(tr("Pegar el contenido del portapapeles en el lugar seleccionado"));
connect(accionPegar, SIGNAL(triggered()), editorTexto, SLOT(paste()));
accionAcercaDe = new QAction(tr("Acerca de"), this);
accionAcercaDe->setStatusTip(tr("Mostrar informacion de la aplicacion"));
connect(accionAcercaDe, SIGNAL(triggered()), this, SLOT(acercaDe()));
accionAcercaDeQT = new QAction(tr("Acerca de Qt"), this);
accionAcercaDeQT->setStatusTip(tr("Mostrar informacion de QT"));
connect(accionAcercaDeQT, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
//Dejar que la disponibilidad de estas acciones se manejen por los eventos
accionCortar->setEnabled(false);
accionCopiar->setEnabled(false);
connect(editorTexto,
SIGNAL(copyAvailable(bool)),
accionCortar,
SLOT(setEnabled(bool)));
connect(editorTexto,
SIGNAL(copyAvailable(bool)),
accionCopiar,
SLOT(setEnabled(bool)));
}