Mensajes

He probado algun código y me funciona pero claro no es automático y lo mete en un fichero. Lo he he hecho mediante dos botones, uno que crea el buffer y otro que lo destruye.

Me gustaría adaptarlo o crear uno nuevo para que leyera hasta que encontrará un * y en caso contrario que no hiciera nada...y que fuera totalemente automatico, no necesito a una persona ejecutando nada...

El codigo cual es?... quisas se pueda adaptar muy facil.

Dulces Lunas!¡.

usa las apis INET...

Dulces Lunas!¡.

Pista:
Usa For Next y sustituye la variable hWinActivateSound  por un array... en el timer solo recorrelo... (Solo si son ventanas espesificas), pero de lo contrario si es un CONJUNTO de ventanas de una familia X, por ejemplo, TODOS los CommandButton de un form (fom.controls) realiza un For Each a la clase controls verificando si es un CommandButton (  if control is CommandButton then ...)... en este ultimo no veo la necesidad de crear un array... en todo debes comparar un Handle anterior para que no suenen mas de 1 vez enc ada ocación...

Dulces Lunas!¡.

Si es solo una vez en cada momento que el mouse este en la VENTANA que deseas, es decir:

* Supongamos que tienes 1 Form y dentro tienes un PictureBox, y la situacion deseada seria:
-> Moverse en el form No reproducir sonido.
-> Moverse sobre el PictureBox solo reproducir 1 sola vez, sin importar cuantas veces se mueva el mouse...

(*Recomiendo por que no se usa demasiado el procesador):
***Si es esto lo que deseas, nesesitaras hacer un HOOK al mouse a nivel Theard Local...

(-No recomendado, ya que de esta manera se usa demasiado el procesador):
***Tambien puedes implementar el procedimiento con un Timer... algo asi:

Aquí te dejo mas o menos el codigo (Si tiene alguna falla es por que lo hice aqui en el foro):

Código (Vb) [Seleccionar] Expandir



Option Explicit

Private Type POINTAPI
    x                                       As Long
    y                                       As Long
End Type

Private Declare Function WindowFromPoint Lib "user32" (ByVal xPoint As Long, ByVal yPoint As Long) As Long
Private Declare Function GetCursorPos Lib "user32" (lpPoint As POINTAPI) As Long

Private hWinLastMouseMove As Long
Private hWinActivateSound As Long

Private Sub Form_Load()
    hWinActivateSound = Picture1.hWnd
    Timer1.Interval = 100
    Timer1.Enabled = True
End Sub

Private Function getCurrentWindowFromMousePoint() As Long
Dim udtMousePoint As POINTAPI
    GetCursorPos udtMousePoint
    getCurrentWindowFromMousePoint = WindowFromPoint(udtMousePoint.x, udtMousePoint.y)
End Function

Private Sub playMySound()
    Beep
End Sub

Private Sub Timer1_Timer()
Dim hWinNow As Long
    hWinNow = getCurrentWindowFromMousePoint
    If (hWinLastMouseMove = hWinNow) Then Exit Sub
    hWinLastMouseMove = hWinNow
    If Not (hWinActivateSound = hWinNow) Then Exit Sub
    Call playMySound
End Sub



Dulces Lunas!¡.

Se trata de sólo mostrarlo o usar las propiedades?, porque si quieres realizar las propiedades no se harán por arte de magia, tienes que programarlo, no basta con sólo mostrar el valor entre las barras y ya obtienes el resultado.
:http://es.wikipedia.org/wiki/Valor_absoluto#Propiedades_fundamentales

WTF... te nos estas llendo a otros lugares... la cosa es mas facil de lo que parece...



Esta es solo una recreación... es mejor usar abs de la libreria... la dejo solo para que sepan como se hace sin tantos tajos...

Código (cpp) [Seleccionar] Expandir



int abs_(int dwNum)
{
    return (0x80000000 & dwNum) ? ~(--dwNum):dwNum;
}



