FAQ :: Mitgliederliste :: MGi Team

Willkommen auf dem Portal für Mediengestalter

Zur Registrierung

Thema: [Scripte] MGI-Codeschnipsel-Ecke vom 08.11.2007

	MGi Foren-Übersicht -> Programmierung -> [Scripte] MGI-Codeschnipsel-Ecke
	Seite: Zurück 1, 2, 3, 4 Weiter

Autor

Nachricht

Pixelpole

Dabei seit: 25.10.2004
Ort: Trier
Alter: 37
Geschlecht: Männlich

Verfasst Mo 28.04.2008 22:57
Titel

so kinners hier mal wieder ein schnipselchen nachdem sich hier wohl garnix mehr tut.

Code:

Code:

<?php

class TEMPLATE {
protected static $tpl_content = array();

public static function assign($name, $content) {
   self::$tpl_content[$name] = $content;
}

public static function unassign($name) {
   if(isset(self::$tpl_content[$name])) {
      unset(self::$tpl_content[$name]);
   }
   else {
      throw new InvalidArgumentException('Element '.$name.' doesn\'t exist');
   }
}

public static function display($template_file) {
   if(file_exists($template_file)) {
      $content = self::$tpl_content;

      require($template_file);
   }
   else {
      throw new InvalidArgumentException($template_file.' doesn\'t exist!');
   }
}

public static function CONTENT($var) {
   if(isset(self::$tpl_content[$var])) {
      return self::$tpl_content[$var];
   }
   else {
      throw new InvalidArgumentException('Element '.$name.' doesn\'t exist');
   }
}
}

TEMPLATE::assign('title', 'Testdokument');
TEMPLATE::assign('headline', 'Testdokument');
TEMPLATE::assign('content', 'lorem ipsum bla, ich schiess dir ins gesicht');

TEMPLATE::assign('list',array('Eintrag 1',
                     'Eintrag 2',
                     'Eintrag 3',
                     'Eintrag 4',
                     'Eintrag 5'));

TEMPLATE::display('test.tpl');

Template:

Code:

Es handelt sich um ein Mini Templatesystem für PHP...naja eigentlich nich ganz...dieser kleiner schnipsel tut eigentlich nix anderes als über ein statisches Objekt einige Variablen in einem eingebundenen Dokument zur Verfügung zu stellen. Das ganze lässt sich dann bequem über die Kontrollstrukturen von PHP abarbeiten.

l'Audiophile
Threadersteller

Dabei seit: 16.09.2004
Ort: Berlin
Alter: 43
Geschlecht: Männlich

Verfasst Sa 17.05.2008 16:19
Titel

Actionscript 3.0

Eine AS3-Klasse für ein dynamisches Scrolling mit integriertem Preloader, das dem altbackenen Yugop-Menü ein bisschen experimentellen Pepp mit auf den Weg gibt *bäh*

Im Klassenaufruf gebt ihr die externe Datei an, die ihr laden wollt, ob ihr sie animieren wollt oder nicht. Die beiden Parameter für die Animation sind daher optional, d.h. man kann sie auch getrost weglassen, wenn man nichts animieren möchte.

Ihr benötigt noch einen externen Grafikfilm, in der die Preloader Animation und ein dynamisches Textfeld für die Anzeige des Ladefortschritts verankert sind.

Die Positon der Loader hab ich noch nicht individuell bestimmt, da weiß ich noch nicht, wie ich welche Objekte später in dem Projekt noch brauch, aber das könnt ihr ja gerade selbst machen.

addLoader.as

Code:

package {
import flash.display.*;
import flash.net.URLRequest;
import flash.events.*;
import fl.transitions.*;
import fl.transitions.easing.*;
//
public class addLoader extends Sprite {
   //
   private var animation:Boolean;
   private var delay:Number;
   private var loaderGUITargetX:Number;
   private var loaderGUITargetY:Number;
   private var loader:Loader;
   private var progressBar:Loader;
   private var rx:Number;
   private var ry:Number;
   private var dx:Number;
   private var dy:Number;
   private var movie:*;
   private var loaderGUI:*;
   private var loadedItem:String;
   //
   public function addLoader():void {
      addEventListener(Event.ADDED_TO_STAGE, addHandler);
   }
   public function loadItem(pLoadedItem:String, pAnimation:Boolean = false, pDelay:Number = .2):void {
      animation = pAnimation;
      loadedItem = pLoadedItem;
      delay = pDelay;
   }
   //
   private function addHandler(event:Event):void {
      loader = new Loader();
      progressBar = new Loader();
      addChild(progressBar);
      addChild(loader);
      progressBar.contentLoaderInfo.addEventListener(Event.INIT, handleInitLBar);
      progressBar.load(new URLRequest("graphicFiles/loader_bar.swf"));
   }
   //
   private function handleInitLBar(event:Event):void {
      loaderGUI = progressBar.content;
      loaderGUI.x = (loaderGUI.stage.stageWidth/2) - (loaderGUI.width);
      loaderGUI.y = (loaderGUI.stage.stageHeight/2) + 100;
      loaderGUITargetY = (loaderGUI.stage.stageHeight/2) - (loaderGUI.height);
      // Events
      loader.contentLoaderInfo.addEventListener(Event.OPEN, handleOpen);
      loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, handleProgress);
      loader.contentLoaderInfo.addEventListener(Event.COMPLETE, handleComplete);
      loader.contentLoaderInfo.addEventListener(Event.INIT, handleInit);
      loader.load(new URLRequest(loadedItem));
   }
   //
   private function handleOpen(event:Event):void {
      loaderGUI.loaderCapture.text = " ";
      var loaderTweenIn:Tween = new Tween(loaderGUI, "y", Elastic.easeOut, loaderGUI.y, loaderGUITargetY, 2, true);
      var loaderAlphaIn:Tween = new Tween(loaderGUI,"alpha", Strong.easeOut, 0, 1, 2, true);
   }
   //
   private function handleProgress(event:ProgressEvent):void {
      var percent:int =event.bytesLoaded/event.bytesTotal*100;
      loaderGUI.loaderCapture.text = percent;
   }
   //
   private function handleComplete(event:Event):void {
      loaderGUI.loaderCapture.text = " ";
      removeChild(progressBar);
      progressBar = null;
   }
   //
   private function handleInit(event:Event):void {
      movie = loader.content;
      if (animation == true) {
      movie.addEventListener(Event.ENTER_FRAME, animateItem);
      }
   }
   //
   private function animateItem(event:Event):void {
      rx = stage.mouseX/stage.stageWidth;
      ry = stage.mouseY/stage.stageHeight;
      rx = Math.max(0, Math.min(1, rx));
      ry = Math.max(0, Math.min(1, ry));
      dx = (stage.stageWidth - this.width)*rx;
      dy = (stage.stageHeight - this.height)*ry;
      this.x += (dx - this.x) * delay;
      this.y += (dy - this.y) * delay;
   }

}
}

