mirror of https://gitlab.com/kicad/code/kicad.git
634 lines
18 KiB
C++
634 lines
18 KiB
C++
/***********************************************************************/
|
||
/* Methodes de base de gestion des classes des elements de schematique */
|
||
/***********************************************************************/
|
||
|
||
#include "fctsys.h"
|
||
#include "gr_basic.h"
|
||
#include "macros.h"
|
||
|
||
#include "common.h"
|
||
#include "program.h"
|
||
#include "libcmp.h"
|
||
#include "general.h"
|
||
#include "id.h"
|
||
|
||
#include "protos.h"
|
||
|
||
#include "macros.h"
|
||
|
||
|
||
/***************************/
|
||
/* class DrawPartStruct */
|
||
/* class EDA_SchComponentStruct */
|
||
/***************************/
|
||
|
||
/***********************************************************************************/
|
||
DrawPartStruct::DrawPartStruct( KICAD_T struct_type, const wxPoint & pos):
|
||
EDA_BaseStruct(struct_type)
|
||
/***********************************************************************************/
|
||
{
|
||
m_Pos = pos;
|
||
m_TimeStamp = 0;
|
||
}
|
||
|
||
/************************************/
|
||
DrawPartStruct::~DrawPartStruct(void)
|
||
/************************************/
|
||
{
|
||
}
|
||
|
||
/****************************************************************/
|
||
wxString ReturnDefaultFieldName(int FieldNumber)
|
||
/****************************************************************/
|
||
/* Return the defult ield name from its number (REFERENCE, VALUE ..)
|
||
FieldDefaultNameList is not static, because we want the text translation
|
||
for I18n
|
||
*/
|
||
{
|
||
wxString FieldDefaultNameList[] = {
|
||
_("Ref"), /* Reference of part, i.e. "IC21" */
|
||
_("Value"), /* Value of part, i.e. "3.3K" */
|
||
_("Footprint"), /* Footprint, used by cvpcb or pcbnew, i.e. "16DIP300" */
|
||
_("Sheet"), /* for components which are a schematic file, schematic file name, i.e. "cnt16.sch" */
|
||
_("Field") /* User fields (1 to n) have an editable name*/
|
||
};
|
||
int ii = FieldNumber;
|
||
if ( ii > FIELD1 ) ii = FIELD1;
|
||
wxString FieldName = FieldDefaultNameList[ii];
|
||
|
||
if (FieldNumber >= FIELD1 ) FieldName << (FieldNumber - FIELD1 + 1);
|
||
return FieldName;
|
||
}
|
||
|
||
|
||
/****************************************************************/
|
||
wxString EDA_SchComponentStruct::ReturnFieldName(int FieldNumber)
|
||
/****************************************************************/
|
||
/* Return the Field name from its number (REFERENCE, VALUE ..)
|
||
*/
|
||
{
|
||
wxString FieldName = m_Field[FieldNumber].m_Name;
|
||
|
||
if ( (FieldNumber < FIELD1) || FieldName.IsEmpty() )
|
||
FieldName = ReturnDefaultFieldName(FieldNumber);
|
||
return FieldName;
|
||
}
|
||
|
||
|
||
/*******************************************************************/
|
||
EDA_SchComponentStruct::EDA_SchComponentStruct(const wxPoint & pos):
|
||
DrawPartStruct(DRAW_LIB_ITEM_STRUCT_TYPE, pos)
|
||
/*******************************************************************/
|
||
{
|
||
int ii;
|
||
m_Multi = 0; /* In multi unit chip - which unit to draw. */
|
||
m_RefIdNumber = 0;
|
||
m_FlagControlMulti = 0;
|
||
m_Convert = 0; /* Gestion des mutiples representations (conversion De Morgan) */
|
||
/* The rotation/mirror transformation matrix. pos normal*/
|
||
m_Transform[0][0] = 1;
|
||
m_Transform[0][1] = 0;
|
||
m_Transform[1][0] = 0;
|
||
m_Transform[1][1] = -1;
|
||
|
||
/* initialisation des Fields */
|
||
for(ii = 0; ii < NUMBER_OF_FIELDS; ii++)
|
||
{
|
||
m_Field[ii].m_Pos = m_Pos;
|
||
m_Field[ii].m_Layer = LAYER_FIELDS;
|
||
m_Field[ii].m_FieldId = REFERENCE + ii;
|
||
m_Field[ii].m_Parent = this;
|
||
}
|
||
|
||
m_Field[VALUE].m_Layer = LAYER_VALUEPART;
|
||
m_Field[REFERENCE].m_Layer = LAYER_REFERENCEPART;
|
||
|
||
m_PinIsDangling = NULL;
|
||
|
||
}
|
||
|
||
|
||
/**********************************************************************/
|
||
EDA_Rect EDA_SchComponentStruct::GetBoundaryBox( void )
|
||
/**********************************************************************/
|
||
{
|
||
EDA_LibComponentStruct * Entry = FindLibPart(m_ChipName.GetData(), wxEmptyString, FIND_ROOT);
|
||
EDA_Rect BoundaryBox;
|
||
int x0, xm, y0, ym;
|
||
/* Get the basic Boundary box */
|
||
if ( Entry )
|
||
{
|
||
BoundaryBox = Entry->GetBoundaryBox( m_Multi, m_Convert);
|
||
x0 = BoundaryBox.GetX(); xm = BoundaryBox.GetRight();
|
||
// We must reverse Y values, because matrix orientation
|
||
// suppose Y axis normal for the library items coordinates,
|
||
// m_Transform reverse Y values, but BoundaryBox ais already reversed!
|
||
y0 = - BoundaryBox.GetY();
|
||
ym = - BoundaryBox.GetBottom();
|
||
}
|
||
else /* if lib Entry not found, give a reasonable size */
|
||
{
|
||
x0 = y0 = -50;
|
||
xm = ym = 50;
|
||
}
|
||
|
||
/* Compute the real Boundary box (rotated, mirrored ...)*/
|
||
int x1 = m_Transform[0][0] * x0 + m_Transform[0][1] * y0;
|
||
|
||
int y1 = m_Transform[1][0] * x0 + m_Transform[1][1] * y0;
|
||
|
||
int x2 = m_Transform[0][0] * xm + m_Transform[0][1] * ym;
|
||
|
||
int y2 = m_Transform[1][0] * xm + m_Transform[1][1] * ym;
|
||
|
||
// H and W must be > 0 for wxRect:
|
||
if ( x2 < x1 ) EXCHG( x2, x1 );
|
||
if ( y2 < y1 ) EXCHG( y2, y1 );
|
||
BoundaryBox.SetX(x1); BoundaryBox.SetY(y1);
|
||
BoundaryBox.SetWidth(x2-x1);
|
||
BoundaryBox.SetHeight(y2-y1);
|
||
|
||
BoundaryBox.Offset(m_Pos);
|
||
return BoundaryBox;
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
void PartTextStruct::SwapData(PartTextStruct * copyitem)
|
||
/**************************************************************************/
|
||
/* Used if undo / redo command:
|
||
swap data between this and copyitem
|
||
*/
|
||
{
|
||
EXCHG(m_Text, copyitem->m_Text);
|
||
EXCHG(m_Layer, copyitem->m_Layer);
|
||
EXCHG(m_Pos, copyitem->m_Pos);
|
||
EXCHG(m_Size, copyitem->m_Size);
|
||
EXCHG(m_Width, copyitem->m_Width);
|
||
EXCHG(m_Orient, copyitem->m_Orient);
|
||
EXCHG(m_Miroir, copyitem->m_Miroir);
|
||
EXCHG(m_Attributs, copyitem->m_Attributs);
|
||
EXCHG(m_CharType, copyitem->m_CharType);
|
||
EXCHG(m_HJustify, copyitem->m_HJustify);
|
||
EXCHG(m_VJustify, copyitem->m_VJustify);
|
||
EXCHG(m_ZoomLevelDrawable, copyitem->m_ZoomLevelDrawable);
|
||
EXCHG(m_TextDrawings, copyitem->m_TextDrawings);
|
||
EXCHG(m_TextDrawingsSize, copyitem->m_TextDrawingsSize);
|
||
}
|
||
|
||
/**************************************************************************/
|
||
void EDA_SchComponentStruct::SwapData(EDA_SchComponentStruct * copyitem)
|
||
/**************************************************************************/
|
||
/* Used if undo / redo command:
|
||
swap data between this and copyitem
|
||
*/
|
||
{
|
||
EXCHG(m_Pos, copyitem->m_Pos);
|
||
EXCHG(m_Multi, copyitem->m_Multi);
|
||
EXCHG(m_Convert, copyitem->m_Convert);
|
||
EXCHG(m_Transform[0][0], copyitem->m_Transform[0][0]);
|
||
EXCHG(m_Transform[0][1], copyitem->m_Transform[0][1]);
|
||
EXCHG(m_Transform[1][0], copyitem->m_Transform[1][0]);
|
||
EXCHG(m_Transform[1][1], copyitem->m_Transform[1][1]);
|
||
for ( int ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
|
||
{
|
||
m_Field[ii].SwapData(©item->m_Field[ii]);
|
||
}
|
||
}
|
||
|
||
|
||
/***********************************************************************/
|
||
void EDA_SchComponentStruct::Place(WinEDA_DrawFrame * frame, wxDC * DC)
|
||
/***********************************************************************/
|
||
{
|
||
/* save old text in undo list */
|
||
if ( g_ItemToUndoCopy &&
|
||
(g_ItemToUndoCopy->m_StructType == m_StructType) &&
|
||
((m_Flags & IS_NEW) == 0) )
|
||
{
|
||
/* restore old values and save new ones */
|
||
SwapData( (EDA_SchComponentStruct*) g_ItemToUndoCopy);
|
||
/* save in undo list */
|
||
((WinEDA_SchematicFrame*)frame)->SaveCopyInUndoList(this, IS_CHANGED);
|
||
/* restore new values */
|
||
SwapData( (EDA_SchComponentStruct*) g_ItemToUndoCopy);
|
||
delete g_ItemToUndoCopy;
|
||
g_ItemToUndoCopy = NULL;
|
||
}
|
||
|
||
EDA_BaseStruct::Place(frame, DC);
|
||
}
|
||
|
||
|
||
/***************************************************/
|
||
void EDA_SchComponentStruct::ClearAnnotation(void)
|
||
/***************************************************/
|
||
/* Suppress annotation ( i.i IC23 changed to IC? and part reset to 1)
|
||
*/
|
||
{
|
||
m_RefIdNumber = 0;
|
||
|
||
while ( isdigit(m_Field[REFERENCE].m_Text.Last() ) )
|
||
m_Field[REFERENCE].m_Text.RemoveLast();
|
||
if ( m_Field[REFERENCE].m_Text.Last() != '?' )
|
||
m_Field[REFERENCE].m_Text.Append('?');
|
||
|
||
EDA_LibComponentStruct *Entry;
|
||
Entry = FindLibPart(m_ChipName.GetData(),wxEmptyString,FIND_ROOT);
|
||
|
||
if ( !Entry || ! Entry->m_UnitSelectionLocked )
|
||
m_Multi = 1;
|
||
}
|
||
|
||
/**************************************************************/
|
||
EDA_SchComponentStruct * EDA_SchComponentStruct::GenCopy(void)
|
||
/**************************************************************/
|
||
{
|
||
EDA_SchComponentStruct * new_item = new EDA_SchComponentStruct( m_Pos );
|
||
int ii;
|
||
|
||
new_item->m_Multi = m_Multi;
|
||
new_item->m_ChipName = m_ChipName;
|
||
new_item->m_FlagControlMulti = m_FlagControlMulti;
|
||
new_item->m_Convert = m_Convert;
|
||
new_item->m_Transform[0][0] = m_Transform[0][0];
|
||
new_item->m_Transform[0][1] = m_Transform[0][1];
|
||
new_item->m_Transform[1][0] = m_Transform[1][0];
|
||
new_item->m_Transform[1][1] = m_Transform[1][1];
|
||
new_item->m_TimeStamp = m_TimeStamp;
|
||
|
||
|
||
/* initialisation des Fields */
|
||
for(ii = 0; ii < NUMBER_OF_FIELDS; ii++)
|
||
{
|
||
m_Field[ii].PartTextCopy(& new_item->m_Field[ii]);
|
||
}
|
||
|
||
return new_item;
|
||
}
|
||
|
||
|
||
/*****************************************************************/
|
||
void EDA_SchComponentStruct::SetRotationMiroir( int type_rotate )
|
||
/******************************************************************/
|
||
/* Compute the new matrix transform for a schematic component
|
||
in order to have the requested transform (type_rotate = rot, mirror..)
|
||
which is applied to the initial transform.
|
||
*/
|
||
{
|
||
int TempMat[2][2];
|
||
bool Transform = FALSE;
|
||
|
||
switch (type_rotate)
|
||
{
|
||
case CMP_ORIENT_0:
|
||
case CMP_NORMAL: /* Position Initiale */
|
||
m_Transform[0][0] = 1;
|
||
m_Transform[1][1] = -1;
|
||
m_Transform[1][0] = m_Transform[0][1] = 0;
|
||
break;
|
||
|
||
case CMP_ROTATE_CLOCKWISE: /* Rotate + */
|
||
TempMat[0][0] = TempMat[1][1] = 0;
|
||
TempMat[0][1] = 1;
|
||
TempMat[1][0] = -1;
|
||
Transform = TRUE;
|
||
break;
|
||
|
||
case CMP_ROTATE_COUNTERCLOCKWISE: /* Rotate - */
|
||
TempMat[0][0] = TempMat[1][1] = 0;
|
||
TempMat[0][1] = -1;
|
||
TempMat[1][0] = 1;
|
||
Transform = TRUE;
|
||
break;
|
||
|
||
case CMP_MIROIR_Y: /* MirrorY */
|
||
TempMat[0][0] = -1;
|
||
TempMat[1][1] = 1;
|
||
TempMat[0][1] = TempMat[1][0] = 0;
|
||
Transform = TRUE;
|
||
break;
|
||
|
||
case CMP_MIROIR_X: /* MirrorX */
|
||
TempMat[0][0] = 1;
|
||
TempMat[1][1] = -1;
|
||
TempMat[0][1] = TempMat[1][0] = 0;
|
||
Transform = TRUE;
|
||
break;
|
||
|
||
case CMP_ORIENT_90:
|
||
SetRotationMiroir( CMP_ORIENT_0 );
|
||
SetRotationMiroir( CMP_ROTATE_COUNTERCLOCKWISE );
|
||
break;
|
||
|
||
case CMP_ORIENT_180:
|
||
SetRotationMiroir( CMP_ORIENT_0 );
|
||
SetRotationMiroir( CMP_ROTATE_COUNTERCLOCKWISE );
|
||
SetRotationMiroir( CMP_ROTATE_COUNTERCLOCKWISE );
|
||
break;
|
||
|
||
case CMP_ORIENT_270:
|
||
SetRotationMiroir( CMP_ORIENT_0 );
|
||
SetRotationMiroir( CMP_ROTATE_CLOCKWISE );
|
||
break;
|
||
|
||
case (CMP_ORIENT_0+CMP_MIROIR_X):
|
||
SetRotationMiroir( CMP_ORIENT_0 );
|
||
SetRotationMiroir( CMP_MIROIR_X );
|
||
break;
|
||
|
||
case (CMP_ORIENT_0+CMP_MIROIR_Y):
|
||
SetRotationMiroir( CMP_ORIENT_0 );
|
||
SetRotationMiroir( CMP_MIROIR_Y );
|
||
break;
|
||
|
||
case (CMP_ORIENT_90+CMP_MIROIR_X):
|
||
SetRotationMiroir( CMP_ORIENT_90 );
|
||
SetRotationMiroir( CMP_MIROIR_X );
|
||
break;
|
||
|
||
case (CMP_ORIENT_90+CMP_MIROIR_Y):
|
||
SetRotationMiroir( CMP_ORIENT_90 );
|
||
SetRotationMiroir( CMP_MIROIR_Y );
|
||
break;
|
||
|
||
case (CMP_ORIENT_180+CMP_MIROIR_X):
|
||
SetRotationMiroir( CMP_ORIENT_180 );
|
||
SetRotationMiroir( CMP_MIROIR_X );
|
||
break;
|
||
|
||
case (CMP_ORIENT_180+CMP_MIROIR_Y):
|
||
SetRotationMiroir( CMP_ORIENT_180 );
|
||
SetRotationMiroir( CMP_MIROIR_Y );
|
||
break;
|
||
|
||
case (CMP_ORIENT_270+CMP_MIROIR_X):
|
||
SetRotationMiroir( CMP_ORIENT_270 );
|
||
SetRotationMiroir( CMP_MIROIR_X );
|
||
break;
|
||
|
||
case (CMP_ORIENT_270+CMP_MIROIR_Y):
|
||
SetRotationMiroir( CMP_ORIENT_270 );
|
||
SetRotationMiroir( CMP_MIROIR_Y );
|
||
break;
|
||
|
||
default:
|
||
Transform = FALSE;
|
||
DisplayError(NULL, wxT("SetRotateMiroir() error: ill value") );
|
||
break;
|
||
}
|
||
|
||
if ( Transform )
|
||
{/* The new matrix transform is the old matrix transform modified by the
|
||
requested transformation, which is the TempMat transform (rot, mirror ..)
|
||
in order to have (in term of matrix transform):
|
||
transform coord = new_m_Transform * coord
|
||
where transform coord is the coord modified by new_m_Transform from the initial
|
||
value coord.
|
||
new_m_Transform is computed (from old_m_Transform and TempMat) to have:
|
||
transform coord = old_m_Transform * coord * TempMat
|
||
*/
|
||
int NewMatrix[2][2];
|
||
|
||
NewMatrix[0][0] = m_Transform[0][0] * TempMat[0][0] +
|
||
m_Transform[1][0] * TempMat[0][1];
|
||
|
||
NewMatrix[0][1] = m_Transform[0][1] * TempMat[0][0] +
|
||
m_Transform[1][1] * TempMat[0][1];
|
||
|
||
NewMatrix[1][0] = m_Transform[0][0] * TempMat[1][0] +
|
||
m_Transform[1][0] * TempMat[1][1];
|
||
|
||
NewMatrix[1][1] = m_Transform[0][1] * TempMat[1][0] +
|
||
m_Transform[1][1] * TempMat[1][1];
|
||
|
||
m_Transform[0][0] = NewMatrix[0][0];
|
||
m_Transform[0][1] = NewMatrix[0][1];
|
||
m_Transform[1][0] = NewMatrix[1][0];
|
||
m_Transform[1][1] = NewMatrix[1][1];
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************/
|
||
int EDA_SchComponentStruct::GetRotationMiroir(void)
|
||
/****************************************************/
|
||
{
|
||
int type_rotate = CMP_ORIENT_0;
|
||
int TempMat[2][2], MatNormal[2][2];
|
||
int ii;
|
||
bool found = FALSE;
|
||
|
||
memcpy(TempMat, m_Transform, sizeof(TempMat));
|
||
SetRotationMiroir(CMP_ORIENT_0);
|
||
memcpy(MatNormal, m_Transform, sizeof(MatNormal));
|
||
|
||
for ( ii = 0; ii < 4; ii++ )
|
||
{
|
||
if ( memcmp(TempMat, m_Transform, sizeof(MatNormal)) == 0)
|
||
{
|
||
found = TRUE; break;
|
||
}
|
||
SetRotationMiroir(CMP_ROTATE_COUNTERCLOCKWISE);
|
||
}
|
||
|
||
if ( ! found )
|
||
{
|
||
type_rotate = CMP_MIROIR_X + CMP_ORIENT_0;
|
||
SetRotationMiroir(CMP_NORMAL);
|
||
SetRotationMiroir(CMP_MIROIR_X);
|
||
for ( ii = 0; ii < 4; ii++ )
|
||
{
|
||
if ( memcmp(TempMat, m_Transform, sizeof(MatNormal)) == 0)
|
||
{
|
||
found = TRUE; break;
|
||
}
|
||
SetRotationMiroir(CMP_ROTATE_COUNTERCLOCKWISE);
|
||
}
|
||
}
|
||
|
||
if ( ! found )
|
||
{
|
||
type_rotate = CMP_MIROIR_Y + CMP_ORIENT_0;
|
||
SetRotationMiroir(CMP_NORMAL);
|
||
SetRotationMiroir(CMP_MIROIR_Y);
|
||
for ( ii = 0; ii < 4; ii++ )
|
||
{
|
||
if ( memcmp(TempMat, m_Transform, sizeof(MatNormal)) == 0)
|
||
{
|
||
found = TRUE; break;
|
||
}
|
||
SetRotationMiroir(CMP_ROTATE_COUNTERCLOCKWISE);
|
||
}
|
||
}
|
||
|
||
memcpy(m_Transform, TempMat, sizeof(m_Transform));
|
||
|
||
if ( found )
|
||
{
|
||
return (type_rotate + ii);
|
||
}
|
||
else
|
||
{
|
||
wxBell(); return CMP_NORMAL;
|
||
}
|
||
}
|
||
|
||
/***********************************************************************/
|
||
wxPoint EDA_SchComponentStruct::GetScreenCoord(const wxPoint & coord)
|
||
/***********************************************************************/
|
||
/* Renvoie la coordonn<6E>e du point coord, en fonction de l'orientation
|
||
du composant (rotation, miroir).
|
||
Les coord sont toujours relatives <20> l'ancre (coord 0,0) du composant
|
||
*/
|
||
{
|
||
wxPoint screenpos;
|
||
screenpos.x = m_Transform[0][0] * coord.x + m_Transform[0][1] * coord.y;
|
||
screenpos.y = m_Transform[1][0] * coord.x + m_Transform[1][1] * coord.y;
|
||
return screenpos;
|
||
}
|
||
|
||
|
||
/***************************************************************************/
|
||
PartTextStruct::PartTextStruct(const wxPoint & pos, const wxString & text):
|
||
EDA_BaseStruct(DRAW_PART_TEXT_STRUCT_TYPE),
|
||
EDA_TextStruct(text)
|
||
/***************************************************************************/
|
||
{
|
||
m_Pos = pos;
|
||
m_FieldId = 0;
|
||
}
|
||
|
||
/************************************/
|
||
PartTextStruct::~PartTextStruct(void)
|
||
/************************************/
|
||
{
|
||
}
|
||
|
||
/***********************************************************/
|
||
void PartTextStruct::PartTextCopy(PartTextStruct * target)
|
||
/***********************************************************/
|
||
{
|
||
target->m_Text = m_Text;
|
||
if ( m_FieldId >= FIELD1 )target->m_Name = m_Name;
|
||
target->m_Layer = m_Layer;
|
||
target->m_Pos = m_Pos;
|
||
target->m_Size = m_Size;
|
||
target->m_Attributs = m_Attributs;
|
||
target->m_FieldId = m_FieldId;
|
||
target->m_Orient = m_Orient;
|
||
target->m_HJustify = m_HJustify;
|
||
target->m_VJustify = m_VJustify;
|
||
target->m_Flags = m_Flags;
|
||
}
|
||
|
||
|
||
/*********************************/
|
||
bool PartTextStruct::IsVoid(void)
|
||
/*********************************/
|
||
/* return True if The field is void, i.e.:
|
||
contains wxEmptyString or "~"
|
||
*/
|
||
{
|
||
if ( m_Text.IsEmpty() || m_Text == wxT("~") ) return TRUE;
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
/********************************************/
|
||
EDA_Rect PartTextStruct::GetBoundaryBox(void)
|
||
/********************************************/
|
||
/* return
|
||
EDA_Rect contains the real (user coordinates) boundary box for a text field,
|
||
according to the component position, rotation, mirror ...
|
||
|
||
*/
|
||
{
|
||
EDA_Rect BoundaryBox;
|
||
int hjustify, vjustify;
|
||
int textlen;
|
||
int orient;
|
||
int dx, dy, x1, y1, x2, y2;
|
||
|
||
EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) m_Parent;
|
||
|
||
orient = m_Orient;
|
||
wxPoint pos = DrawLibItem->m_Pos;
|
||
x1 = m_Pos.x - pos.x;
|
||
y1 = m_Pos.y - pos.y;
|
||
|
||
textlen = GetLength();
|
||
if ( m_FieldId == REFERENCE ) // Real Text can be U1 or U1A
|
||
{
|
||
EDA_LibComponentStruct *Entry =
|
||
FindLibPart(DrawLibItem->m_ChipName.GetData(),wxEmptyString,FIND_ROOT);
|
||
if ( Entry && (Entry->m_UnitCount > 1) )
|
||
textlen ++; // because U1 is show as U1A or U1B ...
|
||
}
|
||
dx = m_Size.x * textlen;
|
||
|
||
// Real X Size is 10/9 char size because space between 2 chars is 1/10 X Size
|
||
dx = (dx * 10) / 9;
|
||
|
||
dy = m_Size.y;
|
||
hjustify = m_HJustify;
|
||
vjustify = m_VJustify;
|
||
|
||
x2 = pos.x + (DrawLibItem->m_Transform[0][0] * x1)
|
||
+ (DrawLibItem->m_Transform[0][1] * y1);
|
||
y2 = pos.y + (DrawLibItem->m_Transform[1][0] * x1)
|
||
+ (DrawLibItem->m_Transform[1][1] * y1);
|
||
|
||
/* If the component orientation is +/- 90 deg, the text orienation must be changed */
|
||
if(DrawLibItem->m_Transform[0][1])
|
||
{
|
||
if ( orient == TEXT_ORIENT_HORIZ) orient = TEXT_ORIENT_VERT;
|
||
else orient = TEXT_ORIENT_HORIZ;
|
||
/* is it mirrored (for text justify)*/
|
||
EXCHG(hjustify, vjustify);
|
||
if (DrawLibItem->m_Transform[1][0] < 0 ) vjustify = - vjustify;
|
||
if (DrawLibItem->m_Transform[0][1] > 0 ) hjustify = - hjustify;
|
||
}
|
||
else /* component horizontal: is it mirrored (for text justify)*/
|
||
{
|
||
if (DrawLibItem->m_Transform[0][0] < 0 )
|
||
hjustify = - hjustify;
|
||
if (DrawLibItem->m_Transform[1][1] > 0 )
|
||
vjustify = - vjustify;
|
||
}
|
||
|
||
if ( orient == TEXT_ORIENT_VERT ) EXCHG(dx, dy);
|
||
|
||
switch ( hjustify )
|
||
{
|
||
case GR_TEXT_HJUSTIFY_CENTER:
|
||
x1 = x2 - (dx/2);
|
||
break;
|
||
case GR_TEXT_HJUSTIFY_RIGHT:
|
||
x1 = x2 - dx;
|
||
break;
|
||
default:
|
||
x1 = x2;
|
||
break;
|
||
}
|
||
switch ( vjustify )
|
||
{
|
||
case GR_TEXT_VJUSTIFY_CENTER:
|
||
y1 = y2 - (dy/2);
|
||
break;
|
||
case GR_TEXT_VJUSTIFY_BOTTOM:
|
||
y1 = y2 - dy;
|
||
break;
|
||
default:
|
||
y1 = y2;
|
||
break;
|
||
}
|
||
|
||
BoundaryBox.SetX(x1);
|
||
BoundaryBox.SetY(y1);
|
||
BoundaryBox.SetWidth(dx);
|
||
BoundaryBox.SetHeight(dy);
|
||
|
||
return BoundaryBox;
|
||
}
|