Soportalo

En Windows XP al arrancar nos puede mandar el mensaje “no hay recursos de sistema suficientes para completar la llamada a API” hay dos posibles causas
una es Disco Duro Lleno , lo que hay que hacer es de varias formas, poner el discu duro de esclavo y vaciar hasta tener unos 300 Mb libres, yo recomiendo un giga

y dos instalar este parche

http://www.microsoft.com/downloads/details.aspx?amp;amp;amp;amp;amp;amp;displaylang=es&familyid=9D20F96A-A8D6-4627-89F7-787CD9B3852C&displaylang=es

Cuando creamos un archivo de Flash para Internet (swf), es importante tener cuidado a la hora de diseñar cada elemento que manejemos o creemos. Cada cosa añadida a un SWF puede incrementar el tamaño del archivo final, generando más tiempo de carga y limitando las visitas para todo tipo de usuarios, como aquellos que se conectan vía telefónica (dialup).

Aquí te decimos algunas recomendaciones para bajar el peso de un SWF.

• Maneja una película principal y has la carga de secciones de manera externa. Esto reducirá los tiempos de espera innecesarios, como la carga total de la película. Además hará mas dinámica la pagina en caso de no querer ver todas las secciones.
• No uses sonidos dentro de ella, a menos que sea muy pero muy necesario. Si lo haces, primero invadirás las bocinas del usuario, que es bastante molesto. Segundo, el peso de tu película se incrementara. Si es necesario que pongas música de fondo, cargala de manera externa y crea una opción de parar dicha música. No pongas sonido en los botones, al final , el oído se acostumbra, no hace caso e irritarás al usuario.
• En lugar de imágenes bitmap utiliza diseño vectorial. Reducirás mucho el peso de la película y es posible hacer zoom sin deformar la figura. En caso de que sea imágenes, cargalas también de manera externa. Utiliza JPG o PNG , NO utilices BMP son demasiado pesadas.
• No sobrecargues de elementos tu pagina. Evalúa su funcionalidad y estética.

Estos son algunos pequeños consejos para poder reducir el tamaño de tus archivos y optimizarlos para la web

Si te sirvio este post y quieres divertirte un poco ahora da click aqui y Visita Soportalo.com Post nuevos todos los dias

A mí me gusta tener desactivadas las actualizaciones automáticas. Pero aún teniendolas desactivadas, me sale el dichoso mensaje de alerta de seguridad de Windows. Esto es molesto y podemos evitar que aparezca, ¿cómo?, es bien sencillo, sólo basta seguir los siguientes pasos:

Vamos a panel de control , y buscamos la opción de centro de seguridad

y en el cuadro que se abre, a la izquierda hay una opción que nos indica cambiar la forma en que windows realizará las alertas.

Ahí desactivas la opción que indica la imagen y listo, ya no aparecerá más este molesto aviso.

Espero sea útil

Muchas veces nos es necesario hacer un efecto de zoom a ciertos clips o imágenes, por ejemplo cuando tenemos mapas, entornos que muestran opciones más pequeñas conforme se van acercando a ella, etc. Realizar este efecto es muy útil y ayuda a la usabilidad de nuestra aplicación.

En este caso en específico explicaré sólo el método de acercamiento por medio del click del mouse a un lugar en específico del clip.

Lo que necesitaremos será el clip a trabajar, dentro del cual podremos poner lo que queramos, imágenes, dibujos, etc. Luego le asignamos un nombre de instancia (en este caso mapa) y sólo resta copiar este código en el primer frame de la película principal.

Código :

incremento = 2;
function zoom(x,y,ancho,alto, aceleracion) {
mapa.onEnterFrame = function() {
this._x += (x-this._x)/aceleracion;
this._y += (y-this._y)/aceleracion;
this._width += (ancho-this._width)/aceleracion;
this._height+= (alto-this._height)/aceleracion;
if (Math.abs(x-this._x)<0.5 && Math.abs(y-this._y)<0.5 && Math.abs(ancho-this._width)<0.5 && Math.abs(alto-this._height)<0.5) {
this._x = x;
this._y = y;
this._width = ancho;
this._height = alto;
delete this.onEnterFrame;
}
};
};
onMouseDown =function(){
if (mapa.hitTest(_xmouse,_ymouse)){
Alto = incremento*mapa._height;
Ancho = incremento*mapa._width;
x = _xmouse-((_xmouse-mapa._x) * incremento);
y= _ymouse-((_ymouse-mapa._y) * incremento);
zoom(x,y,Ancho,Alto,3);
}
};