Und hier noch der Aufruf in der Dokumentenklasse addDisplayItems.as

Code:

package {
import flash.display.Sprite;
//
public class addDisplayItems extends Sprite {
   //
   public function addDisplayItems() {
      var addLoader1:addLoader = new addLoader();
      addLoader1.loadItem("graphicFiles/pattern1.jpg", true, .2);
      addChild(addLoader1);

      var addLoader2:addLoader = new addLoader();
      addLoader2.loadItem("graphicFiles/pattern2.jpg", true, .3)
      addChild(addLoader2);
   }

}
}

Viel spaß damit * Mmmh, lecker... *

//Ach ja, so kann es z.B. dann aussehen:

http://container-media.com/spielereien/test.html

Zuletzt bearbeitet von l'Audiophile am So 18.05.2008 11:08, insgesamt 2-mal bearbeitet

choise

Dabei seit: 01.02.2007
Ort: Würzburg
Alter: 35
Geschlecht: Männlich

Verfasst Do 26.06.2008 10:11
Titel

so ich werd mich mal dazwischen.

wegen ein paar nachfragen zu meinem em counter, hier das script:

BILD.PHP

Code:

<?php

// ################################################################################
//                      #### CONFIG ####


   $schriftart       = 'CALIBRI.TTF'; //muss auf dem Webserver liegen
   $schriftgroesse    = 12;

   $schriftfarbe_r    = 255;
   $schriftfarbe_g    = 255;
   $schriftfarbe_b    = 255;

   $abstand_x       = 13;
   $abstand_y       = 25;          //mind schriftgroesse

   $bild          ='bg.gif';       //backgroundimage, so gross ist dann auch das bild

// ################################################################################

$zeit_1 = "20:45 29-06-2008";
$zeit_2 = time();

// ################################################################################

$explode_1 = explode(" ", $zeit_1);
$explode_2 = explode(":", $explode_1[0]);
$explode_3 = explode("-", $explode_1[1]);

$neue_zeit = mktime ($explode_2[0], $explode_2[1], 0, $explode_3[1], $explode_3[0], $explode_3[2]);

$differenz = ($zeit_2 - $neue_zeit) / 60;

$text = 'Noch ' . floor($differenz) * -1 . ' Minuten bis zum EM - Finale!';

$img = imagecreatefromgif($bild);
$col = imagecolorallocate($img, $schriftfarbe_r, $schriftfarbe_g, $schriftfarbe_b);
imagettftext($img, $schriftgroesse, 0, $abstand_x, $abstand_y, $col, $schriftart, $text);

header('Content-Type: image/gif', true);
imagegif($img);
imagedestroy($img);

?>

wenn man keine .php datei als bild verlinken kann, weil es zb ein forum ist (wie hier),
noch ne .htaccess dazu:

Code:

RewriteEngine on
RewriteBase /

RewriteRule bild.gif bild.php

nun steht das bild unter bild.php und bild.gif zur verfügung

vielleicht nicht ganz elegant, aber zweckerfüllend.

phihochzwei
Moderator

Dabei seit: 08.06.2006
Ort: Mülheim an der Ruhr
Alter: 46
Geschlecht: Männlich

Verfasst Di 15.07.2008 14:37
Titel

Mal ein generischer XML-Parser für AS2.

Wenn ihr einen Struktur habt, bei der der nicht läuft, wäre ich dankbar um eine kleine Info. Und falls wär noch eine Idee hat, was man an sinnigen Methoden reinbauen kann, auch Lächel

Code:

class XMLObject {

/**
   * Konstruktor.
   */
function XMLObject() {
   AsBroadcaster.initialize(this);
   this.addListener(this);
}
/**
   * Method to load and parse XML-File
   * @param url, URL of the XML-file
   */
public function loadXML(url:String):Void {
   var ref:XMLObject = this;
   var _xml:XML = new XML();
   _xml.ignoreWhite = true;
   _xml.onLoad = function(success:Boolean) {
      if (success) {
         var _node:XMLNode = this.firstChild;//.childNodes[i]
         ref[_node.nodeName] = ref.xmlToObject(_node);
         ref.broadcastMessage("onLoad",true);
         delete _xml;
      } else {
         ref.broadcastMessage("onLoadError","Error loading "+url);
      }
   };
   _xml.load(url);
}
/**
   * internal method to transform given XML-structure to Object-based-structure
   * @param node, first node of XML-structur
   * @return converted structure as an object
   */
private function xmlToObject(_node:XMLNode):Object {
   var obj:Object = new Object();
   for (var prop in _node.attributes) {
      var nn:String = (prop.indexOf(":") !== -1) ? prop.split(":")[1] : prop;
      obj[nn] = (String(parseFloat(_node.attributes[prop])) == "NaN") ? _node.attributes[prop] : parseFloat(_node.attributes[prop]);
   }
   if (_node.hasChildNodes()) {
      for (var i:Number = 0; i<_node.childNodes.length; i++) {
         var _node2:XMLNode = _node.childNodes[i];
         var nn:String = (_node2.nodeName.indexOf(":") !== -1) ? _node2.nodeName.split(":")[1] : _node2.nodeName;


         var count:Number = 0;
         for (var c:Number = 0; c<_node.childNodes.length; c++) {
            if (_node.childNodes[c].nodeName == _node2.nodeName) {
               count++;
            }
         }
         if (count>1) {
            if (obj[nn] == undefined) {
               obj[nn] = new Array();
            }
            if (_node2.hasChildNodes() && _node2.firstChild.nodeName == null) {
               obj[nn].push(_node2.firstChild.nodeValue);
            }else{
               obj[nn].push(this.xmlToObject(_node2));
            }
         } else {
            if (_node2.hasChildNodes() && _node2.firstChild.nodeName == null) {
               obj[nn] = _node2.firstChild.nodeValue;
            }else{
               obj[nn] = this.xmlToObject(_node2);
            }
         }
      }
   }
   return obj;
}
/**
   * Method to get all elements of a specific name as an Array.
   * @param id, Name of the searched element(s)
   * @return All found elements
   */
public function getElementsByID(id:String):Array {
   var _arr:Array = new Array();
   for (var item in this) {
      searchForID(this[item],id,_arr);
   }
   return _arr;
}
/**
   * internal method for element search function.
   * @param obj, Object to search in.
   * @param id, ID to search for.
   * @param tgt, Array to place found reference in
   */
private function searchForID(obj:Object, id:String, tgt:Array):Void {
   for (var item in obj) {
      if (item == id) {
         if (obj[item][0] !== undefined) {
            for (var i:Number = 0; i<obj[item].length; i++) {
               tgt.push(obj[item][i]);
            }
         } else {
            tgt.push(obj[item]);
         }
      } else {
         searchForID(obj[item],id,tgt);
      }
   }
}
public function onLoad():Void {
}
public function onLoadError():Void {
}
public function addListener(listener:Object):Void {
}
public function removeListener(listener:Object):Void {
}
public function broadcastMessage(message:String):Void {
}
}

Und hier mal eine Beispielanwendung:

Code:

var testobject:XMLObject = new XMLObject();
var TEST:Array;
testobject.onLoad = function(success:Boolean){
TEST = testobject.getElementsByID("item");
//TEST = testobject.getElementsByID("channel");
}

testobject.onLoadError = function(message:String):Void{
trace(message);
}

testobject.loadXML("http://www.derwesten.de/nachrichten/nachrichten.rss")

Zuletzt bearbeitet von phihochzwei am Di 22.07.2008 11:07, insgesamt 4-mal bearbeitet

phihochzwei
Moderator

Dabei seit: 08.06.2006
Ort: Mülheim an der Ruhr
Alter: 46
Geschlecht: Männlich

Verfasst Fr 18.07.2008 11:12
Titel

Da einige Menschen anscheinend einfach zu Faul sind, Bilder in AS2 anständig zu laden, hier das ganze mal ein wenig vereinfacht als simple Klasse

Code:

class ExternalImage{
/** MovieClip der das Bild aufnimmt */
private var _mc:MovieClip;
/** MovieClipLoader der das Bild läd */
private var loader:MovieClipLoader;
/** Listener für den Loader */
private var lListen:Object;
/** Optionale Parameter für den MovieClip */
private var props:Object;

/**
* Konstruktor
* @param name, Name des zu erzeugenden MovieClips
* @param parent, MovieClip-Instanz, in der das Bild liegen soll
* @param depth, Tiefe des MovieClips in seiner parent-Instanz
* @param url, URL von des Bildes das geladen werden soll
* @param param, Optionales Object, welches alle Eigenschaften enthält, die dem Bild bei erfolgreichem laden zugewiesen werden.
*/
function ExternalImage(name:String, parent:MovieClip, depth:Number, url:String, param:Object){
   AsBroadcaster.initialize(this);
   prepareListener();

   this.addListener(this);
   this.props = param;
   this._mc = parent.createEmptyMovieClip(name, depth);
   this.loader.loadClip(url, _mc);
}

/**
* Guess what
*/
public function killImage():Void{
   this._mc.removeMovieClip();
   delete loader;
   delete lListen;
   delete props;
   this.broadcastMessage("onRemoval");

}

/**
* Bereitet die nötigen Listener des MovieClipLoaders vor
*/
private function prepareListener():Void{
   var ref:ExternalImage = this;
   this.loader = new MovieClipLoader();
   this.lListen = new Object();
   this.lListen.onLoadInit = function(tgt:MovieClip){
      for(var prop in ref.props){
         tgt[prop] = ref.props[prop];
      }
      ref.broadcastMessage("onLoadInit", tgt);
   }

   this.lListen.onLoadComplete = function(tgt:MovieClip):Void{
      ref.broadcastMessage("onLoadComplete", tgt);
   }

   this.lListen.onLoadProgress = function(tgt:MovieClip, lb:Number, tb:Number):Void{
      ref.broadcastMessage("onLoadProgress", tgt, lb, tb);
   }

   this.lListen.onLoadStart = function(tgt:MovieClip):Void{
      ref.broadcastMessage("onLoadStart", tgt);
   }

   this.lListen.onLoadError = function(tgt:MovieClip, ec:String, http:Number):Void{
      ref.broadcastMessage("onLoadError", tgt, ec, http);
   }
   this.loader.addListener(lListen);
}

public function onLoadComplete():Void {}
public function onLoadInit():Void {}
public function onLoadError():Void {}
public function onLoadProgress():Void {}
public function onLoadStart():Void {}
public function onRemoval():Void{}
public function addListener(listener:Object):Void {}
public function removeListener(listener:Object):Void {}
public function broadcastMessage(message:String):Void {}

}

Nutzen tut man diese Klasse wie folgt:

Code:

/** Object das alle Eigenschaften enthält, die wir dem Bild zuweisen wollen */
var initObject:Object = new Object({_x:150, _y:200, _width:100, _height:100, _rotation: 90});