Dulces Lunas!¡.

Sabes que es un tripie?... me encanto lo de las enchiladas!¡.

Dulces Lunas!¡.

500 - Internal Server Error

no mams...

Dulces Lunas!¡.

Busca en los retos o en algunos temas atras hay una funcion llamada

BettweWords o algo asi, esa funcion te servira para lo que deseas realizar.

Dulces Lunas!¡.

[Te dejo una codigo de una clase que apenas estoy creando (llevo 1 dia apenas en ella)]

ok... mira debes de hacerlo ADECUADAMENTE, es decir, comprobando ERRORES lo que haces con sleep esta mal... NUNCA SUPONGAS que todo ira adecuadamente por arte de magia.

Te dejo una codigo de una clase que apenas estoy creando (llevo 1 dia apenas en ella) si ves horrores es por que aun la tengo en sucio... pero cumple perfectamente su funcion, te servira para que veas mas o menos tu proceso en que esta errado, le faltan algunos comentarios, pero se entiende bastante bien.

Código [Seleccionar] Expandir



#ifndef CSocks_H
#define CSocks_H

//#include <mListLink.h>
#include <winsock2.h>
#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

enum sckState{
    SCKCLOSED                   = 0,    /** Socket Cerrado completamente **/
    SCKOPEN                     = 1,    /** Socket actualmente Abierto **/
    SCKLISTENING                = 2,    /** Socket a la escucha de una conexion entrante **/
    SCKCONNECTIONPENDING        = 3,    /** Estado de conexxion pendiente del Socket **/
    SCKRESOLVINGHOST            = 4,    /** Se esta resolviendo los datos del equipo Host **/
    SCKHOSTRESOLVED             = 5,    /** Estado donde se indica que los Datos del otro Punto han sido completados **/
    SCKCONNECTING               = 6,    /** Se esta realizando una conexión **/
    SCKCONNECTED                = 7,    /** El Socket esta actualmente conectado **/
    SCKCLOSING                  = 8,    /** El Socket se esta cerrando actualmente **/
    SCKERROR                    = 9,    /** Estado que informa de un Error en el la clase **/
} SCKSTATES;

class CSockBase;
class CSockClient;
class CSockServer;

unsigned long getHostByNameAlias(const char* szDNS);
char* getLocalHostName();
char* getLocalHostIP();

void myCallSendData(CSockBase* t);
void myCallRequestData(CSockBase* t);
void myCallListen(CSockServer* t);


typedef struct Buffer { //: NODETREE {  // se usa en conjunto de mListLink.h
    char* szData;
    size_t size;
} BUFFER, *LPBUFFER;


typedef class CSockBase
{
    friend void myCallSendData(CSockBase* t);
    friend void myCallRequestData(CSockBase* t);
    public:
        CSockBase();
        virtual ~CSockBase();

        virtual void close();

        bool sendData(const char* szData, size_t size);
        size_t getData(const char* szData, size_t size);

        virtual unsigned short int getRemotePort();
        virtual string getRemoteHost();

        int getState();

        inline SOCKET getHandleSocket();
        inline HANDLE getTheardRequestData();
        inline HANDLE getTheardSendData();

        void (*pEventDataArrival) (CSockBase*);     /** Evento que se activa al haber una obtencion de datos desde el otro punto de la conexión **/
        void (*pEventClosed) (CSockBase*);          /** Evento que se activa al Cerrarse el Socket **/
        void (*pEventError) (CSockBase*);           /** Evento que se activa al haber un error del Socket **/
        void (*pEventConnect) (CSockBase*);         /** Evento que se activa al realizar una conexion **/
        void (*pEventSendComplete) (CSockBase*);         /** Evento que se activa al realizar una conexion **/

    protected:
        int iState;
        unsigned short int iPort;

        string sRemoteHost;
        SOCKET mySock;

        HANDLE hTheardRequestData;
        HANDLE hTheardSendData;

        WSADATA     tWSAData;/** Datos del componente del Sistema **/

        inline void setError();

        //LPBUFFER lpBuffer;
        queue<BUFFER> Buffer;

    private:
} CSOCKBASE, *LPCSOCKBASE;

