Code cleaning. Removed obscure code to draw texts (beeaf53a) · Commits · Elphel / kicad-source-mirror

3d-viewer/3d_draw.cpp

+61 −64

Original line number	Original line	Diff line number	Diff line
	@@ -308,6 +308,7 @@ void Pcb3D_GLCanvas::Draw3D_Via( SEGVIA* via )
	continue;		continue;

	SetGLColor( color );		SetGLColor( color );

	// SetGLColor( LIGHTGRAY );		// SetGLColor( LIGHTGRAY );
	glNormal3f( 0.0, 0.0, (layer == COPPER_LAYER_N) ? -1.0 : 1.0 );		glNormal3f( 0.0, 0.0, (layer == COPPER_LAYER_N) ? -1.0 : 1.0 );
	if( layer == COPPER_LAYER_N )		if( layer == COPPER_LAYER_N )
	@@ -395,52 +396,48 @@ void Pcb3D_GLCanvas::Draw3D_DrawSegment( DRAWSEGMENT* segment )
	}		}


			/* function to draw 3D segments, called by DrawGraphicText
			* When DrawGraphicText is called to draw a text to an OpenGL DC
			* it calls Draw3dTextSegm to each segment to draw.
			* 2 parameters used by Draw3D_FilledSegment are not handled by DrawGraphicText
			* but are used in Draw3D_FilledSegment().
			* they are 2 local variables. This is an ugly, but trivial code.
			* Using DrawGraphicText to draw all texts ensure texts have the same shape
			* in all contexts
			*/
			static double s_Text3DWidth, s_Text3DZPos;
			static void Draw3dTextSegm( int x0, int y0, int xf, int yf )
			{
			double startx = x0 * g_Parm_3D_Visu.m_BoardScale;
			double starty = y0 * g_Parm_3D_Visu.m_BoardScale;
			double endx = xf * g_Parm_3D_Visu.m_BoardScale;
			double endy = yf * g_Parm_3D_Visu.m_BoardScale;

			Draw3D_FilledSegment( startx, -starty, endx, -endy, s_Text3DWidth, s_Text3DZPos );
			}


	/*************************************************************/		/*************************************************************/
	void Pcb3D_GLCanvas::Draw3D_DrawText( TEXTE_PCB* text )		void Pcb3D_GLCanvas::Draw3D_DrawText( TEXTE_PCB* text )
	/*************************************************************/		/*************************************************************/
	{		{
			if( !Get3DLayerEnable( layer ) )
			return;
	int layer = text->GetLayer();		int layer = text->GetLayer();
	double x, y, xf, yf;
	double zpos, w;
	int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[layer];		int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[layer];
	#define BUFFSIZE 50
	int coord[(BUFFSIZE+2)*2];
	int ii, jj, kk, ll, nbpoints;


	if( Get3DLayerEnable( layer ) )
	{
	zpos = g_Parm_3D_Visu.m_LayerZcoord[layer];
	glNormal3f( 0.0, 0.0, Get3DLayerSide( layer ) );

	jj = 5; ii = jj + 1;
	while( ii < text->m_TextDrawingsSize )
	{
	nbpoints = text->m_TextDrawings[jj];
	if( nbpoints > BUFFSIZE )
	nbpoints = BUFFSIZE;

	for( kk = 0, ll = 0; (kk < nbpoints) && (ii < text->m_TextDrawingsSize); kk++ )
	{
	coord[ll++] = text->m_TextDrawings[ii++] + text->m_Pos.x;
	coord[ll++] = text->m_TextDrawings[ii++] + text->m_Pos.y;
	}

	jj = ii++;

	for( kk = 0, ll = 0; kk < (nbpoints - 1); kk++, ll += 2 )
	{
	SetGLColor( color );		SetGLColor( color );
	w = text->m_Width * g_Parm_3D_Visu.m_BoardScale;		s_Text3DZPos = g_Parm_3D_Visu.m_LayerZcoord[layer];
	x = coord[ll] * g_Parm_3D_Visu.m_BoardScale;		s_Text3DWidth = text->m_Width * g_Parm_3D_Visu.m_BoardScale;
	y = coord[ll + 1] * g_Parm_3D_Visu.m_BoardScale;		glNormal3f( 0.0, 0.0, Get3DLayerSide( layer ) );
	xf = coord[ll + 2] * g_Parm_3D_Visu.m_BoardScale;		DrawGraphicText( NULL, NULL,
	yf = coord[ll + 3] * g_Parm_3D_Visu.m_BoardScale;		text->m_Pos, (EDA_Colors) color, text->m_Text,
			text->m_Orient, text->m_Size,
	Draw3D_FilledSegment( x, -y, xf, -yf, w, zpos );		text->m_HJustify,
	}		text->m_VJustify,
	}		text->m_Width, text->m_Italic,
	}		Draw3dTextSegm );
	}		}

