Administración remota!!

[acertij022]

Hola amigos delphinos me encuentro entre la espada y la pared, les comento para entrar en tema.Estoy continuamente trabajando remotamente instalando y configurando maquinas de clientes pero me suele pasar que mis clientes o le parece muy dificil decime su IP o Passord (VNC) para ingresar remotamente o peor no saben como abrir algun puerto TCP para realizar la conexion, gracias a este dolor de cabeza estoy diseñando algo parecido a un VNC con algunas mejoras administativa, la idea que tengo es que el cliente se conecte a la mesa de ayuda por medio de un ejecutable para chatear y si fuese necesario poder ingresar a la pc para realizar la reparcion o configuracion.
Para evitar el Firewall se me ocurrio que la aplicacion funcione inversamente que el VNC o sea el cliente tiene un socket cliente y yo un server (emularia un browser o saldria por el port 21)hasta ahi cerramaba pero ahora necesitaba enviar una imagen de la pc y actualizar solo los pixeles que cambiaban utilizando el siguiente codigo:
para tomar una imagen:

procedure TFServer.GetDesktop(Imagen:integer);
var
imag: TImage;
jpg: TJpegImage;
desktop: TCanvas;

begin
imag:=TImage.Create(FServer);
imag.Width:=screen.Width;
imag.Height:=screen.Height;
desktop:=TCanvas.Create;
with DeskTop do
Handle := GetWindowDC (GetDesktopWindow) ;

with Imag.Canvas do
CopyRect (Rect (0, 0, screen.Width, screen.Height),DeskTop,Rect (0, 0, screen.Width, screen.Height));
jpg:=TJPegImage.Create;
jpg.Assign(imag.Picture.Bitmap);
imag.Free;
jpg.CompressionQuality:=80; //Calidad del JPEG
jpg.Compress; //Comprimimos la imagen
jpg.SaveToFile(IntToStr(Imagen)+'.jpg');
jpg.Free;
desktop.Free;
end;

Y para tomar las diferencias:

procedure comparar();
var
jpg: TJpegImage;
bmp1,bmp2: TImage;
int1,int2,int3:integer;
FInteger: file of integer;
begin
if (not fileexists('1.jpg'))or(not fileexists('2.jpg')) then exit;
bmp1:=TImage.Create(FServer);
jpg := TJpegImage.Create;
try
jpg.LoadFromFile('1.jpg');
bmp1.Picture.Bitmap.Assign(jpg); // Carga la imagen como BMP
finally
jpg.Free;
end;

bmp2:=TImage.Create(FServer);
jpg := TJpegImage.Create;
try
jpg.LoadFromFile('2.jpg');
bmp2.Picture.Bitmap.Assign(jpg); // Carga la imagen como BMP
finally
jpg.Free;
end;

AssignFile(FInteger,'3.int');
Rewrite(FInteger);
// Recorrer la imagen
for int1 := 0 to (bmp1.Picture.Bitmap.Height - 1) do
begin
for int2 := 0 to (bmp1.Picture.Bitmap.Width - 1) do
begin
// Diferentes
if (bmp1.Picture.Bitmap.Canvas.Pixels[int2,int1] <>
bmp2.Picture.Bitmap.Canvas.Pixels[int2,int1]) then
begin
// guardo las diferencias
int3:=bmp2.Picture.Bitmap.Canvas.Pixels[int2,int1];
Write(FInteger,int3);//valor del color del pixel
Write(FInteger,int2);// posicion X
Write(FInteger,int1);// posicion Y
end;
end;
end;
CloseFile(FInteger);
bmp1.Free;
bmp2.Free;
end;


pero noto que las imagenes generadas pesan 112Kb y el archivo de diferencias pesan mas que la imagen y que el recorrido de pixel a pixel es muy lento.

A Alguien se le ocurre como optimizar el codigo o como puedo interactuar con las DLL del VNC
Desde ya muchas gracias :cool:

[seoane]

Antes de meternos a reinventar la rueda, puedes usar alguna solución como UltraVNC SC. En este hilo se hablo de este tema, y se llego a una solución a prueba de tontos :D