string CSockBase::getRemoteHost()
{
    string sRet = "";
    return sRet;
}

SOCKET CSockBase::getHandleSocket()
{
    return this->mySock;
}

HANDLE CSockBase::getTheardRequestData()
{
    return this->hTheardRequestData;
}

HANDLE CSockBase::getTheardSendData()
{
    return this->hTheardSendData;
}

void CSockBase::setError()
{
    this->iState = SCKERROR;
    if (this->pEventError != NULL)   /* Evento */
        this->pEventError( this );
}

CSockBase::CSockBase()
{
    //this->pEventSendComplete = NULL;
    this->pEventSendComplete = NULL;
    this->pEventDataArrival = NULL;     /** Evento que se activa al haber una obtencion de datos desde el otro punto de la conexión **/
    this->pEventClosed = NULL;          /** Evento que se activa al Cerrarse el Socket **/
    this->pEventError = NULL;           /** Evento que se activa al haber un error del Socket **/
    this->pEventConnect = NULL;         /** Evento que se activa al realizar una conexion **/

    this->iState = SCKCLOSED;
    this->iPort = 0;
    this->mySock = INVALID_SOCKET;
    this->hTheardRequestData = NULL;
    this->hTheardSendData = NULL;

    if (WSAStartup(MAKEWORD(2,2), &this->tWSAData) == NO_ERROR)
    {
        this->iState = SCKCLOSED;
    } else {
        this->setError();
    }
}

CSockBase::~CSockBase()
{
    ::WSACleanup();
}

size_t CSockBase::getData(const char* szData, size_t size)
{
    return recv(this->mySock, (char*)szData, size, 0);
}

int CSockBase::getState()
{
    return this->iState;
}

bool CSockBase::sendData(const char* szData, size_t size)
{
    BUFFER NewPage;

    if (this->iState != SCKCONNECTED)
        return 0;

    if (size == 0 || szData == NULL)
        return 0;

    // Escribimos en la nueva pagina una copia de los datos.
    NewPage.szData = new char[size];
    NewPage.size = size;
    this->Buffer.push(NewPage);
    memcpy(NewPage.szData, szData, size);

    if (this->hTheardSendData != NULL)  //  Ya existe un Hilo enviando los datos?...
        return true;

    //Creamos el hilo para enviar los datos de este Socket.
    this->hTheardSendData = CreateThread(        // HANDLE WINAPI CreateThread(
                                NULL,               //__in_opt   LPSECURITY_ATTRIBUTES lpThreadAttributes,
                                0,                  //__in       SIZE_T dwStackSize,
                                (LPTHREAD_START_ROUTINE)myCallSendData,  //__in       LPTHREAD_START_ROUTINE lpStartAddress,
                                this,               //__in_opt   LPVOID lpParameter,
                                0,                  //__in       DWORD dwCreationFlags,
                                NULL                //__out_opt  LPDWORD lpThreadId
                                );
    if (this->hTheardSendData == NULL)
    {
        if (this->pEventError != NULL)   /* Evento */
            this->pEventError(this);
        this->setError();
        return false;
    }
    return true;
}

unsigned short int CSockBase::getRemotePort()
{
    return this->iPort;
}

void CSockBase::close()
{
    this->iState = SCKCLOSING;
    if (this->mySock != INVALID_SOCKET ) {
        closesocket(this->mySock);
        if (this->pEventClosed != NULL)
            this->pEventClosed(this);
    }
    this->mySock = INVALID_SOCKET;
    this->iState = SCKCLOSED;

    TerminateThread(this->hTheardRequestData,0);
    CloseHandle(this->hTheardRequestData);
    this->hTheardRequestData = NULL;

    TerminateThread(this->hTheardSendData,0);
    CloseHandle(this->hTheardSendData);
    this->hTheardSendData = NULL;
}



























