void GuitarNeckComponent::resized()
{
int w = getWidth();
int h = getHeight();
if (w > 0 && h > 0)
{
int kx2, kw2;
getFretPos (rangeEnd, kx2, kw2);
kx2 += kw2;
if (firstFret != rangeStart)
{
int kx1, kw1;
getFretPos (rangeStart, kx1, kw1);
if (kx2 - kx1 <= w)
{
firstFret = rangeStart;
sendChangeMessage();
repaint();
}
}
xOffset = 0;
firstFret = rangeStart;
timerCallback();
repaint();
}
}
bool MoviePlayer::play(const Common::String &filename, bool looping, int x, int y, bool start) {
Common::StackLock lock(_frameMutex);
deinit();
_x = x;
_y = y;
_fname = filename;
_videoLooping = looping;
if (!loadFile(_fname))
return false;
Debug::debug(Debug::Movie, "Playing video '%s'.\n", filename.c_str());
init();
_internalSurface = NULL;
if (start) {
_videoDecoder->start();
// Get the first frame immediately
timerCallback(this);
}
return true;
}
void paint (Graphics&)
{
ComponentPeer* const peer = owner.getPeer();
if (peer != nullptr)
peer->addMaskedRegion (owner.getScreenBounds() - peer->getScreenPosition());
if (owner.isUsingDedicatedThread())
{
if (peer != nullptr && owner.isShowing())
{
#if ! JUCE_LINUX
owner.updateContext();
#endif
if (! owner.threadStarted)
{
owner.threadStarted = true;
owner.startRenderThread();
}
}
}
else
{
owner.updateContext();
if (isTimerRunning())
timerCallback();
}
}
int main (int argc, char ** argv)
{
GLenum type;
glutInit(&argc, argv);
glutInitWindowSize(1024,768);
type = GLUT_RGB;
type |= GLUT_DOUBLE;
type |= GLUT_DEPTH;
type |= GLUT_MULTISAMPLE;
glutInitDisplayMode(type);
glutCreateWindow("Project1");
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
sun_2d=LoadGLTexture("sun.jpg");
earth_2d=LoadGLTexture("earth_sphere.jpg");
moon_2d=LoadGLTexture("moon.jpg");
moon2_2d=LoadGLTexture("texture.jpg");
mars_2d=LoadGLTexture("jupiter.jpg");
glMatrixMode(GL_PROJECTION);
gluPerspective(70, 1024/768, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
timerCallback(0);
glutDisplayFunc(Draw);
glutMainLoop();
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
int main (int argc, char ** argv)
{
GLenum type;
glutInit(&argc, argv);
glutInitWindowSize(800,600);
type = GLUT_RGB;
type |= GLUT_DOUBLE;
type |= GLUT_DEPTH;
type |= GLUT_MULTISAMPLE;
glutInitDisplayMode(type);
glutCreateWindow("Simple Solar System");
glClearColor(0.0, 0, 1, 1.0);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
gluPerspective(55, 800/600, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
setupLight();
timerCallback(0);
//setupLight();
glutDisplayFunc(Draw);
glutMainLoop();
return 0;
}
void SmushPlayer::restore(SaveGame *state) {
if (isPlaying()) {
_smushDecoder->seek((uint32)_movieTime);
_smushDecoder->start();
timerCallback(this);
}
}
void paint (Graphics&)
{
ComponentPeer* const peer = owner.getPeer();
if (peer != nullptr)
peer->addMaskedRegion (owner.getScreenBounds() - peer->getScreenPosition());
if (owner.isUsingDedicatedThread())
{
if (peer != nullptr && owner.isShowing())
{
#if ! JUCE_LINUX
owner.updateContext();
#endif
owner.startRenderThread();
}
}
else
{
owner.updateContext();
#if JUCE_ANDROID
triggerAndroidOpenGLRepaint (owner.getCurrentContext());
#else
if (isTimerRunning())
timerCallback();
#endif
}
}
void PwmConfig::weComplexInit(const char *msg, int phaseCount, float *switchTimes, int waveCount,
pin_state_t **pinStates, pwm_cycle_callback *pwmCycleCallback, pwm_gen_callback *stateChangeCallback) {
efiAssertVoid(periodNt != 0, "period is not initialized");
if (phaseCount == 0) {
firmwareError(CUSTOM_ERR_PWM_1, "signal length cannot be zero");
return;
}
if (phaseCount > PWM_PHASE_MAX_COUNT) {
firmwareError(CUSTOM_ERR_PWM_2, "too many phases in PWM");
return;
}
efiAssertVoid(waveCount > 0, "waveCount should be positive");
checkSwitchTimes2(phaseCount, switchTimes);
this->pwmCycleCallback = pwmCycleCallback;
this->stateChangeCallback = stateChangeCallback;
multiWave.waveCount = waveCount;
copyPwmParameters(this, phaseCount, switchTimes, waveCount, pinStates);
safe.phaseIndex = 0;
safe.periodNt = -1;
safe.iteration = -1;
// let's start the indefinite callback loop of PWM generation
timerCallback(this);
}
int main (int argc, char ** argv)
{
glutInit(&argc, argv);
InitGL();
timerCallback(0);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
glutDisplayFunc(Draw);
glutMainLoop();
return 0;
}
int main (int argc, char ** argv)
{
GLenum type;
glutInit(&argc, argv);
glutInitWindowSize(CurrentWidth,CurrentHeight);
type = GLUT_RGB;
type |= GLUT_DOUBLE;
type |= GLUT_DEPTH;
type |= GLUT_MULTISAMPLE;
glutInitDisplayMode(type);
glutCreateWindow("");
glewInit();
glClearColor(0.0, 0.0, 0.0, 1.0);
// Z-Buffer i aciyoruz
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
const GLubyte* glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
printf("GLSL Version: %s\n",glslVersion);
const GLubyte* glVersion = glGetString(GL_VERSION);
printf("GL Version: %s\n",glVersion);
setupScene();
timerCallback(0);
glutReshapeFunc(ResizeFunction);
glutDisplayFunc(Draw);
glutKeyboardFunc(Key);
glutIdleFunc(IdleFunction);
printf("\n\n\tControls:\n");
printf("\t---------\n");
printf("\tQ: Increase power\n");
printf("\tA: Decrease power\n");
printf("\tW: Increase reflectance\n");
printf("\tS: Decrease reflectance\n\n");
glutMainLoop();
return 0;
}
int main (int argc, char ** argv)
{
GLenum type;
glutInit(&argc, argv);
glutInitWindowSize(CurrentWidth,CurrentHeight);
type = GLUT_RGB;
type |= GLUT_DOUBLE;
type |= GLUT_DEPTH;
type |= GLUT_MULTISAMPLE;
glutInitDisplayMode(type);
glutCreateWindow("");
#ifdef _WIN32
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
#endif
const GLubyte* glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
printf("GLSL Version: %s\n",glslVersion);
const GLubyte* glVersion = glGetString(GL_VERSION);
printf("GL Version: %s\n",glVersion);
glClearColor(0.0, 1.0, 0.0, 1.0);
// Z-Buffer i aciyoruz
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
setupScene();
timerCallback(0);
glutReshapeFunc(ResizeFunction);
glutDisplayFunc(Draw);
glutKeyboardFunc(Key);
glutIdleFunc(IdleFunction);
glutMainLoop();
return 0;
}
void Clock::setTimeDisplayFormat(const int newFormat)
{
displayFormat = newFormat;
if ((displayFormat & showDayShort) && (displayFormat & showDayLong))
displayFormat -= showDayShort;
if ((displayFormat & showTime))
startTimer (5900);
if ((displayFormat & showSeconds))
startTimer (950);
// if ((displayFormat & showTenthSeconds))
// startTimer(99);
timerCallback();
}
task checkPsuedoTimer()
{
while (true) {
for (int i = 0; i < PSUEDO_TIMER_SIZE; i++) {
if (psuedoTimer[i].expirationTime > 0) {
if (psuedoTimer[i].expirationTime <= nSysTime) {
int timerId = psuedoTimer[i].timerId;
if (psuedoTimer[i].recurring) {
psuedoTimer[i].expirationTime = nSysTime + psuedoTimer[i].duration;
} else {
psuedoTimer[i].timerId = 0;
psuedoTimer[i].expirationTime = 0;
psuedoTimer[i].duration = 0;
}
timerCallback(timerId);
}
}
}
waitInMilliseconds(1);
}
}
int main (int argc, char ** argv)
{
GLenum type;
int width,height;
double range;
glutInit(&argc, argv);
type = GLUT_RGB;
type |= GLUT_DOUBLE;
width=glutGet(GLUT_SCREEN_WIDTH);
height=glutGet(GLUT_SCREEN_HEIGHT);
glutInitWindowPosition(width*0.25,height*0.25);
glutInitWindowSize(width*.8,height*.8);
glutInitDisplayMode( type );
glutCreateWindow("Proje-1");
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
Init();
range=2;
glMatrixMode(GL_PROJECTION);
gluPerspective(70,(double)width/height,1,10);
glMatrixMode(GL_MODELVIEW);
setLight();
glutKeyboardFunc(Key);
glutDisplayFunc(Draw);
timerCallback(0);
timerCallback1(0);
timerCallback1(2);
glutMainLoop();
return 0;
}
void AudioThumbnailImage::triggerWaveformRefresh()
{
// we need to remove ourselves from the thread first so we don't
// end up drawing into the middle of the image
backgroundThread.removeTimeSliceClient (this);
{
const ScopedWriteLock sl (imageLock);
lastTimeDrawn = 0.0;
waveformImage.clear (waveformImage.getBounds(), backgroundColour);
renderComplete = false;
}
listeners.call (&Listener::imageChanged, this);
if (sourceLoaded)
backgroundThread.addTimeSliceClient (this);
timerCallback();
startTimer (100);
}
int main (int argc, char ** argv)
{
GLenum type;
glutInit(&argc, argv);
glutInitWindowSize(1600,1200);
type = GLUT_RGB;
type |= GLUT_DOUBLE;
type |= GLUT_DEPTH;
type |= GLUT_MULTISAMPLE;
glutInitDisplayMode(type);
glutCreateWindow("Ders 2");
glClearColor(0.0, 0, 0.0, 0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
texture[0] = LoadGLTexture("sun_sphere.jpg");
texture[1] = LoadGLTexture("earth_sphere.jpg");
texture[2] = LoadGLTexture("moon_sphere.jpg");
texture[3] = LoadGLTexture("mercury_sphere.bmp");
glMatrixMode(GL_PROJECTION);
gluPerspective(55, 1600/1200, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
timerCallback(0);
glutDisplayFunc(Draw);
setupLight();
glutMainLoop();
return 0;
}
void glwindow::makeList() {
// create a cube display list
vector dir[3], base;
dir[0] = _vector(e1);
dir[1] = _vector(e2);
dir[2] = _vector(e3);
glNewList(cubeListName, GL_COMPILE);
drawCube(base, dir);
glEndList();
// create vector field display list
glNewList(fieldListName, GL_COMPILE);
glColor3f(lineColor[0], lineColor[1], lineColor[2]);
// set up the cube
base.set(vector_e1_e2_e3, -0.5f * g_cubeSize+g_cx, -0.5f * g_cubeSize+g_cy, -0.5f * g_cubeSize+g_cz);
dir[0] = _vector(e1 * g_cubeSize);
dir[1] = _vector(e2 * g_cubeSize);
dir[2] = _vector(e3 * g_cubeSize);
// draw it's vector field
glDisable(GL_NORMALIZE);
glDisable(GL_LIGHTING);
drawVectorField(base, dir, g_vgs, g_evalFunc,
g_vectorSize*0.05f, g_unitField);
glEndList();
glNewList(resultListName, GL_COMPILE);
// evaluate, draw
if (g_lighting) {
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
double t = u_timeGet();
extern int g_refines;
g_boxes=0; g_refines=0;
findSingularities(base, dir, g_gs, g_evalFunc, 0, g_maxDepth);
g_lastTiming = u_timeGet() - t;
timerCallback(NULL);
glEndList();
if ( g_Dcube > 0 ) {
glNewList(sphereListName, GL_COMPILE);
glDisable(GL_NORMALIZE);
glDisable(GL_LIGHTING);
drawSphere(g_gs, 0);
glEndList();
glNewList(spherePListName, GL_COMPILE);
if (g_lighting) {
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
drawSphere(g_gs,1);
glEndList();
glNewList(sphereNListName, GL_COMPILE);
if (g_lighting) {
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
drawSphere(g_gs,2);
glEndList();
glNewList(circListName, GL_COMPILE);
glDisable(GL_NORMALIZE);
glDisable(GL_LIGHTING);
drawCirc(g_gs, 0);
glEndList();
glNewList(circPListName, GL_COMPILE);
if (g_lighting) {
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
drawCirc(g_gs,1);
glEndList();
glNewList(circNListName, GL_COMPILE);
if (g_lighting) {
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
drawCirc(g_gs,2);
glEndList();
}
}
void MidiKeyboardComponent::resized()
{
int w = getWidth();
int h = getHeight();
if (w > 0 && h > 0)
{
if (orientation != horizontalKeyboard)
std::swap (w, h);
blackNoteLength = roundToInt (h * 0.7f);
int kx2, kw2;
getKeyPos (rangeEnd, kx2, kw2);
kx2 += kw2;
if (firstKey != rangeStart)
{
int kx1, kw1;
getKeyPos (rangeStart, kx1, kw1);
if (kx2 - kx1 <= w)
{
firstKey = rangeStart;
sendChangeMessage();
repaint();
}
}
const bool showScrollButtons = canScroll && (firstKey > rangeStart || kx2 > w + xOffset * 2);
scrollDown->setVisible (showScrollButtons);
scrollUp->setVisible (showScrollButtons);
xOffset = 0;
if (showScrollButtons)
{
const int scrollButtonW = jmin (12, w / 2);
if (orientation == horizontalKeyboard)
{
scrollDown->setBounds (0, 0, scrollButtonW, getHeight());
scrollUp->setBounds (getWidth() - scrollButtonW, 0, scrollButtonW, getHeight());
}
else if (orientation == verticalKeyboardFacingLeft)
{
scrollDown->setBounds (0, 0, getWidth(), scrollButtonW);
scrollUp->setBounds (0, getHeight() - scrollButtonW, getWidth(), scrollButtonW);
}
else if (orientation == verticalKeyboardFacingRight)
{
scrollDown->setBounds (0, getHeight() - scrollButtonW, getWidth(), scrollButtonW);
scrollUp->setBounds (0, 0, getWidth(), scrollButtonW);
}
int endOfLastKey, kw;
getKeyPos (rangeEnd, endOfLastKey, kw);
endOfLastKey += kw;
float mousePositionVelocity;
const int spaceAvailable = w - scrollButtonW * 2;
const int lastStartKey = remappedXYToNote (Point<int> (endOfLastKey - spaceAvailable, 0), mousePositionVelocity) + 1;
if (lastStartKey >= 0 && firstKey > lastStartKey)
{
firstKey = jlimit (rangeStart, rangeEnd, lastStartKey);
sendChangeMessage();
}
int newOffset = 0;
getKeyPos (firstKey, newOffset, kw);
xOffset = newOffset - scrollButtonW;
}
else
{
firstKey = rangeStart;
}
timerCallback();
repaint();
}
}
MainWindow::MainWindow(int width, int height, int fps, bool tcp)
: logger(0),
depthImage(width, height, QImage::Format_RGB888),
rgbImage(width, height, QImage::Format_RGB888),
recording(false),
lastDrawn(-1),
width(width),
height(height),
fps(fps),
tcp(tcp),
comms(tcp ? new Communicator : 0)
{
this->setMaximumSize(width * 2, height + 160);
this->setMinimumSize(width * 2, height + 160);
QVBoxLayout * wrapperLayout = new QVBoxLayout;
QHBoxLayout * mainLayout = new QHBoxLayout;
QHBoxLayout * fileLayout = new QHBoxLayout;
QHBoxLayout * optionLayout = new QHBoxLayout;
QHBoxLayout * buttonLayout = new QHBoxLayout;
wrapperLayout->addLayout(mainLayout);
depthLabel = new QLabel(this);
depthLabel->setPixmap(QPixmap::fromImage(depthImage));
mainLayout->addWidget(depthLabel);
imageLabel = new QLabel(this);
imageLabel->setPixmap(QPixmap::fromImage(rgbImage));
mainLayout->addWidget(imageLabel);
wrapperLayout->addLayout(fileLayout);
wrapperLayout->addLayout(optionLayout);
QLabel * logLabel = new QLabel("Log file: ", this);
logLabel->setMaximumWidth(logLabel->fontMetrics().boundingRect(logLabel->text()).width());
fileLayout->addWidget(logLabel);
logFile = new QLabel(this);
logFile->setTextInteractionFlags(Qt::TextSelectableByMouse);
logFile->setStyleSheet("border: 1px solid grey");
fileLayout->addWidget(logFile);
#ifdef __APPLE__
int cushion = 25;
#else
int cushion = 10;
#endif
browseButton = new QPushButton("Browse", this);
browseButton->setMaximumWidth(browseButton->fontMetrics().boundingRect(browseButton->text()).width() + cushion);
connect(browseButton, SIGNAL(clicked()), this, SLOT(fileBrowse()));
fileLayout->addWidget(browseButton);
dateNameButton = new QPushButton("Date filename", this);
dateNameButton->setMaximumWidth(dateNameButton->fontMetrics().boundingRect(dateNameButton->text()).width() + cushion);
connect(dateNameButton, SIGNAL(clicked()), this, SLOT(dateFilename()));
fileLayout->addWidget(dateNameButton);
autoExposure = new QCheckBox("Auto Exposure");
autoExposure->setChecked(false);
autoWhiteBalance = new QCheckBox("Auto White Balance");
autoWhiteBalance->setChecked(false);
compressed = new QCheckBox("Compressed");
compressed->setChecked(true);
memoryRecord = new QCheckBox("Record to RAM");
memoryRecord->setChecked(false);
memoryStatus = new QLabel("");
connect(autoExposure, SIGNAL(stateChanged(int)), this, SLOT(setExposure()));
connect(autoWhiteBalance, SIGNAL(stateChanged(int)), this, SLOT(setWhiteBalance()));
connect(compressed, SIGNAL(released()), this, SLOT(setCompressed()));
connect(memoryRecord, SIGNAL(stateChanged(int)), this, SLOT(setMemoryRecord()));
optionLayout->addWidget(autoExposure);
optionLayout->addWidget(autoWhiteBalance);
optionLayout->addWidget(compressed);
optionLayout->addWidget(memoryRecord);
optionLayout->addWidget(memoryStatus);
wrapperLayout->addLayout(buttonLayout);
startStop = new QPushButton(tcp ? "Stream && Record" : "Record", this);
connect(startStop, SIGNAL(clicked()), this, SLOT(recordToggle()));
buttonLayout->addWidget(startStop);
QPushButton * quitButton = new QPushButton("Quit", this);
connect(quitButton, SIGNAL(clicked()), this, SLOT(quit()));
buttonLayout->addWidget(quitButton);
setLayout(wrapperLayout);
startStop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
quitButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QFont currentFont = startStop->font();
currentFont.setPointSize(currentFont.pointSize() + 8);
startStop->setFont(currentFont);
quitButton->setFont(currentFont);
painter = new QPainter(&depthImage);
painter->setPen(Qt::green);
painter->setFont(QFont("Arial", 30));
painter->drawText(10, 50, "Attempting to start OpenNI2...");
depthLabel->setPixmap(QPixmap::fromImage(depthImage));
#ifndef OS_WINDOWS
char * homeDir = getenv("HOME");
logFolder.append(homeDir);
logFolder.append("/");
#else
char * homeDrive = getenv("HOMEDRIVE");
char * homeDir = getenv("HOMEPATH");
logFolder.append(homeDrive);
logFolder.append("\\");
logFolder.append(homeDir);
logFolder.append("\\");
#endif
logFolder.append("Kinect_Logs");
boost::filesystem::path p(logFolder.c_str());
boost::filesystem::create_directory(p);
logFile->setText(QString::fromStdString(getNextFilename()));
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(timerCallback()));
timer->start(15);
}
//==============================================================================
Ambix_encoderAudioProcessorEditor::Ambix_encoderAudioProcessorEditor (Ambix_encoderAudioProcessor* ownerFilter)
: AudioProcessorEditor (ownerFilter),
sld_el (0),
sld_az (0),
sld_size (0),
#if INPUT_CHANNELS > 1
sld_width (0),
#endif
sld_speed (0),
sld_el_move (0),
sld_az_move (0),
txt_az_move (0),
txt_el_move (0),
sphere_opengl(0),
changed_(true)
{
tooltipWindow.setMillisecondsBeforeTipAppears (700); // tooltip delay
addAndMakeVisible (sld_el = new Slider ("new slider"));
sld_el->setTooltip ("elevation");
sld_el->setRange (-SLIDER_MAX, SLIDER_MAX, 1);
sld_el->setSliderStyle (Slider::LinearVertical);
sld_el->setTextBoxStyle (Slider::TextBoxBelow, false, 41, 20);
sld_el->setColour (Slider::thumbColourId, Colours::grey);
sld_el->setColour (Slider::textBoxTextColourId, Colours::black);
sld_el->setColour (Slider::textBoxBackgroundColourId, Colours::white);
sld_el->addListener (this);
addAndMakeVisible (sld_az = new Slider ("new slider"));
sld_az->setTooltip ("azimuth");
sld_az->setRange (-SLIDER_MAX, SLIDER_MAX, 1);
sld_az->setSliderStyle (Slider::LinearHorizontal);
sld_az->setTextBoxStyle (Slider::TextBoxRight, false, 40, 20);
sld_az->setColour (Slider::thumbColourId, Colours::grey);
sld_az->setColour (Slider::textBoxTextColourId, Colours::black);
sld_az->setColour (Slider::textBoxBackgroundColourId, Colours::white);
sld_az->addListener (this);
addAndMakeVisible (sld_size = new Slider ("new slider"));
sld_size->setTooltip ("higher order scaling - decrease spatial sharpness");
sld_size->setRange (0, 1, 0.01);
sld_size->setSliderStyle (Slider::RotaryHorizontalVerticalDrag);
sld_size->setTextBoxStyle (Slider::NoTextBox, false, 40, 20);
sld_size->setColour (Slider::thumbColourId, Colours::white);
sld_size->setColour (Slider::trackColourId, Colours::white);
sld_size->setColour (Slider::rotarySliderFillColourId, Colours::white);
sld_size->setColour (Slider::rotarySliderOutlineColourId, Colours::white);
sld_size->setColour (Slider::textBoxTextColourId, Colours::white);
sld_size->setColour (Slider::textBoxBackgroundColourId, Colours::white);
sld_size->setColour (Slider::textBoxHighlightColourId, Colours::white);
sld_size->addListener (this);
sld_size->setPopupDisplayEnabled(true, this);
addAndMakeVisible (sld_speed = new Slider ("new slider"));
sld_speed->setTooltip ("movement speed in deg/sec");
sld_speed->setRange (0, 360, 1);
sld_speed->setSliderStyle (Slider::LinearHorizontal);
sld_speed->setTextBoxStyle (Slider::TextBoxRight, false, 40, 20);
sld_speed->setColour (Slider::thumbColourId, Colour (0xffe98273));
sld_speed->setColour (Slider::textBoxTextColourId, Colours::black);
sld_speed->setColour (Slider::textBoxBackgroundColourId, Colours::white);
sld_speed->addListener (this);
addAndMakeVisible (sld_el_move = new Slider ("new slider"));
sld_el_move->setTooltip ("elevation movement speed");
sld_el_move->setRange (0, 1, 0.01);
sld_el_move->setSliderStyle (Slider::RotaryHorizontalVerticalDrag);
sld_el_move->setTextBoxStyle (Slider::NoTextBox, false, 80, 20);
sld_el_move->setColour (Slider::trackColourId, Colour (0xff2d7dff));
sld_el_move->setColour (Slider::rotarySliderFillColourId, Colours::white);
sld_el_move->setColour (Slider::rotarySliderOutlineColourId, Colours::azure);
sld_el_move->addListener (this);
addAndMakeVisible (sld_az_move = new Slider ("new slider"));
sld_az_move->setTooltip ("azimuth movement speed");
sld_az_move->setRange (0, 1, 0.01);
sld_az_move->setSliderStyle (Slider::RotaryHorizontalVerticalDrag);
sld_az_move->setTextBoxStyle (Slider::NoTextBox, false, 80, 20);
sld_az_move->setColour (Slider::trackColourId, Colour (0xff2d7dff));
sld_az_move->setColour (Slider::rotarySliderFillColourId, Colours::white);
sld_az_move->setColour (Slider::rotarySliderOutlineColourId, Colours::azure);
sld_az_move->addListener (this);
addAndMakeVisible (txt_az_move = new TextEditor ("new text editor"));
txt_az_move->setMultiLine (false);
txt_az_move->setReturnKeyStartsNewLine (false);
txt_az_move->setReadOnly (true);
txt_az_move->setScrollbarsShown (false);
txt_az_move->setCaretVisible (false);
txt_az_move->setPopupMenuEnabled (false);
txt_az_move->setColour (TextEditor::outlineColourId, Colour (0x706884ff));
txt_az_move->setColour (TextEditor::shadowColourId, Colour (0x0));
txt_az_move->setText ("-180 deg/s");
addAndMakeVisible (txt_el_move = new TextEditor ("new text editor"));
txt_el_move->setTooltip ("elevation movement speed");
txt_el_move->setMultiLine (false);
txt_el_move->setReturnKeyStartsNewLine (false);
txt_el_move->setReadOnly (true);
txt_el_move->setScrollbarsShown (false);
txt_el_move->setCaretVisible (false);
txt_el_move->setPopupMenuEnabled (false);
txt_el_move->setColour (TextEditor::outlineColourId, Colour (0x706884ff));
txt_el_move->setColour (TextEditor::shadowColourId, Colour (0x0));
txt_el_move->setText ("-180 deg/s");
addAndMakeVisible (sphere_opengl = new SphereOpenGL());
sphere_opengl->setName ("new OpenGl");
// sphere_opengl->setBounds(10, 30, 240, 240);
sphere_opengl->processor = ownerFilter;
sld_az->setDoubleClickReturnValue(true, 0);
sld_size->setDoubleClickReturnValue(true, 0);
sld_el->setDoubleClickReturnValue(true, 0);
sld_speed->setDoubleClickReturnValue(true, 90);
sld_az_move->setDoubleClickReturnValue(true, 0.5f);
sld_el_move->setDoubleClickReturnValue(true, 0.5f);
addAndMakeVisible (lbl_id = new Label ("new label",
TRANS("ID: 1")));
lbl_id->setFont (Font (15.00f, Font::plain));
lbl_id->setJustificationType (Justification::centredRight);
lbl_id->setEditable (false, false, false);
lbl_id->setColour (Label::textColourId, Colour (0xff888888));
lbl_id->setColour (TextEditor::textColourId, Colours::black);
lbl_id->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
#if INPUT_CHANNELS > 1
addAndMakeVisible (sld_width = new Slider ("new slider"));
sld_width->setTooltip ("multiple input sources are equally spread along this range");
sld_width->setRange (0, 360, 1);
sld_width->setSliderStyle (Slider::RotaryHorizontalVerticalDrag);
sld_width->setTextBoxStyle (Slider::NoTextBox, false, 41, 20);
sld_width->setColour (Slider::thumbColourId, Colour (0xffe982cd));
sld_width->setColour (Slider::rotarySliderFillColourId, Colours::white);
sld_width->setColour (Slider::rotarySliderOutlineColourId, Colours::white);
sld_width->setColour (Slider::textBoxTextColourId, Colours::black);
sld_width->setColour (Slider::textBoxBackgroundColourId, Colours::white);
sld_width->addListener (this);
sld_width->setPopupDisplayEnabled(true, this);
sld_width->setDoubleClickReturnValue(true, 45);
#endif
addAndMakeVisible (btn_settings = new ImageButton ("new button"));
btn_settings->setTooltip (TRANS("OSC settings"));
btn_settings->setButtonText (TRANS("settings"));
btn_settings->addListener (this);
btn_settings->setImages (false, true, true,
ImageCache::getFromMemory (settings_png, settings_pngSize), 1.000f, Colour (0x00000000),
ImageCache::getFromMemory (settings_white_png, settings_white_pngSize), 1.000f, Colour (0x00000000),
ImageCache::getFromMemory (settings_png, settings_pngSize), 1.000f, Colour (0x00000000));
//[UserPreSize]
//[/UserPreSize]
#if INPUT_CHANNELS > 1
setSize (330, 400);
#else
setSize (330, 400);
#endif
// register as change listener (gui/dsp sync)
ownerFilter->addChangeListener(this);
ownerFilter->sendChangeMessage(); // get status from dsp
String str_id = "ID: ";
str_id << ownerFilter->m_id;
lbl_id->setText(str_id, dontSendNotification);
timerCallback(); // get status from dsp
startTimer(45); // update display rate
}
void JuceTimerDeleter::flush() throw()
{
timerCallback();
}
MyComposite::MyComposite(QWidget *parent)
: QMainWindow(parent)
{
undoStack = new QUndoStack(this);
QMenu* fileMenu = this->menuBar()->addMenu("&File");
newAction = new QAction("&New",fileMenu);
newAction->setShortcuts(QKeySequence::New);
fileMenu->addAction(newAction);
openAction = new QAction("&Open",fileMenu);
openAction->setShortcuts(QKeySequence::Open);
fileMenu->addAction(openAction);
saveAction = new QAction("&Save",fileMenu);
saveAction->setShortcuts(QKeySequence::Save);
fileMenu->addAction(saveAction);
saveAsAction = new QAction("S&ave as",fileMenu);
saveAsAction->setShortcuts(QKeySequence::SaveAs);
fileMenu->addAction(saveAsAction);
quitAction = new QAction("&Quit",fileMenu);
quitAction->setShortcuts(QKeySequence::Quit);
fileMenu->addAction(quitAction);
QMenu* editMenu = this->menuBar()->addMenu("&Edit");
undoAction = undoStack->createUndoAction(editMenu, "&Undo");
undoAction->setShortcuts(QKeySequence::Undo);
editMenu->addAction(undoAction);
redoAction = undoStack->createRedoAction(editMenu, "&Redo");
redoAction->setShortcuts(QKeySequence::Redo);
editMenu->addAction(redoAction);
editMenu->addSeparator();
cutAction = new QAction("&Cut ",editMenu);
cutAction->setShortcuts(QKeySequence::Cut);
cutAction->setEnabled(0);
editMenu->addAction(cutAction);
copyAction = new QAction("&Copy ",editMenu);
copyAction->setShortcuts(QKeySequence::Copy);
copyAction->setEnabled(0);
editMenu->addAction(copyAction);
pasteAction = new QAction("&Paste ",editMenu);
pasteAction->setShortcuts(QKeySequence::Paste);
pasteAction->setEnabled(0);
editMenu->addAction(pasteAction);
editMenu->addSeparator();
addCollectionAction = new QAction("Add &Collection",editMenu);
addCollectionAction->setShortcut(QKeySequence("Ctrl+1"));
editMenu->addAction(addCollectionAction);
addImageAction = new QAction("Add &Image",editMenu);
addImageAction->setShortcut(QKeySequence("Ctrl+2"));
editMenu->addAction(addImageAction);
deleteAllAction = new QAction("&Delete All Images",editMenu);
deleteAllAction->setShortcut(QKeySequence("Ctrl+3"));
editMenu->addAction(deleteAllAction);
deleteImageAction = new QAction("&Delete Image",editMenu);
deleteImageAction->setShortcut(QKeySequence("Ctrl+4"));
deleteImageAction->setEnabled(0);
editMenu->addAction(deleteImageAction);
QMenu* playMenu = this->menuBar()->addMenu("&Play");
setTimerAction = new QAction("&Set Timer",playMenu);
setTimerAction->setShortcut(QKeySequence("Ctrl+5"));
playMenu->addAction(setTimerAction);
playAction = new QAction("&Play",playMenu);
playAction->setShortcut(QKeySequence("Ctrl+6"));
playAction->setEnabled(0);
playMenu->addAction(playAction);
pauseAction = new QAction("&Pause",playMenu);
pauseAction->setShortcut(QKeySequence("Ctrl+7"));
pauseAction->setEnabled(0);
playMenu->addAction(pauseAction);
playSAction = new QAction("&Play from selection",playMenu);
playSAction->setShortcut(QKeySequence("Ctrl+8"));
playSAction->setEnabled(0);
playMenu->addAction(playSAction);
resetAction = new QAction("&Reset",playMenu);
resetAction->setShortcut(QKeySequence("Ctrl+9"));
playMenu->addAction(resetAction);
splitter = new QSplitter();
/*QFrame *leftWidget = new QFrame();
QVBoxLayout *leftLayout = new QVBoxLayout();
leftWidget->setLayout(leftLayout);
leftWidget->setStyleSheet("QFrame { background-color: rgb(219, 226, 228); }");*/
/*QFrame *innerWidget = new QFrame();
QGridLayout *innerLayout = new QGridLayout();
innerWidget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
innerWidget->setLayout(innerLayout);*/
dock = new QDockWidget();
addDockWidget(Qt::LeftDockWidgetArea, dock);
//leftLayout->addWidget(dock);
//leftLayout->addWidget(innerWidget,0,0, Qt::AlignTop);
splitter->addWidget(dock);
QFrame *rightWidget = new QFrame();
rightLayout = new QGridLayout();
rightWidget->setLayout(rightLayout);
rightWidget->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
rightLayout->setVerticalSpacing(0);
rightLayout->setHorizontalSpacing(0);
QScrollArea *scrollArea = new QScrollArea();
scrollArea->setWidgetResizable(1);
BoxImage *boxImage = new BoxImage(this);
//boxImage->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
boxImage->setStyleSheet("QFrame { background-color: rgb(254,254,254); }");
scrollArea->setWidget(rightWidget);
splitter->addWidget(scrollArea);
//scrollArea->setStyleSheet("QScrollArea { background-color: rgb(254,254,254); }");
setStyleSheet("QSplitter {background-color: rgb(219, 226, 228);}");
QList<int> sizeList = QList<int>() << 300 << 760;
splitter->setSizes(sizeList);
setCentralWidget(splitter);
resize(760+300+20,500+20);
connect (quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
connect (addCollectionAction, SIGNAL(triggered()), boxImage, SLOT(addCollectionCallback()));
connect (addImageAction, SIGNAL(triggered()), boxImage, SLOT(addImageCallback()));
connect (deleteAllAction, SIGNAL(triggered()), boxImage, SLOT(deleteAllCallback()));
connect (deleteImageAction, SIGNAL(triggered()), boxImage, SLOT(deleteImageCallback()));
connect(cutAction, SIGNAL(triggered()), boxImage, SLOT(cutCallback()));
connect(copyAction, SIGNAL(triggered()), boxImage, SLOT(copyCallback()));
connect(pasteAction, SIGNAL(triggered()), boxImage, SLOT(pasteCallback()));
connect(setTimerAction, SIGNAL(triggered()), boxImage, SLOT(timerCallback()));
connect(playAction, SIGNAL(triggered()), boxImage, SLOT(playCallback()));
connect(pauseAction, SIGNAL(triggered()), boxImage, SLOT(pauseCallback()));
connect(playSAction, SIGNAL(triggered()), boxImage, SLOT(playSCallback()));
connect(resetAction, SIGNAL(triggered()), boxImage, SLOT(resetCallback()));
connect(newAction,SIGNAL(triggered()),this,SLOT(notYetCallback()));
connect(openAction,SIGNAL(triggered()),this,SLOT(notYetCallback()));
connect(saveAction,SIGNAL(triggered()),this,SLOT(notYetCallback()));
connect(saveAsAction,SIGNAL(triggered()),this,SLOT(notYetCallback()));
}
/**********************************************************************
* Function: Timer2IntHandler
* @return none
* @remark This is the interrupt handler used by the LCD module to update
* the display by calling an update function every time this interrupt
* occurs.
**********************************************************************/
void __ISR(_TIMER_2_VECTOR, ipl3) Timer2IntHandler(void) {
timerCallback();
// Reset Timer 2 interrupt flag
mT2ClearIntFlag();
}
//==============================================================================
MidiNoteGainComponent::MidiNoteGainComponent (MidiNoteGain *midiNoteGain)
: midiNoteGain(midiNoteGain)
{
addAndMakeVisible (label12 = new Label ("new label",
"B"));
label12->setFont (Font (15.00f, Font::plain));
label12->setJustificationType (Justification::centred);
label12->setEditable (false, false, false);
label12->setColour (TextEditor::textColourId, Colours::black);
label12->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (label2 = new Label ("new label",
"C"));
label2->setFont (Font (15.00f, Font::plain));
label2->setJustificationType (Justification::centred);
label2->setEditable (false, false, false);
label2->setColour (TextEditor::textColourId, Colours::black);
label2->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider1 = new Slider ("new slider"));
slider1->setRange (0, 10, 1);
slider1->setSliderStyle (Slider::Rotary);
slider1->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider1->addListener (this);
addAndMakeVisible (label3 = new Label ("new label",
"Db"));
label3->setFont (Font (15.00f, Font::plain));
label3->setJustificationType (Justification::centred);
label3->setEditable (false, false, false);
label3->setColour (TextEditor::textColourId, Colours::black);
label3->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider2 = new Slider ("new slider"));
slider2->setRange (0, 10, 1);
slider2->setSliderStyle (Slider::Rotary);
slider2->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider2->addListener (this);
addAndMakeVisible (label4 = new Label ("new label",
"D"));
label4->setFont (Font (15.00f, Font::plain));
label4->setJustificationType (Justification::centred);
label4->setEditable (false, false, false);
label4->setColour (TextEditor::textColourId, Colours::black);
label4->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider3 = new Slider ("new slider"));
slider3->setRange (0, 10, 1);
slider3->setSliderStyle (Slider::Rotary);
slider3->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider3->addListener (this);
addAndMakeVisible (label5 = new Label ("new label",
"Eb"));
label5->setFont (Font (15.00f, Font::plain));
label5->setJustificationType (Justification::centred);
label5->setEditable (false, false, false);
label5->setColour (TextEditor::textColourId, Colours::black);
label5->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider4 = new Slider ("new slider"));
slider4->setRange (0, 10, 1);
slider4->setSliderStyle (Slider::Rotary);
slider4->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider4->addListener (this);
addAndMakeVisible (label6 = new Label ("new label",
"E"));
label6->setFont (Font (15.00f, Font::plain));
label6->setJustificationType (Justification::centred);
label6->setEditable (false, false, false);
label6->setColour (TextEditor::textColourId, Colours::black);
label6->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider5 = new Slider ("new slider"));
slider5->setRange (0, 10, 1);
slider5->setSliderStyle (Slider::Rotary);
slider5->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider5->addListener (this);
addAndMakeVisible (label7 = new Label ("new label",
"F"));
label7->setFont (Font (15.00f, Font::plain));
label7->setJustificationType (Justification::centred);
label7->setEditable (false, false, false);
label7->setColour (TextEditor::textColourId, Colours::black);
label7->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider6 = new Slider ("new slider"));
slider6->setRange (0, 10, 1);
slider6->setSliderStyle (Slider::Rotary);
slider6->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider6->addListener (this);
addAndMakeVisible (label8 = new Label ("new label",
"Gb"));
label8->setFont (Font (15.00f, Font::plain));
label8->setJustificationType (Justification::centred);
label8->setEditable (false, false, false);
label8->setColour (TextEditor::textColourId, Colours::black);
label8->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider7 = new Slider ("new slider"));
slider7->setRange (0, 10, 1);
slider7->setSliderStyle (Slider::Rotary);
slider7->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider7->addListener (this);
addAndMakeVisible (label9 = new Label ("new label",
"G"));
label9->setFont (Font (15.00f, Font::plain));
label9->setJustificationType (Justification::centred);
label9->setEditable (false, false, false);
label9->setColour (TextEditor::textColourId, Colours::black);
label9->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider8 = new Slider ("new slider"));
slider8->setRange (0, 10, 1);
slider8->setSliderStyle (Slider::Rotary);
slider8->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider8->addListener (this);
addAndMakeVisible (label10 = new Label ("new label",
"A"));
label10->setFont (Font (15.00f, Font::plain));
label10->setJustificationType (Justification::centred);
label10->setEditable (false, false, false);
label10->setColour (TextEditor::textColourId, Colours::black);
label10->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider10 = new Slider ("new slider"));
slider10->setRange (0, 10, 1);
slider10->setSliderStyle (Slider::Rotary);
slider10->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider10->addListener (this);
addAndMakeVisible (label11 = new Label ("new label",
"Bb"));
label11->setFont (Font (15.00f, Font::plain));
label11->setJustificationType (Justification::centred);
label11->setEditable (false, false, false);
label11->setColour (TextEditor::textColourId, Colours::black);
label11->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider11 = new Slider ("new slider"));
slider11->setRange (0, 10, 1);
slider11->setSliderStyle (Slider::Rotary);
slider11->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider11->addListener (this);
addAndMakeVisible (slider12 = new Slider ("new slider"));
slider12->setRange (0, 10, 1);
slider12->setSliderStyle (Slider::Rotary);
slider12->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider12->addListener (this);
addAndMakeVisible (enableToggle = new ToggleButton ("new toggle button"));
enableToggle->setButtonText ("on/off");
enableToggle->addListener (this);
addAndMakeVisible (label13 = new Label ("new label",
"Ab\n"));
label13->setFont (Font (15.00f, Font::plain));
label13->setJustificationType (Justification::centred);
label13->setEditable (false, false, false);
label13->setColour (TextEditor::textColourId, Colours::black);
label13->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (slider9 = new Slider ("new slider"));
slider9->setRange (0, 10, 1);
slider9->setSliderStyle (Slider::Rotary);
slider9->setTextBoxStyle (Slider::TextBoxBelow, false, 80, 20);
slider9->addListener (this);
//[UserPreSize]
//[/UserPreSize]
setSize (800, 120);
//[Constructor] You can add your own custom stuff here..
IntParam *param;
param=midiNoteGain->getParamGroup(MidiNoteGain::noteVelocitiesIndex)->getIntParam(1);
slider1->setRange(param->getMin(),param->getMax(),slider1->getInterval());
slider2->setRange(param->getMin(),param->getMax(),slider2->getInterval());
slider3->setRange(param->getMin(),param->getMax(),slider3->getInterval());
slider4->setRange(param->getMin(),param->getMax(),slider4->getInterval());
slider5->setRange(param->getMin(),param->getMax(),slider5->getInterval());
slider6->setRange(param->getMin(),param->getMax(),slider6->getInterval());
slider7->setRange(param->getMin(),param->getMax(),slider7->getInterval());
slider8->setRange(param->getMin(),param->getMax(),slider8->getInterval());
slider9->setRange(param->getMin(),param->getMax(),slider9->getInterval());
slider10->setRange(param->getMin(),param->getMax(),slider10->getInterval());
slider11->setRange(param->getMin(),param->getMax(),slider11->getInterval());
slider12->setRange(param->getMin(),param->getMax(),slider12->getInterval());
timerCallback();
//[/Constructor]
}
MainWindow::MainWindow(Logger * logger)
: logger(logger),
depthImage(640, 480, QImage::Format_RGB888),
rgbImage(640, 480, QImage::Format_RGB888),
recording(false),
lastDrawn(-1)
{
this->setMaximumSize(1280, 600);
this->setMinimumSize(1280, 600);
QVBoxLayout * wrapperLayout = new QVBoxLayout;
QHBoxLayout * mainLayout = new QHBoxLayout;
QHBoxLayout * fileLayout = new QHBoxLayout;
QHBoxLayout * buttonLayout = new QHBoxLayout;
wrapperLayout->addLayout(mainLayout);
depthLabel = new QLabel(this);
depthLabel->setPixmap(QPixmap::fromImage(depthImage));
mainLayout->addWidget(depthLabel);
imageLabel = new QLabel(this);
imageLabel->setPixmap(QPixmap::fromImage(rgbImage));
mainLayout->addWidget(imageLabel);
wrapperLayout->addLayout(fileLayout);
QLabel * logLabel = new QLabel("Log file: ", this);
logLabel->setMaximumWidth(logLabel->fontMetrics().boundingRect(logLabel->text()).width());
fileLayout->addWidget(logLabel);
logFile = new QLabel(this);
logFile->setTextInteractionFlags(Qt::TextSelectableByMouse);
logFile->setStyleSheet("border: 1px solid grey");
fileLayout->addWidget(logFile);
browseButton = new QPushButton("Browse", this);
browseButton->setMaximumWidth(browseButton->fontMetrics().boundingRect(browseButton->text()).width() + 10);
connect(browseButton, SIGNAL(clicked()), this, SLOT(fileBrowse()));
fileLayout->addWidget(browseButton);
dateNameButton = new QPushButton("Date filename", this);
dateNameButton->setMaximumWidth(dateNameButton->fontMetrics().boundingRect(dateNameButton->text()).width() + 10);
connect(dateNameButton, SIGNAL(clicked()), this, SLOT(dateFilename()));
fileLayout->addWidget(dateNameButton);
wrapperLayout->addLayout(buttonLayout);
startStop = new QPushButton("Record", this);
connect(startStop, SIGNAL(clicked()), this, SLOT(recordToggle()));
buttonLayout->addWidget(startStop);
QPushButton * quitButton = new QPushButton("Quit", this);
connect(quitButton, SIGNAL(clicked()), this, SLOT(quit()));
buttonLayout->addWidget(quitButton);
setLayout(wrapperLayout);
startStop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
quitButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QFont currentFont = startStop->font();
currentFont.setPointSize(currentFont.pointSize() + 8);
startStop->setFont(currentFont);
quitButton->setFont(currentFont);
painter = new QPainter(&depthImage);
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(timerCallback()));
timer->start(15);
#ifdef unix
char * homeDir = getenv("HOME");
logFolder.append(homeDir);
logFolder.append("/");
#else
char * homeDrive = getenv("HOMEDRIVE");
char * homeDir = getenv("HOMEPATH");
logFolder.append(homeDrive);
logFolder.append("\\");
logFolder.append(homeDir);
logFolder.append("\\");
#endif
logFolder.append("Kinect_Logs");
boost::filesystem::path p(logFolder.c_str());
boost::filesystem::create_directory(p);
logFile->setText(QString::fromStdString(getNextFilename()));
}
void DnsHealthMonitor::StartTimer()
{
_spTimer->Reuse();
KAsyncContextBase::CompletionCallback timerCallback(this, &DnsHealthMonitor::OnTimer);
_spTimer->StartTimer(TimeoutInSeconds * 1000, this/*parent*/, timerCallback);
}
//==============================================================================
MumuAudioGranularAudioProcessorEditor::MumuAudioGranularAudioProcessorEditor (MumuAudioGranularAudioProcessor& p)
: AudioProcessorEditor (&p), processor (p), Tab(TabbedButtonBar::TabsAtLeft), Tab1_stretchButton("Grain")
{
// Make sure that before the constructor has finished, you've set the
// editor's size to whatever you need it to be.
setSize (600, 280);
LookAndFeel::setDefaultLookAndFeel(&myLookAndFeel);
//======== Tab Bar =========
addAndMakeVisible(Tab);
Tab.setBounds(0, 20, 20, 180);
Tab.addTab("Pitch / Stretch", Colour(Colours::darkgrey), 1);
Tab.addTab("Rhythmic Chop", Colour(Colours::darkgrey), 2);
Tab.addTab("Patches", Colour(Colours::darkgrey), 3);
Tab.setAlpha(0.8);
Tab.addChangeListener(this);
//======== Tab 1 ===========
PitchStretch.setBounds(20, 0, 580, 280);
PitchStretch.addAndMakeVisible(Tab1_pitchKnob);
PitchStretch.addAndMakeVisible(Tab1_densityKnob);
PitchStretch.addAndMakeVisible(Tab1_grainSizeKnob);
PitchStretch.addAndMakeVisible(Tab1_dryWayKnob);
PitchStretch.addAndMakeVisible(Tab1_stretchSpeedKnob);
PitchStretch.addAndMakeVisible(Tab1_stretchButton);
addChildComponent(PitchStretch);
Tab1_pitchKnob.setTextBoxStyle(Slider::NoTextBox, false, 0, 0);
Tab1_pitchKnob.setName("Slider 1");
Tab1_pitchKnob.setSliderStyle(Slider::RotaryVerticalDrag);
Tab1_pitchKnob.setRange(0.0, 1.0);
Tab1_pitchKnob.addListener(this);
Tab1_pitchKnob.setBounds(60, 28, 75, 75);
Tab1_pitchLabel.setText("Pitch", dontSendNotification);
Tab1_pitchLabel.setColour(juce::Label::textColourId, juce::Colour(255.0f, 255.0f, 255.0f));
Tab1_pitchLabel.attachToComponent(&Tab1_pitchKnob, true);
Tab1_densityKnob.setTextBoxStyle(Slider::NoTextBox, false, 0, 0);
Tab1_densityKnob.setName("Slider 2");
Tab1_densityKnob.setSliderStyle(Slider::RotaryVerticalDrag);
Tab1_densityKnob.setRange(0.0, 1.0);
Tab1_densityKnob.addListener(this);
Tab1_densityKnob.setBounds(160, 88, 75, 75);
Tab1_densityLabel.setText("Density", dontSendNotification);
Tab1_densityLabel.setColour(juce::Label::textColourId, juce::Colour(255.0f, 255.0f, 255.0f));
Tab1_densityLabel.attachToComponent(&Tab1_densityKnob, true);
Tab1_grainSizeKnob.setTextBoxStyle(Slider::NoTextBox, false, 0, 0);
Tab1_grainSizeKnob.setName("Slider 3");
Tab1_grainSizeKnob.setSliderStyle(Slider::RotaryVerticalDrag);
Tab1_grainSizeKnob.setRange(0.0, 1.0);
Tab1_grainSizeKnob.addListener(this);
Tab1_grainSizeKnob.setBounds(260, 28, 75, 75);
Tab1_grainSizeLabel.setText("GrainSize", dontSendNotification);
Tab1_grainSizeLabel.setColour(juce::Label::textColourId, juce::Colour(255.0f, 255.0f, 255.0f));
Tab1_grainSizeLabel.attachToComponent(&Tab1_grainSizeKnob, true);
addAndMakeVisible(Tab1_grainSizeLabel);
Tab1_dryWayKnob.setTextBoxStyle(Slider::NoTextBox, false, 0, 0);
Tab1_dryWayKnob.setName("Slider 4");
Tab1_dryWayKnob.setSliderStyle(Slider::RotaryVerticalDrag);
Tab1_dryWayKnob.setRange(0.0, 1.0);
Tab1_dryWayKnob.addListener(this);
Tab1_dryWayKnob.setBounds(360, 88, 75, 75);
Tab1_dryWetLabel.setText("Dry/Wet", dontSendNotification);
Tab1_dryWetLabel.setColour(juce::Label::textColourId, juce::Colour(255.0f, 255.0f, 255.0f));
Tab1_dryWetLabel.attachToComponent(&Tab1_dryWayKnob, true);
addAndMakeVisible(Tab1_dryWetLabel);
Tab1_stretchSpeedKnob.setTextBoxStyle(Slider::NoTextBox, false, 0, 0);
Tab1_stretchSpeedKnob.setName("Slider 5");
Tab1_stretchSpeedKnob.setSliderStyle(Slider::RotaryVerticalDrag);
Tab1_stretchSpeedKnob.setRange(0.0, 1.0);
Tab1_stretchSpeedKnob.addListener(this);
Tab1_stretchSpeedKnob.setBounds(500, 88, 45, 45);
Tab1_stretchSpeedLabel.setText("Speed", dontSendNotification);
Tab1_stretchSpeedLabel.setColour(juce::Label::textColourId, juce::Colour(255.0f, 255.0f, 255.0f));
Tab1_stretchSpeedLabel.attachToComponent(&Tab1_stretchSpeedKnob, false);
addAndMakeVisible(Tab1_stretchSpeedLabel);
Tab1_stretchButton.setBounds(480,28,80,20);
Tab1_stretchButton.setColour(juce::ToggleButton::textColourId , Colours::white);
Tab1_stretchButton.addListener(this);
addMouseListener(this, true);
timerCallback();
checkTabs();
startTimer(50);
}