/** Hier erzeugen wir die Instanz */
var Test:ExternalImage = new ExternalImage("Test", this, 1, "rauchen.jpg", initObject);

/** Wenn Laden beginnt*/
Test.onLoadStart = function(tgt:MovieClip):Void{
trace("Bild wird jetzt geladen");
}

/** Wenn Teil des Bild geladen */
Test.onLoadProgress = function(tgt:MovieClip, bytesGeladen:Number, bytesGesamt:Number):Void{
trace("Bild teilweise geladen. " + bytesGeladen + " von " + bytesGesamt);
}

/** Wenn Bild geladen und NICHT inizialisiert */
Test.onLoadComplete = function(tgt:MovieClip):Void{
trace("Bild geladen aber NICHT inizialisiert");
}

/** Wenn Bild geladen und inizialisiert */
Test.onLoadInit = function(tgt:MovieClip):Void{
trace("Bild geladen und inizialisiert");
}

/** Wenn Bild nicht geladen werden kann */
Test.onLoadError = function(tgt:MovieClip, errorCode:String, http:Number ):Void{
trace(errorCode + " http-Status: " + http);
}

/** Wenn Bild gelöscht wurde */
Test.onRemoval = function():Void{
trace("Gelöscht");

}

das initObject ist optional. Man kann was immer man auch machen will genausogut im jeweiligen Event veranstalten.

l'Audiophile
Threadersteller

Dabei seit: 16.09.2004
Ort: Berlin
Alter: 43
Geschlecht: Männlich

Verfasst Mi 20.08.2008 20:50
Titel

TextArea-Resizer inkl. Drag&Drop und Custom-Button-Templ

TextArea-Resizer inkl. Drag&Drop und Custom-Button-Templates (Beta 1)

Ich hab’ mich der TextArea-Komponente angenommen und sie mal ordentlich
aufgemotzt und sie mit einem intelligentem Resizing, Drag and Drop und der
Option, eigene Schaltflächen als Templates einzubinden, versehen. *zwinker*

BEISPIEL ANSEHEN

Die Klasse TextfieldResizer.as

Code:

package {
import flash.display.*;

import flash.events.MouseEvent;
import flash.events.Event;
import flash.utils.Timer;
import flash.net.URLRequest;

import fl.controls.ScrollPolicy;
import fl.controls.TextArea;

//
public class TextfieldResizer extends Sprite {

   private var TRheight:Number;
   private var TRwidth:Number;
   private var TRposX:Number;
   private var TRposY:Number;
   private var TRscrollH:String;
   private var TRscrollV:String;
   private var htmlTextArea:TextArea;
   private var _defaultBtn:Sprite;
   private var _customBtn:Loader;
   private var _customDrag:Loader;
   private var _btnContainer:Sprite;
   private var _dragContainer:Sprite;
   private var _defaultDragBar:Sprite;
   private var TRresizer:String;
   private var TRgraphicPathBtn:String;
   private var TRgraphicPathDrag:String;
   private var pWordWrap:Boolean;

   public function TextfieldResizer(
                           posX:Number=0,
                           posY:Number=0,
                           width:Number=100,
                           height:Number=100,
                           pWordWrap:Boolean=true,
                           scrollH:String="auto",
                           scrollV:String="auto",
                           resizer:String="default",
                           pathBtn:String="",
                           pathDrag:String="") {
      TRheight=height;
      TRwidth=width;
      TRposX=posX;
      TRposY=posY + 10;
      TRscrollH=scrollH;
      TRscrollV=scrollV;
      TRresizer=resizer;
      TRgraphicPathBtn=pathBtn;
      TRgraphicPathDrag=pathDrag;

      createTextArea();
   }
   //
   //
   /* Anfang --> Methode zur Erstellung der eigentlichen TextArea */
   private function createTextArea() {
      htmlTextArea=new TextArea ;
      switch (TRscrollH) {
         case "true" :
            htmlTextArea.horizontalScrollPolicy=ScrollPolicy.ON;
            break;
         case "false" :
            htmlTextArea.horizontalScrollPolicy=ScrollPolicy.OFF;
            break;
         case "auto" :
            htmlTextArea.horizontalScrollPolicy=ScrollPolicy.AUTO;
            break;
      }
      switch (TRscrollV) {
         case "true" :
            htmlTextArea.verticalScrollPolicy=ScrollPolicy.ON;
            break;
         case "false" :
            htmlTextArea.verticalScrollPolicy=ScrollPolicy.OFF;
            break;
         case "auto" :
            htmlTextArea.verticalScrollPolicy=ScrollPolicy.AUTO;
            break;
      }
      htmlTextArea.condenseWhite=true;
      htmlTextArea.setSize(TRwidth,TRheight);
      htmlTextArea.x=TRposX;
      htmlTextArea.y=TRposY;
      htmlTextArea.wordWrap=pWordWrap;
      addChild(htmlTextArea);

      createResizer();
   }
   /* Ende --> Methode zur Erstellung der eigentlichen TextArea */
   //
   //
   /* Anfang --> Methode zur Bestimmung der Resize-Schaltfläche (Default/Custom) */
   public function createResizer() {
      _btnContainer=new Sprite ;
      _dragContainer=new Sprite ;
      addChild(_btnContainer);
      addChild(_dragContainer);

      switch (TRresizer) {
         case "custom" :
            createCustomResizeBtn();
            break;
         case "default" :
            createDefaultDragBar();
            createDefaultResizeBtn();
            break;
      }
   }
   /* Ende --> Methode zur Bestimmung der Resize-Schaltfläche (Default/Custom) */
   //
   //
   /* Anfang --> benutzerdefinierter Button */
   private function createCustomResizeBtn() {
      _customBtn=new Loader ;
      _btnContainer.addChild(_customBtn);
      _customBtn.contentLoaderInfo.addEventListener(Event.INIT,handleResizerHelper);
      _customBtn.load(new URLRequest(TRgraphicPathBtn));
      //
      _customDrag=new Loader ;
      _dragContainer.addChild(_customDrag);
      _customDrag.contentLoaderInfo.addEventListener(Event.INIT,handleDragerHelper);
      _customDrag.load(new URLRequest(TRgraphicPathDrag));
   }
   private function handleResizerHelper(event:Event) {
      handleResizer();
   }
   private function handleDragerHelper(event:Event) {
      handleDragBar();
   }
   /* Ende --> benutzerdefinierter Button */
   //
   //
   /* Anfang --> Default-Button */
   private function createDefaultResizeBtn() {
      _defaultBtn=new Sprite ;
      _defaultBtn.graphics.beginFill(0x333333,1);
      _defaultBtn.graphics.drawRect(0,0,15,15);
      _defaultBtn.graphics.endFill();
      _btnContainer.addChild(_defaultBtn);

      handleResizer();
   }
   /* Ende --> Default-Button */
   //
   //
   /* Anfang --> Default-DragBar */
   private function createDefaultDragBar() {
      _defaultDragBar=new Sprite ;
      _defaultDragBar.graphics.beginFill(0x333333,1);
      _defaultDragBar.graphics.drawRect(0,0,40,10);
      _defaultDragBar.graphics.endFill();
      _dragContainer.addChild(_defaultDragBar);

      handleDragBar();
   }
   /* Ende --> Default-DragBar */
   //
   //
   private function handleDragBar() {
      _dragContainer.x=htmlTextArea.x;
      _dragContainer.y=htmlTextArea.y - _dragContainer.height;
      _dragContainer.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownDragBar);
      _dragContainer.addEventListener(MouseEvent.MOUSE_UP,mouseReleaseDragBar);
   }
   //
   //
   private function mouseDownDragBar(event:MouseEvent):void {
      this.startDrag();
      htmlTextArea.setFocus();
   }
   private function mouseReleaseDragBar(event:MouseEvent):void {
      this.stopDrag();
   }
   //
   //
   /* Anfang --> Definition der Position und des Verhaltens des Resize-Buttons */
   private function handleResizer() {
      _btnContainer.x=TRposX + TRwidth - _btnContainer.width / 2;
      _btnContainer.y=TRposY + TRheight - _btnContainer.height / 2;
      _btnContainer.addEventListener(MouseEvent.MOUSE_DOWN,mouseDown);
      _btnContainer.addEventListener(MouseEvent.MOUSE_UP,mouseReleased);
   }
   //
   //
   private function btnMove(event:Event) {
      htmlTextArea.width=_btnContainer.x - TRposX + _btnContainer.width / 2;
      htmlTextArea.height=_btnContainer.y - TRposY + _btnContainer.height / 2;
      if (_btnContainer.x < TRposX || _btnContainer.y < TRposY) {
         _btnContainer.x=TRposX + htmlTextArea.width;
         _btnContainer.y=TRposY + htmlTextArea.height;
         _btnContainer.stopDrag();
      }
   }
   //
   //
   private function mouseDown(event:MouseEvent):void {
      _btnContainer.startDrag();
      htmlTextArea.setFocus();

      this.addEventListener(Event.ENTER_FRAME,btnMove);
   }
   //
   //
   private function mouseReleased(event:MouseEvent):void {
      _btnContainer.stopDrag();
      _btnContainer.removeEventListener(Event.ENTER_FRAME,btnMove);
   }
   /* Ende --> Definition der Position und des Verhaltens des Resize-Buttons */
}
}

