├── .gitattributes
├── source
    ├── options.txt
    ├── uniCorpus.txt
    ├── main.h
    ├── PosChart.h
    ├── ValidChar.h
    ├── openGL.h
    ├── enums.h
    ├── Button.h
    ├── main.cpp
    ├── ButtonSet.h
    ├── MouseStatus.h
    ├── Keyboard.h
    ├── Predictor.h
    ├── DiskPart.h
    ├── Trie.h
    ├── KeyMain.h
    └── Drawer.h
├── SliceType.zip
└── README.md


/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto
2 | 
3 | *.zip binary
4 | 


--------------------------------------------------------------------------------
/source/options.txt:
--------------------------------------------------------------------------------
1 | Select Time (ms):
2 | 1000
3 | Animation Time (ms):
4 | 250


--------------------------------------------------------------------------------
/SliceType.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bbenligiray/slicetype/HEAD/SliceType.zip


--------------------------------------------------------------------------------
/source/uniCorpus.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bbenligiray/slicetype/HEAD/source/uniCorpus.txt


--------------------------------------------------------------------------------
/source/main.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAIN_H
 2 | #define MAIN_H
 3 | 
 4 | #include "openGL.h"
 5 | #include "KeyMain.h"
 6 | 
 7 | void runMainLoop(int val);
 8 | void update();
 9 | void render();
10 | 
11 | void handleMousePos(int x, int y);
12 | void handleMouseClick(int button, int state, int x, int y);
13 | void handleKeys(unsigned char key, int x, int y);
14 | 
15 | KeyMain kbMain;
16 | 
17 | using std::string;
18 | using std::cout;
19 | using std::endl;
20 | 
21 | 
22 | #endif


--------------------------------------------------------------------------------
/source/PosChart.h:
--------------------------------------------------------------------------------
 1 | #ifndef POSCHART_H
 2 | #define POSCHART_H
 3 | 
 4 | #include <algorithm>
 5 | #include <vector>
 6 | 
 7 | using std::fill_n;
 8 | using std::vector;
 9 | 
10 | class PosChart
11 | {
12 | 	vector<int> loop0;
13 | 	vector<int> loop1;
14 | 	vector<int> loop2;
15 | public:
16 | 	PosChart();
17 | 	void fillPos(int loop, int row);
18 | 	const vector<int>& PosChart::getLoop(int loop) const;
19 | };
20 | 
21 | 
22 | 
23 | PosChart::PosChart()
24 | {
25 | 	//initialize all elements with 0
26 | 	loop0 = vector<int>(2, 0);
27 | 	loop1 = vector<int>(12, 0);
28 | 	loop2 = vector<int>(12, 0);
29 | }
30 | 
31 | void PosChart::fillPos(int loop, int row)
32 | {
33 | 	switch (loop)
34 | 	{
35 | 	case 0:
36 | 		loop0[row] = 1;
37 | 		break;
38 | 	case 1:
39 | 		loop1[row] = 1;
40 | 		break;
41 | 	case 2:
42 | 		loop2[row] = 1;
43 | 		break;
44 | 	}
45 | }
46 | 
47 | const vector<int>& PosChart::getLoop(int loop) const
48 | {
49 | 	switch (loop)
50 | 	{
51 | 	case 0:
52 | 		return loop0;
53 | 	case 1:
54 | 		return loop1;
55 | 	case 2:
56 | 		return loop2;
57 | 	}
58 | }
59 | 
60 | #endif


--------------------------------------------------------------------------------
/source/ValidChar.h:
--------------------------------------------------------------------------------
 1 | #ifndef VALIDCHAR_H
 2 | #define VALIDCHAR_H
 3 | 
 4 | #include <string>
 5 | 
 6 | using std::string;
 7 | 
 8 | //holds a char and its matching prediction
 9 | class ValidChar
10 | {
11 | 	char character;
12 | 	string prediction;
13 | 	unsigned int freq;
14 | public:
15 | 	ValidChar();
16 | 	ValidChar(char ch, string str, unsigned int fq);
17 | 	const char ValidChar::getChar() const;
18 | 	const string& getString() const;
19 | 	const unsigned int getFreq() const;
20 | 	void updatePred(string newPred, unsigned int newFreq);
21 | 	string getPrediction();
22 | };
23 | 
24 | ValidChar::ValidChar()
25 | {
26 | 	character = ' ';
27 | 	prediction = "";
28 | 	freq = 0;
29 | }
30 | 
31 | ValidChar::ValidChar(char ch, string str, unsigned int fq)
32 | {
33 | 	character = ch;
34 | 	prediction = str;
35 | 	freq = fq;
36 | }
37 | 
38 | const char ValidChar::getChar() const
39 | {
40 | 	return character;
41 | }
42 | const string& ValidChar::getString() const
43 | {
44 | 	return prediction;
45 | }
46 | const unsigned int ValidChar::getFreq() const
47 | {
48 | 	return freq;
49 | }
50 | void ValidChar::updatePred(string newPred, unsigned int newFreq)
51 | {
52 | 	prediction = newPred;
53 | 	freq = newFreq;
54 | }
55 | 
56 | string ValidChar::getPrediction()
57 | {
58 | 	return prediction;
59 | }
60 | 
61 | #endif


--------------------------------------------------------------------------------
/source/openGL.h:
--------------------------------------------------------------------------------
 1 | #ifndef OPENGL_H
 2 | #define OPENGL_H
 3 | 
 4 | #include <GL/glew.h>
 5 | #include <GL/freeglut.h>
 6 | #include <GL/gl.h>
 7 | #include <GL/glu.h>
 8 | #include <string>
 9 | #include <iostream>
10 | #include "enums.h"
11 | 
12 | void initGL()
13 | {
14 | 	//Create OpenGL 2.1 context
15 | 	glutInitContextVersion(2, 1);
16 | 
17 | 	//Create Double Buffered Window with multisampled buffer
18 | 	glutInitDisplayMode(GLUT_DOUBLE | GLUT_MULTISAMPLE);
19 | 	glutInitWindowSize(SCREEN_SIZE + 16, SCREEN_SIZE + 16);
20 | 	glutCreateWindow("SliceType");
21 | 
22 | 	//Initialize GLEW
23 | 	glewInit();
24 | 
25 | 	//Set the viewport
26 | 	glViewport(0.f, 0.f, SCREEN_SIZE, SCREEN_SIZE);
27 | 
28 | 	//Initialize Projection Matrix
29 | 	glMatrixMode(GL_PROJECTION);
30 | 	glLoadIdentity();
31 | 	glOrtho(0.0, SCREEN_SIZE + 8, SCREEN_SIZE, -8, 1.0, -1.0);
32 | 
33 | 	//Initialize Modelview Matrix
34 | 	glMatrixMode(GL_MODELVIEW);
35 | 	glLoadIdentity();
36 | 
37 | 	//Initialize clear color
38 | 	glClearColor(0.f, 0.f, 0.f, 1.f);
39 | 
40 | 	//Set blending
41 | 	glEnable(GL_BLEND);
42 | 	glDisable(GL_DEPTH_TEST);
43 | 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
44 | 
45 | 	//Set antialiasing/multisampling
46 | 	glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
47 | 	glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
48 | 	glEnable(GL_LINE_SMOOTH);
49 | 	glEnable(GL_POLYGON_SMOOTH);
50 | 	glEnable(GL_MULTISAMPLE);
51 | 	glDisable(GL_TEXTURE_2D);
52 | }
53 | 
54 | #endif
55 | 


--------------------------------------------------------------------------------
/source/enums.h:
--------------------------------------------------------------------------------
 1 | #ifndef ENUMS_H
 2 | #define ENUMS_H
 3 | 
 4 | 
 5 | int SCREEN_SIZE = 920;
 6 | int SCREEN_SIZE_X = SCREEN_SIZE;
 7 | int SCREEN_SIZE_Y = SCREEN_SIZE;
 8 | const int SCREEN_FPS = 60;
 9 | const float radi0 = SCREEN_SIZE / 7.f;
