 |
Club Builder
Foro de C++Builder en español
|
| Ver tema anterior :: Ver tema siguiente |
| Autor |
Mensaje |
Picard
Master
Registrado: 18 Ene 2004Mensajes: 218Ubicación: Palamos (Girona) España
|
 Publicado: Vie 10 Dic, 2004 11:23 pm Asunto: una duda |
 |
|
compañeros, tengo una duda apabullante,(al menos para mi lo es).
quiero crear un objeto TBuque, que ha de tener unas propiedades color,pos_x,pos_y,rumbo,velocidad,proa,popa,etc....
bueno hasta ahi lo tengo claro y mas o menos medio estudiado,pero mi duda es la sigueinte ha de ser un objeto visible, que ha de dibujarse en el canvas de otro objeto el cual es algo parecido a un tPanel pero tiene la particularidad de que sirve para visualizar mapas.
como represento esto? me refiero a la forma que ha de tener,mas o menos a la de un barco visto desde arriba. ademas quiero que me dibuje una linea desde la proa del buque siempre orientada hacia la direccion a donde se dirige posiblemente una linea de puntos.podeis echarme una mano?
es posible? se vera?como defino que la proa va desde x hasta x1 y que la popa esta en x-180? me refiero a la forma de alinearlo
gracias
_________________
El hombre es el unico ser que tropieza dos veces en la misma piedra ( en mi caso infinitas veces) |
|
| Volver arriba |
|
 |