Der Aufruf

Code:

var TR1:TextfieldResizer = new TextfieldResizer(0,0, 100, 100, true, "auto", "auto", "custom", "graphicFiles/resizer.swf", "graphicFiles/drager.swf");
addChild(TR1);

… oder unter Benutzung der Default-Werte:

Code:

var TR1:TextfieldResizer = new TextfieldResizer();
addChild(TR1);

Viel Spaß damit! Lächel

Zuletzt bearbeitet von l'Audiophile am Fr 09.01.2009 15:04, insgesamt 2-mal bearbeitet

phihochzwei
Moderator

Dabei seit: 08.06.2006
Ort: Mülheim an der Ruhr
Alter: 46
Geschlecht: Männlich

Verfasst Mi 17.09.2008 16:28
Titel

MP3-Player Engine.

Einfach ein Interface drüberstülpen und fertig

Code:

/**
* MP3-Player-Engine.
* @version 0.1.0
* @author Jens Koblitz (koblitz@phihochzwei.com)
*/
package{

import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundLoaderContext;
import flash.media.SoundTransform;
import flash.net.URLRequest;

import flash.events.*

public class MP3player extends EventDispatcher{
   /** Trackliste */
   private var tracks:Array = new Array();
   /** Aktueller Titel */
   private var currTr:Number = 0;
   /** Aktuelle Lautstärke */
   private var vol:Number = 1;
   /** Aktuelle Zeit */
   private var currPos:Number = 0;
   /** Endlos ja/nein */
   private var looping:Boolean = false;
   /** Skip-Flag */
   private var skip:Boolean = true;


   /** internes Soundobjekt */
   private var sound:Sound;
   /** internes Channelobjekt */
   private var channel:SoundChannel;
   /** internes SoundTransformObjekt */
   private var trans:SoundTransform = new SoundTransform();

   /** Staus */
   private var _state:String;

   /** Status-Konstanten */
   public static var PLAYING = "playing";
   public static var PAUSED = "paused";
   public static var STOPPED = "stopped";
   public static var LOADING = "loading";
   public static var COMPLETE = "complete";
   public static var STARTED = "started";
   public static var NEXT = "next";
   public static var PREV = "prev";
   public static var TRACK_COMPLETE = "trackComplete";



   /**
   * Konstruktor
   */
   function MP3player(){
      this.tracks = new Array();
      this._state = MP3player.STOPPED;
   }


   /**
   * Startet den aktuellen Track.
   */
   public function play(e:Event = null):void{

      if(this._state == MP3player.PAUSED){
         this.channel = this.sound.play(this.currPos);
         this._state = MP3player.PLAYING;
      }else if(this.skip){
         this.skip = false;
         if(this.channel !== null){
            this.channel.stop();
         }
         this.sound = new Sound(new URLRequest(this.tracks[this.currTr]));
         this.sound.addEventListener("progress" , playerLoadProgress);
         this.sound.addEventListener("complete" , playerLoadComplete);
         this._state = MP3player.LOADING;
      }
      trace((this._state !== MP3player.PLAYING) && this.skip)
   }

   /**
   * Springt zum nächsten Track in der Trackliste
   */
   public function next(e:Event = null):void{
      if(this.looping){
         this.currTr = (this.currTr < this.tracks.length - 1) ? currTr + 1 : 0;
      }else{
         this.currTr = (this.currTr < this.tracks.length - 1 && this.currTr >= 0) ? currTr + 1 : -1;
      }

      if(this.currTr !== -1){
         this.skip = true;
         this.play();
         this.dispatchEvent(new PlayerEvent(MP3player.NEXT, this.currTr, this.sound.id3, this.sound.length));
      }
   }

   /**
   * Springt zum vorherigen Track in der Trackliste
   */
   public function prev(e:Event = null):void{
      if(this.currTr > 0){
         this.currTr --;
         this.skip = true;
         this.play();
         this.dispatchEvent(new PlayerEvent(MP3player.PREV, this.currTr, this.sound.id3, this.sound.length));
      }else if(this.currTr == -1){
         this.currTr = this.tracks.length - 2;
         this.skip = true;
         this.play();
         this.dispatchEvent(new PlayerEvent(MP3player.PREV, this.currTr, this.sound.id3, this.sound.length));
      }
   }

   /**
   * Stoppt die Wiedergabe
   */
   public function stop(e:Event = null):void{
      if(this.channel !== null){
         this.channel.stop();
         this.channel = null;
         this.skip = true;
         this._state = MP3player.STOPPED;
         this.dispatchEvent(new PlayerEvent(this._state, this.currTr, this.sound.id3, this.sound.length));
      }
   }


   /**
   * Pausiert die Wiedergabe
   */
   public function pause(e:Event = null):void{
      if(this._state == MP3player.PAUSED){
         this.channel = this.sound.play(this.currPos);
         this._state = MP3player.PLAYING;
      }else{
         this.currPos = this.channel.position;
         this.channel.stop();
         this._state = MP3player.PAUSED;
         this.dispatchEvent(new PlayerEvent(this._state, this.currTr, this.sound.id3, this.sound.length));
      }
   }




   /**
   * Events
   */

   private function playerLoadProgress(e:ProgressEvent){
      this.dispatchEvent(e);
      this._state = MP3player.LOADING;
   }

   private function playerLoadComplete(e:Event){
      this.dispatchEvent(new PlayerEvent(MP3player.STARTED, this.currTr, this.sound.id3, this.sound.length));
      this._state = MP3player.PLAYING;
      this.channel = this.sound.play();
      this.channel.soundTransform = this.trans;
      this.channel.addEventListener("soundComplete", playerSoundComplete);
   }


   private function playerSoundComplete(e:Event):void{
      this.dispatchEvent(new PlayerEvent(MP3player.TRACK_COMPLETE, this.currTr, this.sound.id3, this.sound.length));
      if(this.looping || this.currTr < this.tracks.length - 1){
         next();
      }else{
         stop();
      }

   }





   /**
   * Fügt der Trackliste ein Lied hinzu
   * @param n, URL der Datei die hinzugefügt werden soll
   */
   public function addTrack(n:String):void{
      this.tracks.push(n);
   }


   /**
   * Leer die Playliste
   */
   public function clearTracklist():void{
      this.tracks = new Array();
      this.currTr = 0;
      this.stop();
   }


   /**
   * Lautstärke des Players
   * @param n, Neue Lautstärke zwischen 0 und 1
   */
   public function set volume(n:Number):void{
      if(n >= 0 && n <= 1){
         this.vol = n;
         this.trans.volume = this.vol;
         if(this.channel !== null){
            this.channel.soundTransform = this.trans;
         }
      }
   }
   public function get volume():Number{
      return this.vol;
   }



   /**
   * Endlos-Modus
   * @param n, Schaltet den Endlos-Modus aus und ein
   */
   public function set isLooping(n:Boolean):void{
      this.looping = n;
   }
   public function get isLooping():Boolean{
      return this.looping;
   }


   /**
   * Aktueller Track
   * @param n, Aktueller Track
   */
   public function set currentTrack(n:Number):void{
      this.currTr = n;
      this.stop();
   }
   public function get currentTrack():Number{
      return this.currTr;
   }



   /**
   * Überschreibt die aktuelle Playlist mir einer neuen
   * @param n, Neue Playlist
   */
   public function set tracklist(n:Array):void{
      this.tracks = n;
   }
   public function get tracklist():Array{
      return this.tracks;
   }


   /**
   * Die aktuelle Zeit in Millisekunden
   */
   public function get position():Number{
      this.currPos = this.channel.position;
      return this.currPos;
   }
   /**
   * Aktueller Player-Status
   */
   public function get state():String{
      return this._state;
   }
   /**
   * Anzahl der Track in der Playlist
   */
   public function get totalTracks():uint{
      return this.tracks.length;
   }

}
}

