PyMOL: layer1/Text.cpp - v2.1.0 vs. -open-source2.2.0 changes

"Fossies" - the Fresh Open Source Software Archive

Source code changes of the file "layer1/Text.cpp" between
pymol-v2.1.0.tar.bz2 and pymol-open-source-2.2.0.tar.gz

About: PyMOL is a Python-enhanced molecular graphics tool. It excels at 3D visualization of proteins, small molecules, density, surfaces, and trajectories. It also includes molecular editing, ray tracing, and movies. Open Source version.

[ To the main PyMOL source changes report ]

Text.cpp (pymol-v2.1.0.tar.bz2)	:	Text.cpp (pymol-open-source-2.2.0)

skipping to change at line 27		skipping to change at line 27
#include"os_python.h"		#include"os_python.h"

#include"MemoryDebug.h"		#include"MemoryDebug.h"
#include"Text.h"		#include"Text.h"
#include"Font.h"		#include"Font.h"

#include"FontGLUT.h"		#include"FontGLUT.h"
#include"FontType.h"		#include"FontType.h"
#include"Color.h"		#include"Color.h"
#include"Vector.h"		#include"Vector.h"

		#include"Executive.h"

#ifdef _PYMOL_FREETYPE		#ifdef _PYMOL_FREETYPE
#include "FontTTF.h"		#include "FontTTF.h"
#include "FontTTF2.h"		#include "FontTTF2.h"
#endif		#endif

#define FONT_NAME_MAX 255		#define FONT_NAME_MAX 255

#define TEXT_DEFAULT_SIZE 12.0F		#define TEXT_DEFAULT_SIZE 12.0F
static const float _255 = 255.0F;		static const float _255 = 255.0F;

skipping to change at line 48		skipping to change at line 49

typedef struct {		typedef struct {
int Src;		int Src;
int Code;		int Code;
char Name[FONT_NAME_MAX];		char Name[FONT_NAME_MAX];
int Mode;		int Mode;
int Style;		int Style;
CFont *Font;		CFont *Font;
} ActiveRec;		} ActiveRec;


		#define NFONTS 20

struct _CText {		struct _CText {
int NActive;		int NActive;
ActiveRec *Active;		ActiveRec *Active;
float Pos[4];		float Pos[4];
float WorldPos[4];		float WorldPos[4];
float ScreenWorldOffset[3];		float ScreenWorldOffset[3];

		float TargetPos[3];
		float LabelPushPos[3];
		float LabelPos[3];
		unsigned char LabelPosIsSet; // 1 for just z, 2 for 3f
		float TextIndentFactor[2];
float Color[4];		float Color[4];
unsigned char UColor[4];		unsigned char UColor[4];
unsigned char OutlineColor[4];		unsigned char OutlineColor[4];
int Default_ID;		int Default_ID;

int Flat;		float Height, Width;
		float Spacing, Just;
		float LabelBuf[2];

		int XHRFetched[NFONTS];
		int XHRFailed[NFONTS];
		bool Flat, IsPicking;
};		};

static void TextUpdateUColor(CText * I)		static void TextUpdateUColor(CText * I)
{		{
I->UColor[0] = (unsigned char) (_255 * I->Color[0] + _499);		I->UColor[0] = (unsigned char) (_255 * I->Color[0] + _499);
I->UColor[1] = (unsigned char) (_255 * I->Color[1] + _499);		I->UColor[1] = (unsigned char) (_255 * I->Color[1] + _499);
I->UColor[2] = (unsigned char) (_255 * I->Color[2] + _499);		I->UColor[2] = (unsigned char) (_255 * I->Color[2] + _499);
I->UColor[3] = (unsigned char) (_255 * I->Color[3] + _499);		I->UColor[3] = (unsigned char) (_255 * I->Color[3] + _499);
}		}