Cesar C. Salazar Gonzalez
Master
Registrado: 01 Oct 2002Mensajes: 2155Ubicación: San Cristóbal de Las Casas, Chiapas
|
| Publicado: Sab 11 Dic, 2004 1:54 am Asunto: |
|
|
de momento, no tengo la ayuda, pero checa, las propiedades _property, de una clase, y defines, una funcion o propiedad.
llamada
__property void __fascall Dibuja_Buque(etc,etc)
Checa esto de es lo que tengo
| Código: | This section describes ANSI-conforming keyword extensions implemented in C++Builder to support the VCL and CLX.
The __declspec keyword also provides VCL support.
__classid
The __classid operator is used by the compiler to generate a pointer to the vtable for the specified classname. This operator is used to obtain the meta class from a class.
Syntax: __classid(classname)
For example, __classid is used when registering property editors, components, and classes, and with the InheritsFrom method of TObject. The following code illustrates the use of __classid
for creating a new component derived from TWinControl:
namespace Ywndctrl
{
void __fastcall PACKAGE Register()
{
TComponentClass classes[1] = {__classid(MyWndCtrl)};
RegisterComponents("Additional", classes, 0);
}
}
__closure
The __closure keyword is used to declare a special type of pointer to a member function. In standard C++, the only way to get a pointer to a member function is to use the fully qualified member name, as shown in the following example:
class base
{
public:
void func(int x) { };
};
typedef void (base::* pBaseMember)(int);
int main(int argc, char* argv[])
{
base baseObject;
pBaseMember m = &base::func; // Get pointer to member 'func'
// Call 'func' through the pointer to member
(baseObject.*m)(17);
return 0;
}
However, you cannot assign a pointer to a member of a derived class to a pointer to a member of a base class. This rule (called contravariance) is illustrated in the following example:
class derived: public base
{
public:
void new_func(int i) { };
};
int main(int argc, char* argv[])
{
derived derivedObject;
pBaseMember m = &derived::new_func; // ILLEGAL
return 0;
}
The __closure keyword extension allows you to skirt this limitation, and more. Using a closure, you can get a pointer to member function for an object (i.e. a particular instance of a class). The object can be any object, regardless of its inheritance hierarchy. The object’s this pointer is automatically used when calling the member function through the closure. The following example shows how to declare and use a closure. The base and derived classes provided earlier are assumed to be defined.
int main(int argc, char* argv[])
{
derived derivedObject;
void (__closure *derivedClosure)(int);
derivedClosure = derivedObject.new_func; // Get a pointer to the 'new_func' member.
// Note the closure is associated with the
// particular object, 'derivedObject'.
derivedClosure(3); // Call 'new_func' through the closure.
return 0;
}
Closures also work with pointers to objects, as illustrated in this example:
void func1(base *pObj)
{
// A closure taking an int argument and returning void.
void ( __closure *myClosure )(int);
// Initialize the closure.
myClosure = pObj->func;
// Use the closure to call the member function.
myClosure(1);
return;
}
int main(int argc, char* argv[])
{
derived derivedObject;
void (__closure *derivedClosure)(int);
derivedClosure = derivedObject.new_func; // Same as before...
derivedClosure(3);
// We can use pointers to initialize a closure, too.
// We can also get a pointer to the 'func' member function
// in the base class.
func1(&derivedObject);
return 0;
}
Notice that we are passing a pointer to an instance of the derived class, and we are using it to get a pointer to a member function in the base class - something standard C++ does not allow us to do.
Closures are a key part of the C++ Builder RAD environment. They give us the ability to assign an event handler in the Object Inspector. For example, a TButton object has an event called OnClick. In the TButton class, the OnClick event is a property that uses the __closure keyword extension in its declaration. The __closure keyword allows us to assign a member function of another class (typically a member function in a TForm object) to the property. When you place a TButton object on a form, and then create a handler for the button’s OnClick event, C++ Builder creates a member function in the button’s TForm parent, and assigns that member function to the OnClick event of TButton. This way, the event handler is associated with that particular instance of TButton, and no other.
For more information about events and closures, see Creating events
__property
The __property keyword declares an attribute of a class. Properties appear to the programmer just like any other attribute (field) of a class. However, like its Object Pascal counterpart, C++ Builder’s __property keyword adds significantly more functionality beyond just examining and changing the value of the attribute. Since property attributes completely control access to the property, there are no restrictions on how you implement the property within the class itself.
Syntax
__property type propertyName[index1Type index1][indexNType indexN] = { attributes };
where
type is an intrinsic or previously declared data type.
propertyName is any valid identifier.
indexNType is an intrinsic or previously declared data type.
indexN is the name of an index parameter that will be passed to the property’s read and write functions.
attributes is a comma separated sequence of read, write, stored, default (or nodefault), or index.
The indexN parameters in square brackets are optional. If present, they declare an array property. The index parameters are passed to the read and write methods of the array property.
The following example shows some simple property declarations:
class PropertyExample {
private:
int Fx,Fy;
float Fcells[100][100];
protected:
int readX() { return(Fx); }
void writeX(int newFx) { Fx = newFx; }
double computeZ() {
// Do some computation and return a floating point value...
return(0.0);
}
float cellValue(int row, int col) { return(Fcells[row][col]); }
public:
__property int X = { read=readX, write=writeX };
__property int Y = { read=Fy };
__property double Z = { read=computeZ };
__property float Cells[int row][int col] = { read=cellValue };
};
This example shows several property declarations. Property X has read-write access, through the member functions readX and writeX, respectively. Property Y corresponds directly to the member variable Fy, and is read-only. Property Z is a read-only value that is computed; it is not stored as a data member in the class. Finally, the Cells property demonstrates an array property with two indices. The next example shows how you would access these properties in your code:
PropertyExample myPropertyExample;
myPropertyExample.X = 42; // Evaluates to: myPropertyExample.WriteX(42);
int myVal1 = myPropertyExample.Y; // Evaluates to: myVal1 = myPropertyExample.Fy;
double myVal2 = myPropertyExample.Z; // Evaluates to: myVal2 = myPropertyExample.ComputeZ();
float cellVal = myPropertyExample[3][7]; // Evaluates to:
// cellVal = myPropertyExample.cellValue(3,7);
Properties have many other variations and features not shown in this example. Properties can also:
Associate the same read or write method with more than one property, by using the index attribute
Have default values
Be stored in a form file
Extend a property defined in a base class
For more information about properties, see Creating properties
__published
The __published keyword specifies that properties in that section are displayed in the Object Inspector, if the class is on the Component palette. Only classes derived from TObject can have __published sections.
The visibility rules for published members are identical to those of public members. The only difference between published and public members is that Object Pascal-style runtime type information (RTTI) is generated for data members and properties declared in a __published section. RTTI enables an application to dynamically query the data members, member functions, and properties of an otherwise unknown class type.
Note: No constructors or destructors are allowed in a __published section. Properties, Pascal intrinsic or VCL or CLX derived data-members, member functions, and closures are allowed in a __published section. Fields defined in a __published section must be of a class type. Properties defined in a __published section cannot be array properties. The type of a property defined in a __published section must be an ordinal type, a real type, a string type, a small set type, a class type, or a method pointer type. |
_________________
 |
