Club Delphi  
    FTP   CCD     Buscar   Trucos   Trabajo   Foros

Retroceder   Foros Club Delphi > Principal > Internet
Registrarse FAQ Miembros Calendario Guía de estilo Buscar Temas de Hoy Marcar Foros Como Leídos

Grupo de Teaming del ClubDelphi

Respuesta
 
Herramientas Buscar en Tema Desplegado
  #1  
Antiguo 07-11-2006
madmai madmai is offline
Miembro
 
Registrado: oct 2005
Posts: 117
Poder: 19
madmai Va por buen camino
TXMLDocument

Hola, A ver si alguien me puede poner algun ejemplo de como trabajar con este componente. Tengo un documento XML y no consigo modificar nada en ese documento, me gustaria poder añadir y modificar en ese doc xml, a ver si alguien me pone ejemplos de como hacerlo, gracias de antemano.
Responder Con Cita
  #2  
Antiguo 07-11-2006
Avatar de RONPABLO
[RONPABLO] RONPABLO is offline
Miembro Premium
 
Registrado: oct 2004
Posts: 1.514
Poder: 21
RONPABLO Va por buen camino
Y porque no trabaja con el ClientDataSet, el permite cargar la información de un DataSet normal o de un archivo XML por medio del loadFromFile
Responder Con Cita
  #3  
Antiguo 07-11-2006
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

Hace cierto tiempo escribí un componente al que dí el original e imaginativo nombre de "XmlComoIni"... creo que puede servirte para hacerte una idea, por lo menos, de ciertos aspectos del componente "TXmlDocument".

Código Delphi [-]
{ *********************************************************************** }
{                                                                         }
{ DecComp - Unos sencillos componentes                                    }
{                                                                         }
{ Copyright (c) 2005 dec - davidesperalta@gmail.com                       }
{ bajo la licencia GNU GPL >> ver en "licencia.txt"                       }
{                                                                         }
{ Créditos: A Lepe, del ClubDelphi.com ;-)                                }
{                                                                         }
{ *********************************************************************** }

unit UXmlComoIni;

interface

uses
  // Delphi 7
  //
  Classes, SysUtils, Graphics, XMLIntf, XMLDoc,

  // Pertenece al proyecto
  //
  UTypesDecComp;

type
  TXmlComoIni = class(TComponent)
  private
    FAcercade: TAcercade;
  published
    property Acercade: TAcercade read
      FAcercade write FAcercade stored false;
  private
    FFileName: TFileName;
    FDocXml: TXMLDocument;
    procedure CrearDocXml;
    procedure AbrirDocXml;
    procedure GuardarDocXml;
  public
    constructor Create(AOwner: TComponent); reintroduce; overload; override;
    constructor Create(AOwner: TComponent; const fileName: TFileName); reintroduce; overload;
    destructor Destroy; override;
    procedure UpdateFile;
    procedure DeleteKey(const seccion, clave: string);
    function SectionExists(const seccion: string) : boolean;
    function KeyExists(const seccion, clave: string) : boolean;
    procedure ReadSections(strings: TStrings);
    procedure DeleteSection(const seccion: string);
    procedure ReadSection(const seccion: string; strings: TStrings);
    procedure ReadSectionValues(const seccion: string; strings: TStrings);
    procedure WriteString(const seccion, clave, valor: string);
    function ReadString(const seccion, clave, defecto: string): string;
    procedure WriteInteger(const seccion, clave: string; const valor: integer);
    function ReadInteger(const seccion, clave: string; const defecto: integer) : integer;
    procedure WriteColor(const seccion, clave: string; const valor: TColor);
    function ReadColor(const seccion, clave: string; const defecto: TColor) : integer;
    procedure WriteBool(const seccion, clave: string; const valor: boolean);
    function ReadBool(const seccion, clave: string; const defecto: boolean) : boolean;
    procedure WriteDateTime(const seccion, clave: string; const valor: TDateTime);
    function ReadDateTime(const seccion, clave: string; const defecto: TDateTime) : TDateTime;
    procedure WriteFloat(const seccion, clave: string; valor: Double);
    function ReadFloat(const seccion, clave: string; const defecto: Double) : Double;
  end;

