Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/glbitmapfont_8cpp_source.html below:

NCBI C++ ToolKit: src/gui/opengl/glbitmapfont.cpp Source File

rk1.

< rk2.

;

((

*)iter->second->name);

(

= 0;

< iter->second->num_chars; ++

) {

(iter->second->ch[

]) {

[] iter->second->ch[

]->bitmap;

[] iter->second->ch[

];

[] iter->second->ch;

(iter->first == font) {

}

(iter->first != font) {

(iter->first & 0xff);

(this_face == face) {

back != sc_FontMap.begin() &&

forward != sc_FontMap.end(); ) {

(back != sc_FontMap.begin()) {

(back->first & 0xff);

(this_face == face) {

(forward != sc_FontMap.end()) {

(forward->first & 0xff);

(this_face == face) {

forward->second;

);

(c < font_ptr->

||

font_ptr->

[c - font_ptr->

];

ch? ch->

: 0.0;

(

charidx = 0; charidx < source_font->

; ++charidx) {

row_len = (orig_ch->

+ 7) / 8;

new_row_len = (orig_ch->

+ 7) / 8;

GLubyte*

=

GLubyte[new_row_len * orig_ch->

];

memset(

, 0, new_row_len * orig_ch->

* sizeof (GLubyte));

(

= 0;

< new_char->

;

++) {

(j = 0; j < new_row_len; j++) {

GLubyte *

=

+

* new_row_len + j;

max_k =

(8, new_char->

- j*8);

(k = 0; k < max_k; k++){

src_row = orig_ch->

- j * 8 - k - 1;

src_byte = src_bit / 8 + row_len * src_row;

src_bit_off = src_bit % 8;

(orig_ch->

[src_byte] & (0x80 >> src_bit_off)){

row_len = (orig_ch->

+ 7) / 8;

GLubyte*

=

GLubyte[row_len * orig_ch->

];

memset(

, 0, row_len * orig_ch->

* sizeof (GLubyte));

(

= 0;

< new_char->

;

++) {

(j = 0; j < row_len; j++) {

GLubyte *

=

+

* row_len + j;

max_k =

(8, new_char->

- j*8);

(k = 0; k < max_k; k++){

src_row = orig_ch->

-

- 1;

src_bit = orig_ch->

- j * 8 - k - 1;

src_byte = src_bit / 8 + row_len * src_row;

src_bit_off = src_bit % 8;

(orig_ch->

[src_byte] & (0x80 >> src_bit_off)){

row_len = (orig_ch->

+ 7) / 8;

new_row_len = (orig_ch->

+ 7) / 8;

GLubyte*

=

GLubyte[new_row_len * orig_ch->

];

memset(

, 0, new_row_len * new_char->

* sizeof (GLubyte));

(

= 0;

< new_char->

;

++) {

(j = 0; j < new_row_len; j++) {

GLubyte *

=

+

* new_row_len + j;

max_k =

(8, new_char->

- j*8);

(k = 0; k < max_k; k++){

src_row = j * 8 + k;

src_bit = orig_ch->

-

- 1;

src_byte = src_bit / 8 + row_len * src_row;

src_bit_off = src_bit % 8;

(orig_ch->

[src_byte] & (0x80 >> src_bit_off)){

new_char->

= orig_ch->

+ (GLfloat)cap_ht;

[charidx] = new_char;

* name =

;

name =

((

(source_font->

) +

).c_str());

name =

((

(source_font->

) +

).c_str());

name =

((

(source_font->

) +

).c_str());

name =

((

(source_font->

) +

).c_str());

name =

((

(source_font->

) +

).c_str());

name =

((

(source_font->

) +

).c_str());

new_font->

= name;

ch ? ch->

: 0.0;

ch ? ch->

: 0.0;

(

charidx = 0; charidx < font_ptr->

; ++charidx) {

: m_Font(eBitmap8x13)

, m_FontRotate(eFontRotate_0)

, m_Condensed(

)

, m_FontRotate(eFontRotate_0)

, m_Condensed(

)

faces.push_back(iter->second);

sizes.push_back(iter->second);

(iter != sc_FaceMap.end()) {

(

== iter->second) {

(iter != sc_SizeMap.end()) {

(

== iter->second) {

s_face, s_size;

(face != 0 &&

!= 0) {

<

TOutputMethod>

glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);

glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);

glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);

glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);

glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);

glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);

glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);

glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);

glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);

glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);

glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);

glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);

glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);

glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);

glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);

(

* p =

; p && *p; ++p) {

x_adv = ch->

+ 1.0;

x_adv = -ch->

- 1.0;

x_orig = ch->

;

y_adv = ch->

+ 1.0;

y_adv = -ch->

- 1.0;

(GLfloat)x_orig, (GLfloat)y_orig,

(GLfloat)x_adv, (GLfloat)y_adv, ch->

);

glGetIntegerv(GL_RENDER_MODE, &

);

glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);

glGetFloatv(GL_CURRENT_RASTER_COLOR, col);

vector<float> TFList;

(TFList, it, vectext) {

vector<CRgbaColor*>*

,

(

* p =

; p && *p; ++p) {

off_x = ch->

* k_x;

off_y = ch->

* k_y;

(

* p =

; p && *p; ++p) {

(*p < m_FontPtr->

||

glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);

glGetFloatv(GL_CURRENT_RASTER_COLOR, col);

vector<float> TFList;

(TFList, it, vectext) {

vector<CRgbaColor*>*

,

glGetIntegerv(GL_RENDER_MODE, &

);

scale_x, scale_y, font_ptr);

ras_x = x + (w - text_wid);

ras_x = x + (w - text_wid) * 0.5;

ras_y = y + (h - text_ht);

ras_y = y + (h - text_ht) * 0.5;

ras_y = y + (h - text_wid);

ras_y = y + (h - text_wid) * 0.5;

ras_x = x + w - text_ht;

ras_x = x - text_ht;

ras_x = x + (w + text_ht) * 0.5;

ras_x = x + (w - text_ht) * 0.5;

ras_x = x + text_wid;

ras_x = x + w - (w - text_wid) * 0.5;

ras_y = y - text_ht;

ras_y = y + (h - text_ht);

ras_y = y + (h + text_ht) * 0.5;

ras_y = y + (h - text_ht) * 0.5;

ras_y = y + text_wid;

ras_y = y + (h + text_wid) * 0.5f;

ras_x = x + text_ht;

ras_x = x + (w - text_ht);

ras_x = x + (w - text_ht) * 0.5f;

ras_x = x + (w + text_ht) * 0.5f;

*

,

text_len)

* sc_caps =

;

(

* p = sc_caps; p && *p; ++p) {

max_ht =

(max_ht, ht);

(

= font_ptr->

; i < font_ptr->num_chars; ++

) {

max_ht =

(max_ht, ht);

(

= font_ptr->

; i < font_ptr->num_chars; ++

) {

wid / float(

);

(

= font_ptr->

; i < font_ptr->num_chars; ++

) {

* p =

;

( ; text_len && p && *p; ++p, --text_len) {

*p =

;

( ; text_len && p && *p; ++p, --text_len) {

*

)

* sc_ellipsis =

;

* ellip =

;

* end_pos =

;

end_pos =

+ pos;

ellip = sc_ellipsis;

(end_pos >

) {

( ; end_pos && *end_pos && w >= 0; ++end_pos) {

(end_pos <

) {

->assign(

, end_pos);

(

)(end_pos -

);

bNegative = Number < 0;

Number =

(Number);

s_number, s_postfix;

(Number != 0 && b_postfix) {

Rest = Number % 1000;

( i_postfix = 0; Rest == 0; i_postfix++) {

Number = Number / 1000;

Rest = Number % 1000;

sTemplGroup[] =

;

sTemplGroup[0] = cSep;

sTemplLast[] =

;

Rest = Number % 1000;

Number = Number / 1000;

sprintf(

, Number ? sTemplGroup : sTemplLast, Rest);

s_number =

(

) + s_number;

s_number += s_postfix;

s_number =

+ s_number;

MaxDigits = (

) ceil(

((

) Number));

nSep = (MaxDigits - 1) / 3;

MaxDigits + nSep;

max_dig_w = 0;

(

c =

; c <=

; c++) {

max_dig_w =

(max_dig_w, char_w);

=

(max_num);

commas_count = (digits_count - 1) / 3;

w = digits_count * max_dig_w + commas_count * comma_w;

glRasterPos2d(x, y);

glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);

GLdouble modelview_matrix[16];

GLdouble projection_matrix[16];

glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix);

glGetDoublev(GL_PROJECTION_MATRIX, projection_matrix);

glGetIntegerv(GL_VIEWPORT, viewport);

GLdouble wx, wy, wz;

modelview_matrix, projection_matrix, viewport,

GLdouble unprojected_center_x = 0;

GLdouble unprojected_center_y = 0;

GLdouble unprojected_center_z = 0;

GLdouble centerx = viewport[0] + (viewport[2]-viewport[0])/2.0;

GLdouble centery = viewport[1] + (viewport[3]-viewport[1])/2.0;

modelview_matrix, projection_matrix, viewport,

&unprojected_center_x, &unprojected_center_y, &unprojected_center_z);

glRasterPos2d(unprojected_center_x, unprojected_center_y);

GLfloat deltax = (GLfloat)(wx-centerx);

GLfloat deltay = (GLfloat)(wy-centery);

deltax, deltay,

);

const BitmapFontRec *const & m_FontPtr

CFeedbackTextArrayPrinter(const char *text, TModelUnit x, TModelUnit y, TModelUnit dx, TModelUnit dy, TModelUnit scale_x, TModelUnit scale_y, const BitmapFontRec *const &font_ptr)

class CRgbaColor provides a simple abstraction for managing colors.

class CStaticArrayMap<> is an array adaptor that provides an STLish interface to statically-defined a...

TBase::const_iterator const_iterator

const vector< CRgbaColor * > * m_Colors

CTextArrayPrinter(const char *text, const vector< CRgbaColor * > *colors, TModelUnit x, TModelUnit y, TModelUnit dx, TModelUnit dy, TModelUnit scale_x, TModelUnit scale_y, CGlBitmapFont *font)

const BitmapFontRec *const m_FontPtr

const CGlBitmapFont::EFontRotate m_FontRotate

CTextPrinter(const char *text, const BitmapFontRec *font_ptr, CGlBitmapFont::EFontRotate rot, bool condensed=false)

container_type::iterator iterator

const_iterator end() const

const_iterator find(const key_type &key) const

static const Colors colors

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static const char * str(char *buf, int n)

static const BitmapFontRec *const sc_ncbi_fixed_18_ptr

static const BitmapFontRec *const sc_ncbi_lucida_18_ptr

static const BitmapFontRec *const sc_ncbi_lucida_8_ptr

static const BitmapFontRec *const sc_ncbi_helvetica_10_ptr

static const BitmapFontRec *const sc_ncbi_lucida_12_ptr

static TModelUnit s_GetCharBitmapWidth(char c, const BitmapFontRec *font_ptr)

static TModelUnit s_GetCharAdvance(char c, const BitmapFontRec *font_ptr)

static const BitmapFontRec *const sc_ncbi_helvetica_12_ptr

map< SRotateKey, const BitmapFontRec *, SRotateKeyLess > TRotatedFontCache

static const BitmapFontRec *const sc_ncbi_times_12_ptr

static const BitmapFontRec *const sc_ncbi_fixed_8_ptr

static const BitmapFontRec *const sc_ncbi_courier_8_ptr

static const BitmapFontRec *const s_FindFontPtr(CGlBitmapFont::EFont font)

static const BitmapFontRec *const sc_ncbi_clean_6_ptr

static const BitmapFontRec *const sc_ncbi_clean_16_ptr

SStaticPair< CGlBitmapFont::EFont, const BitmapFontRec * > TFontPair

static const BitmapFontRec *const sc_ncbi_helvetica_14_ptr

static const BitmapFontRec *const sc_ncbi_clean_12_ptr

static const char * kPostfixes[]

static SRotatedFontCachePurger s_FontCachePurger

static const BitmapFontRec *const sc_ncbi_helvetica_6_ptr

static const BitmapFontRec *const sc_ncbi_helvetica_18_ptr

static const BitmapFontRec *const sc_ncbi_clean_10_ptr

static TModelUnit s_GetCharDescender(char c, const BitmapFontRec *font_ptr)

static const BitmapFontRec *const sc_ncbi_times_8_ptr

static const BitmapFontRec *const sc_ncbi_helvetica_24_ptr

static const BitmapFontRec *const sc_ncbi_times_10_ptr

static const BitmapFontRec *const sc_ncbi_courier_20_ptr

static const BitmapFontRec *const sc_ncbi_lucida_6_ptr

CStaticPairArrayMap< CGlBitmapFont::EFont, const BitmapFontRec * > TFontMap

static const BitmapFontRec *const sc_ncbi_times_14_ptr

static const BitmapFontRec *const sc_ncbi_helvetica_8_ptr

static const BitmapFontRec *const sc_ncbi_times_24_ptr

CStaticPairArrayMap< CGlBitmapFont::EFontFace, const char * > TFaceMap

static const BitmapFontRec *const s_GetFont(CGlBitmapFont::EFont font, CGlBitmapFont::EFontRotate rot)

static TModelUnit s_GetCharWidth(char c, const BitmapFontRec *font_ptr)

static const BitmapFontRec *const sc_ncbi_lucida_24_ptr

DEFINE_STATIC_ARRAY_MAP(TFontMap, sc_FontMap, sc_Fonts)

SStaticPair< CGlBitmapFont::EFontFace, const char * > TFaceElem

static const BitmapFontRec *const sc_ncbi_courier_14_ptr

static const BitmapFontRec *const sc_ncbi_times_18_ptr

void DoTextOut(TOutputMethod &method)

static const BitmapCharRec * s_GetCharPtr(const BitmapFontRec *font_ptr, int c)

static const BitmapFontRec *const sc_ncbi_courier_18_ptr

static const BitmapFontRec *const sc_ncbi_helvetica_20_ptr

CStaticPairArrayMap< CGlBitmapFont::EFontSize, const char * > TSizeMap

static const BitmapFontRec *const sc_ncbi_fixed_10_ptr

static const BitmapFontRec *const sc_ncbi_lucida_20_ptr

static const BitmapFontRec *const sc_ncbi_clean_15_ptr

static const BitmapFontRec *const sc_ncbi_fixed_12_ptr

static const BitmapFontRec *const sc_ncbi_courier_10_ptr

static const BitmapFontRec *const sc_ncbi_clean_8_ptr

static const BitmapFontRec *const sc_ncbi_lucida_14_ptr

static const TSizeElem sc_SizeTagArray[]

static const BitmapFontRec *const sc_ncbi_courier_24_ptr

static const BitmapFontRec *const sc_ncbi_clean_13_ptr

SStaticPair< CGlBitmapFont::EFontSize, const char * > TSizeElem

static const BitmapFontRec *const sc_ncbi_courier_6_ptr

static const BitmapFontRec *const sc_ncbi_times_6_ptr

static const TFaceElem sc_FaceTagArray[]

#define NCBI_FONT(x)

Standard non-rotated fonts; the explicit sc_foo_ptr business works around a bug in ICC 9,...

static TModelUnit s_GetFontDescender(const BitmapFontRec *font_ptr)

static const BitmapFontRec *const sc_ncbi_courier_12_ptr

static TRotatedFontCache s_RotatedCache

static TModelUnit s_GetCapHeight(const BitmapFontRec *font_ptr)

static const BitmapFontRec *const sc_ncbi_fixed_14_ptr

static const BitmapFontRec *const sc_ncbi_times_20_ptr

static const TFontPair sc_Fonts[]

static const BitmapFontRec *const sc_ncbi_lucida_10_ptr

static const BitmapFontRec * s_CreateRotatedFont(const BitmapFontRec *source_font, CGlBitmapFont::EFontRotate rot)

create a rotated font

static const BitmapFontRec *const sc_ncbi_fixed_20_ptr

static const BitmapFontRec *const sc_ncbi_clean_14_ptr

const BitmapFontRec ncbi_lucida_6

const BitmapFontRec ncbi_courier_20

const BitmapFontRec ncbi_clean_13

const BitmapFontRec ncbi_lucida_24

const BitmapFontRec ncbi_courier_12

const BitmapFontRec ncbi_fixed_8

const BitmapFontRec ncbi_courier_14

const BitmapFontRec ncbi_helvetica_8

const BitmapFontRec ncbi_clean_16

const BitmapFontRec ncbi_clean_6

const BitmapFontRec ncbi_fixed_10

const BitmapFontRec ncbi_clean_12

const BitmapFontRec ncbi_clean_14

const BitmapFontRec ncbi_helvetica_20

const BitmapFontRec ncbi_clean_15

const BitmapFontRec ncbi_fixed_18

const BitmapFontRec ncbi_fixed_20

const BitmapFontRec ncbi_helvetica_10

const BitmapFontRec ncbi_times_14

const BitmapFontRec ncbi_times_18

const BitmapFontRec ncbi_lucida_18

const BitmapFontRec ncbi_courier_6

const BitmapFontRec ncbi_fixed_14

const BitmapFontRec ncbi_helvetica_6

const BitmapFontRec ncbi_times_24

const BitmapFontRec ncbi_lucida_20

const BitmapFontRec ncbi_helvetica_12

const BitmapFontRec ncbi_helvetica_14

const BitmapFontRec ncbi_lucida_12

const BitmapFontRec ncbi_courier_8

const BitmapFontRec ncbi_courier_24

const BitmapFontRec ncbi_courier_18

const BitmapFontRec ncbi_clean_10

const BitmapFontRec ncbi_lucida_8

const BitmapFontRec ncbi_times_6

const BitmapFontRec ncbi_lucida_10

const BitmapFontRec ncbi_times_20

const BitmapFontRec ncbi_times_10

const BitmapFontRec ncbi_lucida_14

const BitmapFontRec ncbi_times_12

const BitmapFontRec ncbi_helvetica_18

const BitmapFontRec ncbi_courier_10

const BitmapFontRec ncbi_helvetica_24

const BitmapFontRec ncbi_times_8

const BitmapFontRec ncbi_clean_8

const BitmapFontRec ncbi_fixed_12

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

#define NCBI_THROW2(exception_class, err_code, message, extra)

Throw exception with extra parameter.

int gluProjectX(GLdouble objx, GLdouble objy, GLdouble objz, const GLdouble modelMatrix[16], const GLdouble projMatrix[16], const GLint viewport[4], GLdouble *winx, GLdouble *winy, GLdouble *winz)

static TModelUnit GetMaxWidth(int max_num, const CGlBitmapFont &font)

returns minimal space sufficient to render any number in the range [0, max_num].

bool IsCondensed(void) const

static void SetRasterPosSafe(TModelUnit x, TModelUnit y)

static string SizeToString(EFontSize size)

static EFontSize SizeFromInt(int i)

virtual void TextOut(const char *text) const

string Truncate(const char *, TModelUnit w, ETruncate trunc=eTruncate_Ellipsis) const

static void GetAllSizes(vector< string > &sizes)

void SetFontSize(EFontSize size)

int x_Truncate(const char *text, TModelUnit w, ETruncate trunc, string *str=NULL) const

EFontRotate m_FontRotate

The font - combination of face and size.

static string FaceToString(EFontFace face)

TModelUnit GetAdvance(char c) const

void SetFontRotate(EFontRotate rot)

static int GetCharsCount(int number)

returns number of characters in symbolic representation of the given number including non-digit separ...

static vector< float > EncodeText(GLfloat pos[4], const CRgbaColor &color, const char *text, size_t length)

static string FormatSeparatedNumber(int number, bool b_postfix=false)

virtual TModelUnit GetMetric(EMetric metric, const char *text_start=NULL, int len=-1) const

virtual TModelUnit TextHeight(void) const

compute the height of a string

static EFontFace FaceFromString(const string &str)

EFontRotate GetFontRotate(void) const

EFontFace GetFontFace() const

const void * GetFontPtr() const

virtual TModelUnit TextWidth(const char *text) const

compute the length of a null-terminated string

void FromString(const string &value)

bool m_Condensed

rotation state of the font

void glColorC(const CRgbaColor &color)

CGlBitmapFont & operator=(const CGlBitmapFont &)

void ArrayTextOut(TModelUnit x, TModelUnit y, TModelUnit dx, TModelUnit dy, const char *text, const vector< CRgbaColor * > *colors=NULL, TModelUnit scale_x=1.0f, TModelUnit scale_y=1.0f) const

prints array of characters in positions (x + i*dx, y + i*dy) where "i" is index of a character in the...

static EFontSize SizeFromString(const string &str)

void SetFontFace(EFontFace face)

void SetCondensed(bool condensed)

EFontSize GetFontSize() const

virtual TModelUnit GetFontDescender() const

int gluUnProjectX(GLdouble winx, GLdouble winy, GLdouble winz, const GLdouble modelMatrix[16], const GLdouble projMatrix[16], const GLint viewport[4], GLdouble *objx, GLdouble *objy, GLdouble *objz)

static void GetAllFaces(vector< string > &faces)

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

static bool SplitInTwo(const CTempString str, const CTempString delim, string &str1, string &str2, TSplitFlags flags=0)

Split a string into two pieces using the specified delimiters.

static string TruncateSpaces(const string &str, ETrunc where=eTrunc_Both)

Truncate whitespace in a string.

unsigned int

A callback function used to compare two keys in a database.

static void text(MDB_val *v)

const struct ncbi::grid::netcache::search::fields::SIZE size

const GenericPointer< typename T::ValueType > T2 value

static const BitmapCharRec *const chars[]

const BitmapCharRec *const * ch

bool operator()(const SRotateKey &rk1, const SRotateKey &rk2) const

rotated versions of the above we store a cache of these that is generated on the fly these fonts are ...

const BitmapFontRec * font

non-rotated font

CGlBitmapFont::EFontRotate rot

rotation type

~SRotatedFontCachePurger()

Template structure SStaticPair is simlified replacement of STL pair<> Main reason of introducing this...

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4