|
| Volver arriba |
|
|
Picard
Master
Registrado: 18 Ene 2004Mensajes: 218Ubicación: Palamos (Girona) España
|
| Publicado: Mie 15 Dic, 2004 6:34 pm Asunto: |
|
|
uffffffffffffff, Cesar, lo siento,pero no encuentro la solucion,es ams ahora aun estoy mas perdido que antes.
gracias de todos modos
_________________
El hombre es el unico ser que tropieza dos veces en la misma piedra ( en mi caso infinitas veces) |
|
| Volver arriba |
|
|
kalux
Master
Registrado: 21 Nov 2003Mensajes: 313Ubicación: Alicante - España
|
| Publicado: Mie 15 Dic, 2004 9:16 pm Asunto: |
|
|
Hola hace tiempo, quise aprender a realizar un componente (me siguieron varios problemas que no pude solucionar, con reinstalacion de Builder incluida) y al final lo he dejado aparcado a un lado.
Pero te puedo orientar un poco:
Hay 2 tipos de componentes: Visuales y No visuales. En tu caso seria del tipo Visual.
Para crear un nuevo componente nos apoyaremos en el asistente. Seleccionamos en el menú “Component”, “New component”. Y posteriormente veremos una ventana que nos pedirá una serie de datos para comenzar a crear nuestro componente, que son:
-Ancesor type: Es el tipo de ascendente. Una clase puede heredar de otra sus características, convirtiéndose en una clase derivada o descendiente. Todos los componentes que forman la VCL descienden a su vez de otro, siendo la raíz común la clase “TComponent” (esto seria lo normal para componentes No Visuales), para los Visuales (que seria tu caso) hay dos tipos: TGraphicControl y TWinControl (yo intente hacerlo con uno No visual, asi que aqui si alguien puede confirmar mejor, porque no estoy muy seguro) deberia utilizar TGraphicControl.
-Class Name: Es el nombre de la clase del componente. Por convencionalismo se precede en el nombre la letra T (Tipo). Conviene dar un nombre que sea lo mas descriptivo posible del comportamiento del componente.
-Palette Page: Es el lugar donde aparecerá en la paleta de componentes., ya sea una existente o bien una nueva. Es aconsejable no utilizar las propias del C++Builder.
-“Unit file name”: Nombre del fichero cpp. Aquí escogemos la ubicación del componente.
-Search path: Seleccionamos el path del componente.
Ahora tenemos dos opciones: “Install” que crea el componente y lo instala; “Ok” que crea el componente pero no lo instala, para instalarlo mas tarde vamos a “Component”, “Install Component” . En este caso pulsamos “Ok”, ya que aun no lo hemos creado.
Automáticamente nos crea el fichero .cpp y el .h, creando la estructura base del componente.
En el fichero de cabecera encontramos la definición de una nueva clase, T....., que esta derivada de TGraphicControl, vemos que tenemos 4 partes: private, protected, public y publised. Además tenemos una llamada a la funcion RegisterComponents, el cual le comunica a C++Builder, donde insertara este componente en la paleta.
Este componente, tal cual, de momento se comporta idénticamente que el componente del que deriva, ya que no se han incluido ninguna propiedad, variable, etc.
Una propiedad es parecida a una variable, a la cual se pueden asignar y obtener valores. Aunque además, puede provocar la ejecución de métodos internos para su consecución. La declaración de una propiedad se inicia con la palabra __property que ira seguida del tipo y del nombre de la propiedad. Tras el nombre, ira un operador de asignación (=), seguido de unas llaves ({}) en la cual aparecerán las palabras read para la función de lectura y write para la función de escritura.
Una propiedad puede ser de lectura y escritura, de solo lectura y rara vez de solo escritura. Si es de solo lectura, solamente cuenta con la palabra read; si es de solo escritura solamente llevara la palabra write; y si es de lectura / escritura llevara ambas palabras.
Las propiedades se colocan en la parte de published
Ya solo nos quedaria poner todas las funciones que se necesiten asi como las propiedades con las que contara el componente.
A mas no llegue por problemas. Espero haberte orientado un poco. |
|
| Volver arriba |
|
|
kalux
Master
Registrado: 21 Nov 2003Mensajes: 313Ubicación: Alicante - España
|
| Publicado: Mie 15 Dic, 2004 9:25 pm Asunto: |
|
|
Ahh, cuando lo tengas, supongo que desearas colocarle un icono:
Podemos crear una imagen que identifique a nuestro componente, en vez de utilizar la imagen que por defecto coloca el C++Builder.
Para ello abrimos el Editor de Imágenes (se encuentra en “Tools”, “Image Editor”). Seleccionamos “Resources / New Bitmap”. En las propiedades debemos poner Width=24, Height=24 y VGA (16 colores). Ahora seleccionamos Resource / Rename y lo llamamos de la misma forma que el componente (Tnombre_componente). Doble clic en éste y aquí creamos o abrimos un bmp de las mismas características. Ya solo queda guardarlo (File / Save as) con el mismo nombre que el archivo cpp del componente y en el mismo directorio. |
|
| Volver arriba |
|
|
penita
Invitado
|
| Publicado: Mie 12 Ene, 2005 6:53 pm Asunto: Eso es la otra mitad!! |
|
|
Aqui puedo ver la otra mitad!!
Pero y si el codigo ya lo tenemos? Como se incorpora un nuevo componente en una paleta?? |
|
| Volver arriba |
|
|
|
|
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro
|
© 2002–2026 Club Builder · Funciona con phpBB.
|
FAQ
Buscar
Miembros
Grupos de Usuarios
Registrarse
Perfil
Entra para ver tus mensajes privados
Entrar