void TextSetPosNColor(PyMOLGlobals * G, float pos, float color)		void TextSetLabelBkgrdInfo(PyMOLGlobals * G, float label_spacing, float label_ju
		st, const float *buff){
		CText *I = G->Text;
		I->Spacing = label_spacing;
		I->Just = label_just;
		if (buff){
		I->LabelBuf[0] = buff[0];
		I->LabelBuf[1] = buff[1];
		} else {
		I->LabelBuf[0] = I->LabelBuf[1] = .2f;
		}
		}

		void TextSetIsPicking(PyMOLGlobals * G, bool IsPicking)
		{
		CText *I = G->Text;
		I->IsPicking = IsPicking;
		}

		bool TextGetIsPicking(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		return I->IsPicking;
		}

		void TextSetPosNColor(PyMOLGlobals * G, const float pos, const float color)
{		{
CText *I = G->Text;		CText *I = G->Text;
copy3f(pos, I->Pos);		copy3f(pos, I->Pos);
copy3f(color, I->Color);		copy3f(color, I->Color);
I->Flat = false;		I->Flat = false;
I->Pos[3] = 1.0F;		I->Pos[3] = 1.0F;
I->Color[3] = 1.0F;		I->Color[3] = 1.0F;
TextUpdateUColor(I);		TextUpdateUColor(I);
}		}

void TextAdvance(PyMOLGlobals * G, float advance)		void TextAdvance(PyMOLGlobals * G, float advance)
{		{
G->Text->Pos[0] += advance;		G->Text->Pos[0] += advance;
}		}


