Mensajes

Revisa este foro hay una clase que posteo alguien no recuerdo su nick pero aplica el Efecto AERO directamente an los Form de vb6.

Dulces Lunas!¡.

.
Que mas inperfecto hay que los humanos, por ello nuestras creaciones no estan libres de errores, sean quienes sean, las personas dicen, hablan y no se que tanto se murmurean, pero lo unico que se, es que, es mejor oir ARGUMENTOS que digan los "por que" que oir COMENTARIOS de que el producto es malo y cuando se le pregunta el por que, digan tonterias o no sepan que decir, ni windows ni Linux son 100% eficientes ni libres de errores, vaya.

Dulces Lunas!¡.

jaja no tengo ni la mas misera idea del usu de nada de linux ni de sus distros.

lee mas sobre esas blibliotemas... los codigos que te deje los puedes correr en C/C++.

Dulces LunaS!¡.

Código [Seleccionar] Expandir



mi pregunta es como puedo hacer una ventana en algun lenguaje de programación sin tener que usasr esos programas???



APIS, hay muchas por ejemplo una multi-plataforma que ando yo ocupando es Glut + Glui (Opengl), aun que cada sistema operativo tiene sus propias APIS para crear ventanas y cosas similares, aun que hay alternativas lo mejor es usar las apis de los sistemas operativos.

Por ejemplo: en Glut  (OpenGL)

Código (Vb) [Seleccionar] Expandir


   
    int iWin;
    const char szTitle = "BlackZeroX";
    iWin = ::glutCreateWindow( szTitle );  // Creamos la ventana y se asignamos un titulo.
    ::glutSetWindow( iWin ); // Usamos la ventana.
    ::glutInitWindowSize ( ancho , alto ); // seteamos sus dimensiones.
    ::glutInitWindowPosition ( x , y ); // Seteamos su posicion.
    ::glutDestroyWindow ( iWin ); // Destruimos la ventana



en Glui + Glut... esta mas completo... pero incompleto... xP

Código [Seleccionar] Expandir



#include <GL/glut.h>
#include "glui.h"
void myGlutInit();
void myGlutKeyboard(unsigned char Key, int x, int y)
void myGlutMenu( int value )
void myGlutIdle( void )
void myGlutMouse(int button, int button_state, int x, int y )
void myGlutMotion(int x, int y )
void myGlutReshape( int x, int y )
void myGlutDisplay( void );
void control_cb( int ID );

. . .

void main(int argc, char* argv[])
{
int main_window;
/** Initialize GLUT and create window - This **/
/** is all regular GLUT code so far **/
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutInitWindowPosition( 50, 50 );
glutInitWindowSize( 300, 300 );
main_window = glutCreateWindow( "GLUI test app" );
glutKeyboardFunc( myGlutKeyboard );
glutDisplayFunc( myGlutDisplay );
glutReshapeFunc( myGlutReshape );
glutMotionFunc( myGlutMotion );
glutMouseFunc( myGlutMouse );
myGlutInit();
/** Now create a GLUI user interface window and add controls **/
GLUI *glui = GLUI_Master.create_glui( "GLUI", 0 );
glui->add_statictext( "Simple GLUI Example" );
glui->add_separator();
glui->add_checkbox( "Wireframe", &wireframe, 1, control_cb );
GLUI_Spinner *segment_spinner =
glui->add_spinner( "Segments:",GLUI_SPINNER_INT, &segments );
segment_spinner->set_int_limits( 3, 60, GLUI_LIMIT_WRAP );
GLUI_EditText *edittext =
glui->add_edittext( "Text:", GLUI_EDITTEXT_TEXT, text );
glui->add_column(true); /** Begin new column - 'true' indicates **/
/* * a vertical bar should be drawn **/
GLUI_Panel *obj_panel = glui->add_panel ( "Object Type" );
GLUI_RadioGroup *group1 =
glui->add_radiogroup_to_panel(obj_panel,&obj,3,control_cb);
glui->add_radiobutton_to_group( group1, "Sphere" );
glui->add_radiobutton_to_group( group1, "Torus" );
glui->add_button( "Quit", 0,(GLUI_Update_CB)exit );
/** Tell GLUI window which other window to recognize as the main gfx window **/
glui->set_main_gfx_window( main_window );
/** Register the Idle callback with GLUI (instead of with GLUT) **/
GLUI_Master.set_glutIdleFunc( myGlutIdle );
/** Now call the regular GLUT main loop **/
glutMainLoop();
}



hpara crear botones paneles y demas esta la libreria Glui que es compatible con la libreria Glut.

Dulces Lunas!¡.

SendMessage()

...

@79137913

para tu bloqueado se me ocurre usar OpenGL + el bloqueo de teclas para windows, si no mal recuerdo eso no hace efecto en OpenGL.

Dulces Lunas!¡.

.
Estoy realizando pruebas con OpenGL+C ( No me recomienden otro por que antes de cambiarme quiero solucionar este problema ), y estoy con las luces. mi problema radica en que la luz no apunta a donde deberia de apunter ( Algo asi como un Eje ), ya que se mueve emisor d ela luz a otra coordenada y obviamente el eje (en este caso esta representado con una espera solida) deberia estar SIEMPRE iluminado, pero no es asi...