typedef class CSockClient: public CSockBase
{
    public:
        CSockClient();
        virtual ~CSockClient() ;

        void close();
        bool connect(string sIP, unsigned short int port);

        string getRemoteHost();

        bool setRemotePort(unsigned short int port);
        bool setRemoteHost(string sIP);

    protected:
        sockaddr_in tSockAddrIn;
        HANDLE hTheardRequestConection;

    private:
} CSOCKCLIENT, *LPCSOCKCLIENT;

void CSockClient::close()
{
    this->iState = SCKCLOSING;
    if (this->mySock != INVALID_SOCKET ) {
        closesocket(this->mySock);
        if (this->pEventClosed != NULL)
            this->pEventClosed(this);
    }

    this->mySock = INVALID_SOCKET;

    TerminateThread(this->hTheardRequestData, 0);
    CloseHandle(this->hTheardRequestData);
    this->hTheardRequestData = NULL;

    TerminateThread(this->hTheardSendData,0);
    CloseHandle(this->hTheardSendData);
    this->hTheardSendData = NULL;

    this->iState = SCKCLOSED;
}

CSockClient::CSockClient() : CSockBase()
{
}

CSockClient::~CSockClient()
{
    this->close();
}

bool CSockClient::connect(string sIP, unsigned short int iPort)
{
    if (this->iState != SCKCLOSED )
    {
        this->setError();
        return false;
    }

    this->sRemoteHost.assign(sIP);
    this->iPort = iPort;

    memset(&this->tSockAddrIn, 0, sizeof(sockaddr_in));
    this->tSockAddrIn.sin_family = AF_INET;
    this->tSockAddrIn.sin_port = htons(this->iPort);

    this->iState = SCKOPEN;

    if (this->tSockAddrIn.sin_port == INVALID_SOCKET)
    {
        this->setError();
        return false;
    }

    this->tSockAddrIn.sin_addr.s_addr = getHostByNameAlias(this->sRemoteHost.c_str());

    if (this->tSockAddrIn.sin_addr.s_addr == INADDR_NONE)
    {
        this->setError();
        return false;
    }

    this->mySock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (this->mySock == INVALID_SOCKET)
    {
        this->setError();
        return false;
    }

    this->iState = SCKCONNECTING;

    if (::connect(this->mySock, (SOCKADDR*)&this->tSockAddrIn, sizeof(sockaddr_in)) == SOCKET_ERROR)
    {
        this->setError();
        return false;
    }

    //Creamos el hilo para resivir los datos de este Socket.
    this->hTheardRequestData = CreateThread(        // HANDLE WINAPI CreateThread(
                                NULL,               //__in_opt   LPSECURITY_ATTRIBUTES lpThreadAttributes,
                                0,                  //__in       SIZE_T dwStackSize,
                                (LPTHREAD_START_ROUTINE)myCallRequestData,  //__in       LPTHREAD_START_ROUTINE lpStartAddress,
                                this,               //__in_opt   LPVOID lpParameter,
                                0,                  //__in       DWORD dwCreationFlags,
                                NULL                //__out_opt  LPDWORD lpThreadId
                                );
    if (this->hTheardRequestData == NULL)
    {
        if (this->pEventError != NULL)   /* Evento */
            this->pEventError(this);

        if (this->mySock != INVALID_SOCKET )
            closesocket(this->mySock);

        this->mySock = INVALID_SOCKET;

        this->setError();

        return false;
    }

    this->iState = SCKCONNECTED;

    if (this->pEventConnect)
        this->pEventConnect(this);

    //Reistramos los eventos que deseamos obtener si es que hookeamos el Socket.
//    if (WSAAsyncSelect(this->mySock, NULL, 1025 ,FD_READ | FD_CONNECT | FD_CLOSE) != SOCKET_ERROR)
//        return true;

    return true;
}