implementation

// Recursos/cadenas
//
{$I ..\inc\rsDecComp.inc}

{ TXmlComoIni }

// Constructor del componente.
//
constructor TXmlComoIni.Create(AOwner: TComponent);
begin
  inherited;
  FFileName := rsFileName;
  if not (csDesigning in ComponentState) then
  begin
    CrearDocXml;
    FFileName := ChangeFileExt(ParamStr(0), rsExtXml);
    AbrirDocXml;
  end;
end;

// Otro constructor del componente: en
// realidad desde el primero, como puede
// verse, llamamos a este otro.
//
constructor TXmlComoIni.Create(AOwner:
  TComponent; const fileName: TFileName);
begin
  CrearDocXml;
  if (fileName <> EmptyStr) then
    FFileName := fileName
  else
    FFileName := ChangeFileExt(ParamStr(0), rsExtXml);
  AbrirDocXml;
end;

// Destructor del componente.
//
destructor TXmlComoIni.Destroy;
begin
  if not (csDesigning in
    ComponentState) then
      GuardarDocXml;
  FDocXml.Free;
  inherited;
end;

// Crear el documento XML.
//
procedure TXmlComoIni.CrearDocXml;
begin
  FDocXml :=  TXMLDocument.Create(Self);
  FDocXml.Options := [doNodeAutoIndent];
end;

// Guardar el documento XML.
//
procedure TXmlComoIni.GuardarDocXml;
begin
  if FDocXml.Modified then
  begin
    FDocXml.SaveToFile(FFileName);
  end;
end;

// Actualizar el archivo XML.
//
procedure TXmlComoIni.UpdateFile;
begin
  GuardarDocXml;
end;

// Abrir el archivo XML.
//
procedure TXmlComoIni.AbrirDocXml;
begin
  if FileExists(FFileName) then
    FDocXml.LoadFromFile(FFileName)
  else
  begin
    FDocXml.Active := true;
    FDocXml.Version := '1.0';
    FDocXml.AddChild(rsRaizXml);
  end;
end;

// Leer el texto contenido en una determinada
// sección (nodo XML) dentro de una determinada
// clave (nodo XML).
//
function TXmlComoIni.ReadString(const
  seccion, clave, defecto: string): string;
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  Result := defecto;
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if not Assigned(nodoSeccion) then
    Exit; // No existe la sección
  with nodoSeccion do
    nodoClave := ChildNodes.FindNode(clave);
  if not Assigned(nodoClave) then
    Exit; // No existe la clave
  Result := nodoClave.Text;
end;

// Escribir una cadena en una
// determinada sección y clave.
//
procedure TXmlComoIni.WriteString(const
  seccion, clave, valor: string);
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  if ReadString(seccion, clave, EmptyStr) = valor then
    Exit; // El valor a escribir y el actual coinciden
  with FDocXml.DocumentElement do begin
    nodoSeccion := ChildNodes.FindNode(seccion);
    if not Assigned(nodoSeccion) then
      nodoSeccion := AddChild(seccion);
  end;
  with nodoSeccion do begin
    nodoClave := ChildNodes.FindNode(clave);
    if not Assigned(nodoClave) then
      nodoClave := AddChild(clave);
  end;
  nodoClave.Text := valor;
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo Integer.
//
function TXmlComoIni.ReadInteger(const seccion,
  clave: string; const defecto: integer): integer;