void TextSetLabPos(PyMOLGlobals * G, float pos, LabPosType labpos, const char *text)		void TextSetLabPos(PyMOLGlobals * G, const float pos, const LabPosType labpos , const char *text)
{		{
if((!labpos) \|\| (!labpos->mode))		if((!labpos) \|\| (!labpos->mode))
TextSetPos(G, pos);		TextSetPos(G, pos);
else {		else {
CText *I = G->Text;		CText *I = G->Text;
switch (labpos->mode) {		switch (labpos->mode) {
default:		default:
copy3f(pos, I->Pos);		copy3f(pos, I->Pos);
add3f(labpos->offset, I->Pos, I->Pos);		add3f(labpos->offset, I->Pos, I->Pos);
break;		break;

skipping to change at line 107		skipping to change at line 145
}		}
}		}

void TextIndent(PyMOLGlobals * G, float x, float y)		void TextIndent(PyMOLGlobals * G, float x, float y)
{		{
CText *I = G->Text;		CText *I = G->Text;
I->Pos[0] -= x;		I->Pos[0] -= x;
I->Pos[1] -= y;		I->Pos[1] -= y;
}		}


void TextSetPos(PyMOLGlobals * G, float *pos)		void TextSetPos(PyMOLGlobals * G, const float *pos)
{		{
CText *I = G->Text;		CText *I = G->Text;
copy3f(pos, I->Pos);		copy3f(pos, I->Pos);
I->Pos[3] = 1.0F;		I->Pos[3] = 1.0F;
}		}


void TextSetWorldPos(PyMOLGlobals * G, float *pos)		void TextSetWorldPos(PyMOLGlobals * G, const float *pos)
{		{
CText *I = G->Text;		CText *I = G->Text;
copy3f(pos, I->WorldPos);		copy3f(pos, I->WorldPos);
I->WorldPos[3] = 1.0F;		I->WorldPos[3] = 1.0F;
}		}
float TextGetWorldPos(PyMOLGlobals G){		float TextGetWorldPos(PyMOLGlobals G){
CText *I = G->Text;		CText *I = G->Text;
return I->WorldPos;		return I->WorldPos;
}		}

void TextSetScreenWorldOffset(PyMOLGlobals * G, float *pos)		void TextSetLabelPos(PyMOLGlobals * G, const float *pos)
		{
		CText *I = G->Text;
		copy3f(pos, I->LabelPos);
		}

		float TextGetLabelPos(PyMOLGlobals G)
		{
		CText *I = G->Text;
		return (I->LabelPos);
		}

		void TextSetLabelPosIsSet(PyMOLGlobals * G, unsigned char isSet)
		{
		CText *I = G->Text;
		I->LabelPosIsSet = isSet;
		}

		unsigned char TextGetLabelPosIsSet(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		return I->LabelPosIsSet;
		}

		void TextSetLabelPushPos(PyMOLGlobals * G, const float *pos)
		{
		CText *I = G->Text;
		copy3f(pos, I->LabelPushPos);
		}
		float TextGetLabelPushPos(PyMOLGlobals G){
		CText *I = G->Text;
		return I->LabelPushPos;
		}
		void TextSetScreenWorldOffset(PyMOLGlobals * G, const float *pos)
{		{
CText *I = G->Text;		CText *I = G->Text;
I->ScreenWorldOffset[0] = -pos[0];		I->ScreenWorldOffset[0] = -pos[0];
I->ScreenWorldOffset[1] = -pos[1];		I->ScreenWorldOffset[1] = -pos[1];
I->ScreenWorldOffset[2] = -pos[2];		I->ScreenWorldOffset[2] = -pos[2];
}		}
float TextGetScreenWorldOffset(PyMOLGlobals G){		float TextGetScreenWorldOffset(PyMOLGlobals G){
CText *I = G->Text;		CText *I = G->Text;
return I->ScreenWorldOffset;		return I->ScreenWorldOffset;
}		}

		void TextSetTargetPos(PyMOLGlobals * G, const float *pos){
		CText *I = G->Text;
		copy3f(pos, I->TargetPos);
		}
		float TextGetTargetPos(PyMOLGlobals G){
		CText *I = G->Text;
		return I->TargetPos;
		}

void TextDrawSubStrFast(PyMOLGlobals * G, const char *c, int x, int y, int start , int n ORTHOCGOARG)		void TextDrawSubStrFast(PyMOLGlobals * G, const char *c, int x, int y, int start , int n ORTHOCGOARG)
{		{
c += start;		c += start;
TextSetPos2i(G, x, y);		TextSetPos2i(G, x, y);
if(n)		if(n)
while(*c) {		while(*c) {
n--;		n--;
TextDrawChar(G, *(c++) ORTHOCGOARGVAR);		TextDrawChar(G, *(c++) ORTHOCGOARGVAR);
if(n <= 0)		if(n <= 0)

skipping to change at line 177		skipping to change at line 256

static void TextSetPos3f(PyMOLGlobals * G, float x, float y, float z)		static void TextSetPos3f(PyMOLGlobals * G, float x, float y, float z)
{		{
CText *I = G->Text;		CText *I = G->Text;
I->Pos[0] = x;		I->Pos[0] = x;
I->Pos[1] = y;		I->Pos[1] = y;
I->Pos[2] = z;		I->Pos[2] = z;
I->Pos[3] = 1.0F;		I->Pos[3] = 1.0F;
}		}


void TextSetColor(PyMOLGlobals * G, float *color)		void TextSetColor(PyMOLGlobals * G, const float *color)
{		{
CText *I = G->Text;		CText *I = G->Text;
copy3f(color, I->Color);		copy3f(color, I->Color);
I->Color[3] = 1.0F;		I->Color[3] = 1.0F;
I->Flat = false;		I->Flat = false;
TextUpdateUColor(I);		TextUpdateUColor(I);
}		}

void TextSetColor3f(PyMOLGlobals * G, float red, float green, float blue)		void TextSetColor3f(PyMOLGlobals * G, float red, float green, float blue)
{		{

skipping to change at line 201		skipping to change at line 280
I->Color[1] = green;		I->Color[1] = green;
I->Color[2] = blue;		I->Color[2] = blue;
I->Color[3] = 1.0F;		I->Color[3] = 1.0F;
TextUpdateUColor(I);		TextUpdateUColor(I);
}		}

void TextSetOutlineColor(PyMOLGlobals * G, int color)		void TextSetOutlineColor(PyMOLGlobals * G, int color)
{		{
CText *I = G->Text;		CText *I = G->Text;
if(color >= 0) {		if(color >= 0) {

float *fcolor = ColorGet(G, color);		const float *fcolor = ColorGet(G, color);
I->OutlineColor[0] = (unsigned char) (_255 * fcolor[0]);		I->OutlineColor[0] = (unsigned char) (_255 * fcolor[0]);
I->OutlineColor[1] = (unsigned char) (_255 * fcolor[1]);		I->OutlineColor[1] = (unsigned char) (_255 * fcolor[1]);
I->OutlineColor[2] = (unsigned char) (_255 * fcolor[2]);		I->OutlineColor[2] = (unsigned char) (_255 * fcolor[2]);
I->OutlineColor[3] = 0xFF;		I->OutlineColor[3] = 0xFF;
} else {		} else {
I->OutlineColor[3] = 0;		I->OutlineColor[3] = 0;
}		}
}		}

static const float _inv255 = 1.0F / 255.0F;		static const float _inv255 = 1.0F / 255.0F;

skipping to change at line 231		skipping to change at line 310
I->UColor[1] = ((unsigned char) ((index & 0xF0) \| 0x8));		I->UColor[1] = ((unsigned char) ((index & 0xF0) \| 0x8));
I->UColor[2] = ((unsigned char) ((index & 0xF00) >> 4));		I->UColor[2] = ((unsigned char) ((index & 0xF00) >> 4));
I->UColor[3] = 0xFF;		I->UColor[3] = 0xFF;

I->Color[0] = I->UColor[0] * _inv255;		I->Color[0] = I->UColor[0] * _inv255;
I->Color[1] = I->UColor[1] * _inv255;		I->Color[1] = I->UColor[1] * _inv255;
I->Color[2] = I->UColor[2] * _inv255;		I->Color[2] = I->UColor[2] * _inv255;
I->Color[3] = 1.0F;		I->Color[3] = 1.0F;
}		}


		void TextSetColorFromUColor(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		I->Color[0] = I->UColor[0] * _inv255;
		I->Color[1] = I->UColor[1] * _inv255;
		I->Color[2] = I->UColor[2] * _inv255;
		I->Color[3] = 1.0F;
		}

float TextGetPos(PyMOLGlobals G)		float TextGetPos(PyMOLGlobals G)
{		{
CText *I = G->Text;		CText *I = G->Text;
return I->Pos;		return I->Pos;
}		}


		float TextGetWidth(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		return I->Width;
		}

		float TextGetHeight(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		return I->Height;
		}

		void TextSetIndentFactorX(PyMOLGlobals * G, float factor){
		CText *I = G->Text;
		I->TextIndentFactor[0] = factor;
		}

		void TextSetIndentFactorY(PyMOLGlobals * G, float factor){
		CText *I = G->Text;
		I->TextIndentFactor[1] = factor;
		}
		float TextGetIndentFactor(PyMOLGlobals G){
		CText *I = G->Text;
		return I->TextIndentFactor;
		}

		void TextSetWidth(PyMOLGlobals * G, float text_width)
		{
		CText *I = G->Text;
		I->Width = text_width;
		}

		void TextSetHeight(PyMOLGlobals * G, float text_height)
		{
		CText *I = G->Text;
		I->Height = text_height;
		}

float TextGetColor(PyMOLGlobals G)		float TextGetColor(PyMOLGlobals G)
{		{
CText *I = G->Text;		CText *I = G->Text;
return I->Color;		return I->Color;
}		}


		unsigned char TextGetColorUChar4uv(PyMOLGlobals G){
		CText *I = G->Text;
		return I->UColor;
		}

void TextGetColorUChar(PyMOLGlobals * G, unsigned char *red,		void TextGetColorUChar(PyMOLGlobals * G, unsigned char *red,
unsigned char green, unsigned char blue, unsigned char *alpha)		unsigned char green, unsigned char blue, unsigned char *alpha)
{		{
CText *I = G->Text;		CText *I = G->Text;
*red = I->UColor[0];		*red = I->UColor[0];
*green = I->UColor[1];		*green = I->UColor[1];
*blue = I->UColor[2];		*blue = I->UColor[2];
*alpha = I->UColor[3];		*alpha = I->UColor[3];
}		}


skipping to change at line 265		skipping to change at line 396
unsigned char green, unsigned char blue, unsigned cha r *alpha)		unsigned char green, unsigned char blue, unsigned cha r *alpha)
{		{
CText *I = G->Text;		CText *I = G->Text;
*red = I->OutlineColor[0];		*red = I->OutlineColor[0];
*green = I->OutlineColor[1];		*green = I->OutlineColor[1];
*blue = I->OutlineColor[2];		*blue = I->OutlineColor[2];
*alpha = I->OutlineColor[3];		*alpha = I->OutlineColor[3];
}		}

const char TextRenderOpenGL(PyMOLGlobals G, RenderInfo * info, int text_id,		const char TextRenderOpenGL(PyMOLGlobals G, RenderInfo * info, int text_id,

const char st, float size, float rpos, CGO *shaderCGO)		const char st, float size, float rpos,
		short needSize, short relativeMode, short shouldRender,
		CGO *shaderCGO)
{		{
CText *I = G->Text;		CText *I = G->Text;
CFont *font;		CFont *font;
FontRenderOpenGLFn *fn;		FontRenderOpenGLFn *fn;
if((text_id < 0) \|\| (text_id >= I->NActive))		if((text_id < 0) \|\| (text_id >= I->NActive))
text_id = 0;		text_id = 0;

if(st && (*st)) {		if(st && (*st)) {
if((text_id >= 0) && (text_id < I->NActive)) {		if((text_id >= 0) && (text_id < I->NActive)) {

		if (I->Active[text_id].Font) {
font = I->Active[text_id].Font;		font = I->Active[text_id].Font;
if(I->Flat)		if(I->Flat)
fn = font->fRenderOpenGLFlat;		fn = font->fRenderOpenGLFlat;
else		else
fn = font->fRenderOpenGL;		fn = font->fRenderOpenGL;
if(fn)		if(fn)

return fn(info, font, st, size, rpos SHADERCGOARGVAR);		return fn(info, font, st, size, rpos, needSize, relativeMode, shouldRen
		der SHADERCGOARGVAR);
		}
}		}
/* make sure we got to end of string */		/* make sure we got to end of string */
if(*st)		if(*st)
while(*(st++));		while(*(st++));
}		}
return st;		return st;
}		}

void TextDrawStrAt(PyMOLGlobals * G, const char *st, int x, int y ORTHOCGOARG)		void TextDrawStrAt(PyMOLGlobals * G, const char *st, int x, int y ORTHOCGOARG)
{		{
CText *I = G->Text;		CText *I = G->Text;
TextSetPos3f(G, (float) x, (float) y, 0.0F);		TextSetPos3f(G, (float) x, (float) y, 0.0F);

TextRenderOpenGL(G, NULL, I->Default_ID, st, TEXT_DEFAULT_SIZE, NULL ORTHOCGOA RGVAR);		TextRenderOpenGL(G, NULL, I->Default_ID, st, TEXT_DEFAULT_SIZE, NULL, false, 0 , 1 ORTHOCGOARGVAR);
}		}

void TextDrawStr(PyMOLGlobals * G, const char *st ORTHOCGOARG)		void TextDrawStr(PyMOLGlobals * G, const char *st ORTHOCGOARG)
{		{
CText *I = G->Text;		CText *I = G->Text;

TextRenderOpenGL(G, NULL, I->Default_ID, st, TEXT_DEFAULT_SIZE, NULL ORTHOCGOA RGVAR);		TextRenderOpenGL(G, NULL, I->Default_ID, st, TEXT_DEFAULT_SIZE, NULL, false, 0 , 1 ORTHOCGOARGVAR);
}		}

void TextDrawChar(PyMOLGlobals * G, char ch ORTHOCGOARG)		void TextDrawChar(PyMOLGlobals * G, char ch ORTHOCGOARG)
{		{
char st[2] = { 0, 0 };		char st[2] = { 0, 0 };
CText *I = G->Text;		CText *I = G->Text;
st[0] = ch;		st[0] = ch;

TextRenderOpenGL(G, NULL, I->Default_ID, st, TEXT_DEFAULT_SIZE, NULL ORTHOCGOA RGVAR);		TextRenderOpenGL(G, NULL, I->Default_ID, st, TEXT_DEFAULT_SIZE, NULL, false, 0 , 1 ORTHOCGOARGVAR);
}		}

const char TextRenderRay(PyMOLGlobals G, CRay * ray, int text_id,		const char TextRenderRay(PyMOLGlobals G, CRay * ray, int text_id,

const char st, float size, float rpos)		const char st, float size, float rpos, short needSize, short relativeMode)
{		{
CText *I = G->Text;		CText *I = G->Text;
CFont *font;		CFont *font;
FontRenderRayFn *fn;		FontRenderRayFn *fn;

if((text_id < 0) \|\| (text_id >= I->NActive))		if((text_id < 0) \|\| (text_id >= I->NActive))
text_id = 0;		text_id = 0;

if(st && (*st)) {		if(st && (*st)) {
if((text_id >= 0) && (text_id < I->NActive)) {		if((text_id >= 0) && (text_id < I->NActive)) {
font = I->Active[text_id].Font;		font = I->Active[text_id].Font;
if(size >= 0.0F)		if(size >= 0.0F)
size *= ray->Magnified;		size *= ray->Magnified;

fn = font->fRenderRay;		fn = font->fRenderRay;
if(fn)		if(fn)

return fn(ray, font, st, size, rpos);		return fn(ray, font, st, size, rpos, needSize, relativeMode);
}		}
/* make sure we got to end of string */		/* make sure we got to end of string */
if(*st)		if(*st)
while(*(st++));		while(*(st++));
}		}
return st;		return st;
}		}

int TextInit(PyMOLGlobals * G)		int TextInit(PyMOLGlobals * G)
{		{
CText *I = NULL;		CText *I = NULL;
if((I = (G->Text = Calloc(CText, 1)))) {		if((I = (G->Text = Calloc(CText, 1)))) {

		int i = 0;
		for (; i < NFONTS; i++) {
		I->XHRFetched[i] = 0;
		I->XHRFailed[i] = 0;
		}

I->NActive = 0;		I->NActive = 0;
I->Active = VLACalloc(ActiveRec, 10);		I->Active = VLACalloc(ActiveRec, 10);
I->Default_ID = 0;		I->Default_ID = 0;
I->Flat = false;		I->Flat = false;

/* font 0 is old reliable GLUT 8x13 */		/* font 0 is old reliable GLUT 8x13 */

VLACheck(I->Active, ActiveRec, I->NActive);		VLACheck(I->Active, ActiveRec, I->NActive);
I->Active[I->NActive].Font = FontGLUTNew(G, cFontGLUT8x13);		I->Active[I->NActive].Font = FontGLUTNew(G, cFontGLUT8x13);

skipping to change at line 611		skipping to change at line 751
int a;		int a;
CFont *fp;		CFont *fp;
for(a = 0; a < I->NActive; a++) {		for(a = 0; a < I->NActive; a++) {
fp = I->Active[a].Font;		fp = I->Active[a].Font;
if(fp && fp->fFree)		if(fp && fp->fFree)
fp->fFree(fp);		fp->fFree(fp);
}		}
VLAFreeP(I->Active);		VLAFreeP(I->Active);
FreeP(G->Text);		FreeP(G->Text);
}		}

		float TextGetSpacing(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		return I->Spacing;
		}
		float TextGetJustification(PyMOLGlobals * G)
		{
		CText *I = G->Text;
		return I->Just;
		}
		float TextGetLabelBuffer(PyMOLGlobals G)
		{
		CText *I = G->Text;
		return I->LabelBuf;
		}

		/*
		* GUI elements like internal menus or the wizard prompt can handle text
		* color markup in the form "\\RGB" where RGB are three digits (0-9) or
		* "---" to reset the color.
		*
		* Return true if `p` starts with "\\RGB" or "\\---".
		*/
		bool TextStartsWithColorCode(const char *p)
		{
		if (p[0] != '\\') {
		return false;
		}

		if (p[1] == '-') {
		return p[2] == '-' && p[3] == '-';
		}

		return (
		('0' <= p[1] && p[1] <= '9') &&
		('0' <= p[2] && p[2] <= '9') &&
		('0' <= p[3] && p[3] <= '9'));
		}

		/*
		* Set text color from "\\RGB" code.
		*
		* "\\---" -> defaultcolor
		*
		* Return false if `p` does not start with a color code.
		*/
		bool TextSetColorFromCode(PyMOLGlobals * G,
		const char *p,
		const float *defaultcolor)
		{
		if (!TextStartsWithColorCode(p)) {
		return false;
		}

		if (p[1] == '-') {
		TextSetColor(G, defaultcolor);
		} else {
		TextSetColor3f(G,
		(p[1] - '0') / 9.0F,
		(p[2] - '0') / 9.0F,
		(p[3] - '0') / 9.0F);
		}

		return true;
		}

End of changes. 25 change blocks.
15 lines changed or deleted		157 lines changed or added

"Fossies" - the Fresh Open Source Software Archive

Source code changes of the file "layer1/Text.cpp" betweenpymol-v2.1.0.tar.bz2 and pymol-open-source-2.2.0.tar.gz

Source code changes of the file "layer1/Text.cpp" between
pymol-v2.1.0.tar.bz2 and pymol-open-source-2.2.0.tar.gz