common/base_struct.cpp

+50 −342

Original line number	Original line	Diff line number	Diff line
	@@ -147,11 +147,14 @@ void EDA_BaseStruct::Show( int nestLevel, std::ostream& os )
	std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os )		std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os )
	{		{
	for( int i = 0; i<nestLevel; ++i )		for( int i = 0; i<nestLevel; ++i )
	os << " "; // number of spaces here controls indent per nest level		os << " ";

			// number of spaces here controls indent per nest level

	return os;		return os;
	}		}


	#endif		#endif


	@@ -163,25 +166,17 @@ EDA_TextStruct::EDA_TextStruct( const wxString& text )
	m_Size.x = m_Size.y = DEFAULT_SIZE_TEXT; /* XY size of font */		m_Size.x = m_Size.y = DEFAULT_SIZE_TEXT; /* XY size of font */
	m_Orient = 0; /* Orient in 0.1 degrees */		m_Orient = 0; /* Orient in 0.1 degrees */
	m_Attributs = 0;		m_Attributs = 0;
	m_Miroir = 0; // vue normale / miroir		m_Miroir = 0; // display mirror if 1
	m_HJustify = GR_TEXT_HJUSTIFY_CENTER;		m_HJustify = GR_TEXT_HJUSTIFY_CENTER;
	m_VJustify = GR_TEXT_VJUSTIFY_CENTER; /* Justifications Horiz et Vert du texte */		m_VJustify = GR_TEXT_VJUSTIFY_CENTER; /* Justifications Horiz et Vert du texte */
	m_Width = 0; /* epaisseur du trait */		m_Width = 0; /* thickness */
	m_CharType = 0; /* normal, bold, italic ... */		m_Italic = false; /* true = italic shape */
	m_Text = text;		m_Text = text;
	m_ZoomLevelDrawable = 0; /* Niveau de zoom acceptable pour affichage normal */
	m_TextDrawings = NULL; /* Pointeur sur le dessin du caractere */
	m_TextDrawingsSize = 0; /* taille du tableau point�*/
	}		}


	EDA_TextStruct::~EDA_TextStruct()		EDA_TextStruct::~EDA_TextStruct()
	{		{
	if( m_TextDrawings ) /* pointeur sur la liste des segments de dessin */
	{
	free( m_TextDrawings ); m_TextDrawings = NULL;
	}
	m_TextDrawingsSize = 0; /* nombre de sommets a dessiner */
	}		}


	@@ -259,337 +254,62 @@ int EDA_TextStruct::Pitch()


	/***************************************************************/		/***************************************************************/
	void EDA_TextStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,		void EDA_TextStruct::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
	const wxPoint& offset, int color, int draw_mode,		const wxPoint& aOffset, EDA_Colors aColor,
	int display_mode, int anchor_color )		int aDrawMode,
			GRFillMode aDisplayMode, EDA_Colors aAnchor_color )
	/***************************************************************/		/***************************************************************/

	/*		/** Function Draw
	* Trace de 1 texte type EDA_TextStruct.		* @param aPanel = the current DrawPanel
	* offset = Offset de trace (usuellement (0,0)		* @param aDC = the current Device Context
	* color = couleur du texte		* @param aOffset = draw offset (usually (0,0))
	* draw_mode = GR_OR, GR_XOR.., -1 si mode courant.		* @param EDA_Colors aColor = text color
	* display_mode = FILAIRE, FILLED ou SKETCH		* @param aDrawMode = GR_OR, GR_XOR.., -1 to use the current mode.
	* anchor_color = couleur de l'ancre ( -1 si pas d'ancre ).		* @param aDisplayMode = FILAIRE, FILLED or SKETCH
			* @param EDA_Colors aAnchor_color = anchor color ( UNSPECIFIED_COLOR = do not draw anchor ).
	*/		*/
	{		{
	int zoom;		int zoom;
	int coord[104];
	int ii, jj, kk, ll, nbpoints;
	int width;		int width;

	if( m_TextDrawings == NULL ) /* pointeur sur la liste des segments de dessin */		zoom = aPanel->GetZoom();
	CreateDrawData();		width = m_Width;
			if( aDisplayMode == FILAIRE )
	if( m_TextDrawings == NULL )
	return;

	zoom = panel->GetZoom();
	width = m_Width / zoom;
	if( display_mode == FILAIRE )
	width = 0;		width = 0;

	/* choix de la couleur du texte : */		if( aDrawMode != -1 )
	if( draw_mode != -1 )		GRSetDrawMode( aDC, aDrawMode );
	GRSetDrawMode( DC, draw_mode );

	/* trace du texte */		/* Draw text anchor, if allowed */
	if( zoom > m_ZoomLevelDrawable )		if( aAnchor_color != UNSPECIFIED_COLOR )
	{
	GRLine( &panel->m_ClipBox, DC,
	m_TextDrawings[1] + offset.x + m_Pos.x,
	m_TextDrawings[2] + offset.y + m_Pos.y,
	m_TextDrawings[3] + offset.x + m_Pos.x,
	m_TextDrawings[4] + offset.y + m_Pos.y,
	width, color );
	}
	else
	{
	/* trace ancre du texte ? */
	if( anchor_color != -1 )
	{		{
	int anchor_size = 2 * zoom;		int anchor_size = 2 * zoom;
	anchor_color &= MASKCOLOR;		aAnchor_color = (EDA_Colors) (aAnchor_color & MASKCOLOR);

	/* calcul de la position du texte */
	int cX = m_Pos.x - offset.x;
	int cY = m_Pos.y - offset.y;

	/* trace ancre du texte */
	GRLine( &panel->m_ClipBox, DC, cX - anchor_size, cY,
	cX + anchor_size, cY, 0, anchor_color );

	GRLine( &panel->m_ClipBox, DC, cX, cY - anchor_size,
	cX, cY + anchor_size, 0, anchor_color );
	}
	jj = 5; ii = jj + 1;
	while( ii < m_TextDrawingsSize )
	{
	nbpoints = m_TextDrawings[jj];
	if( nbpoints > 50 )
	nbpoints = 50;

	for( kk = 0, ll = 0; (kk < nbpoints) && (ii < m_TextDrawingsSize); kk++ )
	{
	coord[ll++] = m_TextDrawings[ii++] + offset.x + m_Pos.x;
	coord[ll++] = m_TextDrawings[ii++] + offset.y + m_Pos.y;
	}

	jj = ii++;

	if( width > 2 )
	{
	for( kk = 0, ll = 0; kk < (nbpoints - 1); kk++, ll += 2 )
	{
	if( display_mode == SKETCH )
	GRCSegm( &panel->m_ClipBox, DC,
	coord[ll], coord[ll + 1],
	coord[ll + 2], coord[ll + 3],
	m_Width, color );

	else
	GRFillCSegm( &panel->m_ClipBox, DC,
	coord[ll], coord[ll + 1],
	coord[ll + 2], coord[ll + 3],
	m_Width, color );
	}
	}
	else
	GRPoly( &panel->m_ClipBox, DC, nbpoints, coord, 0, 0, color, color );
	}
	}
	}


	/****************************************/
	void EDA_TextStruct::CreateDrawData()
	/****************************************/

	/* Cree le tableau de donn�s n�essaire au trace d'un texte (pcb, module..)
	* Met a jour:
	* m_ZoomLevelDrawable Niveau de zoom acceptable pour affichage normal
	* m_TextDrawings Pointeur sur le tableau de donn�s
	* m_TextDrawingsSize taille (en int) du tableau
	* Codage dans le tableau:
	* Suite des coord des sommets des polygones a tracer pr��du nombre de sommets
	* nn xx1 yy1 xx2 yy2 .. xxn yyn mm xx1 yy1 xx2 yy2 .. xxm yym
	* les 2 premiers sommets sont le segment symbolisant le texte pour les
	* affichages a trop petite echelle
	*/
	{
	int ii, jj, kk, nbchar, nbpoints, AsciiCode, endcar;
	int k1, k2, x0, y0;
	int size_h, size_v, espacement;
	char f_cod, plume = 'U';
	const wxChar* ptr;
	const SH_CODE* ptcar;
	int ux0, uy0, dx, dy; // Coord de trace des segments de texte & variables de calcul */
	int cX, cY; // Centre du texte
	int ox, oy; // coord de trace du caractere courant
	int* coord; // liste des coord des segments a tracer
	int coord_count_max = 1000;

	if( m_TextDrawings ) /* pointeur sur la liste des segments de dessin */
	{
	free( m_TextDrawings ); m_TextDrawings = 0;
	}
	m_TextDrawingsSize = 0; /* nombre de segments a dessiner */

	nbchar = m_Text.Length();
	if( nbchar == 0 )
	return;

	size_h = m_Size.x;
	size_v = m_Size.y;
	espacement = Pitch();
	if( m_Miroir == 0 )
	{
	size_h = -size_h; espacement = -espacement;
	}

	kk = 0; ptr = m_Text.GetData(); /* ptr pointe 1er caractere du texte */

	/* calcul de la position du debut des textes: ox et oy */
	ox = cX = 0; oy = cY = 0;

	/* Calcul du cadrage du texte */
	dx = (espacement * nbchar) / 2;
	dy = size_v / 2; /* Decalage du debut du texte / centre */

	ux0 = uy0 = 0; /* Decalage du centre du texte / ccord de ref */

	if( (m_Orient == 0) \|\| (m_Orient == 1800) ) /* Texte Horizontal */
	{
	switch( m_HJustify )
	{
	case GR_TEXT_HJUSTIFY_CENTER:
	break;

	case GR_TEXT_HJUSTIFY_RIGHT:
	ux0 = -dx;
	break;

	case GR_TEXT_HJUSTIFY_LEFT:
	ux0 = dx;
	break;
	}

	switch( m_VJustify )
	{
	case GR_TEXT_VJUSTIFY_CENTER:
	break;

	case GR_TEXT_VJUSTIFY_TOP:
	uy0 = dy;
	break;

	case GR_TEXT_VJUSTIFY_BOTTOM:		int cX = m_Pos.x + aOffset.x;
	uy0 = -dy;		int cY = m_Pos.y + aOffset.y;
	break;
	}
	}
	else /* Texte Vertical */
	{
	switch( m_HJustify )
	{
	case GR_TEXT_HJUSTIFY_CENTER:
	break;

	case GR_TEXT_HJUSTIFY_RIGHT:		GRLine( &aPanel->m_ClipBox, aDC, cX - anchor_size, cY,
	ux0 = -dy;		cX + anchor_size, cY, 0, aAnchor_color );
	break;

	case GR_TEXT_HJUSTIFY_LEFT:		GRLine( &aPanel->m_ClipBox, aDC, cX, cY - anchor_size,
	ux0 = dy;		cX, cY + anchor_size, 0, aAnchor_color );
	break;
	}		}

	switch( m_VJustify )		if( aDisplayMode == SKETCH )
	{		width = -width;
	case GR_TEXT_VJUSTIFY_CENTER:
	break;

	case GR_TEXT_VJUSTIFY_TOP:
	uy0 = dx;
	break;

	case GR_TEXT_VJUSTIFY_BOTTOM:		DrawGraphicText( aPanel, aDC,
	uy0 = -dx;		aOffset + m_Pos, aColor, m_Text,
	break;		m_Orient, m_Size,
	}		m_HJustify, m_VJustify, width, m_Italic );
	}		}
	cX += ux0; cY += uy0;
	ox = cX - dx;; oy = cY + dy;

	/* lorsque les chars sont trop petits pour etre dessines,
	* le texte est symbolise par une barre */
	m_ZoomLevelDrawable = MAX( ABS(m_Size.x), ABS(m_Size.y) ) / 3;
	dx = (espacement * nbchar) / 2;
	dy = size_v / 2; /* Decalage du debut du texte / centre */

	ux0 = cX - dx;
	uy0 = cY;

	dx += cX;
	dy = cY;

	RotatePoint( &ux0, &uy0, cX, cY, m_Orient );
	RotatePoint( &dx, &dy, cX, cY, m_Orient );

	coord = (int) MyMalloc( (coord_count_max + 2) sizeof(int) );
	coord[0] = 2;
	coord[1] = ux0; coord[2] = uy0;
	coord[3] = dx; coord[4] = dy;

	jj = 5; ii = jj + 1; nbpoints = 0;
	while( kk++ < nbchar )
	{
	x0 = 0; y0 = 0;
	#if defined(wxUSE_UNICODE) && defined(KICAD_CYRILLIC)
	AsciiCode = (*ptr) & 0x7FF;
	if ( AsciiCode > 0x40F && AsciiCode < 0x450 ) // big small Cyr
	AsciiCode = utf8_to_ascii[AsciiCode - 0x410] & 0xFF;
	else
	AsciiCode = AsciiCode & 0xFF;
	#else
	AsciiCode = (*ptr) & 255;
	#endif
	ptcar = graphic_fonte_shape[AsciiCode]; /* ptcar pointe la description
	* du caractere a dessiner */

	for( endcar = FALSE; !endcar; ptcar++ )
	{
	f_cod = *ptcar;

	/* get code n de la forme selectionnee */
	switch( f_cod )
	{
	case 'X':
	endcar = TRUE; /* fin du caractere */
	break;

	case 'U':
	if( nbpoints && (plume == 'D' ) )
	{
	if( jj >= coord_count_max )
	{
	coord_count_max *= 2;
	coord = (int) realloc( coord, coord_count_max sizeof(int) );
	}
	coord[jj] = nbpoints;
	jj = ii++;
	}
	plume = f_cod;
	nbpoints = 0;
	break;

	case 'D':
	plume = f_cod;
	nbpoints = 1; /* 1 point va suivre (origine du trac� */
	break;

	default:
	{
	k1 = f_cod; /* trace sur axe V */
	k1 = -( (k1 * size_v) / 9 );
	ptcar++;
	f_cod = *ptcar;
	k2 = f_cod; /* trace sur axe H */
	k2 = (k2 * size_h) / 9;

	dx = k2 + ox;
	dy = k1 + oy;

	RotatePoint( &dx, &dy, cX, cY, m_Orient );
	if( ii >= coord_count_max )
	{
	coord_count_max *= 2;
	coord = (int) realloc( coord, coord_count_max sizeof(int) );
	}

	coord[ii++] = dx;
	coord[ii++] = dy;

	nbpoints++;
	break;
	}
	}

	/* end switch */
	}

	/* end boucle for = end trace de 1 caractere */

	ptr++;
	ox += espacement;
	}

	/* end trace du texte */

	m_TextDrawings = (int) realloc( coord, ii sizeof(int) );
	m_TextDrawingsSize = ii; //taille (en int) du tableau
	}

			/******************/
			/* Class EDA_Rect */
			/******************/

	/******************************/		/******************************/
	void EDA_Rect::Normalize()		void EDA_Rect::Normalize()
	@@ -646,15 +366,6 @@ bool EDA_Rect::Intersects( const EDA_Rect aRect ) const
	// this logic taken from wxWidgets' geometry.cpp file:		// this logic taken from wxWidgets' geometry.cpp file:
	bool rc;		bool rc;

	#if 0 && defined(DEBUG)

	std::cout << "this: ";
	std::cout << m_Pos << m_Size << '\n';
	std::cout << "aRect: ";
	std::cout << aRect.m_Pos << aRect.m_Size;

	#endif

	int left = MAX( m_Pos.x, aRect.m_Pos.x );		int left = MAX( m_Pos.x, aRect.m_Pos.x );
	int right = MIN( m_Pos.x + m_Size.x, aRect.m_Pos.x + aRect.m_Size.x );		int right = MIN( m_Pos.x + m_Size.x, aRect.m_Pos.x + aRect.m_Size.x );
	int top = MAX( m_Pos.y, aRect.m_Pos.y );		int top = MAX( m_Pos.y, aRect.m_Pos.y );
	@@ -665,8 +376,6 @@ bool EDA_Rect::Intersects( const EDA_Rect aRect ) const
	else		else
	rc = false;		rc = false;

	//D( std::cout << "rc=" << rc << '\n'; )

	return rc;		return rc;
	}		}

	@@ -771,4 +480,3 @@ void EDA_Rect::Merge( const EDA_Rect& aRect )
	end.y = MAX( end.y, rect_end.y );		end.y = MAX( end.y, rect_end.y );
	SetEnd( end );		SetEnd( end );
	}		}

