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:

Código Delphi [-]
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:

Código Delphi [-]
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

[[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

Software Control Remoto, sin abrir puertos en routers

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]

Empezado por 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

Software Control Remoto, sin abrir puertos en routers

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:

Código Delphi [-]
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

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

[acertij022]

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

Código Delphi [-]
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.
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:

Código Delphi [-]
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:

Código Delphi [-]
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.Widththen Desktop1.Width:=Bitmap1.Width;
       if Desktop1.Heightthen 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

[[seoane]]

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

Código Delphi [-]
 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:

Código Delphi [-]
 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 funciona perfecto ahora solo me falta emular el raton y el teclado.

MUCHISIMAS GRACIAS!!!