Software Control Remoto, sin abrir puertos en routers (http://www.clubdelphi.com/foros/showthread.php?t=34732)

Aunque si sigues queriendo hacerlo tu, te recomiendo un par de cosas. Primero, trabaja sobre imágenes bmp aunque luego las vayas a enviar como jpg, comparar dos jpeg puede ser problemático. Segundo no utilices la propiedad pixels del canvas, utiliza la propiedad Scanline del Bitmap es mucho mas rápido.

[Casimiro Notevi]

Antes de meternos a reinventar la rueda, puedes usar alguna solución como UltraVNC SC. En este hilo se hablo de este tema, y se llego a una solución a prueba de tontos :D

Software Control Remoto, sin abrir puertos en routers (http://www.clubdelphi.com/foros/showthread.php?t=34732)

Aunque si sigues queriendo hacerlo tu, te recomiendo un par de cosas. Primero, trabaja sobre imágenes bmp aunque luego las vayas a enviar como jpg, comparar dos jpeg puede ser problemático. Segundo no utilices la propiedad pixels del canvas, utiliza la propiedad Scanline del Bitmap es mucho mas rápido.

Y además, el UltraVNC lleva incorporado, entre otros, unos "botoncitos" muy útiles: chat para conversar con el cliente, una utilidad para enviar y recibir ficheros (justo lo que necesitas), etc.

No hay que abrir ningún puerto, ni saber ninguna IP, ni nada de nada, absolutamente cómodo y rápido

[seoane]

Aparte de lo dicho anteriormente, volvamos a tu pregunta original, por si a alguien le puede resultar útil. Yo enfocaría el problema de otra manera, en vez de mandar pixel a pixel, encontraría el rectángulo de la imagen que ha cambiado, lo copiara, lo comprimiría usando jpeg y lo mandaría junto con sus coordenadas. Por otro lado al recibirlo solo tendríamos que dibujar el rectángulo en las coordenadas indicadas. Al comprimir la imagen usando jpeg puede que obtengamos un feo efecto de borde, pero es un mal menor comparada con lo que ganamos en velocidad.

La ventaja son que al enviar un recuadro completo podemos usar formatos de compresión como jpeg, gif o png. La desventaja es que si la imagen tiene muchos cambios repartidos por toda la superficie, el cuadro resultante puede ser prácticamente del mismo tamaño que el original. Es decir, donde realmente se muestra eficaz es en imágenes donde los cambios están localizados en una parte concreta de la pantalla.

Vamos con un poco de código:

function Min(i,j: Integer): Integer;
begin
if i < j then
Result:= i
else
Result:= j;
end;

function Max(i,j: Integer): Integer;
begin
if i > j then
Result:= i
else
Result:= j;
end;

procedure Seleccionar(Bitmap1, Bitmap2: TBitmap; var R: TRect);
var
P1, P2: PByte;
i, j: Integer;
begin
R.Right:= 0;
R.Bottom:= 0;
R.Left:= Min(Bitmap1.Width,Bitmap2.Width);
R.Top:= Min(Bitmap1.Height,Bitmap2.Height);
Bitmap1.PixelFormat:= pf24bit;
Bitmap2.PixelFormat:= pf24bit;
for j:= 0 to Min(Bitmap1.Height,Bitmap2.Height) - 1 do
begin
P1:= Bitmap1.ScanLine[j];
P2:= Bitmap2.ScanLine[j];
for i:= 0 to Min(Bitmap1.Width,Bitmap2.Width) - 1 do
begin
if not CompareMem(P1,P2,3) then
begin
R.Right:= Max(i,R.Right);
R.Bottom:= Max(j,R.Bottom);
R.Left:= Min(i,R.Left);
R.Top:= Min(j,R.Top);
end;
inc(P1,3); inc(P2,3);
end;
end;
end;

// Un ejemplo de como usar la funcion anterior:
var
Bitmap1, Bitmap2, Bitmap3: TBitmap;
R: TRect;
begin
Bitmap1:= TBitmap.Create;
Bitmap2:= TBitmap.Create;
Bitmap3:= TBitmap.Create;
try
// Cargamos dos imagenes
Bitmap1.LoadFromFile('d:\1.bmp');
Bitmap2.LoadFromFile('d:\2.bmp');
// Encontramos el recuadro donde estan localizados los cambios
Seleccionar(Bitmap1,Bitmap2,R);
// Copiamos ese recuadro en un nuevo bitmap
Bitmap3.Width:= R.Right - R.Left;
Bitmap3.Height:= R.Bottom - R.Top;
with Bitmap3 do
Canvas.CopyRect(Rect(0,0,Width,Height),Bitmap2.Canvas,R);
// En este ejemplo lo guardo, pero podriamos convertirlo a jpeg primero
Bitmap3.SaveToFile('d:\3.bmp');
finally
Bitmap1.Free;
Bitmap2.Free;
Bitmap3.Free;
end;
end;


Esta solución se puede mejorar bastante, un posible camino seria utilizar mas de un recuadro, mas pequeños, para localizar los cambios. Pero eso ya es otra historia ...

[acertij022]

Gracias a ambos pero intentare hacer lo que me dijo seoane (hacerlo desde delphi)ya que puedo agregar muchas mejoras administrativa como ser: si el cliente tiene deuda, toda la info del hardaware, chat,etc aunque tienen razon de que no hay que reiventar la rueda por eso en un momento comente como interactuar con las DLL :D

pd:Estoy muy contento de ser parte de este sitio las respuestas son increblemente rapidas y uno puede evaluar varias postura de una idea :cool:

[acertij022]

Hasta ahora solo logre esto pero nose como comparar y enviar solo la porcion que cambio

nit UServer;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, Jpeg, IdBaseComponent, IdComponent,
IdTCPConnection, IdTCPClient;

type
TFServer = class(TForm)
Timer1: TTimer;
tcp: TIdTCPClient;
procedure GetDesktop(Imagen:integer);
procedure Timer1Timer(Sender: TObject);
procedure Enviar(Imagen:integer);

private
{ Private declarations }
public
{ Public declarations }
end;

var
FServer: TFServer;
streamBMP1,streamBMP2:TMemoryStream;
BMPEstado:integer=0; //indica que imagen esta para comparar

implementation

{$R *.dfm}
//##############################################################################
procedure TFServer.GetDesktop(Imagen:integer);
var
imag: TImage;
desktop: TCanvas;
begin
imag:=TImage.Create(FServer);
imag.Width:=screen.Width;
imag.Height:=screen.Height;
desktop:=TCanvas.Create;
with DeskTop do Handle := GetWindowDC (GetDesktopWindow) ;
with Imag.Canvas do CopyRect (Rect (0, 0, screen.Width, screen.Height),DeskTop,Rect (0, 0, screen.Width, screen.Height));
desktop.Free;
if Imagen=1 then
begin
streamBMP1:=TMemoryStream.Create;
imag.Picture.Bitmap.SaveToStream(streamBMP1);
end;
if Imagen=2 then
begin
streamBMP2:=TMemoryStream.Create;
imag.Picture.Bitmap.SaveToStream(streamBMP2);
end;
imag.Free;
end;
//##############################################################################
function comparar():boolean;
begin
Result:=true;
if streamBMP1<>streamBMP2 then Result:=true;
end;
//##############################################################################
procedure TFServer.Timer1Timer(Sender: TObject);
begin
Application.ProcessMessages;
if BMPEstado=0 then
begin
GetDesktop(1);
try
tcp.Connect;
except Timer1.Enabled:=false; exit; end;
Enviar(1);
BMPEstado:=2;
end;
if BMPEstado=1 then
begin
GetDesktop(1);
if not comparar then
begin
try
tcp.Connect;
except Timer1.Enabled:=false; exit; end;
Enviar(1);
streamBMP2.Free;
BMPEstado:=2;
end
else streamBMP1.Free;
end;
if BMPEstado=2 then
begin
GetDesktop(2);
if not comparar then
begin
try
tcp.Connect;
except Timer1.Enabled:=false; exit; end;
Enviar(2);
streamBMP1.Free;
BMPEstado:=1;
end
else streamBMP2.Free;
end;
end;
//##############################################################################
procedure TFServer.enviar(Imagen:integer);
begin
try
with tcp do
begin
OpenWriteBuffer;
if Imagen=1 then WriteStream(streamBMP1);
if Imagen=2 then WriteStream(streamBMP2);
CloseWriteBuffer;
Disconnect;
end;
except end;
end;
//##############################################################################
end.

[acertij022]

1º ante todo te pido disculpa por no leer tu pos seoane porque es la solucion:D.
Lo que no me sale ahora es redibujar la porción de BMP en el cliente

en servidor (que se le entrega al cliente) use el siguiente codigo:

unit Umain;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, Jpeg, ZipForge, ScktComp, IdBaseComponent,
IdComponent, IdTCPConnection, IdTCPClient;

type
TFMain = class(TForm)
Button1: TButton;
MainZip: TZipForge; // componente para zipera y dezipear
IdTCPClient1: TIdTCPClient;
procedure GetDesktop();
procedure comparar();
procedure FormCreate(Sender: TObject);
procedure Enviar(var streamZip:TStream);
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
FMain: TFMain;
Recuadro : array [0..1000] of Trect;
BMPEstado:integer=0; //indica que imagen esta para comparar
Bitmap1,Bitmap2: TBitmap;
StreamZip: TStream;
implementation

{$R *.dfm}
//##############################################################################
function Min(i,j: Integer): Integer;
begin
if i < j then
Result:= i
else
Result:= j;
end;
//##############################################################################
function Max(i,j: Integer): Integer;
begin
if i > j then
Result:= i
else
Result:= j;
end;
//##############################################################################
function Seleccionar(Bitmap_a, Bitmap_b: TBitmap):integer;
var
P1, P2: PByte;
a,b,i, j: Integer;
R: TRect;
intR:integer;
begin
Result:=0;
intR:=0;
b:=0;
R.Right:= 0;
R.Bottom:= 0;
R.Left:= Min(Bitmap_a.Width,Bitmap_b.Width);
R.Top:= Min(Bitmap_a.Height,Bitmap_b.Height);
Bitmap_a.PixelFormat:= pf24bit;
Bitmap_b.PixelFormat:= pf24bit;
for j:= 0 to Min(Bitmap_a.Height,Bitmap_b.Height) - 1 do
begin
a:=0;
P1:= Bitmap_a.ScanLine[j];
P2:= Bitmap_b.ScanLine[j];
for i:= 0 to Min(Bitmap_a.Width,Bitmap_b.Width) - 1 do
begin
if not CompareMem(P1,P2,3) then
begin
R.Right:= Max(i,R.Right);
R.Bottom:= Max(j,R.Bottom);
R.Left:= Min(i,R.Left);
R.Top:= Min(j,R.Top);
a:=1;
b:=1;
end;
inc(P1,3); inc(P2,3);
end;
if (a=0)and(b=1)then
begin
a:=0;b:=0;
Recuadro[intR].Right :=R.Right;
Recuadro[intR].Bottom:=R.Bottom;
Recuadro[intR].Left :=R.Left;
Recuadro[intR].Top :=R.Top;
inc(intR);

R.Right:= 0;
R.Bottom:= 0;
R.Left:= Min(Bitmap_a.Width,Bitmap_b.Width);
R.Top:= Min(Bitmap_a.Height,Bitmap_b.Height);
end;
end;
Result:=intR;
end;
//##############################################################################
procedure TFMain.comparar();
var
desktop: TCanvas;
Bitmap: TBitmap;
int1,int2:integer;
jpg: TJpegImage;
stream: TStream;
str1:string;
begin
int2:=-1;
Bitmap:= TBitmap.Create;
jpg:=TJPegImage.Create;
// MainZip.FileName:='data.zip';
StreamZip:=TMemoryStream.Create;
MainZip.OpenArchive(StreamZip,true);

desktop:=TCanvas.Create;
with DeskTop do Handle := GetWindowDC (GetDesktopWindow) ;

try
// Encontramos el recuadro donde estan localizados los cambios
if BMPEstado=0 then int2:=0;
if BMPEstado=2 then int2:=Seleccionar(Bitmap1,Bitmap2);
if BMPEstado=1 then int2:=Seleccionar(Bitmap2,Bitmap1);
// Copiamos ese recuadro en un nuevo bitmap
if int2 = -1 then exit;
for int1:=0 to int2 do
begin
Bitmap.Width:= Recuadro[int1].Right - Recuadro[int1].Left;
Bitmap.Height:= Recuadro[int1].Bottom - Recuadro[int1].Top;
if BMPEstado=0 then
begin
Bitmap.Width:= screen.Width;
Bitmap.Height:= screen.Height;
with Bitmap do Canvas.CopyRect(Rect(0,0,Bitmap1.Width, Bitmap1.Height),Bitmap1.Canvas,Rect(0,0,Bitmap1.Width, Bitmap1.Height));
Recuadro[int1].Left:=0;
Recuadro[int1].Top:=0;
Recuadro[int1].Right:=Bitmap.Width;
Recuadro[int1].Bottom:=Bitmap.Height;
end;
if BMPEstado=1 then with Bitmap do Canvas.CopyRect(Rect(0,0,Width,Height),Bitmap1.Canvas,Recuadro[int1]);
if BMPEstado=2 then with Bitmap do Canvas.CopyRect(Rect(0,0,Width,Height),Bitmap2.Canvas,Recuadro[int1]);
str1:=str1+IntToStr(Recuadro[int1].Left)+';';
str1:=str1+IntToStr(Recuadro[int1].Top)+';';
str1:=str1+IntToStr(Recuadro[int1].Right)+';';
str1:=str1+IntToStr(Recuadro[int1].Bottom)+';'+#10;
// convierto a jpeg
stream:=TMemoryStream.Create;
jpg.Assign(Bitmap);
jpg.CompressionQuality:=80; //Calidad del JPEG
jpg.Compress; //Comprimimos la imagen
jpg.SaveToStream(stream);
jpg.SaveToFile(IntToStr(int1)+'.jpg');
stream.Position:=0;
MainZip.AddFromStream(IntToStr(int1)+'.jpg',stream,0,stream.Size);
Stream.Free;
end;
finally
Bitmap.Free;
jpg.Free;
stream:=TMemoryStream.Create;
Stream.WriteBuffer(Pointer(str1)^, Length(str1));
MainZip.AddFromStream('Position.txt',stream,0,stream.Size);
MainZip.CloseArchive;

desktop.Free;
if str1<>'' then
begin
StreamZip.Position:=0;
Enviar(StreamZip);
end;
StreamZip.Free;
end;
end;
//##############################################################################
procedure TFMain.GetDesktop();
label salto;
var
desktop: TCanvas;
begin
if BMPEstado in[0,2] then
begin
Bitmap1.Width:=screen.Width;
Bitmap1.Height:=screen.Height;
desktop:=TCanvas.Create;
with DeskTop do Handle := GetWindowDC (GetDesktopWindow) ;
with Bitmap1.Canvas do CopyRect (Rect (0, 0, screen.Width, screen.Height),DeskTop,Rect (0, 0, screen.Width, screen.Height));
desktop.Free;
if BMPEstado=0 then
begin
comparar;
BMPEstado:=1;
goto salto;
end;
BMPEstado:=1;
comparar;
goto salto;
end;
if BMPEstado =1 then
begin
Bitmap2.Width:=screen.Width;
Bitmap2.Height:=screen.Height;
desktop:=TCanvas.Create;
with DeskTop do Handle := GetWindowDC (GetDesktopWindow) ;
with Bitmap2.Canvas do CopyRect (Rect (0, 0, screen.Width, screen.Height),DeskTop,Rect (0, 0, screen.Width, screen.Height));
desktop.Free;
BMPEstado:=2;
comparar;
goto salto;
end;
salto:;
end;
//##############################################################################
procedure TFMain.FormCreate(Sender: TObject);
begin
Bitmap1:= TBitmap.Create;
Bitmap2:= TBitmap.Create;
end;
//##############################################################################
procedure TFMain.Enviar(var StreamZip:TStream);
begin
IdTCPClient1.Connect;
IdTCPClient1.OpenWriteBuffer;
IdTCPClient1.WriteStream(StreamZip);
IdTCPClient1.CloseWriteBuffer;
IdTCPClient1.Disconnect;
end;
//##############################################################################
procedure TFMain.Button1Click(Sender: TObject);
begin
GetDesktop; // EN REALIDAD ESTO DEVERIA ESTAR EN UN TIMER
end;
//##############################################################################
end.


Y en el cliente (osea mi PC ;) )coloco este codigo:

unit Umain;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ScktComp, ExtCtrls, ZipForge, IdBaseComponent, IdComponent,
IdTCPServer, StdCtrls, Jpeg;

type
TForm1 = class(TForm)
imgDesktop: TImage;
MainZip: TZipForge; // componente para zipera y dezipear
IdTCPServer1: TIdTCPServer;
procedure IdTCPServer1Execute(AThread: TIdPeerThread);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;
Desktop1:TBitmap;

implementation

{$R *.dfm}
//##############################################################################
procedure TForm1.IdTCPServer1Execute(AThread: TIdPeerThread);
var
AStream,FileStream:TStream;
str1,strPosicion:string;
int1,int2:integer;
jpg: TJpegImage;
Bitmap1: TBitmap;
R:Trect;
begin
with AThread.Connection do
begin
AStream:=TMemoryStream.Create;
ReadStream(AStream, -1, true);
AStream.Position:=0;
MainZip.OpenArchive(AStream,false);
MainZip.ExtractToString('Position.txt',str1);
caption:=str1;
int2:=0;
while length(str1)>0 do
begin
if pos(#10,str1)>0 then
begin
strPosicion:=copy(str1,1,pos(#10,str1)-1);
int1:=pos(';',strPosicion); R.Left:=StrToInt(copy(strPosicion,1,int1-1)); strPosicion:=copy(strPosicion,int1+1,length(strPosicion));
int1:=pos(';',strPosicion); R.Top:=StrToInt(copy(strPosicion,1,int1-1)); strPosicion:=copy(strPosicion,int1+1,length(strPosicion));
int1:=pos(';',strPosicion); R.Right:=StrToInt(copy(strPosicion,1,int1-1)); strPosicion:=copy(strPosicion,int1+1,length(strPosicion));
int1:=pos(';',strPosicion); R.Bottom:=StrToInt(copy(strPosicion,1,int1-1)); strPosicion:=copy(strPosicion,int1+1,length(strPosicion));
str1:=copy(str1,pos(#10,str1)+1,length(str1));
FileStream:=TMemoryStream.Create;
MainZip.ExtractToStream(IntToStr(int2)+'.jpg',FileStream);
FileStream.Position:=0;
jpg:=TJPegImage.Create;
jpg.LoadFromStream(FileStream);
FileStream.Free;
Bitmap1:=TBitmap.Create;
Bitmap1.Assign(jpg);
if Desktop1.Width<Bitmap1.Width then Desktop1.Width:=Bitmap1.Width;
if Desktop1.Height<Bitmap1.Height then Desktop1.Height:=Bitmap1.Height;
with Desktop1 do Canvas.CopyRect(R,Bitmap1.Canvas,R);//FUNCIONA LA 1º VEZ (PANTALLA COMPLETA)
imgDesktop.Picture.Assign(Desktop1);
Bitmap1.Free;
jpg.Free;
inc(int2);
end;
end;
MainZip.CloseArchive;
AStream.Free;
end;
end;
//##############################################################################
procedure TForm1.FormCreate(Sender: TObject);
begin
Desktop1:=TBitmap.Create;
end;
//##############################################################################
end.

Como lo indique en el codigo solo me funciona una unica ves el copiar un BMP en una parte de otro BMP

Si a alguien sabe porque por favor me lo puden explicar o indicarme como solucionarlo.
Desde ya muchas gracias a todos por los aportes :cool:

[seoane]

:confused: La verdad es que me pierdo entre tanto código. Pero hay algo que me llama la atención:


with Desktop1 do Canvas.CopyRect(R,Bitmap1.Canvas,R);


Entiendo que R son las coordenadas donde quieres dibujar el recuadro, pero ten en cuenta el 3 parámetro del método CopyRect es el recuadro de origen y no es el mismo que el de destino como tu indicas (menos cuando es la pantalla completa, por eso te funciona la primera vez). Yo haría algo como esto:


with Desktop1 do Canvas.CopyRect(R,Bitmap1.Canvas,Rect(0,0,Bitmap1.Width,Bitmap1.Height));

[acertij022]

jajaj me rio de mi mismo tenes razon seoane:D funciona perfecto ahora solo me falta emular el raton y el teclado.

MUCHISIMAS GRACIAS!!!:D