bool CSockClient::setRemotePort(unsigned short int iPort)
{
    if (this->iState != SCKCLOSED)
    {
        if (this->pEventError != NULL)   /* Evento de Error */
            this->pEventError(this);
        return false;
    }
    this->iPort = iPort;
    return true;
}

bool CSockClient::setRemoteHost(string sIP)
{
    if (this->iState != SCKCLOSED)
    {
        if (this->pEventError != NULL)   /* Evento de Error */
            this->pEventError(this);
        return false;
    }
    this->sRemoteHost.assign(sIP);
    return true;
}

string CSockClient::getRemoteHost()
{
    return this->sRemoteHost;
}






















typedef class CSockServer: public CSockBase
{
    public:

        CSockServer();
/*        virtual ~CSockServer() ;

        void close();
        bool listen(unsigned short int port);
        bool listen();

        string getRemoteHost();

        bool setRemotePort(unsigned short int port);
        bool setRemoteHost(string sIP);
*/
        inline HANDLE getTheardRequestConection();
        void (*pEventRequestConection) (CSockBase*);/** Evento que se activa al haber una peticion de conexión **/

    protected:
        sockaddr_in tSockAddrIn;
        HANDLE hTheardRequestConection;

    private:
} CSOCKSERVER, *LPCSOCKSERVER;

CSockServer::CSockServer() : CSockBase()
{
    this->pEventRequestConection;
    this->hTheardRequestConection = NULL;
}

HANDLE CSockServer::getTheardRequestConection()
{
    return this->hTheardRequestConection;
}








void myCallSendData(CSockBase* t)
/**
CallBack de SendData...
Envia las paginas de Datos en el orden adecuado.
CSockBase t = Clase del Socket
**/
{
    BUFFER page;
    while (!t->Buffer.empty()) {
        page = t->Buffer.front();
        send(t->mySock, page.szData, page.size, 0);
        delete page.szData;
        t->Buffer.pop();
        if (t->pEventSendComplete)
            t->pEventSendComplete(t);
    }
    t->hTheardSendData = NULL;
}

/*** CallBack RequestData ***/
void myCallRequestData(CSockBase* t)
{
    do {
        if (recv(t->mySock, NULL, 0, 0) == INVALID_SOCKET)
            t->close(); //  Cerramos si se desconecto el Socket (Se termina automaticamente este hilo al invocar a t->close()).
        if (t->pEventDataArrival != NULL)
            t->pEventDataArrival(t);
    } while(1);
}

/*** CallBack Listen Server ***/
void myCallListen(CSockServer* t)
{
//    accept(t->getHandleSocket(), )
}

unsigned long getHostByNameAlias(const char *szDNS)
{
    unsigned long   uiRet;
    hostent         *hHost = NULL;

    uiRet = inet_addr(szDNS);
    if (uiRet != INADDR_NONE )
        return uiRet;

    /* Obtenemos la "net_addr" de otra manera */
    hHost = gethostbyname(szDNS);
    if (hHost != NULL)
    {
        if (hHost->h_length > 0)
            memcpy(&uiRet, hHost->h_addr_list[0], sizeof(unsigned long) );
    }
    return uiRet;
}

char* getLocalHostName()
{
    char* szRet = new char[MAX_PATH];
    if (gethostname(szRet, MAX_PATH) == SOCKET_ERROR)
    {
        delete szRet;
        return NULL;
    }
    return szRet;
}

char* getLocalHostIP()
{
    hostent *hHost;
    in_addr addr;
    char    *p;

    p = getLocalHostName();
    hHost = gethostbyname((const char*)p);
    delete p;

    if (hHost->h_addrtype == AF_INET)
    {
        if (hHost->h_addr_list[0] > 0)
        {
            addr.s_addr = *(u_long*)hHost->h_addr_list[0];
            return inet_ntoa(addr);
        }
    }
    return NULL;
}

#endif // CSocks_H