¡Y listo! Ya puede usarse, sólo prueba dando click encima del clip.

Ahora procederé a explicar el código.

Incremento es la variable que determina el tamaño del acercamiento, en este caso lo incrementa en un 200% puede ser modificable a nuestro antojo.

Esta porción de código es parte de este tip con la diferencia que incrementa dos variables más, ancho y alto, las cuales se encargarán de modificar el ancho y el alto del clip, haciendo la misma función que las variables de columna y fila y la misma comprobación, si se ha cumplido, para poder eliminar el enterframe.

Código :

function zoom(x,y,ancho,alto, aceleracion) {

mapa.onEnterFrame = function() {

this._x += (x-this._x)/aceleracion;

this._y += (y-this._y)/aceleracion;

this._width += (ancho-this._width)/aceleracion;

this._height+= (alto-this._height)/aceleracion;

if (Math.abs(x-this._x)<0.5 && Math.abs(y-this._y)<0.5 && Math.abs(ancho-this._width)<0.5 && Math.abs(alto-this._height)<0.5) {

this._x = x;

this._y = y;

this._width = ancho;

this._height = alto;

delete this.onEnterFrame;

}

};

};

La siguiente parte es la importante, lo primero que hará será detectar si el mouse ha sido presionado.

Código :

onMouseDown =function(){

Esto hará la comprobación por medio de la cual verificará si las coordenadas del mouse en el momento que se presionó están sobre el clip, lo cual indicará que se ha echo click sobre él.

Código :

if (mapa.hitTest(_xmouse,_ymouse)){

Después de eso se calculará el tamaño de la película con el zoom:

Código :

Alto = incremento*mapa._height;
Ancho = incremento*mapa._width;

que es donde interviene la variable incremento, la cual, reitero, podremos manejar a nuestro antojo.

Luego haremos el cálculo de la nueva posición del clip, ya que si lo dejamos en esa posición, se nos moverá hacia la derecha y hacia abajo, lo cual nos desubica, para lo cual se emplea la siguiente ecuación:

Código :

x = _xmouse-((_xmouse-mapa._x) * incremento);
y= _ymouse-((_ymouse-mapa._y) * incremento);

Y por último le mandamos a la función los parámetros y ella se encargará del resto.

Código :

zoom(x,y,Ancho,Alto,3);

Nota: es importante que al crear el clip, el punto de registro sea a la izquierda arriba.

Espero les sirva.

Si te sirvio este post y quieres divertirte un poco ahora da click aqui y Visita Soportalo.com Post nuevos todos los dias

En este tema les voy a mostrar  una función que permite mover los objetos con efecto easing de autoría original de solislarg (moderador del difunto nomaster.com) modificada a mi gusto.

El código es el siguiente:

Código :

function Mover(x,y, aceleracion) {
          NombreInstanciaClip.onEnterFrame = function() {
          this._x += (x-this._x)/aceleracion;
          this._y += (y-this._y)/aceleracion;

         if (Math.abs(x-this._x)<0.5 && Math.abs(y-this._y)<0.5 ) {
                 this._x = x; 

                 this._y = y;
                 delete this.onEnterFrame; 

           }
};
}

¿Cómo funciona? bueno, pues es bastante sencillo solo necesita tres parámetros, columna, fila, y aceleración, la columna y la fila es la posición final hacia la cual queramos que vaya este clip, lo interesante aquí es la aceleración. En que se basa, no es otra cosa mas que los puntos intermedios para llegar a ese punto dividiendo la distancia en varios tramos para hacer la animación fluida, (entre mas puntos, más fluido, pero mas lento)

Código :

NombreInstanciaClip.onEnterFrame = function() {

Aquí cuando mandamos a llamar a la función, se le asigna al clip un enterframe para que realicé la función en cada iteración, se podría asignar el nombre del clip desde los parámetros, pero lo hago así para que sea más entendible,

Después

Código :

this._x += (x-this._x)/aceleracion; 

          this._y += (y-this._y)/aceleracion;

Esto es lo que hace el efecto, en cada iteración divide la distancia final, entre la actual, entre el numero de iteraciones y asigna las nuevas coordenadas a el clip

Código :

if (Math.abs(x-this._x)<0.5 && Math.abs(y-this._y)<0.5 ) {
        this._x = x; 

        this._y = y;
        delete this.onEnterFrame;
}

Esta parte lo único que hace es verificar que la coordenada de el clip tanto x como y no sean menores a 0.5 de diferencia respecto a la coordenada final por que una ves siendo menor, las iteraciones se pueden volver infinitas o mino muy tardadas, por eso en cuanto detecta esa diferencia, asigna las coordenadas finales a el clip y borra este enterframe para que ya no se siga moviendo

Si te sirvio este post y quieres divertirte un poco ahora da click aqui y Visita Soportalo.com Post nuevos todos los dias

Si utilizamos Windows XP nos podemos encontrar con una pantalla azul al inicio del arranque del sistema operativo, en los casos como el que después de una instalación apagamos el ordenador sin ir al clásico Inicio -> Apagar Equipo -> Apagar. Esto ocurre cuando se corrompe el sistema de archivos y puede ser arreglado.

Es posible solucionarlo sin quebraderos de cabeza. Necesitaremos arrancar el ordenador desde el CD, para ello necesitaremos el disco de WinXP. Seguiremos estos pasos:

• Insertar el cd de Windows XP en la bandeja de CD
• Reiniciar y presionar cualquier tecla para iniciar desde CD cuando el sistema lo pida
• En la pantalla que nos menciona si es reparación presionar “R” para entrar en ese modo
• Selecciona la partición donde se encuentra el sistema operativo
• Si tienes contraseña de administrador, ponla, si no simplemente presiona Enter
• Te aparecerá una linea de comando donde teclearas esto chkdsk /r
• Después que termine el proceso, escribir exit para reiniciar, saca el CD para que inicie desde el disco duro y listo tu máquina debe de funcionar

La otra opción es que el disco duro tenga un cable IDe de 40 hilos y necesite uno de 80 (los hilos son más delgados)

También lo he resuelto poniendo el disco dañado como esclavo en una máquina con WinXP, al iniciar hará una comprobación, al terminar de cargar apagaremos.

Muchos de nosotros hemos visto paginas hechas en Flash que contienen un menú con el efecto del famoso menú de Mac OsX.

Realmente no tiene mucha dificultad.

Antes que nada deberemos leer este tip (la ultima edición echa por mi corrige el error, así que no hagan caso a la primera) en la cual se explica una de las dos partes fundamentales de este menú en ese tip hará la detección de la cercanía del mouse, es necesario entenderlo a conciencia para no confundirnos.

Ahora veremos los pasos necesarios para la creación del menú.

Empezamos desde cero, creamos un documento en blanco.

Primer paso, crear los elementos del menú, convertirlos a clip individuales por cada elemento , no importa el numero, es una de las ventajas como he diseñado esta versión, una ves terminados , asignarles a cada uno de ellos un nombre de instancia empezando por 0 en base a este termino
btn00, btn01, btn02 … etc.

Después los seleccionamos todos y los convertimos a un solo clip con el punto de registro en la parte superior izquierda, esto es muy importante para el correcto funcionamiento.

Una vez hecho esto pegaremos este código dentro del primer frame del clip que contiene todos los elementos de el menú:

Código :

//align = bottom;
//esto hara que el punto de centro sea la mitad por si tenemos que reposicionarlo , el punto 1,1
//sera sera siemrpe el punto de en medio de este menú, se la asigno a variables para ser flexible
//por si necesitamos hacer algo con ello
centerx = 0;
centery = 0;

//Establecemos el menú de items para saber cuanto tenemos que recorrer para hacer los cálculos
menucount = 6;

// establecemos de que ancho son los items, para hacerlo dinámico, tomo el ultimo y asigno el ancho
// los items para ser optimos deberian tener la misma anchura
miwidth = this["btn0" + menucount - 1]._width;

// establecesmos que espacio entre cada item deseamos
miborder = 5;

// establecemos la variable inicial en el valor cero, que lelvara el control del ancho del menu
AnchMen = 0;

//esto hara que cada ves que el menú haga un enterframe se ejecute y tengamos un monitoreo constante
onEnterFrame = function ()
{
   var AnchMen = 0;

   //esta es la parte del tip anterior, con la única diferencia que este acumula en la variable 
   //AnchMen el ancho del menú
   for (var i = 0; i < menucount; i++) {
      var xxm = this["btn0" + i]._xmouse;

      var yym = this["btn0" + i]._ymouse;
      var xm = Math.sqrt(xxm * xxm + yym * yym);
      if (xm < 80) {
         this["btn0" + i]._xscale = this["btn0" + i]._yscale += ((200 - xm) - this["btn0" + i]._yscale) / 3;
      } else {

         this["btn0" + i]._xscale = this["btn0" + i]._yscale += (100 - this["btn0" + i]._yscale) / 3;
      }

      //esta parte va acumulando el ancho de los elementos
      AnchMen += this["btn0" + i]._width;
   }

   //hacemos el calculo total de incremento de los espacios entre elementos del menu mas el espacio de los elementos
   AnchMen += (menucount - 1) * miborder;

   // Inicializamos las posiciones
   // toma el ancho lo divide entre dos  y se lo resta al centro garantizando que el menu quede centrado
   var xpos = Math.round((centerx - AnchMen) / 2);

   // como el primer item no tiene un elemento anterior de donde partir en la funcion  se establece el punto de parida
   // se hace el calculo del espacio del elemento uno se incrementa y se parte del elemento 2
   xpos += Math.round((this["btn0" + 0]._width + miborder) / 2);
   for (var i = 1; i < menucount; i++) {
      x = i - 1;
      xpos += (this["btn0" + x]._width / 2) + miborder + (this["btn0" + i]._width / 2);

      this["btn0" + i]._x = xpos;
      this["btn0" + i]._y = centery;
   }

   //como el elemento uno no ha sido establecido se le resta su ancho menos al elemento 2 para lograr su posición
   this["btn0" + 0]._x = (this["btn0" + 1]._x - this["btn0" + 0]._width - miborder);
   this["btn0" + 0]._y = centery;
};

Resultado:

Se puede cambiar, por ejemplo, en lugar de convertir los elementos a clip podemos hacerlo a botones y el botón dispara la acción, o dentro del clip podemos establecer animaciones para hacerlo mas vistoso y así lanzar la acción de ese botón.

Si parece muy extenso es solo por los comentarios, realmente el código de el menú es este

Código :

centerx = 0;
centery = 0;
menucount = 6;
miwidth = this["btn0" + menucount - 1]._width;
miborder = 5;
AnchMen = 0;
onEnterFrame = function ()
{
   var AnchMen = 0;
   for (var i = 0; i < menucount; i++) {

      var xxm = this["btn0" + i]._xmouse;
      var yym = this["btn0" + i]._ymouse;
      var xm = Math.sqrt(xxm * xxm + yym * yym);
      if (xm < 80) {
         this["btn0" + i]._xscale = this["btn0" + i]._yscale += ((200 - xm) - this["btn0" + i]._yscale) / 3;

      } else {
         this["btn0" + i]._xscale = this["btn0" + i]._yscale += (100 - this["btn0" + i]._yscale) / 3;
      }
      AnchMen += this["btn0" + i]._width;
   }
   AnchMen += (menucount - 1) * miborder;

   var xpos = Math.round((centerx - AnchMen) / 2);
   xpos += Math.round((this["btn0" + 0]._width + miborder) / 2);
   for (var i = 1; i < menucount; i++) {
      x = i - 1;
      xpos += (this["btn0" + x]._width / 2) + miborder + (this["btn0" + i]._width / 2);
      this["btn0" + i]._x = xpos;

      this["btn0" + i]._y = centery;
      //trace(centerx);
   }
   this["btn0" + 0]._x = (this["btn0" + 1]._x - this["btn0" + 0]._width - miborder);
   this["btn0" + 0]._y = centery;
};

Es optimizable, así que se aceptan sugerencias.

Si te sirvio este post y quieres divertirte un poco ahora da click aqui y Visita Soportalo.com Post nuevos todos los dias

bueno este es el efecto de un boton que creece conforme el mouse se acerca a el

bueno primero crearemos un dibujo , imagen , lo que ustedes quieran,
cuando hayan terminado despues lo selecionan todo y presionan f8, lo convierten en clip de pelicula, con su punto de registro en la parte central, si por default lo tienen en otro punto solo den doble clik sobre el clip para editarlo y de acuerdo a su ancho ,acomodenlo a la mitad por ejemplo
si es de 80 x 80 entonces solo pongano en x = -40 y= -40
ahora salgan de la edicion , seleccionen el clip
y pongan este codigo

Código :

onClipEvent(load){
Ancho=this._width;
Aumento=200;
perimetro=this._width+20;
}
onClipEvent (enterFrame){
x = this._xmouse;
y = this._ymouse;
radio = Math.sqrt(x*x+y*y);
if (radio < perimetro){
this._yscale += ((Aumento-radio)-this._yscale)/6;
this._xscale = this._yscale;
}
else {
this._yscale += (100-this._yscale)/6;
this._xscale = this._yscale;
}
}

y listo el efecto esta terminado, ahora procedere a explicarles como funciona

Código :

onClipEvent(load){
Ancho=this._width;
Aumento=200;
perimetro=this._width+20;
}

esta parte se efectua cuando se carga el clip por lo tanto solo lo hara una vez

dentro de el estan las acciones a ejecutarse, que en este caso es declarar ancho y aumento, en ancho , obtiene el ancho de el clip para determinar el area de egistro de actividad del mouse
despues en aumento asigna 200, este es el porcentaje que queremos que creesca nuestro clip en este caso crecera un 200% se obtiene el ancho y se le añade 20 pixeles mas para obtener el perimetro a partir del cual detectaremos la cercania del mouse

Código :

onClipEvent (enterFrame){

esto hara que cada vez que revise este objeto se ejecute el codigo siguiente

Código :

x = this._xmouse;
y = this._ymouse;

en esta parte se almacena en x y en y la posicion, tanto columna como fila de el mouse dentro del mc para las ecuaciones que necesitamos hacer

Código :

radio = Math.sqrt(x*x+y*y);

en esta se obtiene a que distancia esta obteniendo el radio, e

esto verifica que el radio sea menor a el area de impacto que hemos definido, que es el ancho original de lapelicula

Código :

this._yscale += ((Aumento-radio)-this._yscale)/3;
this._xscale = this._yscale;

en esta parte lo que hace es que quita del aumento el radio, por lo tanto entre menos radio, osea mas ccerca, mas crece, se le resta la escaa actual
y se le divide entre 36 para un efecto fluido , esto se puede cambiar, mas pequeño el numero mas rapido y mas seco, mas grande , mas fluido pero mas lento, yo recomiendo 6

despues asigna la misma escala a xscale por qu ees cuadrado

Código :

else {
this._yscale += (100-this._yscale)/6;
this._xscale = this._yscale;
}

esta parte se ejecuta si el mouse esta fuera del area de impacto de el boton
entonces hace una disminucion hasta el 100 % , lo que es el tamaño original

y listo eso es todo , nada complicado

En este tip mostraré un código para los que necesitan hacer el scroll de una imagen por medio del movimiento del mouse, esto es útil en el manejo de mapas, exploración de imágenes, y varias aplicaciones mas.

Primero pondremos este código en el primer frame de la película que sera para lograr el efecto de deslizamiento de la imagen explicado en este tip.

Código :

function mover(x,y, aceleracion) {
_root.show.foto.onEnterFrame = function() {
this._x += (x-this._x)/aceleracion;
this._y += (y-this._y)/aceleracion;
if (Math.abs(x-this._x)<0.5 && Math.abs(y-this._y)<0.5 ) {
this._x = x;
this._y = y;
delete this.onEnterFrame;
}
};
}

Después crearemos un cuadrado con relleno normal, lo seleccionaremos y lo convertiremos en clip (F con el punto de registro en la parte superior izquierda (esto es muy importante en cada uno de los clips que crearemos, verificar que el punto de registro sea el que se indica para cada uno de ellos) al clip que acabamos de crear le daremos el nombre de instancia show (recordar el nombre de instancia de los clips para poder hacer referencia y no perdernos, por que sera un poquito confuso)

A este clip le asignamos estas acciones (que después explicare con detalle)

Código :

onClipEvent (mouseMove){
if (this.hitTest(_root._xmouse, _root._ymouse, true)){
_root.mover( -((foto._width-btn._width) /btn._width) * _xmouse,-((foto._height -btn._height) /btn._height) * _ymouse,7);
}
}

Seleccionamos el clip show y le damos doble clip, accederemos dentro de este y encontraremos el cuadrado, lo seleccionamos y lo convertimos en clip de nuevo, si de nuevo, es para generar otro clip dentro del clip show que es el que hará el efecto.

Después de haberlo convertido en clip le asignaremos el nombre de instancia btn, posterior a esto, generaremos otras dos capas en la parte de abajo.

Después en la segunda capa copiamos el keyframe de la primera y lo pegamos y en la tercera importamos una imagen a la cual convertimos en clip también (f y le asignamos el nombre de instancia foto, quedando en este orden:

1. Capa, el cuadrado convertido en clip
2. Capa la copia del keyframe del cuadrado, con lo cual tendremos dos cuadrados
3. La imagen importada convertida en clip

A el clip ftoo lo seleccionamos y le asignamos en acciones (f9) este código

Código :

onClipEvent (load){
this._x=-(this._width/2)+(_parent.btn._width/2);
this._y=-(this._height/2)+(_parent.btn._height/2);
}

Que hará que la imagen se centre de inicio. Después de esto seleccionamos la segunda capa y damos click derecho, seleccionando la opción mascara del menú.

Seleccionamos el clip de la primera capa y le damos efecto de alpha 0 para que sea transparente.

Vamos a la película principal y listo, debe quedar algo como esto:

Ahora la parte de explicación. El código que hace las maravillas, y lo demás es solo adorno, es este:

Código :

onClipEvent (mouseMove){
[code]if (this.hitTest(_root._xmouse, _root._ymouse, true)){[/code]
_root.mover( -((foto._width-btn._width) /btn._width) * _xmouse,-((foto._height -btn._height) /btn._height) * _ymouse,7);
}
}

Al detectar que se mueve el mouse onClipEvent (mouseMove) hace una detección si el puntero del mouse hace contacto con este clip if (this.hitTest(_root._xmouse, _root._ymouse, true)){ hace el cálculo de esta manera a grandes rasgos, una regla de tres, si el cuadro pequeño se mueve 1 el grande se moverá 2 dependiendo del tamaño de la imagen, por eso se hace una equivalencia, y cabe notar que se le resta el ancho del cuadrado para que no salga del área total, y siempre se mantenga una proporción dentro de lo visible, esto se puede hacer inmediato sin llamar a la función, solo que con la función el efecto de easing lo hace mucho mas atractivo

Cualquier error que se me haya pasado por favor comentarlo aquí para hacer la corrección.

Actualizacion,

Este es un codigo Diseñado por Teseo, uno de lso programadores que mas me impresionan y admiro

Código :

function scrollvisor(imagen, x0, y0, w0, h0) {
   ori = this.createEmptyMovieClip("nulo", this.getNextHighestDepth());
   ori.rt = new flash.geom.Rectangle(x0,y0,w0,h0);
   if(imagen instanceof MovieClip){

     ori.img=g=new flash.display.BitmapData(imagen._width,imagen._height,true,0);
     ori.img.draw(imagen);
  } else {ori.img = g = flash.display.BitmapData.loadBitmap(imagen);}
   ori.w = w = ori.img.width; ori.h = h = ori.img.height;
  w < w0 ? ori.wt = wt = w : ori.wt = wt = w0;
  h < h0 ? ori.ht = ht = h : ori.ht = ht = h0;

   ori._x = x0; ori._y = y0;
   ori.tmp = new flash.display.BitmapData(wt, ht, true, 0);
   ori.attachBitmap(ori.tmp, 1, "auto", true);
   ori.tmp.copyPixels(g, new flash.geom.Rectangle((w-wt)/2,(h-ht)/2,wt,ht),null);
   ori.onRollOver = function() {
      with (this) {
         onMouseMove = function () {

            xm = this._xmouse; ym = this._ymouse;
            xm>rt.x && xm<rt.x+wt ? xx=(xm-rt.x)*(w-wt)/wt : xm>rt.x ? xx=w-wt : xx=0;
            ym>rt.y && ym<rt.y+ht ? yy=(ym-rt.y)*(h-ht)/ht : ym>rt.y ? yy=h-ht : yy=0;

            tmp.copyPixels(img, new flash.geom.Rectangle(xx, yy, wt, ht), null);
         }
      }
   }
   ori.onRollOut = function() {delete onMouseMove;}
}
/*
 Tipo de llamada a la función
 imagen : instancia de clip o nombre de imagen vinculada desde la biblioteca.
 x0, y0 : esquina superior izquierda donde mostrar.
 w0, h0 : ancho y alto de la zona donde mostrar.
*/
// Ejemplos:
//scrollvisor("imagen1", 0, 0, 300, 200);
//scrollvisor("imagen", 0, 200, 100, 100);
//scrollvisor(clip1, 100, 100, 200, 200);

Esto es lo que resulta con las 3 llamadas del ejemplo ( 2 son imágenes de biblioteca y otra un clip instanciado en el escenario.

Si te sirvio este post y quieres divertirte un poco ahora da click aqui y Visita Soportalo.com Post nuevos todos los dias

El primer ejemplo pueden descargarlo en cristalab.com, http://www.cristalab.com/ejemplos/descargar/99  el mismo archivo.