begin
  Result := StrToInt(ReadString(
    seccion, clave, IntToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un Integer.
//
procedure TXmlComoIni.WriteInteger(const seccion,
  clave: string; const valor: integer);
begin
  WriteString(seccion, clave, IntToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo TColor.
//
function TXmlComoIni.ReadColor(const seccion,
  clave: string; const defecto: TColor): integer;
begin
  Result := StringToColor(ReadString(
    seccion, clave, ColorToString(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un TColor.
//
procedure TXmlComoIni.WriteColor(const seccion,
  clave: string; const valor: TColor);
begin
  WriteString(seccion, clave, ColorToString(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo boolean.
//
function TXmlComoIni.ReadBool(const seccion,
  clave: string; const defecto: boolean): boolean;
begin
  Result := StrToBool(ReadString(
    seccion, clave, BoolToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un boolean.
//
procedure TXmlComoIni.WriteBool(const seccion,
  clave: string; const valor: boolean);
begin
  WriteString(seccion, clave, BoolToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo TDateTime.
//
function TXmlComoIni.ReadDateTime(const seccion,
  clave: string; const defecto: TDateTime): TDateTime;
begin
  Result := StrToDateTime(ReadString(
    seccion, clave, DateTimeToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un TDateTime.
//
procedure TXmlComoIni.WriteDateTime(const seccion,
  clave: string; const valor: TDateTime);
begin
  WriteString(seccion, clave, DateTimeToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo Double.
//
function TXmlComoIni.ReadFloat(const seccion,
  clave: string; const defecto: Double): Double;
begin
  Result := StrToFloat(ReadString(
    seccion, clave, FloatToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un Double.
//
procedure TXmlComoIni.WriteFloat(const
  seccion, clave: string; valor: Double);
begin
  WriteString(seccion, clave, FloatToStr(valor));
end;

// Borrar una determinada clave (nodo XML).
//
procedure TXmlComoIni.DeleteKey(const
  seccion, clave: string);
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    nodoClave := nodoSeccion.ChildNodes.FindNode(clave);
    if Assigned(nodoClave) then
      nodoSeccion.ChildNodes.Delete(nodoClave.NodeName);
  end;
end;

// Comprobar la existencia de una
// determinda clave (nodo XML).
//
function TXmlComoIni.KeyExists(const
  seccion, clave: string) : boolean;
var
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    with nodoSeccion do
      Result := (ChildNodes.IndexOf(clave)<>-1);
  end
  else
    Result := false;
end;

// Comprobar la existencia de una
// determinada sección (nodo XML).
//
function TXmlComoIni.SectionExists(const
  seccion: string) : boolean;
var
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  Result := Assigned(nodoSeccion);
end;

// Leer los valores (strings) de una determinada
// sección o, como queda dicho, nodo XML. ;-)
// 
procedure TXmlComoIni.ReadSectionValues(const
  seccion: string; strings: TStrings);
var
  i: integer;
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
    begin
      nodoClave := nodoSeccion.ChildNodes[i];
      if Assigned(nodoClave)  and
        (nodoClave.IsTextElement) then
          strings.Add(nodoClave.Text);
    end;
  end;
end;

// Leer los nombres de las diferentes secciones.
//
procedure TXmlComoIni.ReadSections(strings: TStrings);
var
  i: integer;
  nodoSeccion: IXMLNode;
begin
  nodoSeccion := FDocXml.DocumentElement;
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
      strings.Add(nodoSeccion.ChildNodes[i].NodeName);
  end;
end;

// Leer las claves de una determinada sección.
//
procedure TXmlComoIni.ReadSection(const
  seccion: string; strings: TStrings);
var
  i: integer;
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
    begin
      nodoClave := nodoSeccion.ChildNodes[i];
      strings.Add(nodoClave.NodeName);
    end;
  end;
end;

// Borrar una sección (nodo XML) completa.
//
procedure TXmlComoIni.DeleteSection(const seccion: string);
var
  nodoSeccion: IXMLNode;
begin
  nodoSeccion := FDocXml.DocumentElement.ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
    FDocXml.DocumentElement.ChildNodes.Delete(nodoSeccion.NodeName);
end;

end.
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #4  
Antiguo 07-11-2006
madmai madmai is offline
Miembro
 
Registrado: oct 2005
Posts: 117
Poder: 19
madmai Va por buen camino
TXMLDocument

Gracias pero prefiero trabajar con componentes de delphi, si alguien tiene ejemplos de como trabajar con TXMLDocument, se lo agradeceria si los colgase, gracias de antemano.
Responder Con Cita
  #5  
Antiguo 07-11-2006
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

Esto... el código fuente que expongo más arriba trabaja con el componente de Delphi "TXMLDocument"... No he dicho que uses "mi componente", sino que te fijes en que ahí se implementan métodos que usan el componente "TXMLDocument" para escribir, leer, editar un archivo XML, etc.

Es decir, en mi opinión, me ha parecido que el componente que yo escribí (y que no dije que useses) trabaja con el componente que a ti te interesa. Lo puse por si podía servirte de algo, vamos.
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #6  
Antiguo 07-11-2006
madmai madmai is offline
Miembro
 
Registrado: oct 2005
Posts: 117
Poder: 19
madmai Va por buen camino
Vale, no te entendí, lo mirare gracias
Responder Con Cita
  #7  
Antiguo 07-11-2006
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

Estupendo. Como además me doy cuenta de que el código de arriba tiene ciertas "dependencias", porque el componente que expongo forma parte de un conjunto de componentes que comparten cierto código, digo, que te paso el enlace desde donde puedes descargar todo el conjunto de componentes: no para que los uses, sino para que puedas instalarlos (temporalmente) y echar un vistazo en su plenitud al componente que más puede intersarte: TXmlComoIni.

Paquete de componentes DecComp.

Por otro lado en About Delphi tienes algunos enlaces que pueden ser de tu interés.
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #8  
Antiguo 08-11-2006
madmai madmai is offline
Miembro
 
Registrado: oct 2005
Posts: 117
Poder: 19
madmai Va por buen camino
Muchas gracias, de momento lo que queria ya lo he conseguido, un saludo a todos.
Responder Con Cita
  #9  
Antiguo 14-05-2007
Avatar de juangiron
juangiron juangiron is offline
Miembro
 
Registrado: ene 2007
Posts: 26
Poder: 0
juangiron Va por buen camino
Question ayuda

podrias ayudarme??

necesito crear un archivo xml con los datos de una clase persona

Código Delphi [-]
type 
persona = class
private
 nombre:string;
 edad:integer;
 sexo; string;

la idea es que el archivo Xml
quede asi

<persona>
<nombre>juan<nombre/>
<edad>24<edad/>
<sexo>Masculino<sexo/>
<persona/>

por fa ayudame!! gracias
Responder Con Cita
  #10  
Antiguo 14-05-2007
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

A ver si nos entendemos... para tratar con archivos XML en Delphi se cuenta, entre otros, con el componente "TXMLDocument", que está en la pestaña "Internet" de la paleta de componentes. Ahora bien, ¿tienes algún problema en usar este componente? ¿Estás intentando algo pero no te sale? ¿Qué estás intentando? Yo creo que podríamos empezar por ahí... o por mejor decir podrías empezar por ahí...
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #11  
Antiguo 14-05-2007
Avatar de juangiron
juangiron juangiron is offline
Miembro
 
Registrado: ene 2007
Posts: 26
Poder: 0
juangiron Va por buen camino
Question hola

gracias por contestar.. lo que yo quiero es muy simple

como utilizo el TXMLDocument para crear un archivo XML como el del ejemplo de la persona (es decir llenar el XML de datos de un objeto)...

la verdad no tengo ni idea de como hacerlo y me gustaria ver un ejemplo muy basico de como crear el xml y como leerlo

gracias
Responder Con Cita
  #12  
Antiguo 14-05-2007
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

Tal vez te interese echar un vistazo al componente "TXmlComoIni", que encontrarás dentro del paquete de componentes "DecComp", que a su vez puedes descargar desde el Directorio de archivos del ClubDelphi. Ahí puedes ver cómo se crea un archivo XML a partir del componente "TXmlDocument"; cómo se crean "nodos" en el mismo y se escriben valores en ellos; también puedes ver cómo se leen archivos XML con el mismo componente.
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #13  
Antiguo 14-05-2007
Avatar de juangiron
juangiron juangiron is offline
Miembro
 
Registrado: ene 2007
Posts: 26
Poder: 0
juangiron Va por buen camino
nooo

hola de nuevo...
mira que baje tu componente y lo instale, pero no me da la funcionalidad que necesito... lo que yo quiero hacer es:

tengo un array de objetos (array of Persona), necesito recorrer el array y guardar todos los datos en un XML...

HELPPPPPPPP
Responder Con Cita
  #14  
Antiguo 14-05-2007
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

Bueno... eso de que no te da la funcionalidad que necesitas está por ver. Además de que no te dije que usases sin más el componente "TXmlComoIni", sino que lo estudiaras, que no es lo mismo. Porque en dicho componente puedes ver cómo se crea un archivo XML, cómo puede escribrirse en el mismo, cómo pueden leerse los datos... guardar un archivo, cargar un archivo, entre otras cosas. Tendrías que fijarte un poco más, en mi opinión, de modo que pudieras adaptar el código fuente (y los conocimientos implícitos en el mismo) a tus propias necesidades.
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #15  
Antiguo 14-05-2007
Avatar de juangiron
juangiron juangiron is offline
Miembro
 
Registrado: ene 2007
Posts: 26
Poder: 0
juangiron Va por buen camino
Question Hola Dec

que pena mi ignorancia, pero es que he analizado tu codigo y la verdad es que no logro crear el archivo como yo quiero


Código Delphi [-]
procedure TFrmPrincipal.ToolButton4Click(Sender: TObject);
var
  FDocXml: TXMLDocument;
  nodoClave, nodoSeccion: IXMLNode;

begin
SaveDialog1.Filter:='Archivo XML(*.xml)|*.XML';
if SaveDialog1.Execute then
begin
   FDocXml :=  TXMLDocument.Create(Self);
   FDocXml.Options := [doNodeAutoIndent];
   FDocXml.Active:=true;
   nodoSeccion := FDocXml.AddChild('PERSONA');
   nodoClave := nodoSeccion.AddChild('Nombre');
   FDocXml.SaveToFile(SaveDialog1.FileName+'.xml');;

end;
end;


lo que necesito crear es algo asi

<PERSONA>
<NOMBRE> JUANK <NOMBRE/>
<OTROVALOR>1983<OTROVALOR/>
<PERSONA/>

se que el codigo esta mal, pero te juro que he buscado en muchas partes y no logro encontrar un ejemplo asi de basico

te agradeceria si me ayudas
Responder Con Cita
  #16  
Antiguo 14-05-2007
Avatar de juangiron
juangiron juangiron is offline
Miembro
 
Registrado: ene 2007
Posts: 26
Poder: 0
juangiron Va por buen camino
Question lo hice

bueno creo que lo hice...

Código Delphi [-]
procedure TFrmPrincipal.ToolButton4Click(Sender: TObject);
var
  FDocXml: TXMLDocument;
  nodoClave, nodoSeccion, nodoObjeto: IXMLNode;
  i:Integer;
begin
SaveDialog1.Filter:='Archivo XML(*.xml)|*.XML';
if SaveDialog1.Execute then
begin

   FDocXml :=  TXMLDocument.Create(Self);
   FDocXml.Options := [doNodeAutoIndent];
   FDocXml.Active:=true;
   nodoSeccion := FDocXml.AddChild('OBJETOS');
    for i := 0 to High(ArrayObjetos) do
     begin
      nodoClave := nodoSeccion.AddChild('Objeto');
      nodoObjeto := nodoClave.AddChild('Nomre');
      nodoObjeto.Text := ArrayObjetos[i].getNombreObj;
      nodoObjeto := nodoClave.AddChild('año');
      nodoObjeto.Text := ArrayObjetos[i].getaño;

     end;


   FDocXml.SaveToFile(SaveDialog1.FileName+'.xml');;
end;
end;

pero creo que no me sirve por que dentro del array de objetos tengo valores que no son string como Ticon,

hay alguna forma de guardar el objeto completo??
es decir algo asi como serializarlos
Responder Con Cita
  #17  
Antiguo 15-05-2007
Avatar de juangiron
juangiron juangiron is offline
Miembro
 
Registrado: ene 2007
Posts: 26
Poder: 0
juangiron Va por buen camino
Unhappy Responder Esta

BUENO AL FINAL DEL DIA TOME LA DESICION DE IMPLEMETARLO ASI

Código Delphi [-]

procedure TFrmPrincipal.ToolButton4Click(Sender: TObject);
var
  FDocXml: TXMLDocument;
  nodoClave, nodoSeccion, nodoObjeto, nodoRegla: IXMLNode;
  i,j,k:Integer;
  escena:String;
begin
SaveDialog1.Filter:='Archivo XML(*.xml)|*.XML';
if SaveDialog1.Execute then
begin
   escena:='';
   FDocXml :=  TXMLDocument.Create(Self);
   FDocXml.Options := [doNodeAutoIndent];
   FDocXml.Active:=true;
   FDocXml.Version := '1.0';
   nodoSeccion := FDocXml.AddChild('MODELO');
    for i := 0 to High(ArrayObjetos) do
     begin
      nodoClave := nodoSeccion.AddChild('OBJETO');
        nodoObjeto := nodoClave.AddChild('Nombre');nodoObjeto.Text := ArrayObjetos[i].getNombreObj;
        nodoObjeto := nodoClave.AddChild('Tipo');nodoObjeto.Text :=IntToStr(ArrayObjetos[i].getTipoObj);
        nodoObjeto := nodoClave.AddChild('Color');nodoObjeto.Text :=ColorToString(ArrayObjetos[i].getColor);
        nodoObjeto := nodoClave.AddChild('Movimiento');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getMovimiento);
          nodoObjeto.Attributes['UP']:= BoolToStr(ArrayObjetos[i].getUP);
          nodoObjeto.Attributes['DOWN']:= BoolToStr(ArrayObjetos[i].getDOWN);
          nodoObjeto.Attributes['LEFT']:= BoolToStr(ArrayObjetos[i].getLEFT);
          nodoObjeto.Attributes['RIGT']:= BoolToStr(ArrayObjetos[i].getRIGHT);
       nodoObjeto := nodoClave.AddChild('Expansion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getMovimiento);
          nodoObjeto.Attributes['UP']:= BoolToStr(ArrayObjetos[i].getEUP);
          nodoObjeto.Attributes['DOWN']:= BoolToStr(ArrayObjetos[i].getEDOWN);
          nodoObjeto.Attributes['LEFT']:= BoolToStr(ArrayObjetos[i].getELEFT);
          nodoObjeto.Attributes['RIGT']:= BoolToStr(ArrayObjetos[i].getERIGHT);
       nodoObjeto := nodoClave.AddChild('Decadencia');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getDecadencia);
       nodoObjeto := nodoClave.AddChild('Eliminacion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getEliminacion);
          nodoObjeto.Attributes['ObjAElimin']:= IntToStr(ArrayObjetos[i].getObjAElimin);
      nodoObjeto := nodoClave.AddChild('Neutralizacion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getNeutralizacion);
          nodoObjeto.Attributes['ObjANeutra']:= IntToStr(ArrayObjetos[i].getObjANeutra);
      nodoObjeto := nodoClave.AddChild('Reproduccion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getReproduccion);
      nodoObjeto := nodoClave.AddChild('Retraccion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getRetraccion);
      nodoObjeto := nodoClave.AddChild('Transformacion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getTransformacion);
          nodoObjeto.Attributes['NewObjtransf']:= IntToStr(ArrayObjetos[i].getNewObjtransf);
     end; //end for
     //------------mapa----------------------
        for j := 0 to ColumnaEsc - 1 do
          for k := 0 to FilaEsc - 1 do
             escena:=escena+IntToStr(ArrayEsc[j,k].getTipoObj)+'|';

      nodoClave := nodoSeccion.AddChild('ESCENARIO');
      nodoClave.Attributes['NombreEsc']:=NombreEsc;
      nodoClave.Attributes['ColorEsc']:=ColorToString(ColorEsc);
      nodoClave.Attributes['ColumnaEsc']:=IntToStr(ColumnaEsc);
      nodoClave.Attributes['FilaEsc']:=IntToStr(FilaEsc);
      nodoObjeto := nodoClave.AddChild('Mapa');nodoObjeto.Text := escena;


   FDocXml.SaveToFile(SaveDialog1.FileName+'.xml');;
end;
end;

LO QUE ME GENERA ESTO

Código:
 <?xml version="1.0" ?> 
  - <MODELO>
   - <OBJETO>
     <Nombre>Objeto1</Nombre> 

    <Tipo>0</Tipo> 

    <Color>clBlue</Color> 

    <Movimiento Activa="-1" UP="-1" DOWN="-1" LEFT="-1" RIGT="-1" /> 

    <Expansion Activa="-1" UP="0" DOWN="0" LEFT="0" RIGT="0" /> 

    <Decadencia Activa="0" /> 

    <Eliminacion Activa="0" ObjAElimin="0" /> 

    <Neutralizacion Activa="0" ObjANeutra="0" /> 

    <Reproduccion Activa="0" /> 

    <Retraccion Activa="0" /> 

    <Transformacion Activa="0" NewObjtransf="0" /> 

   </OBJETO>


  - <OBJETO>
     <Nombre>Objeto1</Nombre> 

    <Tipo>1</Tipo> 

    <Color>clYellow</Color> 

    <Movimiento Activa="0" UP="0" DOWN="0" LEFT="0" RIGT="0" /> 

    <Expansion Activa="0" UP="-1" DOWN="-1" LEFT="-1" RIGT="-1" /> 

    <Decadencia Activa="0" /> 

    <Eliminacion Activa="0" ObjAElimin="0" /> 

    <Neutralizacion Activa="0" ObjANeutra="0" /> 

    <Reproduccion Activa="0" /> 

    <Retraccion Activa="0" /> 

    <Transformacion Activa="0" NewObjtransf="0" /> 

   </OBJETO>


  - <ESCENARIO NombreEsc="Prueba"  ColorEsc="clMoneyGreen" ColumnaEsc="10"  FilaEsc="10">
     <Mapa>1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|0|1|1|1|1|1|1|1|1|0|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|</Mapa>  

   </ESCENARIO>


   </MODELO>
AHORA COMO HAGO PARA POR EJEMPLO AL NOMBRE DEL SEGUNDO OBJETO??

AYUDDAAAA

MEJOR DICHO COMO HAGO PARA ACCEDER A CADA UNO DE LOS DATOS

Responder Con Cita
  #18  
Antiguo 15-05-2007
Avatar de xander
xander xander is offline
Miembro
 
Registrado: jul 2006
Posts: 499
Poder: 18
xander Va por buen camino
Cita:
Empezado por dec
... el componente que expongo forma parte de un conjunto de componentes que comparten cierto código, digo, que te paso el enlace desde donde puedes descargar todo el conjunto de componentes: no para que los uses, sino para que puedas instalarlos (temporalmente) y echar un vistazo en su plenitud al componente que más puede intersarte: TXmlComoIni.

Paquete de componentes DecComp.
Oye amigo DEC, ya no se encuentra disponible la liga que diste aquí... de donde puedo descargar tu suite de componentes???
__________________
"Hey, nena, debe ser genial ser tú y verme a mí mismo..."
Responder Con Cita
  #19  
Antiguo 15-05-2007
Avatar de dec
dec dec is offline
Moderador
 
Registrado: dic 2004
Ubicación: Alcobendas, Madrid, España
Posts: 13.107
Poder: 34
dec Tiene un aura espectaculardec Tiene un aura espectacular
Hola,

Cita:
Empezado por xander
Oye amigo DEC, ya no se encuentra disponible la liga que diste aquí... de donde puedo descargar tu suite de componentes???
Bueno. Te pido disculpas. Esto de cambiar de sitio las cosas no puede llevar sino a confundir al personal. En todo caso llamar "suite de componentes" a DecComp... no sé yo, ¿eh? Son más bien unos muy sencillos componentes, que, bueno, llegado el caso puede que te sirvan de algo. Ahora mismo los encuentras disponibles en el Directorio de archivos del ClubDelphi.
__________________
David Esperalta
www.decsoftutils.com
Responder Con Cita
  #20  
Antiguo 20-06-2007
Edgar Perez Edgar Perez is offline
Registrado
 
Registrado: sep 2005
Ubicación: Los Mochis, Sinaloa, Mexico
Posts: 9
Poder: 0
Edgar Perez Va por buen camino
XML con ClientDataSet...

Hola Madmai...

Creo saber lo que ocupas, mira, Yo hice algo mas o menos como lo que necesitas y para ello eche mano del XMLMapper que viene con Delphi, ahi puedes generar el XMLDocument y dos transformaciones que son ToDp.xtr y ToXML.xtr. El archivo ToDp.xtr te sirve para convertir lo que esta en el XMLDocument a un DataPacket y el archivo ToXML.xtr hace lo contrario, convierte el DataPacket a un XML.

Aqui tienes algo sobre XML Mapper:

http://dn.codegear.com/article/28010


Una vez que generes estos 3 archivos: XMLDocument.XML, XMLDocumentToDp.xtr, XMLDocumentToXML.xtr, ahora en Delphi ocupas de los siguientes componentes:

XMLTransformProvider (En la paleta de DataAccess)
ClientDataSet (En la paleta DataAccess o tu preferido)

Ahora bien, primero tienes que configurar el XMLTransformProvider las siguientes propiedades en el inspector de objetos:

* Name = XMLDsp

* TransformRead.TransformationFile = Ruta completa de tu archivo XMLDocumentToDp.xtr

* TransformWrite.TransformationFile = Ruta completa de tu archivo XMLDocumentToXML.xtr

* XMLDataFile = Ruta compleata de tu archivo XMLDocument.XML


Una vez que ya tengas echo lo anterior, ahora en el Componente ClientDataSet solo tienes que ajustar la propiedad

ProviderName = XMLDsp

Espero te sirva....

Edgar Perez...
Responder Con Cita
Respuesta


Herramientas Buscar en Tema
Buscar en Tema:

Búsqueda Avanzada
Desplegado

Normas de Publicación
no Puedes crear nuevos temas
no Puedes responder a temas
no Puedes adjuntar archivos
no Puedes editar tus mensajes

El código vB está habilitado
Las caritas están habilitado
Código [IMG] está habilitado
Código HTML está deshabilitado
Saltar a Foro

Temas Similares
Tema Autor Foro Respuestas Último mensaje
Usar TXMLDocument para Importar/Exportar datos Durbed OOP 4 13-08-2007 20:07:39
TXMLDocument Documentos XML keys Internet 6 05-12-2006 18:47:45
Ayuda sobre TXMLDocument ggram2 Internet 1 12-11-2005 17:19:45
Descargar componente TXMLDocument Tecnic2 OOP 2 24-05-2005 20:36:06
TXMLDocument y la ñ grjordi Internet 1 12-04-2005 21:38:48


La franja horaria es GMT +2. Ahora son las 22:40:23.


Powered by vBulletin® Version 3.6.8
Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
Traducción al castellano por el equipo de moderadores del Club Delphi
Copyright 1996-2007 Club Delphi