10 | const float radi1 = SCREEN_SIZE / 3.f;
11 | const float radi2 = SCREEN_SIZE / 2.f;
12 | 
13 | const double circleBoundary = 1.f;
14 | const double lineWidth = 2.f;
15 | const int slices = 40;
16 | const int loops = 10;
17 | 
18 | const float charScale = (0.225 / 640) * SCREEN_SIZE;
19 | const float predScale = (0.15 / 640) * SCREEN_SIZE;
20 | const float textWidth = 3.f;
21 | const float textSmallWidth = 2.f;
22 | float selectTime;
23 | float morphTime;
24 | 
25 | int selectCount;
26 | int morphCount;
27 | 
28 | const float textSpacing = 2.f;
29 | 
30 | enum colorTypes { cornflowerBlue, paleOrange, orange, black, green, purple, coral, warmgrey, olivedrab, goldenrod, turquoise };
31 | enum lateralMergePhases { firstPhase, secondPhase, thirdPhase };
32 | enum kbState { noSelect, select1, select2, selectOuter, selectOtherKey, selectingOtherKey, secondClear };
33 | 
34 | colorTypes colorFront = turquoise;
35 | colorTypes colorBack = paleOrange;
36 | colorTypes colorS1 = orange;
37 | colorTypes colorS2 = green;
38 | 
39 | 
40 | 
41 | //the first two goes in the middle ring, a total of 26 chars for each screen
42 | static const char firstScreenChars[] = { 'e', 't',
43 | 'a', 'o', 'i', 'n', 's', 'r', 'h', 'l', 'd', 'c', 'u', 'm',
44 | 'f', 'p', 'g', 'w', 'y', 'b', 'v', 'k', 'x', 'j', 'z', 'q' };
45 | 
46 | static const char secondScreenChars[] = { '.', ',',
47 | '\'', '?', '!', ':', ';', '"', '$', '&', '/', '-', '%', '#',
48 | '(', ')', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
49 | 
50 | 
51 | 
52 | #endif


--------------------------------------------------------------------------------
/source/Button.h:
--------------------------------------------------------------------------------
 1 | #ifndef BUTTON_H
 2 | #define BUTTON_H
 3 | 
 4 | #include "DiskPart.h"
 5 | #include "ValidChar.h"
 6 | #include "PosChart.h"
 7 | #include "enums.h"
 8 | 
 9 | int getPosOfChar(const char *array, char c);
10 | void getLocOfChar(char c, int &loop, int &row);
11 | 
12 | //Holds every aspect of a button
13 | class Button
14 | {
15 | 	DiskPart buttonShape;
16 | 	ValidChar writing;
17 | 
18 | public:
19 | 	Button();
20 | 	Button(ValidChar inpWriting);
21 | 	DiskPart& getButtonShape();
22 | 	ValidChar& getWriting();
23 | };
24 | 
25 | Button::Button()
26 | {
27 | }
28 | 
29 | Button::Button(ValidChar inpWriting)
30 | {
31 | 	writing = inpWriting;
32 | 
33 | 	int loop, row;
34 | 	getLocOfChar(writing.getChar(), loop, row);
35 | 
36 | 	buttonShape = DiskPart(loop, row);
37 | }
38 | 
39 | DiskPart& Button::getButtonShape()
40 | {
41 | 	return buttonShape;
42 | }
43 | 
44 | ValidChar& Button::getWriting()
45 | {
46 | 	return writing;
47 | }
48 | 
49 | int getPosOfChar(const char *array, char c)
50 | {
51 | 	size_t size = 26;	//not cool
52 | 	const char* end = array + size;
53 | 	const char* match = std::find(array, end, c);
54 | 	return (end == match) ? -1 : (match - array);
55 | }
56 | 
57 | void getLocOfChar(char c, int &loop, int &row)
58 | {
59 | 	int noOfChar = getPosOfChar(firstScreenChars, c);
60 | 
61 | 	if (noOfChar == -1)
62 | 		noOfChar = getPosOfChar(secondScreenChars, c);
63 | 
64 | 	//middle loop
65 | 	if (noOfChar < 2)
66 | 	{
67 | 		loop = 0;
68 | 		//first half
69 | 		if (noOfChar == 0)
70 | 			row = 0;
71 | 		//second half
72 | 		else
73 | 			row = 1;
74 | 	}
75 | 	//second ring
76 | 	else if (noOfChar < 14)
77 | 	{
78 | 		loop = 1;
79 | 		row = (noOfChar - 2) % 12;
80 | 	}
81 | 	//third ring
82 | 	else
83 | 	{
84 | 		loop = 2;
85 | 		row = (noOfChar - 2) % 12;
86 | 	}
87 | }
88 | 
89 | 
90 | #endif


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## SliceType: Fast Gaze Typing with a Merging Keyboard
 2 | 
 3 | The soft keyboard designed for gaze typing proposed in the following paper:
 4 | 
 5 | [Benligiray, B.; Topal, C.; Akinlar, C., "SliceType: Fast gaze typing with a merging keyboard," Journal on Multimodal Interfaces, 2018.](https://arxiv.org/abs/1706.02499)
 6 | 
 7 | The .zip file contains the soft keyboard built for Windows.
 8 | I also uploaded the source code to refer to it myself.
 9 | I don't provide a makefile at the moment, but it only needs freeglut to build.
10 | It uses Win32 API, so it will take some work to port.
11 | 
12 | #### What is this?
13 | 
14 | * SliceType is a soft keyboard designed for fast and comfortable gaze typing.
15 | * Our main objective in designing SliceType was to use the screen are efficiently. We achieved this by determining the keys that will not be used for the next input, and allocating their space to adjacent keys with a merging animation.
16 | * As a result of the key merging functionality, the target keys are more likely to be larger. Large keys are fast to navigate towards, and easy to dwell on even, when there is eye tracking jitter.
17 | * In addition, Slicetype uses a word completion proposal and selection scheme that is ideal for gaze typing by dwelling.
18 | * The advantages of the features above are quantified using the Fitts' law.
19 | * SliceType is compared with two other gaze typing keyboards, Dasher and GazeTalk. The user experiment done with 37 novice users showed that, SliceType provided the highest text entry rate, and is preferred over the other keyboards.
20 | 
21 | <p align="center">
22 |   <img src="https://user-images.githubusercontent.com/19530665/27763730-ee36c938-5e91-11e7-885a-fe518de4ec5d.png"/>
23 | </p>
24 | 
25 | #### Videos
26 | 
27 | [SliceType: Fast Gaze Typing with a Merging Keyboard](https://www.youtube.com/watch?v=3IM0-utYrDg)
28 | 
29 | [SliceType - Advanced User Performance](https://www.youtube.com/watch?v=um75h3hHcwo)
30 | 
31 | [Slicetype - Gaze Typing Example (Turkish)](https://www.youtube.com/watch?v=WlAcx398p-A)
32 | 
33 | 


--------------------------------------------------------------------------------
/source/main.cpp:
--------------------------------------------------------------------------------
  1 | #include "main.h"
  2 | 
  3 | //text addition
  4 | #include <fstream>
  5 | #include <sstream>
  6 | //text addition
  7 | 
  8 | int main(int argc, char* args[])
  9 | {
 10 | 
 11 | 	string line;
 12 | 	ifstream myfile("options.txt");
 13 | 	std::istringstream convert;
 14 | 	int number = 1000;
 15 | 	if (myfile.is_open())
 16 | 	{
 17 | 		getline(myfile, line);
 18 | 		getline(myfile, line);
 19 | 		convert = std::istringstream(line);
 20 | 		convert >> number;
 21 | 		selectTime = (float)number / 1000;
 22 | 
 23 | 		getline(myfile, line);
 24 | 		getline(myfile, line);
 25 | 		convert = std::istringstream(line);
 26 | 		convert >> number;
 27 | 		morphTime = (float)number / 1000;
 28 | 
 29 | 		myfile.close();
 30 | 
 31 | 		selectCount = (int)(selectTime * SCREEN_FPS);
 32 | 		morphCount = (int)(morphTime * SCREEN_FPS);
 33 | 	}
 34 | 
 35 | 	else
 36 | 		return 1;
 37 | 
 38 | 	glutInit(&argc, args);
 39 | 	initGL();
 40 | 
 41 | 	//Set functions
 42 | 	glutDisplayFunc(render);
 43 | 	glutPassiveMotionFunc(handleMousePos);
 44 | 	glutMouseFunc(handleMouseClick);
 45 | 	glutKeyboardFunc(handleKeys);
 46 | 
 47 | 	//Set loop
 48 | 	glutTimerFunc(1000 / SCREEN_FPS, runMainLoop, 0);
 49 | 	glutMainLoop();
 50 | 
 51 | 
 52 | 
 53 | 	return 0;
 54 | }
 55 | 
 56 | void runMainLoop(int val)
 57 | {
 58 | 	render();
 59 | 
 60 | 	glutTimerFunc(1000 / SCREEN_FPS, runMainLoop, val);
 61 | }
 62 | 
 63 | 
 64 | 
 65 | void render()
 66 | {
 67 | 
 68 | 	kbMain.tickCounter();
 69 | 	kbMain.TEMPDRAW();
 70 | 	glutSwapBuffers();
 71 | }
 72 | 
 73 | void handleMousePos(int x, int y)
 74 | {
 75 | 	kbMain.updateMouseCell(x, y);
 76 | }
 77 | 
 78 | void handleMouseClick(int button, int state, int x, int y)
 79 | {
 80 | 	switch (button)
 81 | 	{
 82 | 	case 0:
 83 | 		cout << "left button ";
 84 | 		break;
 85 | 	case 2:
 86 | 		cout << "right button ";
 87 | 		break;
 88 | 	default:
 89 | 		return;
 90 | 	}
 91 | 	switch (state)
 92 | 	{
 93 | 	case 0:
 94 | 		cout << "down" << endl;
 95 | 		break;
 96 | 	case 1:
 97 | 		cout << "up" << endl;
 98 | 		break;
 99 | 	}
100 | }
101 | 
102 | void handleKeys(unsigned char key, int x, int y)
103 | {
104 | 	cout << key << endl;
105 | }
106 | 
107 | 


--------------------------------------------------------------------------------
/source/ButtonSet.h:
--------------------------------------------------------------------------------
 1 | #ifndef BUTTONSET_H
 2 | #define BUTTONSET_H
 3 | 
 4 | #include <vector>
 5 | #include "Button.h"
 6 | #include "PosChart.h"
 7 | #include "ValidChar.h"
 8 | #include "enums.h"
 9 | 
10 | 
11 | using std::vector;
12 | 
13 | //set of active buttons
14 | class ButtonSet
15 | {
16 | 	vector<Button> buttons;
17 | 	PosChart positions;
18 | 	void initPositions();
19 | 	void mergeButtons();
20 | 
21 | public:
22 | 	ButtonSet();
23 | 	ButtonSet(vector<ValidChar> writings);
24 | 	vector<Button>& getButtons();
25 | 	bool getButtonWithField(int inpLoop, int inpRow, Button& but);
26 | };
27 | ButtonSet::ButtonSet()
28 | {}
29 | ButtonSet::ButtonSet(vector<ValidChar> writings)
30 | {
31 | 	for (vector<ValidChar>::size_type i = 0; i != writings.size(); i++)
32 | 		buttons.push_back(Button(writings[i]));
33 | 	initPositions();
34 | 	mergeButtons();
35 | }
36 | 
37 | //fills positions with the oriinal (non-merged) values
38 | void ButtonSet::initPositions()
39 | {
40 | 	for (vector<Button>::size_type i = 0; i != buttons.size(); i++)
41 | 		positions.fillPos(buttons[i].getButtonShape().getOrigLoop(), buttons[i].getButtonShape().getOrigRow());
42 | }
43 | 
44 | //ValidChars and Buttons will already be sorted wrt frequency
45 | //Simply merge them in order
46 | void ButtonSet::mergeButtons()
47 | {
48 | 	for (vector<Button>::size_type i = 0; i != buttons.size(); i++)
49 | 		buttons[i].getButtonShape().mergeRadially(positions);
50 | 	for (vector<Button>::size_type i = 0; i != buttons.size(); i++)
51 | 		buttons[i].getButtonShape().mergeLaterally(positions, firstPhase);
52 | 	for (vector<Button>::size_type i = 0; i != buttons.size(); i++)
53 | 		buttons[i].getButtonShape().mergeLaterally(positions, secondPhase);
54 | 	for (vector<Button>::size_type i = 0; i != buttons.size(); i++)
55 | 		buttons[i].getButtonShape().mergeLaterally(positions, thirdPhase);
56 | 
57 | }
58 | vector<Button>& ButtonSet::getButtons()
59 | {
60 | 	return buttons;
61 | }
62 | 
63 | bool ButtonSet::getButtonWithField(int inpLoop, int inpRow, Button& but)
64 | {
65 | 	for (vector<Button>::size_type i = 0; i < buttons.size(); i++)
66 | 	{
67 | 		if (buttons[i].getButtonShape().isInDisk(inpLoop, inpRow))
68 | 		{
69 | 			but = buttons[i];
70 | 			return true;
71 | 		}
72 | 	}
73 | 	return false;
74 | }
75 | 
76 | #endif


--------------------------------------------------------------------------------
/source/MouseStatus.h:
--------------------------------------------------------------------------------
  1 | #ifndef MOUSESTATUS_H
  2 | #define MOUSESTATUS_H
  3 | 
  4 | #define M_PI 3.14159265358979323846
  5 | 
  6 | #include <cmath>
  7 | #include "enums.h"
  8 | 
  9 | 
 10 | class MouseStatus
 11 | {
 12 | 	int loop;
 13 | 	int row;
 14 | 	void convertCartToPolar(int x, int y, double &angle, double &radius);
 15 | 	void ConvertPolartoField(double angle, double radius, int &loop, int &row);
 16 | public:
 17 | 	MouseStatus();
 18 | 	bool updateCell(int x, int y);
 19 | 	void getCell(int &outLoop, int &outRow);
 20 | };
 21 | 
 22 | MouseStatus::MouseStatus()
 23 | {
 24 | 	loop = -1;
 25 | 	row = -1;
 26 | }
 27 | 
 28 | bool MouseStatus::updateCell(int x, int y)
 29 | {
 30 | 	x = (x / (double)SCREEN_SIZE_X) * SCREEN_SIZE;
 31 | 	y = (y / (double)SCREEN_SIZE_Y) * SCREEN_SIZE;
 32 | 
 33 | 
 34 | 	int border = 5;
 35 | 	int newLoop = 0;
 36 | 	int newRow = 0;
 37 | 
 38 | 	if ((x < border) || (x > SCREEN_SIZE - border) || (y < border) || (y > SCREEN_SIZE - border))
 39 | 	{
 40 | 		newLoop = -1;
 41 | 		newRow = -1;
 42 | 	}
 43 | 	else
 44 | 	{
 45 | 		double angle = 0;
 46 | 		double radius = 0;
 47 | 		convertCartToPolar(x, y, angle, radius);
 48 | 		ConvertPolartoField(angle, radius, newLoop, newRow);
 49 | 	}
 50 | 
 51 | 	if ((loop != newLoop) || (row != newRow))
 52 | 	{
 53 | 		loop = newLoop;
 54 | 		row = newRow;
 55 | 		return true;
 56 | 	}
 57 | 	else
 58 | 		return false;
 59 | }
 60 | 
 61 | void MouseStatus::getCell(int &outLoop, int &outRow)
 62 | {
 63 | 	outLoop = loop;
 64 | 	outRow = row;
 65 | }
 66 | 
 67 | void MouseStatus::convertCartToPolar(int x, int y, double &angle, double &radius)
 68 | {
 69 | 	angle = -(atan2(y - SCREEN_SIZE / 2, x - SCREEN_SIZE / 2) / M_PI) * 180;
 70 | 	if (angle < 0)
 71 | 		angle += 360;
 72 | 
 73 | 	radius = sqrt(pow(y - SCREEN_SIZE / 2, 2) + pow(x - SCREEN_SIZE / 2, 2));
 74 | }
 75 | 
 76 | void MouseStatus::ConvertPolartoField(double angle, double radius, int &loop, int &row)
 77 | {
 78 | 	if (radius < radi0)
 79 | 	{
 80 | 		loop = 0;
 81 | 		if (angle < 180)
 82 | 			row = 0;
 83 | 		else
 84 | 			row = 1;
 85 | 		return;
 86 | 	}
 87 | 	else if (radius < radi1)
 88 | 		loop = 1;
 89 | 	else if (radius < radi2)
 90 | 		loop = 2;
 91 | 	else
 92 | 	{
 93 | 		loop = 3;
 94 | 		if (angle < 90)
 95 | 			row = 0;
 96 | 		else if (angle < 180)
 97 | 			row = 1;
 98 | 		else if (angle < 270)
 99 | 			row = 2;
100 | 		else
101 | 			row = 3;
102 | 		return;
103 | 	}
104 | 	row = floor(angle / 30);
105 | }
106 | 
107 | #endif


--------------------------------------------------------------------------------
/source/Keyboard.h:
--------------------------------------------------------------------------------
  1 | #ifndef KEYBOARD_H
  2 | #define KEYBOARD_H
  3 | 
  4 | #include <string>
  5 | #include "ButtonSet.h"
  6 | #include "Predictor.h"
  7 | 
  8 | #include "enums.h"
  9 | 
 10 | using std::vector;
 11 | using std::string;
 12 | 
 13 | 
 14 | 
 15 | class Keyboard
 16 | {
 17 | 	ButtonSet *buttons;
 18 | 	ButtonSet *otherKeys;
 19 | 	Predictor predict;
 20 | 	string lastWord, currentWord;
 21 | 	vector<ValidChar> firstScreenVC, secondScreenVC;
 22 | 	void initCharVecs();
 23 | 	void resetVC();
 24 | 	void cleanVC();
 25 | 
 26 | public:
 27 | 	Keyboard();
 28 | 	~Keyboard();
 29 | 	ButtonSet* getButtonSet();
 30 | 	void enterChar(char inpChar);
 31 | 	void exitChar(char inpChar);
 32 | 	string Keyboard::enterWord();
 33 | 	string getCurrWord();
 34 | 	void clearCurrWord();
 35 | 	void setLastWord(string lw);
 36 | 	ButtonSet* getOtherButtons();
 37 | };
 38 | 
 39 | Keyboard::Keyboard()
 40 | {
 41 | 	resetVC();
 42 | 	lastWord = "";
 43 | 	currentWord = "";
 44 | 	initCharVecs();
 45 | 	buttons = new ButtonSet(firstScreenVC);
 46 | 	otherKeys = new ButtonSet(secondScreenVC);
 47 | }
 48 | 
 49 | Keyboard::~Keyboard()
 50 | {
 51 | 	delete buttons;
 52 | 	delete otherKeys;
 53 | }
 54 | 
 55 | void Keyboard::initCharVecs()
 56 | {
 57 | 	for (vector<ValidChar>::size_type i = 0; i < 26; i++)
 58 | 		firstScreenVC[i].updatePred(predict.Predict(lastWord, currentWord + firstScreenVC[i].getChar()), 0);
 59 | }
 60 | 
 61 | //entered a char. prediction for the entered char shouldn't change.
 62 | void Keyboard::enterChar(char inpChar)
 63 | {
 64 | 	resetVC();
 65 | 	currentWord = currentWord + inpChar;
 66 | 	for (vector<ValidChar>::size_type i = 0; i < 26; i++)
 67 | 	{
 68 | 		if (firstScreenVC[i].getChar() != inpChar)
 69 | 			firstScreenVC[i].updatePred(predict.Predict(lastWord, currentWord + firstScreenVC[i].getChar()), 0);
 70 | 		else
 71 | 			firstScreenVC[i].updatePred(predict.Predict(lastWord, currentWord), 0);
 72 | 	}
 73 | 	cleanVC();
 74 | 	buttons = new ButtonSet(firstScreenVC);
 75 | }
 76 | 
 77 | //entered a char. exited its cell before select2 ends. its prediction must be updated.
 78 | void Keyboard::exitChar(char inpChar)
 79 | {
 80 | 	resetVC();
 81 | 	initCharVecs();
 82 | 	cleanVC();
 83 | 
 84 | 	if (firstScreenVC.size() == 0)
 85 | 	{
 86 | 		currentWord = "";
 87 | 		resetVC();
 88 | 		initCharVecs();
 89 | 		cleanVC();
 90 | 	}
 91 | 	buttons = new ButtonSet(firstScreenVC);
 92 | }
 93 | 
 94 | ButtonSet* Keyboard::getButtonSet()
 95 | {
 96 | 	return buttons;
 97 | }
 98 | 
 99 | void Keyboard::resetVC()
100 | {
101 | 	firstScreenVC.clear();
102 | 	secondScreenVC.clear();
103 | 	for (vector<ValidChar>::size_type i = 0; i < 26; i++)
104 | 	{
105 | 		firstScreenVC.push_back(ValidChar(firstScreenChars[i], "", 0));
106 | 		secondScreenVC.push_back(ValidChar(secondScreenChars[i], "", 0));
107 | 	}
108 | }
109 | 
110 | void Keyboard::cleanVC()
111 | {
112 | 	vector<ValidChar> tempVC;
113 | 
114 | 	for (vector<ValidChar>::size_type i = 0; i < 26; i++)
115 | 	{
116 | 		if (firstScreenVC[i].getPrediction() != "")
117 | 			tempVC.push_back(firstScreenVC[i]);
118 | 	}
119 | 	firstScreenVC = tempVC;
120 | }
121 | 
122 | string Keyboard::enterWord()
123 | {
124 | 	currentWord = predict.Predict(lastWord, currentWord);
125 | 	lastWord = currentWord;
126 | 	currentWord = "";
127 | 	resetVC();
128 | 	initCharVecs();
129 | 	buttons = new ButtonSet(firstScreenVC);
130 | 	return lastWord;
131 | }
132 | 
133 | string Keyboard::getCurrWord()
134 | {
135 | 	return currentWord;
136 | }
137 | 
138 | void Keyboard::clearCurrWord()
139 | {
140 | 	currentWord = "";
141 | 	resetVC();
142 | 	initCharVecs();
143 | 	buttons = new ButtonSet(firstScreenVC);
144 | }
145 | 
146 | void Keyboard::setLastWord(string lw)
147 | {
148 | 	lastWord = lw;
149 | }
150 | 
151 | ButtonSet* Keyboard::getOtherButtons()
152 | {
153 | 	return otherKeys;
154 | }
155 | 
156 | 
157 | 
158 | #endif


--------------------------------------------------------------------------------
/source/Predictor.h:
--------------------------------------------------------------------------------
  1 | #ifndef PREDICTOR_H
  2 | #define PREDICTOR_H
  3 | 
  4 | #include <fstream>
  5 | #include <sstream>
  6 | #include "Trie.h"
  7 | using std::string;
  8 | using std::vector;
  9 | using std::stringstream;
 10 | 
 11 | class Predictor
 12 | {
 13 | 	Trie *uniGrams, *biGrams;
 14 | 	unsigned int uniNoOfWords, uniTotalFreq, biNoOfWords, biTotalFreq;
 15 | 	unsigned int strToUint(string str);
 16 | 	void readTextCorpus();
 17 | 	string freqPredict(string word1, string word2);
 18 | 	bool tryLoadingTries();
 19 | public:
 20 | 	Predictor();
 21 | 	~Predictor();
 22 | 	string Predict(string word1, string word2);
 23 | };
 24 | 
 25 | Predictor::Predictor()
 26 | {
 27 | 	if (!tryLoadingTries())
 28 | 	{
 29 | 		readTextCorpus();
 30 | 		uniGrams->saveTrie("uniTrie.txt");
 31 | 		biGrams->saveTrie("biTrie.txt");
 32 | 	}
 33 | }
 34 | 
 35 | Predictor::~Predictor()
 36 | {
 37 | 	delete uniGrams;
 38 | 	delete biGrams;
 39 | }
 40 | 
 41 | void Predictor::readTextCorpus()
 42 | {
 43 | 	std::ifstream uniCorpusFile("uniCorpus.txt");
 44 | 	vector<ValidChar> words;
 45 | 	string word;
 46 | 
 47 | 	std::getline(uniCorpusFile, word);
 48 | 
 49 | 	uniCorpusFile >> word;
 50 | 	uniNoOfWords = strToUint(word);
 51 | 	uniCorpusFile >> word;
 52 | 	uniTotalFreq = strToUint(word);
 53 | 
 54 | 	for (int i = 0; i < uniNoOfWords; i++)
 55 | 	{
 56 | 		uniCorpusFile >> word;
 57 | 		unsigned int f = strToUint(word);
 58 | 
 59 | 		uniCorpusFile >> word;
 60 | 
 61 | 		words.push_back(ValidChar(' ', word, f));
 62 | 
 63 | 	}
 64 | 
 65 | 	uniGrams = new Trie(words);
 66 | 
 67 | 
 68 | 
 69 | 	std::ifstream biCorpusFile("biCorpus.txt");
 70 | 	words.clear();
 71 | 	string biWord;
 72 | 
 73 | 	std::getline(biCorpusFile, word);
 74 | 
 75 | 	biCorpusFile >> word;
 76 | 	biNoOfWords = strToUint(word);
 77 | 	biCorpusFile >> word;
 78 | 	biTotalFreq = strToUint(word);
 79 | 
 80 | 	for (int i = 0; i < biNoOfWords; i++)
 81 | 	{
 82 | 		biCorpusFile >> word;
 83 | 		unsigned int f = strToUint(word);
 84 | 
 85 | 		biCorpusFile >> word;
 86 | 		biCorpusFile >> biWord;
 87 | 
 88 | 		words.push_back(ValidChar(' ', word + " " + biWord, f));
 89 | 	}
 90 | 
 91 | 	biGrams = new Trie(words);
 92 | }
 93 | 
 94 | 
 95 | unsigned int Predictor::strToUint(string str)
 96 | {
 97 | 	stringstream ss(str);
 98 | 	unsigned int num;
 99 | 	ss >> num;
100 | 	return num;
101 | }
102 | 
103 | string Predictor::Predict(string word1, string word2)
104 | {
105 | 	ValidChar uniPrediction, biPrediction;
106 | 
107 | 	if (word1 == "")
108 | 	{
109 | 		uniPrediction = uniGrams->searchWord(word2);
110 | 		return uniPrediction.getString();
111 | 	}
112 | 	else
113 | 	{
114 | 		uniPrediction = uniGrams->searchWord(word2);
115 | 		biPrediction = biGrams->searchWord(word1 + " " + word2);
116 | 
117 | 		if (biPrediction.getString() == "")
118 | 			return uniPrediction.getString();
119 | 
120 | 		string resultStr;
121 | 
122 | 		resultStr = biPrediction.getString().substr(word1.size() + 1, biPrediction.getString().size());
123 | 
124 | 		return resultStr;
125 | 	}
126 | }
127 | 
128 | string Predictor::freqPredict(string word1, string word2)
129 | {
130 | 	ValidChar uniPrediction, biPrediction;
131 | 
132 | 	uniPrediction = uniGrams->searchWord(word2);
133 | 	biPrediction = biGrams->searchWord(word1 + " " + word2);
134 | 
135 | 	/*
136 | 	if (biPrediction.getString()==" ")
137 | 	return uniPrediction.getString();
138 | 	else
139 | 	return biPrediction.getString().substr(word1.size()+1,biPrediction.getString().size());
140 | 	*/
141 | 
142 | 
143 | 	if ((uniPrediction.getFreq() / (double)uniTotalFreq) > (biPrediction.getFreq() / (double)biTotalFreq))
144 | 		return uniPrediction.getString();
145 | 	else
146 | 		return biPrediction.getString().substr(word1.size() + 1, biPrediction.getString().size());
147 | }
148 | 
149 | bool Predictor::tryLoadingTries()
150 | {
151 | 	std::ifstream inputFile("uniTrie.txt");
152 | 
153 | 	if (inputFile.is_open())
154 | 	{
155 | 		delete uniGrams;
156 | 		uniGrams = new Trie();
157 | 		uniGrams->loadTrie(inputFile);
158 | 	}
159 | 	else
160 | 		return false;
161 | 	inputFile.close();
162 | 
163 | 	inputFile.open("biTrie.txt");
164 | 
165 | 	if (inputFile.is_open())
166 | 	{
167 | 		delete biGrams;
168 | 		biGrams = new Trie();
169 | 		biGrams->loadTrie(inputFile);
170 | 	}
171 | 	else
172 | 		return false;
173 | 	inputFile.close();
174 | 
175 | }
176 | 
177 | #endif


--------------------------------------------------------------------------------
/source/DiskPart.h:
--------------------------------------------------------------------------------
  1 | #ifndef DISKPART_H
  2 | #define DISKPART_H
  3 | 
  4 | #include "PosChart.h"
  5 | #include "enums.h"
  6 | 
  7 | //Holds the geometric aspects of a button
  8 | class DiskPart
  9 | {
 10 | 	//Both innerRing and outerRing can take values [0,4]
 11 | 	//0 is the middle point, 1-2-3 are the next outer rings, 4 is the ring outside the screen
 12 | 	int innerRing, outerRing;
 13 | 	//Both startSlice and stopSlice can take values [0,11]
 14 | 	//0 represents 6 o'clock and increasing numbers go ccw
 15 | 	//To draw a full circle, set startSlice==stopSlice
 16 | 	int startSlice, stopSlice;
 17 | 	//These keep the original location (before merge) of the button.
 18 | 	//loop: 0->3 rings going outwards
 19 | 	//row: indexed similar to start/stopSlice
 20 | 	int loop, row;
 21 | 
 22 | public:
 23 | 	DiskPart();
 24 | 	DiskPart(int inpLoop, int inpRow);
 25 | 	int getOrigLoop() const;
 26 | 	int getOrigRow() const;
 27 | 	void mergeRadially(PosChart &positions);
 28 | 	void mergeLaterally(PosChart &positions, lateralMergePhases ph);
 29 | 	void getShape(int &loopStart, int &loopEnd, int &rowStart, int &rowEnd);
 30 | 	bool isInDisk(int inpLoop, int inpRow);
 31 | };
 32 | 
 33 | DiskPart::DiskPart()
 34 | {
 35 | }
 36 | DiskPart::DiskPart(int inpLoop, int inpRow)
 37 | {
 38 | 	loop = inpLoop;
 39 | 	row = inpRow;
 40 | 
 41 | 	innerRing = loop;
 42 | 	outerRing = loop + 1;
 43 | 
 44 | 	if (loop == 0)
 45 | 	{
 46 | 		startSlice = row * 6;
 47 | 		stopSlice = ((row + 1) * 6) % 12;
 48 | 	}
 49 | 	else if (loop == 3)
 50 | 	{
 51 | 		startSlice = row * 4;
 52 | 		stopSlice = ((row + 1) * 4) % 12;
 53 | 	}
 54 | 	else
 55 | 	{
 56 | 		startSlice = row;
 57 | 		stopSlice = (row + 1) % 12;
 58 | 	}
 59 | }
 60 | 
 61 | int DiskPart::getOrigLoop() const
 62 | {
 63 | 	return loop;
 64 | }
 65 | int DiskPart::getOrigRow() const
 66 | {
 67 | 	return row;
 68 | }
 69 | 
 70 | 
 71 | //This is the merge that will happen first.
 72 | void DiskPart::mergeRadially(PosChart &positions)
 73 | {
 74 | 	switch (loop)
 75 | 	{
 76 | 	case 0:
 77 | 		//middle loop cannot merge radially
 78 | 		break;
 79 | 	case 1:
 80 | 		if (positions.getLoop(2)[row] == 0)
 81 | 		{
 82 | 			positions.fillPos(2, row);
 83 | 			outerRing = 3;
 84 | 		}
 85 | 		break;
 86 | 	case 2:
 87 | 		if (positions.getLoop(1)[row] == 0)
 88 | 		{
 89 | 			positions.fillPos(1, row);
 90 | 			innerRing = 1;
 91 | 		}
 92 | 		break;
 93 | 	}
 94 | }
 95 | 
 96 | //Radial merge already happened. Lateral merge can happen in three phases:
 97 | //First phase merges non-radially-merged buttons (ccw).
 98 | //Second phase merges radially-merged buttons (ccw).
 99 | //Third phase merges any remaining empty spaces (cw).
100 | void DiskPart::mergeLaterally(PosChart &positions, lateralMergePhases ph)
101 | {
102 | 	switch (ph)
103 | 	{
104 | 		//only merge ccw if button is not merged radially
105 | 	case firstPhase:
106 | 		//check if button is not merged radially
107 | 		if (outerRing - innerRing == 1)
108 | 		{
109 | 			if (loop == 0)
110 | 			{
111 | 				//the first loop has only two buttons
112 | 				if (positions.getLoop(loop)[(row + 1) % 2] == 0)
113 | 				{
114 | 					positions.fillPos(loop, (row + 1) % 2);
115 | 					startSlice = stopSlice = 0;
116 | 				}
117 | 			}
118 | 			else
119 | 			{
120 | 				//other loops have 12 buttons
121 | 				if (positions.getLoop(loop)[(row + 1) % 12] == 0)
122 | 				{
123 | 					positions.fillPos(loop, (row + 1) % 12);
124 | 					stopSlice = (row + 2) % 12;
125 | 				}
126 | 			}
127 | 		}
128 | 		break;
129 | 
130 | 		//only merge ccw if button is merged radially
131 | 	case secondPhase:
132 | 		//check if button is merged radially
133 | 		if (outerRing - innerRing == 2)
134 | 		{
135 | 			//check if both nearby positions are available
136 | 			if ((positions.getLoop(1)[(row + 1) % 12] == 0) && (positions.getLoop(2)[(row + 1) % 12] == 0))
137 | 			{
138 | 				positions.fillPos(1, (row + 1) % 12);
139 | 				positions.fillPos(2, (row + 1) % 12);
140 | 				stopSlice = (row + 2) % 12;
141 | 			}
142 | 		}
143 | 		break;
144 | 
145 | 		//always merge button if possible in cw
146 | 	case thirdPhase:
147 | 		if (outerRing - innerRing == 1)
148 | 		{
149 | 			//don't need to merge middle again
150 | 			if (loop != 0)
151 | 			{
152 | 				if (positions.getLoop(loop)[(row + 11) % 12] == 0)
153 | 				{
154 | 					positions.fillPos(loop, (row + 11) % 12);
155 | 					startSlice = (row + 11) % 12;
156 | 				}
157 | 			}
158 | 		}
159 | 		else if (outerRing - innerRing == 2)
160 | 		{
161 | 			if ((positions.getLoop(1)[(row + 11) % 12] == 0) && (positions.getLoop(2)[(row + 11) % 12] == 0))
162 | 			{
163 | 				positions.fillPos(1, (row + 11) % 12);
164 | 				positions.fillPos(2, (row + 11) % 12);
165 | 				startSlice = (row + 11) % 12;
166 | 			}
167 | 		}
168 | 		break;
169 | 	}
170 | }
171 | 
172 | void DiskPart::getShape(int &loopStart, int &loopEnd, int &rowStart, int &rowEnd)
173 | {
174 | 	loopStart = innerRing;
175 | 	loopEnd = outerRing;
176 | 	rowStart = startSlice;
177 | 	rowEnd = stopSlice;
178 | }
179 | 
180 | bool DiskPart::isInDisk(int inpLoop, int inpRow)
181 | {
182 | 	switch (inpLoop)
183 | 	{
184 | 	case 0:
185 | 		inpRow *= 6;	//0 for upper half and 1 for lower half. we want 0 for upper half and 6 for lower half.
186 | 		if (innerRing != 0)
187 | 			return false;
188 | 		break;
189 | 	case 1:
190 | 		if ((innerRing >= 2) || (outerRing <= 1))
191 | 			return false;
192 | 		break;
193 | 	case 2:
194 | 		if (outerRing <= 2)
195 | 			return false;
196 | 		break;
197 | 	case 3:
198 | 		return false;
199 | 	}
200 | 
201 | 	if ((startSlice == 0) && (stopSlice == 0))
202 | 		return true;
203 | 
204 | 	int tempStopSlice;
205 | 	if (stopSlice <= startSlice)
206 | 	{
207 | 		tempStopSlice = stopSlice + 12;
208 | 		if (inpRow == 0)
209 | 			inpRow = 12;
210 | 	}
211 | 	else
212 | 		tempStopSlice = stopSlice;
213 | 
214 | 	if ((inpRow >= startSlice) && (inpRow < tempStopSlice))
215 | 		return true;
216 | 	else
217 | 		return false;
218 | }
219 | 
220 | 
221 | #endif


--------------------------------------------------------------------------------
/source/Trie.h:
--------------------------------------------------------------------------------
  1 | #ifndef TRIE_H
  2 | #define TRIE_H
  3 | 
  4 | #include <vector>
  5 | #include <string>
  6 | #include <fstream>
  7 | #include <sstream>
  8 | 
  9 | #include "ValidChar.h"
 10 | 
 11 | enum TrieMode { uni, bi };
 12 | 
 13 | using std::vector;
 14 | using std::string;
 15 | using std::ofstream;
 16 | using std::ifstream;
 17 | using std::stringstream;
 18 | using std::endl;
 19 | 
 20 | vector<string> splitLine(string& line);
 21 | 
 22 | class Node
 23 | {
 24 | 	ValidChar content;
 25 | 
 26 | public:
 27 | 	vector<Node*> children;
 28 | 	Node();
 29 | 	Node(ValidChar initChar);
 30 | 	Node* findChild(char c);
 31 | 	const ValidChar& getContent() const;
 32 | 	ValidChar& getContentUnprotected();
 33 | 	void appendChild(Node* child);
 34 | 	void Node::writeContent(ofstream& outputFile, string front);
 35 | 	void changeContent(ValidChar inpCon);
 36 | };
 37 | 
 38 | class Trie
 39 | {
 40 | 	Node* root;
 41 | 	void addWord(string start, string pred, unsigned int freq);
 42 | 	void appendWord(ValidChar newWord);
 43 | 	void ascendWord(ValidChar newWord);
 44 | 	void fillWord(ValidChar newWord);
 45 | public:
 46 | 	Trie();
 47 | 	Trie(const vector<ValidChar> &words);
 48 | 	~Trie();
 49 | 	ValidChar searchWord(string s);
 50 | 	void saveTrie(string fileName);
 51 | 	void loadTrie(ifstream& inputFile);
 52 | };
 53 | 
 54 | Trie::Trie()
 55 | {
 56 | 	root = new Node();
 57 | }
 58 | 
 59 | Trie::Trie(const vector<ValidChar> &words)
 60 | {
 61 | 	root = new Node();
 62 | 
 63 | 	for (vector<ValidChar>::size_type i = 0; i < words.size(); i++)
 64 | 	{
 65 | 		appendWord(words[i]);
 66 | 		ascendWord(words[i]);
 67 | 		fillWord(words[i]);
 68 | 	}
 69 | }
 70 | 
 71 | Trie::~Trie()
 72 | {
 73 | 	delete root;
 74 | }
 75 | 
 76 | void Trie::addWord(string start, string pred, unsigned int freq)
 77 | {
 78 | 	Node* currentNode = root;
 79 | 
 80 | 	for (string::size_type i = 0; i < start.size(); i++)
 81 | 	{
 82 | 		Node* childNode = currentNode->findChild(start[i]);
 83 | 		if (childNode != NULL)
 84 | 		{
 85 | 			currentNode = childNode;
 86 | 		}
 87 | 		else
 88 | 		{
 89 | 			Node* temp = new Node(ValidChar(start[i], pred, freq));
 90 | 			currentNode->appendChild(temp);
 91 | 			currentNode = temp;
 92 | 		}
 93 | 	}
 94 | }
 95 | 
 96 | void Trie::appendWord(ValidChar newWord)
 97 | {
 98 | 	Node* currentNode = root;
 99 | 
100 | 	for (string::size_type i = 0; i < newWord.getString().length(); i++)
101 | 	{
102 | 		Node* childNode = currentNode->findChild(newWord.getString()[i]);
103 | 		if (childNode != NULL)
104 | 		{
105 | 			currentNode = childNode;
106 | 			if ((i == newWord.getString().length() - 1) && (currentNode->getContent().getString() == ""))
107 | 				currentNode->getContentUnprotected().updatePred(newWord.getString(), newWord.getFreq());
108 | 		}
109 | 		else
110 | 		{
111 | 			Node* temp;
112 | 			if (i == newWord.getString().length() - 1)
113 | 				temp = new Node(ValidChar(newWord.getString()[i], newWord.getString(), newWord.getFreq()));
114 | 			else
115 | 				temp = new Node(ValidChar(newWord.getString()[i], "", 0));
116 | 
117 | 			currentNode->appendChild(temp);
118 | 			currentNode = temp;
119 | 		}
120 | 	}
121 | }
122 | void Trie::ascendWord(ValidChar ascWord)
123 | {
124 | 	Node* currentNode = root;
125 | 
126 | 	bool couldAscend = false;
127 | 
128 | 	int firstWordLength = 0;
129 | 	for (string::size_type i = 0; i < ascWord.getString().length() - 1; i++)
130 | 	{
131 | 		if (ascWord.getString()[i] == ' ')
132 | 		{
133 | 			firstWordLength = i;
134 | 			break;
135 | 		}
136 | 	}
137 | 
138 | 	for (string::size_type i = 0; i < ascWord.getString().length() - 1; i++)
139 | 	{
140 | 		Node* childNode = currentNode->findChild(ascWord.getString()[i]);
141 | 
142 | 		if ((childNode->getContent().getString() == "") && (i > firstWordLength))
143 | 		{
144 | 			childNode->getContentUnprotected().updatePred(ascWord.getString(), ascWord.getFreq());
145 | 			couldAscend = true;
146 | 			break;
147 | 		}
148 | 		currentNode = childNode;
149 | 	}
150 | 	if (couldAscend)
151 | 	{
152 | 		currentNode = root;
153 | 		for (string::size_type i = 0; i < ascWord.getString().length(); i++)
154 | 		{
155 | 			Node* childNode = currentNode->findChild(ascWord.getString()[i]);
156 | 			currentNode = childNode;
157 | 		}
158 | 		currentNode->getContentUnprotected().updatePred("", 0);
159 | 	}
160 | }
161 | 
162 | void Trie::fillWord(ValidChar fillWord)
163 | {
164 | 	Node* currentNode = root;
165 | 
166 | 	for (string::size_type i = 0; i < fillWord.getString().length(); i++)
167 | 	{
168 | 		Node* childNode = currentNode->findChild(fillWord.getString()[i]);
169 | 
170 | 		if (childNode->getContent().getString() == "")
171 | 		{
172 | 			childNode->getContentUnprotected().updatePred(fillWord.getString(), fillWord.getFreq());
173 | 		}
174 | 		currentNode = childNode;
175 | 	}
176 | }
177 | 
178 | ValidChar Trie::searchWord(string str)
179 | {
180 | 	Node* currentNode = root;
181 | 
182 | 
183 | 	for (string::size_type i = 0; i < str.length(); i++)
184 | 	{
185 | 		Node* temp = currentNode->findChild(str[i]);
186 | 		if (temp == NULL)
187 | 			return ValidChar(' ', "", 0);
188 | 		currentNode = temp;
189 | 	}
190 | 
191 | 	return currentNode->getContent();
192 | 
193 | }
194 | 
195 | void Trie::saveTrie(string fileName)
196 | {
197 | 	ofstream outputFile;
198 | 	outputFile.open(fileName);
199 | 
200 | 	for (vector<Node>::size_type i = 0; i != root->children.size(); ++i)
201 | 		root->children[i]->writeContent(outputFile, "");
202 | 
203 | 	outputFile.close();
204 | }
205 | 
206 | void Trie::loadTrie(ifstream& inputFile)
207 | {
208 | 	string line;
209 | 	vector<string> splortLine;
210 | 	getline(inputFile, line);
211 | 	root->changeContent(ValidChar(' ', "", 0));
212 | 	while (getline(inputFile, line))
213 | 	{
214 | 		splortLine = splitLine(line);
215 | 		addWord(splortLine[0], splortLine[1], atoi(splortLine[2].c_str()));
216 | 	}
217 | }
218 | 
219 | void Node::writeContent(ofstream& outputFile, string front)
220 | {
221 | 	stringstream ss;
222 | 	ss << content.getFreq();
223 | 	string newFront = front + content.getChar();
224 | 
225 | 	outputFile << newFront + "~" + content.getPrediction() + "~" + ss.str() << endl;
226 | 
227 | 	for (vector<Node>::size_type i = 0; i != children.size(); ++i)
228 | 		children[i]->writeContent(outputFile, newFront);
229 | }
230 | 
231 | 
232 | 
233 | 
234 | Node::Node()
235 | {
236 | 
237 | }
238 | 
239 | Node::Node(ValidChar initChar)
240 | {
241 | 	content = initChar;
242 | }
243 | 
244 | const ValidChar& Node::getContent() const
245 | {
246 | 	return content;
247 | }
248 | 
249 | ValidChar& Node::getContentUnprotected()
250 | {
251 | 	return content;
252 | }
253 | 
254 | Node* Node::findChild(char c)
255 | {
256 | 	for (vector<Node>::size_type i = 0; i < children.size(); i++)
257 | 	{
258 | 		Node* tmp = children[i];
259 | 		if (tmp->getContent().getChar() == c)
260 | 			return tmp;
261 | 	}
262 | 	return NULL;
263 | }
264 | 
265 | void Node::appendChild(Node* child)
266 | {
267 | 	children.push_back(child);
268 | }
269 | 
270 | vector<string> splitLine(string& line)
271 | {
272 | 	vector<string> ret;
273 | 	string::size_type i = 0;
274 | 
275 | 	while (i != line.size())
276 | 	{
277 | 		if (line[i] == '~')
278 | 			i++;
279 | 
280 | 		string::size_type j = i;
281 | 
282 | 		while (j != line.size() && line[j] != '~')
283 | 			++j;
284 | 
285 | 		if (i != j)
286 | 		{
287 | 			ret.push_back(line.substr(i, j - i));
288 | 			i = j;
289 | 		}
290 | 	}
291 | 	return ret;
292 | }
293 | 
294 | void Node::changeContent(ValidChar inpCon)
295 | {
296 | 	content = inpCon;
297 | }
298 | 
299 | #endif


--------------------------------------------------------------------------------
/source/KeyMain.h:
--------------------------------------------------------------------------------
  1 | #ifndef KEYMAIN_H
  2 | #define KEYMAIN_H
  3 | 
  4 | #include <iostream>
  5 | #include <sstream>
  6 | #include <algorithm>
  7 | #include <windows.h>
  8 | #include "Drawer.h"
  9 | #include "Keyboard.h"
 10 | #include "Button.h"
 11 | #include "MouseStatus.h"
 12 | #include "enums.h"
 13 | 
 14 | using std::cout;
 15 | using std::endl;
 16 | 
 17 | string progName = "SliceType";
 18 | HWND currentWindow, newWindow, thisWindow;
 19 | char windowText[1024];
 20 | bool halfEntry = false;
 21 | unsigned int lastEnteredWordLength = 1;
 22 | 
 23 | void changeScreenSize(int newWidth, int newHeight);
 24 | string windowTitle = "SliceType";
 25 | 
 26 | class KeyMain
 27 | {
 28 | 	kbState state;
 29 | 	char currChar;
 30 | 	Keyboard kb;
 31 | 	ButtonSet* prevButtons;
 32 | 	Drawer dr;
 33 | 	MouseStatus mouseStat;
 34 | 	int counter, mCounter;
 35 | 	bool boolMorph;
 36 | 	bool isSameButtonset(ButtonSet* bs1, ButtonSet* bs2);
 37 | 	void sendString(string s);
 38 | 	void deleteLastWord();
 39 | public:
 40 | 	void updateMouseCell(int x, int y);
 41 | 	void tickCounter();
 42 | 	KeyMain();
 43 | 	void TEMPDRAW();
 44 | };
 45 | 
 46 | KeyMain::KeyMain()
 47 | {
 48 | 	state = noSelect;
 49 | 	boolMorph = false;
 50 | 	currChar = '\n';
 51 | 	counter = 0;
 52 | 	mCounter = 0;
 53 | 	cout << "Init with no selection." << endl;
 54 | 
 55 | }
 56 | 
 57 | void KeyMain::updateMouseCell(int x, int y)
 58 | {
 59 | 	if (mouseStat.updateCell(x, y))
 60 | 	{
 61 | 		int inpLoop, inpRow;
 62 | 		mouseStat.getCell(inpLoop, inpRow);
 63 | 
 64 | 		if (inpLoop == -1)
 65 | 		{
 66 | 			if (state == selectingOtherKey)
 67 | 			{
 68 | 				state = selectOtherKey;
 69 | 				counter = 0;
 70 | 				currChar = '\n';
 71 | 				return;
 72 | 			}
 73 | 			if (state == select2)
 74 | 			{
 75 | 				prevButtons = kb.getButtonSet();
 76 | 				cout << "Exited screen during 2nd selection phase." << endl;
 77 | 				kb.exitChar(currChar);
 78 | 				boolMorph = true;
 79 | 				mCounter = -1;
 80 | 			}
 81 | 			else if (state == select1)
 82 | 			{
 83 | 				//won't do anything here
 84 | 				cout << "Exited screen during 1st selection phase." << endl;
 85 | 			}
 86 | 			state = noSelect;
 87 | 			counter = 0;
 88 | 			currChar = '\n';
 89 | 			return;
 90 | 		}
 91 | 		else if (inpLoop == 3)
 92 | 		{
 93 | 			if (state == selectOtherKey)
 94 | 			{
 95 | 				state = selectOtherKey;
 96 | 				counter = 0;
 97 | 				currChar = '\n';
 98 | 				return;
 99 | 			}
100 | 			if ((state == noSelect) || (state == select1) || (state == select2))
101 | 			{
102 | 				state = selectOuter;
103 | 				counter = 0;
104 | 				if (inpRow == 0)
105 | 					currChar = 1;
106 | 				else if (inpRow == 1)
107 | 					currChar = 2;
108 | 				else if (inpRow == 2)
109 | 					currChar = 3;
110 | 				else
111 | 					currChar = 4;
112 | 				counter = 0;
113 | 				return;
114 | 			}
115 | 		}
116 | 
117 | 		Button onButton;
118 | 
119 | 		if ((state == selectOtherKey) || (state == selectingOtherKey))
120 | 		{
121 | 			kb.getOtherButtons()->getButtonWithField(inpLoop, inpRow, onButton);
122 | 
123 | 			if (onButton.getWriting().getChar() != currChar)
124 | 			{
125 | 				currChar = onButton.getWriting().getChar();
126 | 				state = selectingOtherKey;
127 | 				counter = 0;
128 | 				return;
129 | 			}
130 | 		}
131 | 
132 | 		if (!kb.getButtonSet()->getButtonWithField(inpLoop, inpRow, onButton))
133 | 		{
134 | 			if (state == select2)
135 | 			{
136 | 				prevButtons = kb.getButtonSet();
137 | 				cout << "Exited screen during 2nd selection phase." << endl;
138 | 				kb.exitChar(currChar);
139 | 				boolMorph = true;
140 | 				mCounter = -1;
141 | 			}
142 | 			else if (state == select1)
143 | 			{
144 | 				//won't do anything here
145 | 				cout << "Exited screen during 1st selection phase." << endl;
146 | 			}
147 | 			state = noSelect;
148 | 			counter = 0;
149 | 			currChar = '\n';
150 | 			return;
151 | 		}
152 | 
153 | 		if (onButton.getWriting().getChar() != currChar)
154 | 		{
155 | 			if (state == select2)
156 | 			{
157 | 				prevButtons = kb.getButtonSet();
158 | 				cout << currChar << " -> " << onButton.getWriting().getChar() << " select2" << endl;
159 | 				kb.exitChar(currChar);
160 | 				boolMorph = true;
161 | 				mCounter = -1;
162 | 			}
163 | 			else if (state == select1)
164 | 			{
165 | 				//won't do anything here
166 | 				cout << currChar << " -> " << onButton.getWriting().getChar() << " select1" << endl;
167 | 			}
168 | 			else if (state == noSelect)
169 | 			{
170 | 				//won't do anything here
171 | 				cout << " "  " -> " << onButton.getWriting().getChar() << " noSelect" << endl;
172 | 			}
173 | 			currChar = onButton.getWriting().getChar();
174 | 			state = select1;
175 | 			counter = 0;
176 | 		}
177 | 	}
178 | }
179 | 
180 | void KeyMain::tickCounter()
181 | {
182 | 	thisWindow = FindWindow(NULL, windowTitle.c_str());
183 | 	if (thisWindow == NULL)
184 | 		return;
185 | 
186 | 
187 | 	RECT thisWindowRect;
188 | 	GetWindowRect(thisWindow, &thisWindowRect);
189 | 
190 | 	POINT p;
191 | 	GetCursorPos(&p);
192 | 	if ((p.x < thisWindowRect.left) || (p.x > thisWindowRect.right) || (p.y < thisWindowRect.top) || (p.y > thisWindowRect.bottom))
193 | 		updateMouseCell(-1, -1);
194 | 
195 | 
196 | 
197 | 
198 | 	int width, height;
199 | 	width = thisWindowRect.right - thisWindowRect.left - 16;
200 | 	height = thisWindowRect.bottom - thisWindowRect.top - 38;
201 | 
202 | 	SCREEN_SIZE_X = width;
203 | 	SCREEN_SIZE_Y = height;
204 | 
205 | 
206 | 
207 | 	newWindow = GetForegroundWindow();
208 | 	if (newWindow == thisWindow)
209 | 	{
210 | 	}
211 | 	else if (newWindow != currentWindow)
212 | 	{
213 | 		currentWindow = newWindow;
214 | 		GetWindowText(currentWindow, windowText, 1024);
215 | 		windowTitle = string(windowText);
216 | 		if (windowTitle.size() == 0)
217 | 		{
218 | 			windowTitle = progName;
219 | 			glutSetWindowTitle(windowTitle.c_str());
220 | 		}
221 | 		else
222 | 		{
223 | 			windowTitle = progName + " >>> " + windowTitle;
224 | 			glutSetWindowTitle(windowTitle.c_str());
225 | 		}
226 | 	}
227 | 
228 | 
229 | 
230 | 	if ((state != noSelect) && (state != selectOtherKey) && (!boolMorph))
231 | 		counter++;
232 | 
233 | 	mCounter++;
234 | 
235 | 	if ((boolMorph) && (mCounter == morphCount))
236 | 	{
237 | 		boolMorph = false;
238 | 		mCounter = 0;
239 | 	}
240 | 
241 | 
242 | 	if (counter == selectCount)
243 | 	{
244 | 		if (state == secondClear)
245 | 		{
246 | 			deleteLastWord();
247 | 			counter = 0;
248 | 			state = noSelect;
249 | 			return;
250 | 		}
251 | 		if (state == selectingOtherKey)
252 | 		{
253 | 			stringstream ss;
254 | 			string stringToSend;
255 | 			ss << currChar;
256 | 			ss >> stringToSend;
257 | 			sendString(stringToSend);
258 | 			kb.setLastWord("");
259 | 			counter = 0;
260 | 			if (isdigit(currChar))
261 | 				state = selectOtherKey;
262 | 			else
263 | 				state = noSelect;
264 | 			return;
265 | 		}
266 | 		if (state == selectOuter)
267 | 		{
268 | 			counter = 0;
269 | 			if (currChar == 1)
270 | 			{
271 | 				prevButtons = kb.getButtonSet();
272 | 				kb.clearCurrWord();
273 | 				boolMorph = !isSameButtonset(prevButtons, kb.getButtonSet());
274 | 				counter = 0;
275 | 				mCounter = 0;
276 | 				state = secondClear;
277 | 				currChar = '\n';
278 | 			}
279 | 			else if (currChar == 2)
280 | 			{
281 | 				kb.setLastWord(kb.getCurrWord());
282 | 				prevButtons = kb.getButtonSet();
283 | 				string stringToSend = kb.getCurrWord();
284 | 				halfEntry = true;
285 | 				sendString(stringToSend);
286 | 				kb.clearCurrWord();
287 | 				kb.setLastWord(stringToSend);
288 | 				boolMorph = !isSameButtonset(prevButtons, kb.getButtonSet());
289 | 				counter = 0;
290 | 				mCounter = 0;
291 | 				state = noSelect;
292 | 				currChar = '\n';
293 | 
294 | 			}
295 | 			else if (currChar == 3)
296 | 			{
297 | 				state = selectOtherKey;
298 | 			}
299 | 			else
300 | 			{
301 | 
302 | 			}
303 | 			return;
304 | 		}
305 | 
306 | 
307 | 		if (state == select1)
308 | 		{
309 | 			prevButtons = kb.getButtonSet();
310 | 			state = select2;
311 | 			cout << "Finish select1 " << currChar << endl;
312 | 			kb.enterChar(currChar);
313 | 		}
314 | 		else if (state == select2)
315 | 		{
316 | 			prevButtons = kb.getButtonSet();
317 | 			state = noSelect;
318 | 			cout << "Finish select2 " << currChar << endl;
319 | 
320 | 
321 | 			string stringToSend = kb.enterWord();
322 | 
323 | 			sendString(stringToSend);
324 | 			currChar = '\n';
325 | 		}
326 | 		boolMorph = !isSameButtonset(prevButtons, kb.getButtonSet());
327 | 		counter = 0;
328 | 		mCounter = 0;
329 | 	}
330 | }
331 | 
332 | void KeyMain::TEMPDRAW()
333 | {
334 | 	if (state == secondClear)
335 | 		int a = 2;
336 | 
337 | 	if (boolMorph)
338 | 		dr.drawButtons(kb.getButtonSet(), prevButtons, state, boolMorph, (double)mCounter / morphCount, currChar, kb.getCurrWord());
339 | 	else if ((state == selectingOtherKey) || (state == selectOtherKey))
340 | 		dr.drawButtons(kb.getOtherButtons(), prevButtons, select1, false, (double)counter / selectCount, currChar, "~");
341 | 	else
342 | 		dr.drawButtons(kb.getButtonSet(), prevButtons, state, boolMorph, (double)counter / selectCount, currChar, kb.getCurrWord());
343 | }
344 | 
345 | bool KeyMain::isSameButtonset(ButtonSet* bs1, ButtonSet* bs2)
346 | {
347 | 	if (bs1->getButtons().size() != bs2->getButtons().size())
348 | 		return false;
349 | 	for (vector<Button>::size_type i = 0; i < bs1->getButtons().size(); i++)
350 | 	{
351 | 		if (bs1->getButtons()[i].getWriting().getChar() != bs2->getButtons()[i].getWriting().getChar())
352 | 			return false;
353 | 
354 | 		int loopStart1, loopEnd1, rowStart1, rowEnd1, loopStart2, loopEnd2, rowStart2, rowEnd2;
355 | 		bs1->getButtons()[i].getButtonShape().getShape(loopStart1, loopEnd1, rowStart1, rowEnd1);
356 | 		bs2->getButtons()[i].getButtonShape().getShape(loopStart2, loopEnd2, rowStart2, rowEnd2);
357 | 
358 | 		if ((loopStart1 != loopStart2) || (loopEnd1 != loopEnd2) || (rowStart1 != rowStart2) || (rowEnd1 != rowEnd2))
359 | 			return false;
360 | 	}
361 | 	return true;
362 | }
363 | 
364 | void KeyMain::sendString(string s)
365 | {
366 | 	SetForegroundWindow(currentWindow);
367 | 
368 | 	INPUT ip;
369 | 	ip.type = INPUT_KEYBOARD;
370 | 	ip.ki.time = 0;
371 | 	ip.ki.dwFlags = KEYEVENTF_UNICODE;
372 | 	ip.ki.wVk = 0;
373 | 	ip.ki.dwExtraInfo = 0;
374 | 
375 | 	lastEnteredWordLength = s.size();
376 | 
377 | 	if (s == ".")
378 | 	{
379 | 		lastEnteredWordLength = 1;
380 | 		deleteLastWord();
381 | 		lastEnteredWordLength = s.size();
382 | 	}
383 | 
384 | 
385 | 	for (string::size_type i = 0; i < s.size(); i++)
386 | 	{
387 | 		ip.ki.wScan = s[i];
388 | 		SendInput(1, &ip, sizeof(INPUT));
389 | 		if (s[i] == s[i + 1] && i + 1 != s.size())
390 | 			Sleep(25);
391 | 	}
392 | 	if (true)
393 | 	{
394 | 		ip.ki.wScan = ' ';
395 | 		SendInput(1, &ip, sizeof(INPUT));
396 | 		lastEnteredWordLength++;
397 | 		halfEntry = false;
398 | 	}
399 | 	if (halfEntry)
400 | 		halfEntry = false;
401 | 
402 | }
403 | 
404 | void KeyMain::deleteLastWord()
405 | {
406 | 	SetForegroundWindow(currentWindow);
407 | 
408 | 
409 | 	INPUT ip;
410 | 
411 | 	ip.type = INPUT_KEYBOARD;
412 | 	ip.ki.wScan = 0;
413 | 	ip.ki.time = 0;
414 | 	ip.ki.dwExtraInfo = 0;
415 | 
416 | 	ip.ki.wVk = 0x08; // bksp
417 | 
418 | 	for (unsigned int i = 0; i < lastEnteredWordLength; i++)
419 | 	{
420 | 		ip.ki.dwFlags = 0;
421 | 		SendInput(1, &ip, sizeof(INPUT));
422 | 		ip.ki.dwFlags = KEYEVENTF_KEYUP;
423 | 		SendInput(1, &ip, sizeof(INPUT));
424 | 	}
425 | 	lastEnteredWordLength = 1;
426 | }
427 | 
428 | #endif


--------------------------------------------------------------------------------
/source/Drawer.h:
--------------------------------------------------------------------------------
   1 | #ifndef DRAWER_H
   2 | #define DRAWER_H
   3 | 
   4 | #define M_PI 3.14159265358979323846
   5 | 
   6 | #include <cmath>
   7 | #include <string>
   8 | #include <sstream>
   9 | #include <cctype>
  10 | #include <windows.h>
  11 | #include "openGL.h"
  12 | #include "enums.h"
  13 | #include "ButtonSet.h"
  14 | 
  15 | class Drawer
  16 | {
  17 | 	vector<Button> butFadeIn;
  18 | 	vector<Button> butFadeOut;
  19 | 	vector<Button> butSame;
  20 | 	vector<Button> butMorphNew;
  21 | 	vector<Button> butMorphOld;
  22 | 
  23 | 	void drawText(Button but, double countDouble, bool FadeIn, bool incPred);
  24 | 	void morphText(Button oldBut, Button newBut, kbState state, double morphDouble, bool incPred);
  25 | 	void setColor(colorTypes colorCode, float alpha);
  26 | 	void convertPolartoCart(double angle, double radius, float &x, float &y);
  27 | 	void extractShapeParams(Button but, double &innerRad, double &outerRad, double &startAngle, double &stopAngle, double &sweepAngle);
  28 | 	double fanBetweenTwoAngles(double angle1, double angle2);
  29 | 
  30 | 
  31 | 	void drawMorphingInnerButton(GLUquadric* obj, double startAngle1, double startAngle2, double sweepAngle1, colorTypes color, double morphRatio);
  32 | 	void drawInnerButton(GLUquadric* obj, double startAngle, double sweepAngle, double fillRatio, colorTypes frontColor, colorTypes backColor, double alpha);
  33 | 	void drawFillingButton(GLUquadric* obj, double innerRad, double outerRad, double startAngle, double sweepAngle, double fillRatio, colorTypes frontColor);
  34 | 	void drawRegularButton(GLUquadric* obj, double innerRad, double outerRad, double startAngle, double sweepAngle, colorTypes frontColor, double alpha);
  35 | 	void updateButtonVectors(ButtonSet *newButtons, ButtonSet *oldButtons);
  36 | 	bool areButtonShapesSame(Button &but1, Button &but2);
  37 | 	void drawBackground(GLUquadric* obj, kbState state, double countDouble, char currChar, string currWord);
  38 | 
  39 | 
  40 | public:
  41 | 	void drawButtons(ButtonSet *newButtons, ButtonSet *oldButtons, kbState state, bool boolMorph, double countDouble, char currChar, string currentWord);
  42 | };
  43 | 
  44 | void Drawer::drawButtons(ButtonSet *newButtons, ButtonSet *oldButtons, kbState state, bool boolMorph, double countDouble, char currChar, string currentWord)
  45 | {
  46 | 	double innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1, innerradi2, outerradi2, startAngle2, stopAngle2, sweepAngle2;
  47 | 
  48 | 	//// mouse dislocation
  49 | 
  50 | 	double limit = 0.2;
  51 | 
  52 | 	if ((boolMorph) && (currChar != '\n') && (countDouble < limit))
  53 | 	{
  54 | 		int indexNew = -1;
  55 | 		bool skip = false;
  56 | 		for (int i = 0; i < newButtons->getButtons().size(); i++)
  57 | 		{
  58 | 			if (newButtons->getButtons()[i].getWriting().getChar() == currChar)
  59 | 				indexNew = i;
  60 | 		}
  61 | 		if (indexNew == -1)
  62 | 			skip = true;
  63 | 
  64 | 		if (!skip)
  65 | 		{
  66 | 			extractShapeParams(newButtons->getButtons()[indexNew], innerradi2, outerradi2, startAngle2, stopAngle2, sweepAngle2);
  67 | 
  68 | 			float newX, newY;
  69 | 			if ((innerradi2 == 0) && (sweepAngle2 == 360))
  70 | 			{
  71 | 				newX = 0;
  72 | 				newY = 0;
  73 | 			}
  74 | 			else
  75 | 			{
  76 | 				double radius = (outerradi2 + innerradi2) / 2;
  77 | 				double angle = startAngle2 + (sweepAngle2 / 2);
  78 | 				convertPolartoCart(angle, radius, newX, newY);
  79 | 			}
  80 | 
  81 | 			HWND tW = GetActiveWindow();
  82 | 			RECT rect;
  83 | 			GetWindowRect(tW, &rect);
  84 | 
  85 | 			newX += SCREEN_SIZE / 2;
  86 | 			newY += SCREEN_SIZE / 2;
  87 | 
  88 | 			//added to rectify resize bug
  89 | 			newX = (newX / SCREEN_SIZE)*(rect.right - rect.left - 38);
  90 | 			newY = (newY / SCREEN_SIZE)*(rect.bottom - rect.top - 16);
  91 | 			newX += 4;
  92 | 			newY += 16;
  93 | 			//added to rectify resize bug
  94 | 
  95 | 			newX += rect.left;
  96 | 			newY += rect.top;
  97 | 
  98 | 			POINT mPoint;
  99 | 			GetCursorPos(&mPoint);
 100 | 			float deltaX = (newX - mPoint.x) * (countDouble / limit);
 101 | 			float deltaY = (newY - mPoint.y) * (countDouble / limit);
 102 | 
 103 | 
 104 | 			SetCursorPos(mPoint.x + deltaX, mPoint.y + deltaY);
 105 | 		}
 106 | 
 107 | 	}
 108 | 
 109 | 	//// mouse dislocation
 110 | 
 111 | 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 112 | 	glLoadIdentity();
 113 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
 114 | 	GLUquadric* obj = gluNewQuadric();
 115 | 
 116 | 
 117 | 
 118 | 	drawBackground(obj, state, countDouble, currChar, currentWord);
 119 | 
 120 | 	if (boolMorph)
 121 | 	{
 122 | 		if (countDouble == 0)
 123 | 			updateButtonVectors(newButtons, oldButtons);
 124 | 
 125 | 		for (vector<Button>::size_type i = 0; i < butMorphNew.size(); i++)
 126 | 		{
 127 | 			extractShapeParams(butMorphOld[i], innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1);
 128 | 			extractShapeParams(butMorphNew[i], innerradi2, outerradi2, startAngle2, stopAngle2, sweepAngle2);
 129 | 
 130 | 			if (innerradi1 == 0)
 131 | 			{
 132 | 				if (butMorphOld[i].getWriting().getChar() == currChar)
 133 | 					drawMorphingInnerButton(obj, startAngle1, startAngle2, sweepAngle1, colorBack, countDouble);
 134 | 				else
 135 | 					drawMorphingInnerButton(obj, startAngle1, startAngle2, sweepAngle1, colorFront, countDouble);
 136 | 			}
 137 | 			else
 138 | 			{
 139 | 				double innerRad, outerRad, startAngle, sweepAngle;
 140 | 				innerRad = innerradi1 + (innerradi2 - innerradi1) * countDouble;
 141 | 				outerRad = outerradi1 + (outerradi2 - outerradi1) * countDouble;
 142 | 
 143 | 				double angleFan = fanBetweenTwoAngles(startAngle1, startAngle2);
 144 | 
 145 | 				if (startAngle1 < startAngle2)
 146 | 				{
 147 | 					if (startAngle1 + 180 > startAngle2)
 148 | 					{
 149 | 
 150 | 						startAngle = startAngle1 + angleFan * countDouble;
 151 | 					}
 152 | 					else
 153 | 					{
 154 | 						startAngle = startAngle1 - angleFan * countDouble;
 155 | 					}
 156 | 				}
 157 | 				else
 158 | 				{
 159 | 					if (startAngle1 - 180 < startAngle2)
 160 | 					{
 161 | 						startAngle = startAngle1 - angleFan * countDouble;
 162 | 					}
 163 | 					else
 164 | 					{
 165 | 						startAngle = startAngle1 + angleFan * countDouble;
 166 | 					}
 167 | 				}
 168 | 				if (startAngle > 360)
 169 | 					startAngle -= 360;
 170 | 
 171 | 				sweepAngle = sweepAngle1 + (sweepAngle2 - sweepAngle1) * countDouble;
 172 | 
 173 | 				if (butMorphOld[i].getWriting().getChar() == currChar)
 174 | 					drawRegularButton(obj, innerRad, outerRad, startAngle, sweepAngle, colorBack, 1);
 175 | 				else
 176 | 					drawRegularButton(obj, innerRad, outerRad, startAngle, sweepAngle, colorFront, 1);
 177 | 			}
 178 | 		}
 179 | 
 180 | 		for (vector<Button>::size_type i = 0; i < butSame.size(); i++)
 181 | 		{
 182 | 			extractShapeParams(butSame[i], innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1);
 183 | 
 184 | 			if (innerradi1 == 0)
 185 | 			{
 186 | 				if (butSame[i].getWriting().getChar() == currChar)
 187 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 0, colorBack, colorBack, 1);
 188 | 				else
 189 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 0, colorFront, colorFront, 1);
 190 | 			}
 191 | 			else
 192 | 			{
 193 | 				if (butSame[i].getWriting().getChar() == currChar)
 194 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorBack, 1);
 195 | 				else
 196 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorFront, 1);
 197 | 			}
 198 | 		}
 199 | 
 200 | 		for (vector<Button>::size_type i = 0; i < butFadeIn.size(); i++)
 201 | 		{
 202 | 			extractShapeParams(butFadeIn[i], innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1);
 203 | 
 204 | 			if (innerradi1 == 0)
 205 | 			{
 206 | 				if (butFadeIn[i].getWriting().getChar() == currChar)
 207 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 0, colorBack, colorBack, countDouble);
 208 | 				else
 209 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 0, colorFront, colorFront, countDouble);
 210 | 			}
 211 | 			else
 212 | 			{
 213 | 				if (butFadeIn[i].getWriting().getChar() == currChar)
 214 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorBack, countDouble);
 215 | 				else
 216 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorFront, countDouble);
 217 | 			}
 218 | 		}
 219 | 
 220 | 		for (vector<Button>::size_type i = 0; i < butFadeOut.size(); i++)
 221 | 		{
 222 | 			extractShapeParams(butFadeOut[i], innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1);
 223 | 
 224 | 			if (innerradi1 == 0)
 225 | 			{
 226 | 				if (butFadeOut[i].getWriting().getChar() == currChar)
 227 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 0, colorBack, colorBack, 1 - countDouble);
 228 | 				else
 229 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 0, colorFront, colorFront, 1 - countDouble);
 230 | 			}
 231 | 			else
 232 | 			{
 233 | 				if (butFadeOut[i].getWriting().getChar() == currChar)
 234 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorBack, 1 - countDouble);
 235 | 				else
 236 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorFront, 1 - countDouble);
 237 | 			}
 238 | 		}
 239 | 
 240 | 		//text
 241 | 		for (vector<Button>::size_type i = 0; i < butMorphNew.size(); i++)
 242 | 		{
 243 | 			if (butMorphOld[i].getWriting().getChar() == currChar)
 244 | 				morphText(butMorphOld[i], butMorphNew[i], state, countDouble, true);
 245 | 			else
 246 | 				morphText(butMorphOld[i], butMorphNew[i], noSelect, countDouble, false);
 247 | 		}
 248 | 		for (vector<Button>::size_type i = 0; i < butSame.size(); i++)
 249 | 		{
 250 | 			if (butSame[i].getWriting().getChar() == currChar)
 251 | 				drawText(butSame[i], 1, true, true);
 252 | 			else
 253 | 				drawText(butSame[i], 1, true, false);
 254 | 		}
 255 | 		for (vector<Button>::size_type i = 0; i < butFadeIn.size(); i++)
 256 | 		{
 257 | 			if (butFadeIn[i].getWriting().getChar() == currChar)
 258 | 				drawText(butFadeIn[i], countDouble, true, true);
 259 | 			else
 260 | 				drawText(butFadeIn[i], countDouble, true, false);
 261 | 		}
 262 | 		for (vector<Button>::size_type i = 0; i < butFadeOut.size(); i++)
 263 | 			drawText(butFadeOut[i], countDouble, false, false);
 264 | 
 265 | 
 266 | 	}
 267 | 	else
 268 | 	{
 269 | 		for (vector<Button>::size_type i = 0; i < newButtons->getButtons().size(); i++)
 270 | 		{
 271 | 			extractShapeParams(newButtons->getButtons()[i], innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1);
 272 | 
 273 | 			if (innerradi1 == 0)
 274 | 			{
 275 | 				if (newButtons->getButtons()[i].getWriting().getChar() == currChar)
 276 | 				{
 277 | 					if (state == select1)
 278 | 						drawInnerButton(obj, startAngle1, sweepAngle1, countDouble, colorS1, colorBack, 1);
 279 | 					else if (state == select2)
 280 | 						drawInnerButton(obj, startAngle1, sweepAngle1, countDouble, colorS2, colorBack, 1);
 281 | 					else
 282 | 						drawInnerButton(obj, startAngle1, sweepAngle1, 1, colorFront, colorFront, 1); //shouldn't happen anyways
 283 | 				}
 284 | 				else
 285 | 					drawInnerButton(obj, startAngle1, sweepAngle1, 1, colorFront, colorFront, 1);
 286 | 			}
 287 | 			else
 288 | 			{
 289 | 				if (newButtons->getButtons()[i].getWriting().getChar() == currChar)
 290 | 				{
 291 | 					if (state == select1)
 292 | 						drawFillingButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, countDouble, colorS1);
 293 | 					else if (state == select2)
 294 | 						drawFillingButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, countDouble, colorS2);
 295 | 					else
 296 | 						drawFillingButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, countDouble, colorFront); //shouldn't happen anyways
 297 | 				}
 298 | 				else
 299 | 					drawRegularButton(obj, innerradi1, outerradi1, startAngle1, sweepAngle1, colorFront, 1);
 300 | 			}
 301 | 		}
 302 | 		if (currentWord == "~")
 303 | 		{
 304 | 			for (vector<Button>::size_type i = 0; i < newButtons->getButtons().size(); i++)
 305 | 			{
 306 | 
 307 | 				drawText(newButtons->getButtons()[i], 1, true, false);
 308 | 			}
 309 | 		}
 310 | 		else
 311 | 		{
 312 | 			for (vector<Button>::size_type i = 0; i < newButtons->getButtons().size(); i++)
 313 | 			{
 314 | 				if (newButtons->getButtons()[i].getWriting().getChar() == currChar)
 315 | 					drawText(newButtons->getButtons()[i], 1, true, true);
 316 | 				else
 317 | 					drawText(newButtons->getButtons()[i], 1, true, false);
 318 | 			}
 319 | 		}
 320 | 
 321 | 	}
 322 | 
 323 | 	gluDeleteQuadric(obj);
 324 | }
 325 | 
 326 | 
 327 | void Drawer::drawText(Button but, double countDouble, bool FadeIn, bool incPred)
 328 | {
 329 | 	double innerRad, outerRad, startAngle, stopAngle, sweepAngle;
 330 | 	extractShapeParams(but, innerRad, outerRad, startAngle, stopAngle, sweepAngle);
 331 | 
 332 | 	float rastX, rastY;
 333 | 	if ((outerRad == radi0) && (sweepAngle == 360))
 334 | 	{
 335 | 		rastX = 0;
 336 | 		rastY = 0;
 337 | 	}
 338 | 	else
 339 | 	{
 340 | 		double radius = (outerRad + innerRad) / 2;
 341 | 		double angle = startAngle + (sweepAngle / 2);
 342 | 		convertPolartoCart(angle, radius, rastX, rastY);
 343 | 	}
 344 | 
 345 | 	glLineWidth(textWidth);
 346 | 	glLoadIdentity();
 347 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
 348 | 
 349 | 	if (FadeIn)
 350 | 		setColor(black, countDouble);
 351 | 	else
 352 | 		setColor(black, 1 - countDouble);
 353 | 
 354 | 	float totLength = glutStrokeWidth(GLUT_STROKE_ROMAN, but.getWriting().getChar()) * charScale;
 355 | 	float totHeight = 119.05 * charScale;
 356 | 	rastX -= totLength / 2;
 357 | 	rastY += totHeight / 2;
 358 | 
 359 | 	glTranslatef(rastX, rastY, 0);
 360 | 	glScalef(charScale, -charScale, charScale);
 361 | 	glutStrokeCharacter(GLUT_STROKE_ROMAN, toupper(but.getWriting().getChar()));
 362 | 
 363 | 	if (incPred)
 364 | 	{
 365 | 		glLineWidth(textSmallWidth);
 366 | 		rastX += totLength / 2;
 367 | 		rastY += 33.33 * charScale;
 368 | 
 369 | 		string pred = but.getWriting().getPrediction();
 370 | 		totLength = 0;
 371 | 		for (int i = 0; i < pred.size(); i++)
 372 | 			totLength += (glutStrokeWidth(GLUT_STROKE_ROMAN, pred[i]) + textSpacing);
 373 | 		totLength -= textSpacing;
 374 | 		totLength *= predScale;
 375 | 		totHeight = 119.05 * predScale;
 376 | 
 377 | 		rastX -= totLength / 2;
 378 | 		rastY += totHeight;
 379 | 
 380 | 
 381 | 		glLoadIdentity();
 382 | 		glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
 383 | 		glTranslatef(rastX, rastY, 0);
 384 | 		glScalef(predScale, -predScale, predScale);
 385 | 
 386 | 		for (int i = 0; i < pred.size(); i++)
 387 | 		{
 388 | 			glutStrokeCharacter(GLUT_STROKE_ROMAN, pred[i]);
 389 | 			glTranslatef(glutStrokeWidth(GLUT_STROKE_ROMAN, pred[i]) * predScale + textSpacing, 0, 0);
 390 | 		}
 391 | 	}
 392 | }
 393 | 
 394 | 
 395 | void Drawer::setColor(colorTypes colorCode, float alpha)
 396 | {
 397 | 	switch (colorCode)
 398 | 	{
 399 | 	case cornflowerBlue:
 400 | 		glColor4f(0.392f, 0.584f, 0.929f, alpha);
 401 | 		break;
 402 | 	case paleOrange:
 403 | 		glColor4f(1.f, 0.898f, 0.706f, alpha);
 404 | 		break;
 405 | 	case orange:
 406 | 		glColor4f(1.f, 0.5f, 0.f, alpha);
 407 | 		break;
 408 | 	case black:
 409 | 		glColor4f(0.f, 0.f, 0.f, alpha);
 410 | 		break;
 411 | 	case green:
 412 | 		glColor4f(0.f, 1.f, 0.f, alpha);
 413 | 		break;
 414 | 	case purple:
 415 | 		glColor4f(0.624f, 0.475f, 0.933f, alpha);
 416 | 		break;
 417 | 	case coral:
 418 | 		glColor4f(0.933f, 0.415f, 0.314f, alpha);
 419 | 		break;
 420 | 	case warmgrey:
 421 | 		glColor4f(0.5f, 0.5f, 0.418f, alpha);
 422 | 		break;
 423 | 	case olivedrab:
 424 | 		glColor4f(0.420f, 0.557f, 0.137f, alpha);
 425 | 		break;
 426 | 	case goldenrod:
 427 | 		glColor4f(0.803f, 0.584f, 0.047f, alpha);
 428 | 		break;
 429 | 	case turquoise:
 430 | 		glColor4f(0.f, 0.773f, 0.804f, alpha);
 431 | 		break;
 432 | 
 433 | 	}
 434 | 
 435 | }
 436 | 
 437 | void Drawer::convertPolartoCart(double angle, double radius, float &x, float &y)
 438 | {
 439 | 	x = cos((angle / 180) * M_PI) * radius;
 440 | 	y = sin((-angle / 180) * M_PI) * radius;
 441 | 	if (angle == 0)
 442 | 	{
 443 | 		x = radius;
 444 | 		y = 0;
 445 | 	}
 446 | 	else if (angle == 90)
 447 | 	{
 448 | 		x = 0;
 449 | 		y = -radius;
 450 | 	}
 451 | 	else if (angle == 180)
 452 | 	{
 453 | 		x = -radius;
 454 | 		y = 0;
 455 | 	}
 456 | 	else if (angle == 270)
 457 | 	{
 458 | 		x = 0;
 459 | 		y = radius;
 460 | 	}
 461 | }
 462 | 
 463 | void Drawer::extractShapeParams(Button but, double &innerRad, double &outerRad, double &startAngle, double &stopAngle, double &sweepAngle)
 464 | {
 465 | 	int loopStart, loopEnd, rowStart, rowEnd;
 466 | 	but.getButtonShape().getShape(loopStart, loopEnd, rowStart, rowEnd);
 467 | 
 468 | 	startAngle = rowStart * 30;
 469 | 	stopAngle = rowEnd * 30;
 470 | 
 471 | 	switch (loopStart)
 472 | 	{
 473 | 	case 0:
 474 | 		innerRad = 0;
 475 | 		break;
 476 | 	case 1:
 477 | 		innerRad = radi0;
 478 | 		break;
 479 | 	case 2:
 480 | 		innerRad = radi1;
 481 | 		break;
 482 | 	}
 483 | 
 484 | 	switch (loopEnd)
 485 | 	{
 486 | 	case 1:
 487 | 		outerRad = radi0;
 488 | 		break;
 489 | 	case 2:
 490 | 		outerRad = radi1;
 491 | 		break;
 492 | 	case 3:
 493 | 		outerRad = radi2;
 494 | 		break;
 495 | 	}
 496 | 
 497 | 	if (rowEnd - rowStart > 0)
 498 | 		sweepAngle = stopAngle - startAngle;
 499 | 	else
 500 | 		sweepAngle = 360 + stopAngle - startAngle;
 501 | }
 502 | 
 503 | 
 504 | 
 505 | double Drawer::fanBetweenTwoAngles(double angle1, double angle2)
 506 | {
 507 | 	double high, low;
 508 | 	if (angle1 < angle2)
 509 | 	{
 510 | 		high = angle2;
 511 | 		low = angle1;
 512 | 	}
 513 | 	else
 514 | 	{
 515 | 		high = angle1;
 516 | 		low = angle2;
 517 | 	}
 518 | 
 519 | 	double fan1 = high - low;
 520 | 	double fan2 = 360 - high + low;
 521 | 
 522 | 	if (fan1 < fan2)
 523 | 		return fan1;
 524 | 	else
 525 | 		return fan2;
 526 | }
 527 | void Drawer::morphText(Button oldBut, Button newBut, kbState state, double morphDouble, bool incPred)
 528 | {
 529 | 	glLoadIdentity();
 530 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
 531 | 
 532 | 	double innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1, innerradi2, outerradi2, startAngle2, stopAngle2, sweepAngle2;
 533 | 	extractShapeParams(oldBut, innerradi1, outerradi1, startAngle1, stopAngle1, sweepAngle1);
 534 | 	extractShapeParams(newBut, innerradi2, outerradi2, startAngle2, stopAngle2, sweepAngle2);
 535 | 
 536 | 	double innerRad, outerRad, startAngle, stopAngle, sweepAngle;
 537 | 	innerRad = innerradi1 + (innerradi2 - innerradi1) * morphDouble;
 538 | 	outerRad = outerradi1 + (outerradi2 - outerradi1) * morphDouble;
 539 | 
 540 | 	double angleFan = fanBetweenTwoAngles(startAngle1, startAngle2);
 541 | 
 542 | 	if (startAngle1 < startAngle2)
 543 | 	{
 544 | 		if (startAngle1 + 180 > startAngle2)
 545 | 		{
 546 | 
 547 | 			startAngle = startAngle1 + angleFan * morphDouble;
 548 | 		}
 549 | 		else
 550 | 		{
 551 | 			startAngle = startAngle1 - angleFan * morphDouble;
 552 | 		}
 553 | 	}
 554 | 	else
 555 | 	{
 556 | 		if (startAngle1 - 180 < startAngle2)
 557 | 		{
 558 | 			startAngle = startAngle1 - angleFan * morphDouble;
 559 | 		}
 560 | 		else
 561 | 		{
 562 | 			startAngle = startAngle1 + angleFan * morphDouble;
 563 | 		}
 564 | 	}
 565 | 	if (startAngle > 360)
 566 | 		startAngle -= 360;
 567 | 
 568 | 	sweepAngle = sweepAngle1 + (sweepAngle2 - sweepAngle1) * morphDouble;
 569 | 	stopAngle = startAngle + sweepAngle;
 570 | 	if (stopAngle > 360)
 571 | 		stopAngle -= 360;
 572 | 
 573 | 
 574 | 
 575 | 	float rastX, rastY;
 576 | 	if (innerradi1 == 0)
 577 | 	{
 578 | 		float y1, y2;
 579 | 
 580 | 		if (sweepAngle1 == 180)
 581 | 		{
 582 | 			if (startAngle1 == 0)
 583 | 				y1 = -radi0 / 2;
 584 | 			else
 585 | 				y1 = radi0 / 2;
 586 | 		}
 587 | 		else
 588 | 			y1 = 0;
 589 | 
 590 | 		if (sweepAngle2 == 180)
 591 | 		{
 592 | 			if (startAngle2 == 0)
 593 | 				y2 = -radi0 / 2;
 594 | 			else
 595 | 				y2 = radi0 / 2;
 596 | 		}
 597 | 		else
 598 | 			y2 = 0;
 599 | 
 600 | 		rastX = 0;
 601 | 		rastY = y1 + (y2 - y1) * morphDouble;
 602 | 	}
 603 | 	else
 604 | 	{
 605 | 		double radius = (outerRad + innerRad) / 2;
 606 | 		double angle = startAngle + (sweepAngle / 2);
 607 | 		convertPolartoCart(angle, radius, rastX, rastY);
 608 | 	}
 609 | 
 610 | 	glLineWidth(textWidth);
 611 | 
 612 | 
 613 | 	setColor(black, 1);
 614 | 
 615 | 	float totLength = glutStrokeWidth(GLUT_STROKE_ROMAN, newBut.getWriting().getChar()) * charScale;
 616 | 	float totHeight = 119.05 * charScale;
 617 | 	rastX -= totLength / 2;
 618 | 	rastY += totHeight / 2;
 619 | 
 620 | 	glTranslatef(rastX, rastY, 0);
 621 | 	glScalef(charScale, -charScale, charScale);
 622 | 	glutStrokeCharacter(GLUT_STROKE_ROMAN, toupper(newBut.getWriting().getChar()));
 623 | 
 624 | 	if (incPred)
 625 | 	{
 626 | 		glLineWidth(textSmallWidth);
 627 | 		rastX += totLength / 2;
 628 | 		rastY += 33.33 * charScale;
 629 | 
 630 | 		string pred = newBut.getWriting().getPrediction();
 631 | 		totLength = 0;
 632 | 		for (int i = 0; i < pred.size(); i++)
 633 | 			totLength += (glutStrokeWidth(GLUT_STROKE_ROMAN, pred[i]) + textSpacing);
 634 | 		totLength -= textSpacing;
 635 | 		totLength *= predScale;
 636 | 		totHeight = 119.05 * predScale;
 637 | 
 638 | 		rastX -= totLength / 2;
 639 | 		rastY += totHeight;
 640 | 
 641 | 
 642 | 		glLoadIdentity();
 643 | 		glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
 644 | 		glTranslatef(rastX, rastY, 0);
 645 | 		glScalef(predScale, -predScale, predScale);
 646 | 
 647 | 		for (int i = 0; i < pred.size(); i++)
 648 | 		{
 649 | 			glutStrokeCharacter(GLUT_STROKE_ROMAN, pred[i]);
 650 | 			glTranslatef(glutStrokeWidth(GLUT_STROKE_ROMAN, pred[i]) * predScale + textSpacing, 0, 0);
 651 | 		}
 652 | 	}
 653 | }
 654 | 
 655 | 
 656 | 
 657 | 
 658 | void Drawer::drawMorphingInnerButton(GLUquadric* obj, double startAngle1, double startAngle2, double sweepAngle1, colorTypes color, double morphRatio)
 659 | {
 660 | 
 661 | 	setColor(color, 1);
 662 | 
 663 | 	gluPartialDisk(obj, 0, radi0, slices, loops, 0, 360);
 664 | 
 665 | 	setColor(black, 1);
 666 | 
 667 | 	if (sweepAngle1 == 180)
 668 | 	{
 669 | 		if (startAngle1 == 0) //up to full	
 670 | 		{
 671 | 			glBegin(GL_POLYGON);
 672 | 			glVertex3f(-radi0, radi0 * morphRatio, 0.0f);
 673 | 			glVertex3f(radi0, radi0 * morphRatio, 0.0f);
 674 | 			glVertex3f(radi0, radi0, 0.0f);
 675 | 			glVertex3f(-radi0, radi0, 0.0f);
 676 | 			glEnd();
 677 | 		}
 678 | 		else // down to full
 679 | 		{
 680 | 			glBegin(GL_POLYGON);
 681 | 			glVertex3f(-radi0, -radi0 * morphRatio, 0.0f);
 682 | 			glVertex3f(radi0, -radi0 * morphRatio, 0.0f);
 683 | 			glVertex3f(radi0, -radi0, 0.0f);
 684 | 			glVertex3f(-radi0, -radi0, 0.0f);
 685 | 			glEnd();
 686 | 		}
 687 | 	}
 688 | 	else
 689 | 	{
 690 | 		if (startAngle2 == 0) // full to up
 691 | 		{
 692 | 			glBegin(GL_POLYGON);
 693 | 			glVertex3f(-radi0, radi0 - radi0 * morphRatio, 0.0f);
 694 | 			glVertex3f(radi0, radi0 - radi0 * morphRatio, 0.0f);
 695 | 			glVertex3f(radi0, radi0, 0.0f);
 696 | 			glVertex3f(-radi0, radi0, 0.0f);
 697 | 			glEnd();
 698 | 		}
 699 | 		else //full to down
 700 | 		{
 701 | 			glBegin(GL_POLYGON);
 702 | 			glVertex3f(-radi0, -radi0 + radi0 * morphRatio, 0.0f);
 703 | 			glVertex3f(radi0, -radi0 + radi0 * morphRatio, 0.0f);
 704 | 			glVertex3f(radi0, -radi0, 0.0f);
 705 | 			glVertex3f(-radi0, -radi0, 0.0f);
 706 | 			glEnd();
 707 | 		}
 708 | 	}
 709 | 
 710 | }
 711 | 
 712 | void Drawer::drawInnerButton(GLUquadric* obj, double startAngle, double sweepAngle, double fillRatio, colorTypes frontColor, colorTypes backColor, double alpha)
 713 | {
 714 | 	double innerRad, outerRad, fillOuterRad;
 715 | 	innerRad = 0;
 716 | 	outerRad = radi0;
 717 | 	fillOuterRad = innerRad + (outerRad - innerRad) * fillRatio;
 718 | 
 719 | 	startAngle += 90;
 720 | 	double stopAngle = startAngle + sweepAngle;
 721 | 	if (stopAngle > 360)
 722 | 		stopAngle -= 360;
 723 | 
 724 | 
 725 | 	if (frontColor == backColor)
 726 | 	{
 727 | 		setColor(colorFront, alpha);
 728 | 		gluPartialDisk(obj, innerRad, outerRad, slices, loops, startAngle, sweepAngle);
 729 | 	}
 730 | 	else
 731 | 	{
 732 | 		setColor(backColor, alpha);
 733 | 		gluPartialDisk(obj, innerRad, outerRad, slices, loops, startAngle, sweepAngle);
 734 | 		setColor(frontColor, alpha);
 735 | 		gluPartialDisk(obj, innerRad, fillOuterRad, slices, loops, startAngle, sweepAngle);
 736 | 	}
 737 | 
 738 | 
 739 | 	setColor(black, alpha);
 740 | 
 741 | 	gluPartialDisk(obj, outerRad - circleBoundary, outerRad, slices, loops, startAngle, sweepAngle);
 742 | 
 743 | 	if (sweepAngle != 360)
 744 | 	{
 745 | 		glLineWidth(lineWidth);
 746 | 
 747 | 		if (outerRad == radi0)
 748 | 		{
 749 | 			glBegin(GL_LINES);
 750 | 			glVertex3f(innerRad + radi0, 0, 0);
 751 | 			glVertex3f(innerRad - radi0, 0, 0);
 752 | 			glEnd();
 753 | 		}
 754 | 		else
 755 | 		{
 756 | 			float sinStartAngle = sin((startAngle / 180) * M_PI);
 757 | 			float cosStartAngle = cos((startAngle / 180) * M_PI);
 758 | 			float sinStopAngle = sin((stopAngle / 180) * M_PI);
 759 | 			float cosStopAngle = cos((stopAngle / 180) * M_PI);
 760 | 
 761 | 			glBegin(GL_LINES);
 762 | 			glVertex3f(innerRad * sinStartAngle, innerRad * cosStartAngle, 0.0);
 763 | 			glVertex3f(outerRad * sinStartAngle, outerRad * cosStartAngle, 0.0);
 764 | 			glVertex3f(innerRad * sinStopAngle, innerRad * cosStopAngle, 0.0);
 765 | 			glVertex3f(outerRad * sinStopAngle, outerRad * cosStopAngle, 0.0);
 766 | 			glEnd();
 767 | 		}
 768 | 	}
 769 | 
 770 | 
 771 | }
 772 | 
 773 | void Drawer::drawFillingButton(GLUquadric* obj, double innerRad, double outerRad, double startAngle, double sweepAngle, double fillRatio, colorTypes frontColor)
 774 | {
 775 | 	double fillOuterRad = innerRad + (outerRad - innerRad) * fillRatio;
 776 | 
 777 | 	startAngle += 90;
 778 | 	double stopAngle = startAngle + sweepAngle;
 779 | 	if (stopAngle > 360)
 780 | 		stopAngle -= 360;
 781 | 
 782 | 	setColor(colorBack, 1);
 783 | 	gluPartialDisk(obj, innerRad, outerRad, slices, loops, startAngle, sweepAngle);
 784 | 
 785 | 	setColor(frontColor, 1);
 786 | 	gluPartialDisk(obj, innerRad, fillOuterRad, slices, loops, startAngle, sweepAngle);
 787 | 
 788 | 	setColor(black, 1);
 789 | 	gluPartialDisk(obj, outerRad - circleBoundary, outerRad, slices, loops, startAngle, sweepAngle);
 790 | 	if (innerRad != 0)
 791 | 		gluPartialDisk(obj, innerRad, innerRad + circleBoundary, slices, loops, startAngle, sweepAngle);
 792 | 
 793 | 	if (sweepAngle != 360)
 794 | 	{
 795 | 		glLineWidth(lineWidth);
 796 | 
 797 | 		if (outerRad == radi0)
 798 | 		{
 799 | 			glBegin(GL_LINES);
 800 | 			glVertex3f(innerRad + radi0, 0, 0);
 801 | 			glVertex3f(innerRad - radi0, 0, 0);
 802 | 			glEnd();
 803 | 		}
 804 | 		else
 805 | 		{
 806 | 			float sinStartAngle = sin((startAngle / 180) * M_PI);
 807 | 			float cosStartAngle = cos((startAngle / 180) * M_PI);
 808 | 			float sinStopAngle = sin((stopAngle / 180) * M_PI);
 809 | 			float cosStopAngle = cos((stopAngle / 180) * M_PI);
 810 | 
 811 | 			glBegin(GL_LINES);
 812 | 			glVertex3f(innerRad * sinStartAngle, innerRad * cosStartAngle, 0.0);
 813 | 			glVertex3f(outerRad * sinStartAngle, outerRad * cosStartAngle, 0.0);
 814 | 			glVertex3f(innerRad * sinStopAngle, innerRad * cosStopAngle, 0.0);
 815 | 			glVertex3f(outerRad * sinStopAngle, outerRad * cosStopAngle, 0.0);
 816 | 			glEnd();
 817 | 		}
 818 | 	}
 819 | 
 820 | }
 821 | 
 822 | void Drawer::drawRegularButton(GLUquadric* obj, double innerRad, double outerRad, double startAngle, double sweepAngle, colorTypes frontColor, double alpha)
 823 | {
 824 | 	startAngle += 90;
 825 | 	double stopAngle = startAngle + sweepAngle;
 826 | 	if (stopAngle > 360)
 827 | 		stopAngle -= 360;
 828 | 
 829 | 	setColor(frontColor, alpha);
 830 | 	gluPartialDisk(obj, innerRad, outerRad, slices, loops, startAngle, sweepAngle);
 831 | 
 832 | 	setColor(black, alpha);
 833 | 	gluPartialDisk(obj, outerRad - circleBoundary, outerRad, slices, loops, startAngle, sweepAngle);
 834 | 	if (innerRad != 0)
 835 | 		gluPartialDisk(obj, innerRad, innerRad + circleBoundary, slices, loops, startAngle, sweepAngle);
 836 | 
 837 | 	if (sweepAngle != 360)
 838 | 	{
 839 | 		glLineWidth(lineWidth);
 840 | 
 841 | 		if (outerRad == radi0)
 842 | 		{
 843 | 			glBegin(GL_LINES);
 844 | 			glVertex3f(innerRad + radi0, 0, 0);
 845 | 			glVertex3f(innerRad - radi0, 0, 0);
 846 | 			glEnd();
 847 | 		}
 848 | 		else
 849 | 		{
 850 | 			float sinStartAngle = sin((startAngle / 180) * M_PI);
 851 | 			float cosStartAngle = cos((startAngle / 180) * M_PI);
 852 | 			float sinStopAngle = sin((stopAngle / 180) * M_PI);
 853 | 			float cosStopAngle = cos((stopAngle / 180) * M_PI);
 854 | 
 855 | 			glBegin(GL_LINES);
 856 | 			glVertex3f(innerRad * sinStartAngle, innerRad * cosStartAngle, 0.0);
 857 | 			glVertex3f(outerRad * sinStartAngle, outerRad * cosStartAngle, 0.0);
 858 | 			glVertex3f(innerRad * sinStopAngle, innerRad * cosStopAngle, 0.0);
 859 | 			glVertex3f(outerRad * sinStopAngle, outerRad * cosStopAngle, 0.0);
 860 | 			glEnd();
 861 | 		}
 862 | 	}
 863 | 
 864 | }
 865 | 
 866 | void Drawer::updateButtonVectors(ButtonSet *newButtons, ButtonSet *oldButtons)
 867 | {
 868 | 	butFadeIn.clear();
 869 | 	butFadeOut.clear();
 870 | 	butSame.clear();
 871 | 	butMorphNew.clear();
 872 | 	butMorphOld.clear();
 873 | 
 874 | 	for (vector<Button>::size_type i = 0; i < oldButtons->getButtons().size(); i++)
 875 | 	{
 876 | 		int foundInd = -1;
 877 | 
 878 | 		for (vector<Button>::size_type j = 0; j < newButtons->getButtons().size(); j++)
 879 | 		{
 880 | 			if (oldButtons->getButtons()[i].getWriting().getChar() == newButtons->getButtons()[j].getWriting().getChar())
 881 | 			{
 882 | 				foundInd = j;
 883 | 				break;
 884 | 			}
 885 | 		}
 886 | 
 887 | 		if (foundInd == -1)
 888 | 			butFadeOut.push_back(oldButtons->getButtons()[i]);
 889 | 		else if (areButtonShapesSame(oldButtons->getButtons()[i], newButtons->getButtons()[foundInd]))
 890 | 			butSame.push_back(newButtons->getButtons()[foundInd]);
 891 | 		else
 892 | 		{
 893 | 			butMorphOld.push_back(oldButtons->getButtons()[i]);
 894 | 			butMorphNew.push_back(newButtons->getButtons()[foundInd]);
 895 | 		}
 896 | 	}
 897 | 
 898 | 	for (vector<Button>::size_type i = 0; i < newButtons->getButtons().size(); i++)
 899 | 	{
 900 | 		int foundInd = -1;
 901 | 
 902 | 		for (vector<Button>::size_type j = 0; j < oldButtons->getButtons().size(); j++)
 903 | 		{
 904 | 			if (newButtons->getButtons()[i].getWriting().getChar() == oldButtons->getButtons()[j].getWriting().getChar())
 905 | 			{
 906 | 				foundInd = j;
 907 | 				break;
 908 | 			}
 909 | 		}
 910 | 
 911 | 		if (foundInd == -1)
 912 | 			butFadeIn.push_back(newButtons->getButtons()[i]);
 913 | 	}
 914 | }
 915 | 
 916 | bool Drawer::areButtonShapesSame(Button &but1, Button &but2)
 917 | {
 918 | 	int loopStart1, loopEnd1, rowStart1, rowEnd1, loopStart2, loopEnd2, rowStart2, rowEnd2;
 919 | 
 920 | 	but1.getButtonShape().getShape(loopStart1, loopEnd1, rowStart1, rowEnd1);
 921 | 	but2.getButtonShape().getShape(loopStart2, loopEnd2, rowStart2, rowEnd2);
 922 | 
 923 | 	if ((loopStart1 == loopStart2) && (loopEnd1 == loopEnd2) && (rowStart1 == rowStart2) && (rowEnd1 == rowEnd2))
 924 | 		return true;
 925 | 	else
 926 | 		return false;
 927 | }
 928 | 
 929 | void Drawer::drawBackground(GLUquadric* obj, kbState state, double countDouble, char currChar, string currWord)
 930 | {
 931 | 	if (currWord == "~")
 932 | 		return;
 933 | 	double halfSize = SCREEN_SIZE / 2;
 934 | 	setColor(colorFront, 1);
 935 | 	glBegin(GL_POLYGON);
 936 | 	glVertex3f(-halfSize, -halfSize, 0);
 937 | 	glVertex3f(halfSize, -halfSize, 0);
 938 | 	glVertex3f(halfSize, halfSize, 0);
 939 | 	glVertex3f(-halfSize, halfSize, 0);
 940 | 	glEnd();
 941 | 
 942 | 	if (state == selectOuter)
 943 | 	{
 944 | 		setColor(colorS1, 1);
 945 | 		double radius = sqrt(pow(halfSize, 2) * 2);
 946 | 		if (currChar == 1)
 947 | 			gluPartialDisk(obj, halfSize, halfSize + (radius - halfSize) * countDouble, slices, loops, 90, 90);
 948 | 		else if (currChar == 2)
 949 | 			gluPartialDisk(obj, halfSize, halfSize + (radius - halfSize) * countDouble, slices, loops, 180, 90);
 950 | 		else if (currChar == 3)
 951 | 			gluPartialDisk(obj, halfSize, halfSize + (radius - halfSize) * countDouble, slices, loops, 270, 90);
 952 | 		else if (currChar == 4)
 953 | 			gluPartialDisk(obj, halfSize, halfSize + (radius - halfSize) * countDouble, slices, loops, 0, 90);
 954 | 	}
 955 | 	else if (state == secondClear)
 956 | 	{
 957 | 		setColor(colorS2, 1);
 958 | 		double radius = sqrt(pow(halfSize, 2) * 2);
 959 | 		gluPartialDisk(obj, halfSize, halfSize + (radius - halfSize) * countDouble, slices, loops, 90, 90);
 960 | 	}
 961 | 
 962 | 	setColor(black, 1);
 963 | 	gluDisk(obj, 0, halfSize, slices, loops);
 964 | 	glLineWidth(textWidth);
 965 | 
 966 | 	setColor(black, 1);
 967 | 	float totLength = 0;
 968 | 	for (int i = 0; i < currWord.size(); i++)
 969 | 	{
 970 | 		currWord[i] = toupper(currWord[i]);
 971 | 		totLength += (glutStrokeWidth(GLUT_STROKE_ROMAN, currWord[i]) + textSpacing);
 972 | 	}
 973 | 	totLength -= textSpacing;
 974 | 	totLength *= charScale;
 975 | 	float totHeight = 119.05 * charScale;
 976 | 	float rastX = -halfSize + textSpacing * 5;
 977 | 	float rastY = -halfSize + totHeight + textSpacing * 5;
 978 | 	glTranslatef(rastX, rastY, 0);
 979 | 	glScalef(charScale, -charScale, charScale);
 980 | 	for (int i = 0; i < currWord.size(); i++)
 981 | 	{
 982 | 		glutStrokeCharacter(GLUT_STROKE_ROMAN, currWord[i]);
 983 | 		glTranslatef(glutStrokeWidth(GLUT_STROKE_ROMAN, currWord[i]) * charScale + textSpacing, 0, 0);
 984 | 	}
 985 | 
 986 | 	setColor(black, 1);
 987 | 	string bksp = "Backspace";
 988 | 	glLineWidth(textSmallWidth);
 989 | 	totLength = 0;
 990 | 	for (int i = 0; i < bksp.size(); i++)
 991 | 		totLength += (glutStrokeWidth(GLUT_STROKE_ROMAN, bksp[i]) + textSpacing);
 992 | 	totLength -= textSpacing;
 993 | 	totLength *= predScale;
 994 | 	rastX = halfSize - totLength*1.25;
 995 | 	rastY = -halfSize + totHeight*1.5;
 996 | 	glLoadIdentity();
 997 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
 998 | 	glTranslatef(rastX, rastY, 0);
 999 | 	glScalef(predScale, -predScale, predScale);
1000 | 	for (int i = 0; i < bksp.size(); i++)
1001 | 	{
1002 | 		glutStrokeCharacter(GLUT_STROKE_ROMAN, bksp[i]);
1003 | 		glTranslatef(glutStrokeWidth(GLUT_STROKE_ROMAN, bksp[i]) * predScale + textSpacing, 0, 0);
1004 | 	}
1005 | 
1006 | 	string otk = "Other Keys";
1007 | 	glLineWidth(textSmallWidth);
1008 | 	totLength = 0;
1009 | 	for (int i = 0; i < otk.size(); i++)
1010 | 		totLength += (glutStrokeWidth(GLUT_STROKE_ROMAN, otk[i]) + textSpacing);
1011 | 	totLength -= textSpacing;
1012 | 	totLength *= predScale;
1013 | 	rastX = -halfSize + textSpacing * 5;
1014 | 	rastY = halfSize - totHeight*0.5 - textSpacing;
1015 | 	glLoadIdentity();
1016 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
1017 | 	glTranslatef(rastX, rastY, 0);
1018 | 	glScalef(predScale, -predScale, predScale);
1019 | 	for (int i = 0; i < otk.size(); i++)
1020 | 	{
1021 | 		glutStrokeCharacter(GLUT_STROKE_ROMAN, otk[i]);
1022 | 		glTranslatef(glutStrokeWidth(GLUT_STROKE_ROMAN, otk[i]) * predScale + textSpacing, 0, 0);
1023 | 	}
1024 | 
1025 | 	string opt = "Options";
1026 | 	glLineWidth(textSmallWidth);
1027 | 	totLength = 0;
1028 | 	for (int i = 0; i < opt.size(); i++)
1029 | 		totLength += (glutStrokeWidth(GLUT_STROKE_ROMAN, otk[i]) + textSpacing);
1030 | 	totLength -= textSpacing;
1031 | 	totLength *= predScale;
1032 | 	rastX = halfSize - totLength*1.5;
1033 | 	rastY = halfSize - totHeight*0.5 - textSpacing;
1034 | 	glLoadIdentity();
1035 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
1036 | 	glTranslatef(rastX, rastY, 0);
1037 | 	glScalef(predScale, -predScale, predScale);
1038 | 	for (int i = 0; i < opt.size(); i++)
1039 | 	{
1040 | 		glutStrokeCharacter(GLUT_STROKE_ROMAN, opt[i]);
1041 | 		glTranslatef(glutStrokeWidth(GLUT_STROKE_ROMAN, opt[i]) * predScale + textSpacing, 0, 0);
1042 | 	}
1043 | 
1044 | 	glLoadIdentity();
1045 | 	glTranslatef(SCREEN_SIZE / 2.f, SCREEN_SIZE / 2.f, 0.f);
1046 | }
1047 | 
1048 | 
1049 | #endif


--------------------------------------------------------------------------------