alguien me puede ayudar?

Código (c) [Seleccionar] Expandir



#include <windows.h>
#include "include/OpenGL/CGL.h"

// Posicion de la luz X, Y, Y, {el 4to elemento indica si es en una posicion infinita 1=NO, 0=SI}
float fposition[4] = {0.0f, 0.0f, 1.0f, 1.0};

void drawZones()
{
    ::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Borramos la pantalla y el buffer de profundidad

    ::glLoadIdentity();
    //  Camara.
    ::gluLookAt( 0, 0, 5,               //  Posicon X, Y, Z.
                 0, 0, -1,              //  Hacia donde vemos X, Y, Z.
                 0.0f, 1.0f, 0.0f );    // Cielo X, Y, Z.

    GLfloat fDirection[] = {0.0,0.0,-1.0}; // Dirrecion hacia adonde apuntamos.
    //Configuramos nuestra Luz.
    ::glEnable ( GL_LIGHT0 );
    ::glLightfv ( GL_LIGHT0, GL_POSITION, fposition );
    ::glLightfv ( GL_LIGHT0, GL_SPOT_DIRECTION, fDirection);
    ::glLightf ( GL_LIGHT0, GL_SPOT_CUTOFF, 5 );

    ::glutSolidSphere(100, 4000, 4000); // Esfero que nos representara las paredes.

    //  Las siguiente son las esferas donde esta la luz.
    //  Posicion del emisor de luz.
    ::glPushMatrix ();
        ::glColor3f ( 1.0f , 0.0f , 0.0f );
        ::glTranslatef ( fposition[0],fposition[1],fposition[2] );
        ::glutWireSphere ( 0.2, 50 , 50 );
    ::glPopMatrix ();

    //  Posicion Destino hacia donde se emite la luz.
    ::glPushMatrix();
        ::glColor3f( 0.0f , 0.0f , 1.0f );
        ::glTranslatef( fDirection[0],fDirection[1],fDirection[2] );
        ::glutSolidSphere( 0.2, 50 , 50 );
    ::glPopMatrix();
    //  Mostramos.
    ::glutSwapBuffers();
}

void keyBoardSFunc(int key, int x, int y)
{
    if (key == GLUT_KEY_LEFT)
        fposition[0] -= 0.1;
    if (key == GLUT_KEY_RIGHT)
        fposition[0] += 0.1;
    if (key == GLUT_KEY_UP)
        fposition[1] -= 0.1;;
    if (key == GLUT_KEY_DOWN)
        fposition[1] += 0.1;
}
void timer( int val ) {
    ::glutTimerFunc       ( 10 , timer,  0);
    ::glutPostRedisplay   (  );
}

int main()
{
    CGL oWindow;

    oWindow.creaVentanaGL ( "Hola Mundo desde OpenGL" , 1024 , 726 , 0 , 0 , false );
    ::glutDisplayFunc ( drawZones );
    ::glutSpecialFunc ( keyBoardSFunc );
    ::glutTimerFunc ( 10, timer, 0 );
    ::glutMainLoop ();

    return EXIT_SUCCESS;
}



CGL.cpp

Código (c) [Seleccionar] Expandir




#include "OpenGL/cgl.h"

//---------------------------------------------------------------
// Nombre: Constructor
// Descripcion: Constructor de la clase. Inicializa las variables
// Parametros: Ninguno
//---------------------------------------------------------------
CGL::CGL()
{
    int_Win = 0;
}

//---------------------------------------------------------------
// Nombre: Destructor
// Descripcion: Destructor de la clase
// Parametros: Ninguno
//---------------------------------------------------------------
CGL::~CGL()
{
    eliminaVentanaGL();
}

//---------------------------------------------------------------
// Nombre: inicializaEscenaGL
// Descripcion: Inicializa los parametros iniciales de la escena
// Parametros:
//        Glsizei ancho: Ancho de la escena
//        Glsizei alto: Alto de la escena
//---------------------------------------------------------------
void CGL::inicializaEscenaGL(GLsizei ancho, GLsizei alto)
{
    if ( alto <= 0 )                                                                    // Previene de la división entre 0
    {
        alto=1;                                                                         // Establece la altura = 1
    }
    ::glViewport            ( 0 , 0 , ancho , alto );                                   // Resetea el actual puerto de visión (ViewPort)
    ::glMatrixMode          ( GL_PROJECTION );                                          // Selecciona la matriz de proyección
    ::glLoadIdentity        (  );                                                       // Resetea la matriz de proyección

    ::gluPerspective        ( 45.0f , (GLfloat)ancho/(GLfloat)alto , 1.0f , 300000.0f );  // Calcula el Aspect Ratio de la ventana

    ::glMatrixMode          ( GL_MODELVIEW );                                           // Selecciona la matriz de modelado
    ::glLoadIdentity        (  );                                                       // Resetea la matriz de modelado
}

