Club Builder - Foros de discusión Club Builder
Foro de C++Builder en español
 
 FAQFAQ   BuscarBuscar   MiembrosMiembros   Grupos de UsuariosGrupos de Usuarios   RegistrarseRegistrarse 
 PerfilPerfil   Entra para ver tus mensajes privadosEntra para ver tus mensajes privados   EntrarEntrar 

Asociar archivos a la aplicación...

 
Publicar nuevo tema   Responder al tema    Foros de discusión -> Consultas
Ver tema anterior :: Ver tema siguiente  
Autor Mensaje
Mensaje    Asunto: Asociar archivos a la aplicación... Responder citando

Hola, en algún sitio he visto, creo que era este foro, la forma de asociar una extensión a una aplicación utilizando la clase TRegistry. Hasta ahí perfecto. Lo que también he visto y no encuentro por más que he buscado es la ejecución de este registro al iniciar la aplicación. Al ejecutarla se procede a registrar la extensión, pero sólo si no existe aún en el registro de windows, y esa es la parte que me interesa. es decir, quiero proceder al registro de la extensión si éste no existe, y no hacer nada si sí existe.

Un saludo.
_________________
Nunca digas "Es imposible" sin intentarlo antes.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Hola.

¿Nadie ha encontrado ese post?

Un saludo.
_________________
Nunca digas "Es imposible" sin intentarlo antes.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Hola, te refieres a este:
https://cppbuilder.es/viewtopic.php?t=1905

Para saber si una estension esta registrada o no mira en el registro en HKEY_CLASSES_ROOT la extension , debes incluir en la busqueda el punto de la extension. Si aparece, entonces esta registrada.
ejemplo: ".cpp"

Para saber con que programa esta asociada, mira en el fichero de la extension la clave predeterminada, te dara el nombre del programa.
ejemplo: BCBUnit

Con este nombre busca en la misma seccion del registro y en valor predeterminado de dara el tipo de fichero.
ejemplo: C++Builder Source File

Si aqui mismo en SHELL\OPEN\COMMAND y en el valor predeterminado nos dara el path del fichero ejecutable.

No se si es esto lo que buscas.
Yo ahora mismo estoy mirando esta parte. Si necesitas como realizar este proceso, dimelo y te lo paso. Me falta la parte de colocar el icono.

Un saludo.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Hola Kalux. No es el post que yo decía pero voy a echarle un vistazo a lo de buscar una extensión y comprobar si ya está registrada. Hasta el fin de semana no podré probarlo (trabajo fuera), pero ya te diré. Gracias por contestar.
El post que busco tenía el código cmpleto dentro del evento OnCreate del form correspondiente.

Un saludo y gracias.
_________________
Nunca digas "Es imposible" sin intentarlo antes.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Hola Kalux.

A ver, dos cosillas. En primer lugar si tienes algo de código sobre cómo consultar el HKEY_CLASSES_ROOT y ver si existe una extensión, a qué ejecutable está asociada, etc, te agradecería que me la hicieras llegar (azzulceruleo ARROBA hotmail PUNTO com).
Por otra parte, tengo otra duda. En base a una respuesta de super _Leo, he estado jugando con los parámetros que recibe la línea de comandos. Con la función ParamsCount() se sabe el número de parámetros que se pasan a la línea de comandos. Si abro la aplicación directamente, ParamsCount() devuelve 1 y en ParamsStr[0] guarda el nombre de la aplicación y en ParamStr[1] me devuelve "k".
Si pincho dos veces sobre un archivo asociado, ParamsCount() devuelve también 1 y en ParamsStr[0] guarda el nombre de la aplicación y en ParamStr[1] me devuelve, por ejemplo, "c:\\Puente.crl".
Lo que quiero saber es cómo distingo entre una llamada directa a la aplicación o una llamada a través de un archivo asociado. En ambos casos se devuelve el mismo valor de ParamCount(), cuando yo creo que no debería ser así, pues en el primer caso no debe existir como parámetro el nombre de ningún archivo, y en el segundo sí.
Ya sé que he soltado un rollazo, pero espero que me hayáis entendido.

Un saludo.
_________________
Nunca digas "Es imposible" sin intentarlo antes.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Hola, yo estoy intentando hacer lo mismo que tu, y ya conseguí que se abriera la ventana hija al abrir un archivo asociado.
Lo que me parece raro es que en ParamStr(1) te pase algo cuando abres la aplicación sin archivo asociado, ya que a mi me aparece vacío.
En el evento OnActivate de la ventana padre puse el siguiente código:

if (!ParamStr(1).IsEmpty()) {
CreateMDIChild(ParamStr(1));
}

¿Cuándo creas tu la ventana hija?, ¿siempre o solo cuando abres un archivo?
Volver arriba
Mensaje    Asunto: Responder citando

Hola. Os pongo un ejemplo para que sea mas entedible:

Supongamos que queremos que nuestro programa, al iniciarse, compruebe si la extension, por ejemplo ".aaa" esta asociada a nuestro programa. Y si no lo esta que la asocie.

Primero, lo que necesitamos (por ejemplo):
Código:

#include <Registry.hpp>

struct REG
{
    AnsiString extension;   // Extension a registrar
    AnsiString descripcion; // Descripcion del programa con el cual esta registrada la extension
    AnsiString tipo;        // Tipo de fichero
    AnsiString path;        // Path del programa junto con parametros
    AnsiString icon;        // Icono para esta estension
} reg;


Ademas:
Código:

//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
    registro();

// .......

    ShowMessage("Se han pasado " + AnsiString(ParamCount()) + " parametro/s");

// Si quiero reconocer estos parametros:
    for (int i=0;i<=ParamCount();i++)
    {
        if (LowerCase(ParamStr(i))== "-x") ShowMessage ("Parametro x");
        if (LowerCase(ParamStr(i))== "-y") ShowMessage ("Parametro y");
        if (LowerCase(ParamStr(i))== "-z") ShowMessage ("Parametro z");
    }

// O bien, solo me interesa el primero, porque sera el archivo que le paso
if (ParamCount()>0) Caption=ParamStr(1);


}
//---------------------------------------------------------------------------
void __fastcall TForm1::registro (void)
{
    Clear();

    reg.extension=".aaa";
    if (esta_asociada(reg.extension)==true)
    {
        if (leer_asociacion()==true)
        {
            ShowMessage ("Los datos de la extension : "+reg.extension+AnsiString("\n")+
                        "Extension : registrada"+AnsiString("\n")+
                        "Fichero tipo : "+reg.tipo+AnsiString("\n")+
                        "Path : "+reg.path+AnsiString("\n"));


            ShowMessage("Lectura realizada");
        }
        else ShowMessage("ERROR... Lectura no realizada");
    }
    else
    {
        ShowMessage ("La extension: "+reg.extension+" no esta registrada");
        ShowMessage ("Se procede a su registro");

        // Inicializamos los valores:
        reg.descripcion="MiPrograma";
        reg.tipo="MiPrograma File";
        reg.path=ParamStr(0)+" \"\%1\"";
        //reg.icon="D:\\monitor00.ico";

        if (escribir_asociacion()==true)
        {
            ShowMessage("Asociacion realizada correctamente");
        }
        else
        {
            ShowMessage("ERROR... Registro no realizado");
        }
    }
}
//---------------------------------------------------------------------------
bool __fastcall TForm1::leer_asociacion(void)
{
    TRegistry *registro = new TRegistry;

    // Las extensiones estan registradas en: HKEY_CLASSES_ROOT
    registro->RootKey= HKEY_CLASSES_ROOT;

    // Existe la key. Con false no se crea
    if(registro->OpenKey(reg.extension,false))
    {   // La leemos
        reg.descripcion=registro->ReadString("");
        registro->CloseKey();

        // Leemos los datos del programa
        if (registro->KeyExists(reg.descripcion)==true)
        {
            // Existe la key. Con false no se crea
            if(registro->OpenKey(reg.descripcion,false))
            {   // La leemos
                reg.tipo=registro->ReadString("");
                registro->CloseKey();

                if(registro->OpenKey(reg.descripcion+"\\Shell\\Open\\Command",false))
                {   // La leemos
                    reg.path=registro->ReadString("");
                    registro->CloseKey();
                    delete registro;
                    return true;
                }
                else
                {   // No podemos leerla
                    registro->CloseKey();
                    delete registro;
                    return false;
                }
            }
            else
            {
                registro->CloseKey();
                delete registro;
                return false;
            }
        }
        else
        {
            registro->CloseKey();
            delete registro;
            return false;
        }
    }
    else
    {   // No podemos leerla
        registro->CloseKey();
        delete registro;
        return false;
    }
}
//---------------------------------------------------------------------------
bool __fastcall TForm1::escribir_asociacion(void)
{
    bool error;

    TRegistry *registro = new TRegistry;

    // Las extensiones estan registradas en: HKEY_CLASSES_ROOT
    registro->RootKey= HKEY_CLASSES_ROOT;

    error=true;

    // 1º Paso: crear la entrada de la extension

    // Creamos la key (.extension)
    if(registro->OpenKey(reg.extension,true))
    {
        registro->WriteString("",reg.descripcion);
        registro->CloseKey();
        error=false;
    }
    else
    {
        error=true;
    }

    // Creamos la entrada descripcion
    if (error==false)
    {
        if(registro->OpenKey(reg.descripcion,true))
        {
            registro->WriteString("",reg.tipo);
            registro->CloseKey();
            error=false;
        }
        else
        {
            error=true;
        }
    }

    // Creamos la entrada "SHELL"
    if (error==false)
    {
        if(registro->OpenKey(reg.descripcion+"\\Shell",true))
        {
            registro->WriteString("","");
            registro->CloseKey();
            error=false;
        }
        else
        {
            error=true;
        }
    }

    // Creamos la entrada "OPEN"
    if (error==false)
    {
        if(registro->OpenKey(reg.descripcion+"\\Shell\\Open",true))
        {
            registro->WriteString("","&Abrir");
            registro->CloseKey();
            error=false;
        }
        else
        {
            error=true;
        }
    }

    // Creamos la entrada "COMMAND"
    if (error==false)
    {
        if(registro->OpenKey(reg.descripcion+"\\Shell\\Open\\Command",true))
        {
            registro->WriteString("",reg.path);
            registro->CloseKey();
            error=false;
        }
        else
        {
            error=true;
        }
    }

    // Creamos la entrada descripcion "DEFAULTICON"
    if (error==false)
    {
        if(registro->OpenKey(reg.descripcion+"\\DefaultIcon",true))
        {
            registro->WriteString("",reg.icon);
            registro->CloseKey();
            error=false;
        }
        else
        {
            error=true;
        }
    }

    delete registro;
    if(error==false)    // Correcto el proceso de asociacion
    {
        return true;
    }
    else    // No se ha realizado correctamente
    {
        return false;
    }
}
//---------------------------------------------------------------------------
// Determina si una estension esta asociada a un programa
bool __fastcall TForm1::esta_asociada(AnsiString ext)
{
    bool result;

    TRegistry *registro = new TRegistry;

    // Las extensiones estan registradas en: HKEY_CLASSES_ROOT
    registro->RootKey= HKEY_CLASSES_ROOT;

    // Extension no registrada
    if (registro->KeyExists(ext)==false)
    {
        result=false;
    }
    else    // Existe la key. Extension registrada
    {
        result=true;
    }

    // Cerramos el registro y liberamos la memoria
    registro->CloseKey();
    delete registro;

    return result;
}
//---------------------------------------------------------------------------