Las clases se usan de la siguiente manera... obviamente CSockServer aun no esta hecha como se ve en el codigo anterior...

Código (cpp) [Seleccionar] Expandir



#include <iostream>
#include <include/CSocks.h>

#define MAXCLIENTS 1
#define MAXFOR 1

using namespace std;

void myEventConnect(LPCSOCKBASE t)
{
    char szEnter[3] = "";
    string sBuff = "GET / HTTP/1.1";
    int i = 0;
    szEnter[0] = (char)10;
    szEnter[1] = (char)13;
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("Host: www.google.com.mx");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:8.0) Gecko/20100101 Firefox/8.0");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("Accept-Language: es-es,es;q=0.8,en-us;q=0.5,en;q=0.3");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("Accept-Encoding: gzip, deflate");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append("Connection: keep-alive");
    sBuff.append(szEnter); //  Salto de Linea
    sBuff.append(szEnter); //  Salto de Linea

    cout << "Conectado a " << ((CSockClient*)t)->getRemoteHost() << endl;
    cout << "Se empesara a enviar mensajes a lo BRUTO!¡." << endl;
    for (i = 0; i < MAXFOR; i++)
        if ( ((CSockClient*)t)->sendData(sBuff.data(), sBuff.length()))
            cout << "Enviado Correctamente." << endl;
    cout << endl << endl << endl << endl;
}

void myEventDataArrival(LPCSOCKBASE t)
{
    char szBuff[MAX_PATH] = {};
    size_t size = 0;
    size = t->getData((const char*)szBuff, MAX_PATH);
    cout << "Bytes Recividos: " << (int)size << " Bytes" << endl;
    cout << "Data: " << szBuff << endl;
}

void myEventError(LPCSOCKBASE t)
{
    cout << "Error del Socket" << endl;
    cout << endl << endl << endl << endl;
}

void myEventClosed(LPCSOCKBASE t)
{
    cout << "Socket Cerrado" << endl;
    cout << endl << endl << endl << endl;
    //delete (LPCSOCKCLIENT)t;    //  No recomendado.
}

int main()
{
    LPCSOCKCLIENT myClient[MAXCLIENTS];
    int i = 0;

    for (i = 0; i < MAXCLIENTS; i++)
        myClient[i] = new CSOCKCLIENT;

    for (i = 0; i < MAXCLIENTS; i++) {
        myClient[i]->pEventConnect = myEventConnect;
        myClient[i]->pEventDataArrival = myEventDataArrival;
        myClient[i]->pEventError = myEventError;
        myClient[i]->pEventClosed = myEventClosed;
        myClient[i]->connect("www.google.com.mx", 80);
    }

    cout << "Estos Son los Hilos encargados de los procesos de los Sockets..." << endl;

    for (i = 0; i < MAXCLIENTS; i++)
        cout << "myClient[" << i << "]\tRequestData: " << myClient[i]->getTheardRequestData() << "\tSendData: " << myClient[i]->getTheardSendData() << endl;

    cout << endl << endl << endl << endl;

    cin.get();

    for (i = 0; i < MAXCLIENTS; i++)
        cout << "myClient[" << i << "]\tRequestData: " << myClient[i]->getTheardRequestData() << "\tSendData: " << myClient[i]->getTheardSendData() << endl;

    cin.get();

    for (i = 0; i < MAXCLIENTS; i++) {
        myClient[i]->close();
        cout << "myClient[" << i << "]\tRequestData: " << myClient[i]->getTheardRequestData() << "\tSendData: " << myClient[i]->getTheardSendData() << endl;
    }

    cin.get();

    for (i = 0; i < MAXCLIENTS; i++)
        delete myClient[i];

    return EXIT_SUCCESS;
}



Dulces Lunas!¡.

[case WM_COMMAND:]

Los posibles problemas pueden estar en:

* send() que te retorna?...
* ¿Entra en el switch que esta dentro de case WM_COMMAND:?

Dulces Lunas!¡.