und hier noch das benötigte Event

Code:

/**
* PlayerEvent für MP3-Player-Engine.
* @version 0.1.0
* @author Jens Koblitz (koblitz@phihochzwei.com)
*/
package{

import flash.events.Event;

public class PlayerEvent extends Event{
   private var tracknumber:uint;
   private var _id:Object;
   private var _length:Number;

   function PlayerEvent(type:String, tracknr:Number, id:Object, l:Number){
      super(type);

      this.tracknumber = tracknr;
      this._id = id;
      this._length = l;
   }


   public function get track():uint{
      return this.tracknumber;
   }

   public function get id3():Object{
      return this._id;
   }

   public function get length():Number{
      return this._length;
   }
}
}

Zuletzt bearbeitet von phihochzwei am Mi 17.09.2008 16:28, insgesamt 1-mal bearbeitet

Pixelpole

Dabei seit: 25.10.2004
Ort: Trier
Alter: 37
Geschlecht: Männlich

Verfasst Di 23.09.2008 16:04
Titel

Eine kleine statische Klasse die den Mime Type einer Datei rausfinden soll. Hinweise dazu finden sich im Quelltext. Nutzung der klasse ist denkbar einfach:

Code:

$mimetype = MimeTypeGetter::get('Pfad/zur/Datei.ext');