common/drawtxt.cpp

+63 −48

File changed.

Preview size limit exceeded, changes collapsed.

eeschema/class_hierarchical_PIN_sheet.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -72,7 +72,7 @@ void Hierarchical_PIN_Sheet_Struct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, con
	/********************************************************************************************/		/********************************************************************************************/
	/* Routine de dessin des Labels type hierarchie */		/* Routine de dessin des Labels type hierarchie */
	{		{
	int side;		GRTextHorizJustifyType side;
	EDA_Colors txtcolor;		EDA_Colors txtcolor;
	int posx, tposx, posy, size2;		int posx, tposx, posy, size2;
	wxSize size;		wxSize size;

eeschema/class_sch_cmp_field.cpp

+6 −28

Original line number	Original line	Diff line number	Diff line
	@@ -53,36 +53,12 @@ void SCH_CMP_FIELD::SwapData( SCH_CMP_FIELD* copyitem )
	EXCHG( m_Orient, copyitem->m_Orient );		EXCHG( m_Orient, copyitem->m_Orient );
	EXCHG( m_Miroir, copyitem->m_Miroir );		EXCHG( m_Miroir, copyitem->m_Miroir );
	EXCHG( m_Attributs, copyitem->m_Attributs );		EXCHG( m_Attributs, copyitem->m_Attributs );
	EXCHG( m_CharType, copyitem->m_CharType );		EXCHG( m_Italic, copyitem->m_Italic );
	EXCHG( m_HJustify, copyitem->m_HJustify );		EXCHG( m_HJustify, copyitem->m_HJustify );
	EXCHG( m_VJustify, copyitem->m_VJustify );		EXCHG( m_VJustify, copyitem->m_VJustify );
	EXCHG( m_ZoomLevelDrawable, copyitem->m_ZoomLevelDrawable );
	EXCHG( m_TextDrawings, copyitem->m_TextDrawings );
	EXCHG( m_TextDrawingsSize, copyitem->m_TextDrawingsSize );
	}		}


	#if 0
	/***********************************************************/
	void SCH_CMP_FIELD::PartTextCopy( SCH_CMP_FIELD* 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;
	}
	#endif


	/*********************************/		/*********************************/
	bool SCH_CMP_FIELD::IsVoid()		bool SCH_CMP_FIELD::IsVoid()
	/*********************************/		/*********************************/
	@@ -92,8 +68,8 @@ bool SCH_CMP_FIELD::IsVoid()
	*/		*/
	{		{
	if( m_Text.IsEmpty() \|\| m_Text == wxT( "~" ) )		if( m_Text.IsEmpty() \|\| m_Text == wxT( "~" ) )
	return TRUE;		return true;
	return FALSE;		return false;
	}		}


	@@ -142,7 +118,7 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
	y2 = pos.y + (DrawLibItem->m_Transform[1][0] * x1)		y2 = pos.y + (DrawLibItem->m_Transform[1][0] * x1)
	+ (DrawLibItem->m_Transform[1][1] * y1);		+ (DrawLibItem->m_Transform[1][1] * y1);

	/* If the component orientation is +/- 90 deg, the text orienation must be changed */		/* If the component orientation is +/- 90 deg, the text orientation must be changed */
	if( DrawLibItem->m_Transform[0][1] )		if( DrawLibItem->m_Transform[0][1] )
	{		{
	if( orient == TEXT_ORIENT_HORIZ )		if( orient == TEXT_ORIENT_HORIZ )
	@@ -206,7 +182,9 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
	}		}


			/*********************************************/
	bool SCH_CMP_FIELD::Save( FILE* aFile ) const		bool SCH_CMP_FIELD::Save( FILE* aFile ) const
			/*********************************************/
	{		{
	char hjustify = 'C';		char hjustify = 'C';
	if( m_HJustify == GR_TEXT_HJUSTIFY_LEFT )		if( m_HJustify == GR_TEXT_HJUSTIFY_LEFT )

Admin message