Comentandolo, vemos que en el evento OnCreate llama a la funcion registro() que lo que hace es comprobar si existe en el registro la entrada ".aaa" si existe es que esta registrada. Si no existe procedemos a registrarla. Creamos la entrada ".aaa" y el valor predeterminado ponemos una descripcion del fichero "MiPrograma". Y por este valor crea mos otra entrada, donde pondremos "Shell" "Open" y "Command" y en esta ultima como valor prederterminado el path del fichero junto con %1 que sera el parametro a introducir. Ademas se crea la entrada "DafaultIcon" que sera el icono que represente a nuestra extension.

A continuacion reconocemos si le pasamos parametros. Con ParamCount nos dice cuantos parametros se pasan y los reconocemos con ParamStr(i). Podemos buscar si se han pasado ciertos parametros (por ejemplo "-x" "-y",...). O bien tomar solo el primero (es decir, el fichero que se pasa) lo vemos en Caption.

Bueno espero que se entienda. Un saludo.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Hola Kalux. Muchas gracias por el código. Tiene muy buena pinta. Lo probaré el viernes (menudo coñazo trabajar fuera) y ya te contaré.

En cuanto a la respuesta de "Invitado"...
Cita:
Hola, yo estoy intentando hacer lo mismo que tu, y ya conseguí que se abriera la ventana hija al abrir un archivo asociado.

Yo no tengo una aplicación MDI. Yo tengo una ventana principal y sobre su canvas dibujo todo.
Cita:
Lo que me parece raro es que en ParamStr(1) te pase algo cuando abres la aplicación sin archivo asociado, ya que a mi me aparece vacío.

Qué suerte que te aparezca vacío. He probado a mostrar en pantalla todos los parámetros de la línea de comandos y a mí me devuelve siempre un valor.
Cita:
En el evento OnActivate de la ventana padre puse el siguiente código:
Código:
if (!ParamStr(1).IsEmpty()) {
CreateMDIChild(ParamStr(1));
}

Voy a probarlo, aunque ya te digo que siempre me devuelve "k".
Cita:
¿Cuándo creas tu la ventana hija?, ¿siempre o solo cuando abres un archivo?

Este valor sólo me lo devuelve cuando abro la aplicación directamente. Cuando la abro haciendo doble click sobre un archivo asociado funciona bien.

Voy a probarlo todo. Gracias a los dos y un saludo.
_________________
Nunca digas "Es imposible" sin intentarlo antes.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Es extraño que no te funcionen correctamente "ParamCount" y "ParamStr", de todos modos tienes otra alternativa, usar "_argc" y "_argv[]", funcionan igual que el "main", o sea, _argc nos da el número de parámetros, y siempre habrá como mínimo 1 que es _argv[0] conteniendo el nombre del ejecutable con la ruta desde donde se ejecuta. En el caso de ejecutar el archivo asociado _argc contendrá 2 y el nombre del archivo estará en _argv[1].
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mostrar mensajes de anteriores:   
Cambiar a:  
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro


Hosting WordPress Indedmedia desde 3,99 €
© 2002–2026 Club Builder · Funciona con phpBB.