"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "layer1/ScrollBar.cpp" between
pymol-open-source-2.2.0.tar.gz and pymol-open-source-2.3.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.

ScrollBar.cpp  (pymol-open-source-2.2.0)	:	ScrollBar.cpp  (pymol-open-source-2.3.0)
skipping to change at line 25		skipping to change at line 25
Z* -------------------------------------------------------------------		Z* -------------------------------------------------------------------
*/		*/
#include"os_gl.h"		#include"os_gl.h"
#include"Base.h"		#include"Base.h"
#include"Block.h"		#include"Block.h"
#include"OOMac.h"		#include"OOMac.h"
#include"Ortho.h"		#include"Ortho.h"
#include"ScrollBar.h"		#include"ScrollBar.h"
#include"CGO.h"		#include"CGO.h"
typedef struct CScrollBar {		bool ScrollBar::isMaxed() const
::Block *Block;
int HorV;
float BackColor[3];
float BarColor[3];
int ListSize;
int DisplaySize;
int BarSize;
int StartPos;
float ExactBarSize;
float Value;
float StartValue;
float ValueMax;
int BarRange;
int BarMin;
int BarMax;
int Grabbed;
} CScrollBar;
void ScrollBarMaxOut(struct CScrollBar *I)
{
I->Value = I->ValueMax;
}
int ScrollBarIsMaxed(struct CScrollBar *I)
{		{
if(I->ValueMax > 0.0F) {		if(m_ValueMax > 0.0F) {
if(I->Value == I->ValueMax)		return m_Value == m_ValueMax;
return true;
else
return false;
} else		} else
return false;		return false;
}		}
static void ScrollBarUpdate(struct CScrollBar *I)		void ScrollBar::update()
{		{
int range;		int range;
if(I->HorV) {		if(m_HorV) {
range = (I->Block->rect.right - I->Block->rect.left);		range = (rect.right - rect.left);
} else {		} else {
range = (I->Block->rect.top - I->Block->rect.bottom);		range = (rect.top - rect.bottom);
}		}
I->ExactBarSize = (range * I->DisplaySize) / (float) I->ListSize;		m_ExactBarSize = (range * m_DisplaySize) / static_cast<float>(m_ListSize);
I->BarSize = (int) (0.499F + I->ExactBarSize);		m_BarSize = static_cast<int> (0.499F + m_ExactBarSize);
if(I->BarSize < 4)		if(m_BarSize < 4)
I->BarSize = DIP2PIXEL(4);		m_BarSize = DIP2PIXEL(4);
I->BarRange = range - I->BarSize;		m_BarRange = range - m_BarSize;
if(I->BarRange < 2)		if(m_BarRange < 2)
I->BarRange = 2;		m_BarRange = 2;
I->ValueMax = (float) I->ListSize - I->DisplaySize;		m_ValueMax = static_cast<float>(m_ListSize - m_DisplaySize);
if(I->ValueMax < 1)		if(m_ValueMax < 1)
I->ValueMax = 1;		m_ValueMax = 1;
if(I->Value > I->ValueMax)		m_Value = pymol::clamp(m_Value, 0.0f, m_ValueMax);
I->Value = (float) I->ValueMax;
else if(I->Value < 0.0)
I->Value = 0.0F;
}		}
void ScrollBarFill(struct CScrollBar *I ORTHOCGOARG)		void ScrollBar::fill(CGO* orthoCGO)
{		{
if (orthoCGO)		if (orthoCGO)
CGOColorv(orthoCGO, I->BackColor);		CGOColorv(orthoCGO, BackColor);
		#ifndef PURE_OPENGL_ES_2
else		else
glColor3fv(I->BackColor);		glColor3fv(BackColor);
BlockFill(I->Block ORTHOCGOARGVAR);		#endif
}		Block::fill(orthoCGO);
static void ScrollBarDraw(Block * block ORTHOCGOARG)
{
ScrollBarDrawImpl(block, true ORTHOCGOARGVAR);
}		}
void ScrollBarDrawImpl(Block * block, short fill ORTHOCGOARG)		void ScrollBar::drawImpl(bool bFill, CGO* orthoCGO)
{		{
PyMOLGlobals *G = block->G;
float value;
int top, left, bottom, right;		int top, left, bottom, right;
CScrollBar *I = (CScrollBar *) block->reference;		if (bFill)
		fill(orthoCGO);
if (fill)		update();
ScrollBarFill(I ORTHOCGOARGVAR);
ScrollBarUpdate(I);		float value = std::min(m_Value, m_ValueMax);
value = I->Value;		if(m_HorV) {
if(value > I->ValueMax)		top = rect.top - 1;
value = I->ValueMax;		bottom = rect.bottom + 1;
		left = (int) (0.499F + rect.left + (m_BarRange * value) / m_ValueMax);
if(I->HorV) {		right = left + m_BarSize;
top = block->rect.top - 1;		m_BarMin = left;
bottom = block->rect.bottom + 1;		m_BarMax = right;
left = (int) (0.499F + block->rect.left + (I->BarRange * value) / I->ValueMa
x);
right = left + I->BarSize;
I->BarMin = left;
I->BarMax = right;
} else {		} else {
top = (int) (0.499F + block->rect.top - (I->BarRange * value) / I->ValueMax)		top = (int) (0.499F + rect.top - (m_BarRange * value) / m_ValueMax);
;		bottom = top - m_BarSize;
bottom = top - I->BarSize;		left = rect.left + 1;
left = block->rect.left + 1;		right = rect.right - 1;
right = block->rect.right - 1;		m_BarMin = top;
I->BarMin = top;		m_BarMax = bottom;
I->BarMax = bottom;
}		}
if(G->HaveGUI && G->ValidContext) {		if(m_G->HaveGUI && m_G->ValidContext) {
if (orthoCGO){		if (orthoCGO){
CGOColor(orthoCGO, 0.8F, 0.8F, 0.8F);		CGOColor(orthoCGO, 0.8F, 0.8F, 0.8F);
CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);		CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);
CGOVertex(orthoCGO, right, top, 0.f);		CGOVertex(orthoCGO, right, top, 0.f);
CGOVertex(orthoCGO, right, bottom + 1, 0.f);		CGOVertex(orthoCGO, right, bottom + 1, 0.f);
CGOVertex(orthoCGO, left, top, 0.f);		CGOVertex(orthoCGO, left, top, 0.f);
CGOVertex(orthoCGO, left, bottom + 1, 0.f);		CGOVertex(orthoCGO, left, bottom + 1, 0.f);
CGOEnd(orthoCGO);		CGOEnd(orthoCGO);
} else {		} else {
glColor3f(0.8F, 0.8F, 0.8F);		glColor3f(0.8F, 0.8F, 0.8F);
skipping to change at line 189		skipping to change at line 150
glColor3f(0.3F, 0.3F, 0.3F);		glColor3f(0.3F, 0.3F, 0.3F);
glBegin(GL_POLYGON);		glBegin(GL_POLYGON);
glVertex2i(right, bottom + 1);		glVertex2i(right, bottom + 1);
glVertex2i(right, bottom);		glVertex2i(right, bottom);
glVertex2i(left, bottom);		glVertex2i(left, bottom);
glVertex2i(left, bottom + 1);		glVertex2i(left, bottom + 1);
glEnd();		glEnd();
}		}
if (orthoCGO){		if (orthoCGO){
CGOColorv(orthoCGO, I->BarColor);		CGOColorv(orthoCGO, m_BarColor);
CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);		CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);
CGOVertex(orthoCGO, right - 1, top - 1, 0.f);		CGOVertex(orthoCGO, right - 1, top - 1, 0.f);
CGOVertex(orthoCGO, right - 1, bottom + 1, 0.f);		CGOVertex(orthoCGO, right - 1, bottom + 1, 0.f);
CGOVertex(orthoCGO, left + 1, top - 1, 0.f);		CGOVertex(orthoCGO, left + 1, top - 1, 0.f);
CGOVertex(orthoCGO, left + 1, bottom + 1, 0.f);		CGOVertex(orthoCGO, left + 1, bottom + 1, 0.f);
CGOEnd(orthoCGO);		CGOEnd(orthoCGO);
} else {		} else {
glColor3fv(I->BarColor);		glColor3fv(m_BarColor);
glBegin(GL_POLYGON);		glBegin(GL_POLYGON);
glVertex2i(right - 1, top - 1);		glVertex2i(right - 1, top - 1);
glVertex2i(right - 1, bottom + 1);		glVertex2i(right - 1, bottom + 1);
glVertex2i(left + 1, bottom + 1);		glVertex2i(left + 1, bottom + 1);
glVertex2i(left + 1, top - 1);		glVertex2i(left + 1, top - 1);
glEnd();		glEnd();
}		}
}		}
}		}
void ScrollBarDrawHandle(struct CScrollBar *I, float alpha ORTHOCGOARG)		void ScrollBar::drawHandle(float alpha, CGO* orthoCGO)
{		{
float value;		float value;
int top, left, bottom, right;		int top, left, bottom, right;
Block *block = I->Block;
PyMOLGlobals *G = block->G;
value = I->Value;		value = std::min(m_Value, m_ValueMax);
if(value > I->ValueMax)
value = I->ValueMax;		if(m_HorV) {
		top = rect.top - 1;
if(I->HorV) {		bottom = rect.bottom + 1;
top = block->rect.top - 1;		left = (int) (0.499F + rect.left + (m_BarRange * value) / m_ValueMax);
bottom = block->rect.bottom + 1;		right = left + m_BarSize;
left = (int) (0.499F + block->rect.left + (I->BarRange * value) / I->ValueMa
x);
right = left + I->BarSize;
} else {		} else {
top = (int) (0.499F + block->rect.top - (I->BarRange * value) / I->ValueMax)		top = (int) (0.499F + rect.top - (m_BarRange * value) / m_ValueMax);
;		bottom = top - m_BarSize;
bottom = top - I->BarSize;		left = rect.left + 1;
left = block->rect.left + 1;		right = rect.right - 1;
right = block->rect.right - 1;
}		}
if(G->HaveGUI && G->ValidContext) {		if(m_G->HaveGUI && m_G->ValidContext) {
glEnable(GL_BLEND);		glEnable(GL_BLEND);
if (orthoCGO){		if (orthoCGO){
CGOAlpha(orthoCGO, alpha);		CGOAlpha(orthoCGO, alpha);
CGOColor(orthoCGO, 0.8F, 0.8F, 0.8F);		CGOColor(orthoCGO, 0.8F, 0.8F, 0.8F);
CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);		CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);
CGOVertex(orthoCGO, right, top, 0.f);		CGOVertex(orthoCGO, right, top, 0.f);
CGOVertex(orthoCGO, right, bottom + 1, 0.f);		CGOVertex(orthoCGO, right, bottom + 1, 0.f);
CGOVertex(orthoCGO, left, top, 0.f);		CGOVertex(orthoCGO, left, top, 0.f);
CGOVertex(orthoCGO, left, bottom + 1, 0.f);		CGOVertex(orthoCGO, left, bottom + 1, 0.f);
skipping to change at line 296		skipping to change at line 253
glBegin(GL_POLYGON);		glBegin(GL_POLYGON);
glVertex2i(right, bottom + 1);		glVertex2i(right, bottom + 1);
glVertex2i(right, bottom);		glVertex2i(right, bottom);
glVertex2i(left, bottom);		glVertex2i(left, bottom);
glVertex2i(left, bottom + 1);		glVertex2i(left, bottom + 1);
glEnd();		glEnd();
}		}
if (orthoCGO){		if (orthoCGO){
CGOAlpha(orthoCGO, alpha);		CGOAlpha(orthoCGO, alpha);
CGOColor(orthoCGO, I->BarColor[0], I->BarColor[1], I->BarColor[2]);		CGOColor(orthoCGO, m_BarColor[0], m_BarColor[1], m_BarColor[2]);
CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);		CGOBegin(orthoCGO, GL_TRIANGLE_STRIP);
CGOVertex(orthoCGO, right - 1, top - 1, 0.f);		CGOVertex(orthoCGO, right - 1, top - 1, 0.f);
CGOVertex(orthoCGO, right - 1, bottom + 1, 0.f);		CGOVertex(orthoCGO, right - 1, bottom + 1, 0.f);
CGOVertex(orthoCGO, left + 1, top - 1, 0.f);		CGOVertex(orthoCGO, left + 1, top - 1, 0.f);
CGOVertex(orthoCGO, left + 1, bottom + 1, 0.f);		CGOVertex(orthoCGO, left + 1, bottom + 1, 0.f);
CGOEnd(orthoCGO);		CGOEnd(orthoCGO);
CGOAlpha(orthoCGO, 1.f);		CGOAlpha(orthoCGO, 1.f);
} else {		} else {
glColor4f(I->BarColor[0], I->BarColor[1], I->BarColor[2], alpha);		glColor4f(m_BarColor[0], m_BarColor[1], m_BarColor[2], alpha);
glBegin(GL_POLYGON);		glBegin(GL_POLYGON);
glVertex2i(right - 1, top - 1);		glVertex2i(right - 1, top - 1);
glVertex2i(right - 1, bottom + 1);		glVertex2i(right - 1, bottom + 1);
glVertex2i(left + 1, bottom + 1);		glVertex2i(left + 1, bottom + 1);
glVertex2i(left + 1, top - 1);		glVertex2i(left + 1, top - 1);
glEnd();		glEnd();
}		}
glDisable(GL_BLEND);		glDisable(GL_BLEND);
}		}
}		}
void ScrollBarSetValueNoCheck(struct CScrollBar *I, float value)		int ScrollBar::click(int button, int x, int y, int mod)
{
I->Value = value;
}
void ScrollBarSetValue(struct CScrollBar *I, float value)
{		{
I->Value = value > I->ValueMax ? I->ValueMax :		int grab = 0;
value < 0.0 ? 0.0 : value;
}
void ScrollBarMoveBy(struct CScrollBar *I, float value) {		if(button == P_GLUT_MIDDLE_BUTTON) {
ScrollBarSetValue(I, I->Value + value);		if(m_HorV) {
}		if(x < m_BarMin || x > m_BarMax)
		setValue((m_ListSize * (x - rect.left)) /
float ScrollBarGetValue(struct CScrollBar *I)		(rect.right - rect.left) - m_DisplaySize * 0.5F);
{		grab = x;
return (I->Value);
}
static void ScrollBarReshape(Block * block, int width, int height)
{
}
int ScrollBarGrabbed(struct CScrollBar *I)
{
return OrthoGrabbedBy(I->Block->G, I->Block);
}
static int ScrollBarClick(Block * block, int button, int x, int y, int mod)
{
PyMOLGlobals *G = block->G;
CScrollBar *I = (CScrollBar *) block->reference;
if(I->HorV) {
if(x > I->BarMax) {
switch (button) {
case P_GLUT_MIDDLE_BUTTON:
{
I->Value = (I->ListSize * (x - block->rect.left)) /
(block->rect.right - block->rect.left) - I->DisplaySize * 0.5F;
if(I->Value > I->ValueMax)
I->Value = I->ValueMax;
OrthoGrab(G, I->Block);
I->StartPos = x;
I->StartValue = I->Value;
}
break;
default:
I->Value += I->DisplaySize;
if(I->Value > I->ValueMax)
I->Value = I->ValueMax;
}
OrthoDirty(G);
} else if(x < I->BarMin) {
switch (button) {
case P_GLUT_MIDDLE_BUTTON:
{
I->Value = (I->ListSize * (x - block->rect.left)) /
(block->rect.right - block->rect.left) - I->DisplaySize * 0.5F;
if(I->Value < 0.0)
I->Value = 0.0F;
OrthoGrab(G, I->Block);
I->StartPos = x;
I->StartValue = I->Value;
}
break;
default:
I->Value -= I->DisplaySize;
if(I->Value < 0.0)
I->Value = 0.0F;
}
OrthoDirty(G);
} else {		} else {
OrthoGrab(G, I->Block);		if(y > m_BarMin || y < m_BarMax)
I->StartPos = x;		setValue((m_ListSize * (y - rect.top)) /
I->StartValue = I->Value;		(rect.bottom - rect.top) - m_DisplaySize * 0.5F);
OrthoDirty(G);		grab = y;
}		}
} else {		} else {
if(y > I->BarMin) {		if(m_HorV) {
switch (button) {		if(x > m_BarMax) {
case P_GLUT_MIDDLE_BUTTON:		m_Value += m_DisplaySize;
{		} else if(x < m_BarMin) {
I->Value = (I->ListSize * (y - block->rect.top)) /		m_Value -= m_DisplaySize;
(block->rect.bottom - block->rect.top) - I->DisplaySize * 0.5F;		} else {
if(I->Value < 0.0)		grab = x;
I->Value = 0.0F;
OrthoGrab(G, I->Block);
I->StartPos = y;
I->StartValue = I->Value;
}
break;
default:
I->Value -= I->DisplaySize;
if(I->Value < 0.0)
I->Value = 0.0F;
}		}
OrthoDirty(G);
} else if(y < I->BarMax) {
switch (button) {
case P_GLUT_MIDDLE_BUTTON:
{
I->Value = (I->ListSize * (y - block->rect.top)) /
(block->rect.bottom - block->rect.top) - I->DisplaySize * 0.5F;
if(I->Value > I->ValueMax)
I->Value = I->ValueMax;
OrthoGrab(G, I->Block);
I->StartPos = y;
I->StartValue = I->Value;
}
break;
default:
I->Value += I->DisplaySize;
if(I->Value > I->ValueMax)
I->Value = I->ValueMax;
}
OrthoDirty(G);
} else {		} else {
OrthoGrab(G, I->Block);		if(y > m_BarMin) {
I->StartPos = y;		m_Value -= m_DisplaySize;
I->StartValue = I->Value;		} else if(y < m_BarMax) {
OrthoDirty(G);		m_Value += m_DisplaySize;
		} else {
		grab = y;
		}
}		}
}		}
		if(grab) {
		OrthoGrab(m_G, this);
		m_StartPos = grab;
		m_StartValue = m_Value;
		}
		OrthoDirty(m_G);
return 0;		return 0;
}		}
static int ScrollBarDrag(Block * block, int x, int y, int mod)		int ScrollBar::drag(int x, int y, int mod)
{		{
PyMOLGlobals *G = block->G;
CScrollBar *I = (CScrollBar *) block->reference;
int displ;		int displ;
if(I->HorV)		if(m_HorV)
displ = I->StartPos - x;		displ = m_StartPos - x;
else		else
displ = y - I->StartPos;		displ = y - m_StartPos;
ScrollBarSetValue(I, I->StartValue - (I->ValueMax * displ) / I->BarRange);		setValue(m_StartValue - (m_ValueMax * displ) / m_BarRange);
OrthoDirty(G);		OrthoDirty(m_G);
return true;		return true;
}		}
static int ScrollBarRelease(Block * block, int button, int x, int y, int mod)		int ScrollBar::release(int button, int x, int y, int mod)
{		{
PyMOLGlobals *G = block->G;		OrthoUngrab(m_G);
OrthoUngrab(G);		OrthoDirty(m_G);
OrthoDirty(G);
return 0;		return 0;
}		}
Block *ScrollBarGetBlock(struct CScrollBar * I)		void ScrollBar::setLimits(int list_size, int display_size)
{
return (I->Block);
}
void ScrollBarSetLimits(struct CScrollBar *I, int list_size, int display_size)
{
I->ListSize = list_size;
I->DisplaySize = display_size;
ScrollBarUpdate(I);
}
void ScrollBarSetBox(struct CScrollBar *I, int top, int left, int bottom, int ri
ght)
{
I->Block->rect.top = top;
I->Block->rect.left = left;
I->Block->rect.bottom = bottom;
I->Block->rect.right = right;
}
void ScrollBarDoDraw(struct CScrollBar *I ORTHOCGOARG)
{
if(I->Block->fDraw)
I->Block->fDraw(I->Block ORTHOCGOARGVAR);
}
void ScrollBarDoDrawNoFill(struct CScrollBar *I ORTHOCGOARG)
{
ScrollBarDrawImpl(I->Block, false ORTHOCGOARGVAR);
}
void ScrollBarDoRelease(struct CScrollBar *I, int button, int x, int y, int mod)
{
if(I->Block->fRelease)
I->Block->fRelease(I->Block, button, x, y, mod);
}
void ScrollBarDoDrag(struct CScrollBar *I, int x, int y, int mod)
{		{
if(I->Block->fDrag)		m_ListSize = list_size;
I->Block->fDrag(I->Block, x, y, mod);		m_DisplaySize = display_size;
}		update();
void ScrollBarDoClick(struct CScrollBar *I, int button, int x, int y, int mod)
{
if(I->Block->fClick)
I->Block->fClick(I->Block, button, x, y, mod);
}
struct CScrollBar *ScrollBarNew(PyMOLGlobals * G, int horizontal)
{
OOAlloc(G, CScrollBar)
I->Block = OrthoNewBlock(G, NULL);
I->Block->fRelease = ScrollBarRelease;
I->Block->fClick = ScrollBarClick;
I->Block->fDrag = ScrollBarDrag;
I->Block->fDraw = ScrollBarDraw;
I->Block->fReshape = ScrollBarReshape;
I->Block->active = false;
I->Block->reference = (void *) I;
I->HorV = horizontal;
I->BackColor[0] = 0.1F;
I->BackColor[1] = 0.1F;
I->BackColor[2] = 0.1F;
I->BarColor[0] = 0.5F;
I->BarColor[1] = 0.5F;
I->BarColor[2] = 0.5F;
I->ListSize = 10;
I->DisplaySize = 7;
I->Value = 0.0F;
I->ValueMax = 0.0F;
return (I);
}		}
void ScrollBarFree(struct CScrollBar *I)		void ScrollBar::setBox(int top, int left, int bottom, int right)
{		{
PyMOLGlobals *G = I->Block->G;		rect.top = top;
OrthoFreeBlock(G, I->Block);		rect.left = left;
OOFreeP(I);		rect.bottom = bottom;
		rect.right = right;
}		}
End of changes. 44 change blocks.
314 lines changed or deleted		113 lines changed or added

---