//---------------------------------------------------------------
// Nombre: iniGL
// Descripcion: Inicializa los valores iniciales de OGL
// Parametros: Ninguno
//---------------------------------------------------------------
bool CGL::iniGL(void)
{
    GLfloat ambientLight[]  = { 0.1f, 0.1f, 0.1f, 1.0f };
    ::glShadeModel          ( GL_SMOOTH );                                  // Activa sombreado suave (Smooth Shading)
    ::glClearDepth          ( 1.0f );                                       // Depth Buffer Setup
    ::glEnable              ( GL_DEPTH_TEST );                              // Activa Z-Buffer
    ::glDepthFunc           ( GL_LEQUAL );                                  // El tipo de Depth Testing que se va a realizar
    ::glHint                ( GL_PERSPECTIVE_CORRECTION_HINT , GL_NICEST ); // Muy buena correción de perspectiva
    ::glEnable              ( GL_TEXTURE_2D );                              // Activa mapeado de texturas
    ::glColorMaterial       ( GL_FRONT , GL_AMBIENT_AND_DIFFUSE );
    ::glClearColor          ( 0.0f , 0.0f , 0.0f , 1.0f );

    ::glLightModeli         ( GL_LIGHT_MODEL_TWO_SIDE , 1 );                // habilita ambas caras (FRONT-iluminada & BACK-oscurecida) de los poligonos
    ::glLightModelfv        ( GL_LIGHT_MODEL_AMBIENT , ambientLight );      // luz ambiental de toda la escena
    ::glEnable              ( GL_COLOR_MATERIAL);                           // habilita el color para los materiales (poligonos rellenos)
    ::glEnable              ( GL_LIGHTING );

    return true;
}

//---------------------------------------------------------------
// Nombre: eliminaVentanaGL
// Descripcion: Destruye toda la información sobre la ventana GL
// Parametros: Ninguno
//---------------------------------------------------------------
void CGL::eliminaVentanaGL(void)
{
    ::glutDestroyWindow(  this->int_Win );
    this->int_Win = 0;
}

//---------------------------------------------------------------
// Nombre: CrearVentanaGL
// Descripcion: Crea una ventana OGL
// Parametros:
//            char* Titulo: Titulo de la ventana
//            int ancho: Ancho de la ventana o en modo pantalla completa
//            int alto: Alto de la ventana o en modo pantalla completa
//            bool fullscreen: Usar pantalla completa (TRUE) o ventana (FALSE)
//---------------------------------------------------------------
bool CGL::creaVentanaGL(const char* Titulo, GLsizei ancho, GLsizei alto, GLsizei x, GLsizei y, bool fullscreen)
{
    if ( x < 0 ) { x=0; }
    if ( y < 0 ) { y=0; }

    ::glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGBA );
    ::glutInitWindowPosition ( x , y );
    ::glutInitWindowSize ( ancho , alto );

    this->int_Win = ::glutCreateWindow( Titulo );

    ::glutSetWindow( this->int_Win );

    if ( fullscreen == true )
        ::glutFullScreen();

    inicializaEscenaGL ( ancho , alto );        // Inicializamos la escena en perspectiva GL

    if ( !iniGL() ) {
        eliminaVentanaGL();
        return false;
    }

    return true;
}



CGL.h

Código (C) [Seleccionar] Expandir



#ifndef _cGL_H_
#define _cGL_H_

// INCLUDES //////////////////////////////////////
#include <windows.h>            // Archivo cabecera para Windows
#include <GL/glut.h>

class CGL
{
    public:
        CGL                                         ();
        virtual         ~CGL                        ();
        bool            creaVentanaGL               (const char* Titulo, GLsizei ancho, GLsizei alto, GLsizei x, GLsizei y, bool fullscreen);
        void            inicializaEscenaGL          (GLsizei ancho, GLsizei alto);      // Cambia de tamaño e inicializa la ventana GL
        void            eliminaVentanaGL            (void);                           // Elimina la ventana
        int             int_Win;
        void            inilight                    (GLfloat ligt[]);
    private:
        bool            iniGL                       (void);                        // Todas la inicializaciónes de OpenGl vienen aqui
};

#endif



Temibles Lunas!¡

[$(]

.
Que significa la linea que resalto?

Código (ajax,3) [Seleccionar] Expandir



var k=function(){
    var l=$("#dtmain_outer, #hatdoiwas_outer");
    if(l.length>0){
    l.remove();
    C.utils.third_party_addon_detected()
}
setTimeout(k,1000)



No tengo ni idea que significa $( alguien lo sabe? entiendo absolutamente TODO pero mi problema radica en el problema que ya mencione.

Dulces Lunas!¡.

La X el cuadrto (Cerrar), la linea (Minimizar), y el recuadro (Maximizar) de las ventanas son dibujos mas NO textos... OJO con eso.

Aun asi con un hook al mouse usando las apis ya mencionadas podras hacerlo muy "profesional", aun que esta terminologia se use cuando te pagan y aun asi, hay algunos que no les queda muy del "que barbaro", aun que funcionan a la perfeccion, pero bueno.

Dulces Lunas!¡.

.
Por que no mejor lo haces o lo modificas a tus nesesidades?

http://www.codeproject.com/KB/IP/WOL.aspx

Dulce sLunas!¡.