Mehr muss nicht gemacht werden.

Code:

<?php

/**
* MimeTypeGetter
*
* @author Bartlomiej Pohl <badek@gmx.de>
*
* Class to get Mime Type. It checks if the fileinfo or mime_magic extension
* is installed and uses the proper extension. If no extension is installed
* it uses its extension list.
*
* Just use MimeTypeGetter::get('path/to/your/file.ext');
*
* /////////////////////////////////////////////////////////////////////////
* ////////////////////////////////WARNING!/////////////////////////////////
* /////////////////////////////////////////////////////////////////////////
* / The used Extension List is not complete! I just copied the List from: /
* / http://www.validome.org/doc/HTML_ge/diverses/mimetypen.htm /
* /                                                    /
* / But in most cases this list should be enough. /
* / Feel Free to add your own extensions to the extensions array if you /
* / think that it's necessary.                                  /
* /////////////////////////////////////////////////////////////////////////
*/

class MimeTypeGetter {
/**
* the Default Mime Type for unknown extensions
*
* @var string
*/
protected static $default_mime_type = 'application/octet-stream';

/**
* Array that associates file extensions with Mime Types
*
* @var array
*/
protected static $extensions = array(
   'dwg' => 'application/acad',
   'asd' => 'application/astound',
   'asn' => 'application/astound',
   'tsp' => 'application/dsptype',
   'dxf' => 'application/dxf',
   'spl' => 'application/futuresplash',
   'gz' => 'application/gzip',
   'ptlk' => 'application/listenup',
   'hqx' => 'application/mac-binhex40',
   'mbd' => 'application/mbedlet',
   'mif' => 'application/mif',
   'xls' => 'application/msexcel',
   'xla' => 'application/msexcel',
   'hlp' => 'application/mshelp',
   'chm' => 'application/mshelp',
   'ppt' => 'application/mspowerpoint',
   'ppz' => 'application/mspowerpoint',
   'pps' => 'application/mspowerpoint',
   'pot' => 'application/mspowerpoint',
   'doc' => 'application/msword',
   'dot' => 'application/msword',
   'bin' => 'application/octet-stream',
   'exe' => 'application/octet-stream',
   'com' => 'application/octet-stream',
   'dll' => 'application/octet-stream',
   'class' => 'application/octet-stream',
   'oda' => 'application/oda',
   'pdf' => 'application/pdf',
   'ai' => 'application/postscript',
   'eps' => 'application/postscript',
   'ps' => 'application/postscript',
   'rtc' => 'application/rtc',
   'rtf' => 'application/rtf',
   'smp' => 'application/studiom',
   'tbk' => 'application/toolbook',
   'vmd' => 'application/vocaltec-media-desc',
   'vmf' => 'application/vocaltec-media-file',
   'htm' => 'application/xhtml+xml',
   'html' => 'application/xhtml+xml',
   'shtml' => 'application/xhtml+xml',
   'xhtml' => 'application/xhtml+xml',
   'xml' => 'application/xml',
   'bcpio' => 'application/x-bcpio',
   'z' => 'application/x-compress',
   'cpio' => 'application/x-cpio',
   'csh' => 'application/x-csh',
   'dcr' => 'application/x-director',
   'dir' => 'application/x-director',
   'dxr' => 'application/x-director',
   'dvi' => 'application/x-dvi',
   'evy' => 'application/x-envoy',
   'gtar' => 'application/x-gtar',
   'hdf' => 'application/x-hdf',
   'php' => 'application/x-httpd-php',
   'phtml' => 'application/x-httpd-php',
   'js' => 'application/x-javascript',
   'latex' => 'application/x-latex',
   'bin' => 'application/x-macbinary',
   'mif' => 'application/x-mif',
   'nc' => 'application/x-netcdf',
   'cdf' => 'application/x-netcdf',
   'nsc' => 'application/x-nschat',
   'sh' => 'application/x-sh',
   'shar' => 'application/x-shar',
   'swf' => 'application/x-shockwave-flash',
   'cab' => 'application/x-shockwave-flash',
   'spr' => 'application/x-sprite',
   'sprite' => 'application/x-sprite',
   'sit' => 'application/x-stuffit',
   'sca' => 'application/x-supercard',
   'sv4cpio' => 'application/x-sv4cpio',
   'sv4crc' => 'application/x-sv4crc',
   'tar' => 'application/x-tar',
   'tcl' => 'application/x-tcl',
   'tex' => 'application/x-tex',
   'texinfo' => 'application/x-texinfo',
   'texi' => 'application/x-texinfo',
   't' => 'application/x-troff',
   'tr' => 'application/x-troff',
   'roff' => 'application/x-troff',
   'man' => 'application/x-troff-man',
   'troff' => 'application/x-troff-man',
   'me' => 'application/x-troff-me',
   'troff' => 'application/x-troff-me',
   'me' => 'application/x-troff-ms',
   'troff' => 'application/x-troff-ms',
   'ustar' => 'application/x-ustar',
   'src' => 'application/x-wais-source',
   'zip' => 'application/zip',
   'au' => 'audio/basic',
   'snd' => 'audio/basic',
   'es' => 'audio/echospeech',
   'tsi' => 'audio/tsplayer',
   'vox' => 'audio/voxware',
   'aif' => 'audio/x-aiff',
   'aiff' => 'audio/x-aiff',
   'aifc' => 'audio/x-aiff',
   'dus' => 'audio/x-dspeeh',
   'cht' => 'audio/x-dspeeh',
   'mid' => 'audio/x-midi',
   'midi' => 'audio/x-midi',
   'mp2' => 'audio/x-mpeg',
   'ram' => 'audio/x-pn-realaudio',
   'ra' => 'audio/x-pn-realaudio',
   'rpm' => 'audio/x-pn-realaudio-plugin',
   'stream' => 'audio/x-qt-stream',
   'wav' => 'audio/x-wav',
   'dwf' => 'drawing/x-dwf',
   'cod' => 'image/cis-cod',
   'ras' => 'image/cmu-raster',
   'fif' => 'image/fif',
   'gif' => 'image/gif',
   'ief' => 'image/ief',
   'jpeg' => 'image/jpeg',
   'jpg' => 'image/jpeg',
   'jpe' => 'image/jpeg',
   'png' => 'image/png',
   'tiff' => 'image/tiff',
   'tif' => 'image/tiff',
   'mcf' => 'image/vasa',
   'fh4' => 'image/x-freehand',
   'fh5' => 'image/x-freehand',
   'fhc' => 'image/x-freehand',
   'pnm' => 'image/x-portable-anymap',
   'pbm' => 'image/x-portable-bitmap',
   'pgm' => 'image/x-portable-graymap',
   'ppm' => 'image/x-portable-pixmap',
   'rgb' => 'image/x-rgb',
   'xwd' => 'image/x-windowdump',
   'xbm' => 'image/x-xbitmap',
   'xpm' => 'image/x-xpixmap',
   'wrl' => 'model/vrml',
   'csv' => 'text/comma-separated-values',
   'css' => 'text/css',
   'htm' => 'text/html',
   'html' => 'text/html',
   'shtml' => 'text/html',
   'js' => 'text/javascript',
   'txt' => 'text/plain',
   'rtx' => 'text/richtext',
   'rtf' => 'text/rtf',
   'tsv' => 'text/tab-separated-values',
   'wml' => 'text/vnd.wap.wml',
   'wmlc' => 'application/vnd.wap.wmlc',
   'wmls' => 'text/vnd.wap.wmlscript',
   'wmlsc' => 'application/vnd.wap.wmlscriptc',
   'xml' => 'text/xml',
   'etx' => 'text/x-setext',
   'sgm' => 'text/x-sgml',
   'sgml' => 'text/x-sgml',
   'talk' => 'text/x-speech',
   'spc' => 'text/x-speech',
   'mpeg' => 'video/mpeg',
   'mpg' => 'video/mpeg',
   'mpe' => 'video/mpeg',
   'qt' => 'video/quicktime',
   'mov' => 'video/quicktime',
   'viv' => 'video/vnd.vivo',
   'vivo' => 'video/vnd.vivo',
   'avi' => 'video/x-msvideo',
   'movie' => 'video/x-sgi-movie',
   'vts' => 'workbook/formulaone',
   'vtts' => 'workbook/formulaone',
   '3dmf' => 'x-world/x-3dmf',
   '3dm' => 'x-world/x-3dmf',
   'qd3d' => 'x-world/x-3dmf',
   'qd3' => 'x-world/x-3dmf',
   'wrl' => 'x-world/x-vrml'
);

/**
* Gets the Mime Type using the Fileinfo Extension.
* If the Extension returns nothing the extension list
* is used.
*
* @param string $file the path to the File
* @return string the Mime Type
*/
protected static function getTypeFinfoExt($file)
{
   $finfo = @finfo_open(FILEINFO_MIME);
   $type = @finfo_file($finfo, $file);

   if($type != '') {
      return $type;
   }
   else {
      return self::getTypeFileExtList($file);
   }
}

/**
* Gets the Mime Type using the mime_magic extension.
* If the function returns nothing the extension list
* is used.
*
* @param string $file the path to the file
* @return string the Mime Type
*/
protected static function getTypeMimeExt($file)
{
   $type = @mime_content_type($file);

   if($type != '') {
      return $type;
   }
   else {
      return self::getTypeFileExtList($file);
   }
}

/**
* extracts the File extension and checks the extension array
* for the extension. If it's found it returns the Mime Type.
* If not it returns the Default Mime Type.
*
* @param string $file the path to the file
* @return string
*/
protected static function getTypeFileExtList($file)
{
   $info = pathinfo($file);

   if(isset(self::$extensions[$info['extension']])) {
      return self::$extensions[$info['extension']];
   }
   else {
      return self::$default_mime_type;
   }
}

/**
* Gets the Mime type for a given File. It first checks which
* extension is installed and uses it. If no extension is loaded
* it gets the Type with the extension list.
*
* You can force the function to use a specific extension by using
* the optional $force_extension param.
*
* Accepted Values:
* - fileinfo
* - mime_magic
*
* @param string $file the path to the File
* @param string $force_extension (optional) Forces specific extension.
* @return string the Mime Type
*/
public static function get($file, $force_extension=false)
{
   if($force_extension == false) {
      if (extension_loaded('fileinfo')) {
         return self::getTypeFinfoExt($file);
      }
      else if (extension_loaded('mime_magic')) {
         return self::getTypeMimeExt($file);
      }
      else {
         return self::getTypeFileExtList($file);
      }
   }
   else {
      switch($force_extension) {
         case 'fileinfo' : return self::getTypeFinfoExt($file);
         case 'mime_magic': return self::getTypeMimeExt($file);
         default : return self::getTypeFileExtList($file);
      }
   }
}
}

PS: Pejot du Flitzpiepe! Entrümpel endlich diesen Konstruktor! Schonmal was davon gehört das es Konventionen gibt die besagen das ab einer gewissen Länge parameterlisten untereinander statt nebeneinander geschrieben werden?

Zuletzt bearbeitet von Pixelpole am Di 23.09.2008 16:06, insgesamt 1-mal bearbeitet

	Seite: Zurück 1, 2, 3, 4 Weiter
	MGi Foren-Übersicht -> Programmierung

Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst an Umfragen in diesem Forum nicht mitmachen.