CServerProxy::EResult CServerProxy::parseMessage(const UInt8* code) { if (memcmp(code, kMsgDMouseMove, 4) == 0) { mouseMove(); } else if (memcmp(code, kMsgDMouseRelMove, 4) == 0) { mouseRelativeMove(); } else if (memcmp(code, kMsgDMouseWheel, 4) == 0) { mouseWheel(); } else if (memcmp(code, kMsgDKeyDown, 4) == 0) { keyDown(); } else if (memcmp(code, kMsgDKeyUp, 4) == 0) { keyUp(); } else if (memcmp(code, kMsgDMouseDown, 4) == 0) { mouseDown(); } else if (memcmp(code, kMsgDMouseUp, 4) == 0) { mouseUp(); } else if (memcmp(code, kMsgDKeyRepeat, 4) == 0) { keyRepeat(); } else if (memcmp(code, kMsgCKeepAlive, 4) == 0) { // echo keep alives and reset alarm CProtocolUtil::writef(m_stream, kMsgCKeepAlive); resetKeepAliveAlarm(); } else if (memcmp(code, kMsgCNoop, 4) == 0) { // accept and discard no-op } else if (memcmp(code, kMsgCEnter, 4) == 0) { enter(); } else if (memcmp(code, kMsgCLeave, 4) == 0) { leave(); } else if (memcmp(code, kMsgCClipboard, 4) == 0) { grabClipboard(); } else if (memcmp(code, kMsgCScreenSaver, 4) == 0) { screensaver(); } else if (memcmp(code, kMsgQInfo, 4) == 0) { queryInfo(); } else if (memcmp(code, kMsgCInfoAck, 4) == 0) { infoAcknowledgment(); } else if (memcmp(code, kMsgDClipboard, 4) == 0) { setClipboard(); } else if (memcmp(code, kMsgCResetOptions, 4) == 0) { resetOptions(); } else if (memcmp(code, kMsgDSetOptions, 4) == 0) { setOptions(); } else if (memcmp(code, kMsgDGameButtons, 4) == 0) { gameDeviceButtons(); } else if (memcmp(code, kMsgDGameSticks, 4) == 0) { gameDeviceSticks(); } else if (memcmp(code, kMsgDGameTriggers, 4) == 0) { gameDeviceTriggers(); } else if (memcmp(code, kMsgCGameTimingReq, 4) == 0) { gameDeviceTimingReq(); } else if (memcmp(code, kMsgCClose, 4) == 0) { // server wants us to hangup LOG((CLOG_DEBUG1 "recv close")); m_client->disconnect(NULL); return kDisconnect; } else if (memcmp(code, kMsgEBad, 4) == 0) { LOG((CLOG_ERR "server disconnected due to a protocol error")); m_client->disconnect("server reported a protocol error"); return kDisconnect; } else { return kUnknown; } // send a reply. this is intended to work around a delay when // running a linux server and an OS X (any BSD?) client. the // client waits to send an ACK (if the system control flag // net.inet.tcp.delayed_ack is 1) in hopes of piggybacking it // on a data packet. we provide that packet here. i don't // know why a delayed ACK should cause the server to wait since // TCP_NODELAY is enabled. CProtocolUtil::writef(m_stream, kMsgCNoop); return kOkay; }
void MediaPluginGStreamer010::receiveMessage(const char *message_string) { //std::cerr << "MediaPluginGStreamer010::receiveMessage: received message: \"" << message_string << "\"" << std::endl; LLPluginMessage message_in; if(message_in.parse(message_string) >= 0) { std::string message_class = message_in.getClass(); std::string message_name = message_in.getName(); if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE) { if(message_name == "init") { LLPluginMessage message("base", "init_response"); LLSD versions = LLSD::emptyMap(); versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION; versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION; versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION; message.setValueLLSD("versions", versions); if ( load() ) { DEBUGMSG("GStreamer010 media instance set up"); } else { WARNMSG("GStreamer010 media instance failed to set up"); } message.setValue("plugin_version", getVersion()); sendMessage(message); } else if(message_name == "idle") { // no response is necessary here. double time = message_in.getValueReal("time"); // Convert time to milliseconds for update() update((int)(time * 1000.0f)); } else if(message_name == "cleanup") { unload(); closedown(); } else if(message_name == "shm_added") { SharedSegmentInfo info; info.mAddress = message_in.getValuePointer("address"); info.mSize = (size_t)message_in.getValueS32("size"); std::string name = message_in.getValue("name"); std::ostringstream str; INFOMSG("MediaPluginGStreamer010::receiveMessage: shared memory added, name: %s, size: %d, address: %p", name.c_str(), int(info.mSize), info.mAddress); mSharedSegments.insert(SharedSegmentMap::value_type(name, info)); } else if(message_name == "shm_remove") { std::string name = message_in.getValue("name"); DEBUGMSG("MediaPluginGStreamer010::receiveMessage: shared memory remove, name = %s", name.c_str()); SharedSegmentMap::iterator iter = mSharedSegments.find(name); if(iter != mSharedSegments.end()) { if(mPixels == iter->second.mAddress) { // This is the currently active pixel buffer. Make sure we stop drawing to it. mPixels = NULL; mTextureSegmentName.clear(); // Make sure the movie decoder is no longer pointed at the shared segment. sizeChanged(); } mSharedSegments.erase(iter); } else { WARNMSG("MediaPluginGStreamer010::receiveMessage: unknown shared memory region!"); } // Send the response so it can be cleaned up. LLPluginMessage message("base", "shm_remove_response"); message.setValue("name", name); sendMessage(message); } else { std::ostringstream str; INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown base message: %s", message_name.c_str()); } } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA) { if(message_name == "init") { // Plugin gets to decide the texture parameters to use. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params"); // lame to have to decide this now, it depends on the movie. Oh well. mDepth = 4; mCurrentWidth = 1; mCurrentHeight = 1; mPreviousWidth = 1; mPreviousHeight = 1; mNaturalWidth = 1; mNaturalHeight = 1; mWidth = 1; mHeight = 1; mTextureWidth = 1; mTextureHeight = 1; message.setValueU32("format", GL_RGBA); message.setValueU32("type", GL_UNSIGNED_INT_8_8_8_8_REV); message.setValueS32("depth", mDepth); message.setValueS32("default_width", mWidth); message.setValueS32("default_height", mHeight); message.setValueU32("internalformat", GL_RGBA8); message.setValueBoolean("coords_opengl", true); // true == use OpenGL-style coordinates, false == (0,0) is upper left. message.setValueBoolean("allow_downsample", true); // we respond with grace and performance if asked to downscale sendMessage(message); } else if(message_name == "size_change") { std::string name = message_in.getValue("name"); S32 width = message_in.getValueS32("width"); S32 height = message_in.getValueS32("height"); S32 texture_width = message_in.getValueS32("texture_width"); S32 texture_height = message_in.getValueS32("texture_height"); std::ostringstream str; INFOMSG("---->Got size change instruction from application with shm name: %s - size is %d x %d", name.c_str(), width, height); LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response"); message.setValue("name", name); message.setValueS32("width", width); message.setValueS32("height", height); message.setValueS32("texture_width", texture_width); message.setValueS32("texture_height", texture_height); sendMessage(message); if(!name.empty()) { // Find the shared memory region with this name SharedSegmentMap::iterator iter = mSharedSegments.find(name); if(iter != mSharedSegments.end()) { INFOMSG("*** Got size change with matching shm, new size is %d x %d", width, height); INFOMSG("*** Got size change with matching shm, texture size size is %d x %d", texture_width, texture_height); mPixels = (unsigned char*)iter->second.mAddress; mTextureSegmentName = name; mWidth = width; mHeight = height; if (texture_width > 1 || texture_height > 1) // not a dummy size from the app, a real explicit forced size { INFOMSG("**** = REAL RESIZE REQUEST FROM APP"); GST_OBJECT_LOCK(mVideoSink); mVideoSink->resize_forced_always = true; mVideoSink->resize_try_width = texture_width; mVideoSink->resize_try_height = texture_height; GST_OBJECT_UNLOCK(mVideoSink); } mTextureWidth = texture_width; mTextureHeight = texture_height; } } } else if(message_name == "load_uri") { std::string uri = message_in.getValue("uri"); navigateTo( uri ); sendStatus(); } else if(message_name == "mouse_event") { std::string event = message_in.getValue("event"); S32 x = message_in.getValueS32("x"); S32 y = message_in.getValueS32("y"); if(event == "down") { mouseDown(x, y); } else if(event == "up") { mouseUp(x, y); } else if(event == "move") { mouseMove(x, y); }; }; } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME) { if(message_name == "stop") { stop(); } else if(message_name == "start") { double rate = 0.0; if(message_in.hasValue("rate")) { rate = message_in.getValueReal("rate"); } // NOTE: we don't actually support rate. play(rate); } else if(message_name == "pause") { pause(); } else if(message_name == "seek") { double time = message_in.getValueReal("time"); // defer the actual seek in case we haven't // really truly started yet in which case there // is nothing to seek upon mSeekWanted = true; mSeekDestination = time; } else if(message_name == "set_loop") { bool loop = message_in.getValueBoolean("loop"); mIsLooping = loop; } else if(message_name == "set_volume") { double volume = message_in.getValueReal("volume"); setVolume(volume); } } else { INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown message class: %s", message_class.c_str()); } } }
int main(int argc, char **argv) { ////////////////////////////////////////////////////////////////////// // check joystick ////////////////////////////////////////////////////////////////////// std::string commandNoJoystick = std::string(argv[0]) + " --no-joystick "; Herve::utilInfo("to disable joystick, use : ", commandNoJoystick.c_str() , __FILE__, __LINE__); if (argc == 2 and std::string(argv[1]) == "--no-joystick") gEnableJoystick = false; ////////////////////////////////////////////////////////////////////// // init ////////////////////////////////////////////////////////////////////// // display device gUptrDisplayDevice.reset(new HerveOvr::DisplayDeviceStereoOvr(1024, 1024)); if (not gUptrDisplayDevice->initDevice()) { gUptrDisplayDevice.reset(new Herve::DisplayDeviceMono()); //gUptrDisplayDevice.reset(new Herve::DisplayDeviceStereoFake(1024, 1024)); gUptrDisplayDevice->initDevice(); } // SDL if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 ) Herve::utilError("SDL_Init", "", __FILE__, __LINE__); const SDL_VideoInfo* info = SDL_GetVideoInfo(); int maxWidth = info->current_w; int maxHeight = info->current_h; SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); gPtrSurface = SDL_SetVideoMode( gUptrDisplayDevice->getWidth(), gUptrDisplayDevice->getHeight(), 24, SDL_OPENGL|SDL_RESIZABLE ); if( gPtrSurface == NULL ) Herve::utilError("SDL_SetVideoMode", "", __FILE__, __LINE__); atexit(SDL_Quit); SDL_EnableUNICODE( SDL_TRUE ); SDL_WM_SetCaption( "DemoSdl1", NULL ); // joysticks int nbJoysticks = SDL_NumJoysticks(); for(int i=0; i<nbJoysticks; i++) { SDL_Joystick * stick = SDL_JoystickOpen( i ); if( stick ) { Herve::utilInfo("joystick = ", SDL_JoystickName(i), __FILE__, __LINE__); } } // scene data gUptrDisplayDevice->initDisplay(maxWidth, maxHeight); gScene.init(gUptrDisplayDevice.get()); gFpsCounter.start(); Herve::utilInfo("width = ", std::to_string(gUptrDisplayDevice->getWidth()).c_str(), __FILE__, __LINE__); Herve::utilInfo("height = ", std::to_string(gUptrDisplayDevice->getHeight()).c_str(), __FILE__, __LINE__); Herve::utilInfo("maxWidth = ", std::to_string(gUptrDisplayDevice->getMaxWidth()).c_str(), __FILE__, __LINE__); Herve::utilInfo("maxHeight = ", std::to_string(gUptrDisplayDevice->getMaxHeight()).c_str(), __FILE__, __LINE__); ////////////////////////////////////////////////////////////////////// // main loop ////////////////////////////////////////////////////////////////////// SDL_Event event; while (true) { // handle events while( SDL_PollEvent( &event ) ) { switch(event.type) { case SDL_QUIT: exit(0); break; case SDL_KEYDOWN: keyDown(event.key); break; case SDL_KEYUP: keyUp(event.key); break; case SDL_MOUSEBUTTONUP : mouseUp(event.button); break; case SDL_MOUSEBUTTONDOWN : mouseDown(event.button); break; case SDL_MOUSEMOTION : mouseMotion(event.motion); break; case SDL_VIDEORESIZE : resize(event.resize); break; case SDL_JOYAXISMOTION : joyMotion(event.jaxis); break; } } updateCamera(); render(); } return 0; }
static int onLBUTTONDOWN(HWND win, BOOL dbl, int x, int y, UINT flacv) { return mouseDown(win, CVK_MOUSELEFT); }
/** * The 'delta' version of the click and drag command. This function moves an xy * distance from a startpoint. This distance is 'wrapping', so if it is outside * of the window, we mouseup, return to the start position, mousedown, and then * move again. We give a one pixel border at each side of the window and clamp * using that value to avoid accidental resizing. */ bool clickAndDragDelta(std::string window_name, nlohmann::json action){ //get the values of the student's window. int x_start, x_end, y_start, y_end, mouse_button; bool no_clamp = false; bool success = populateClickAndDragValues(action, window_name, x_start, x_end, y_start, y_end, mouse_button, no_clamp); //if we can't populate the click and drag values, do nothing. if(!success){ std::cout << "Could not populate the click and drag values."<< std::endl; return false; } //Define the corners of our window. (We use vectors as 2d points.) std::vector<int> upper_left, upper_right, lower_left, lower_right; upper_left.push_back(x_start); upper_left.push_back(y_start); upper_right.push_back(x_end); upper_right.push_back(y_start); lower_left.push_back(x_start); lower_left.push_back(y_end); lower_right.push_back(x_end); lower_right.push_back(y_end); //delta version, 2 values movement x and movement y. int amt_x_movement_remaining = action.value("x_distance", 0); int amt_y_movement_remaining = action.value("y_distance", 0); std::string start_location = action.value("start_location", "center"); //This shouldn't fail unless there isn't a mouse. std::string mouse_location_string = output_of_system_command("xdotool getmouselocation"); std::vector<int> xy = extractIntsFromString(mouse_location_string); //if the mouse isn't detected, fail. if(xy.size() < 2){ std::cout << "Mouse coordinates couldn't be found. Mouse undetected." << std::endl; return false; } //get the current mouse location int start_mouse_x = xy[0]; int start_mouse_y = xy[1]; //clamp the mouse within the screen (and move in by a pixel). clamp(start_mouse_x, x_start+1, x_end-1); clamp(start_mouse_y, y_start+1, y_end-1); //get the center of the window int width = x_end - x_start; int height = y_end - y_start; int x_middle = x_start + (width/2); int y_middle = y_start+(height/2); //NOTE: check my arithmetic. /** * The process that this algorithm goes through is as follows: * 1) Determine the slope of the dragged line and its distance. * 2) while we have not traversed the necessary distance * 3) project a line from the current mouse position towards the end * position with length equal to the remaining distance. * 4) Now that we have a line segment defined, find where/if it intersects * any of the window's edges * 5) if it does intersect, cut it off at the point of intersection, and only * drag that far. Else, if it doesn't intersect, we can assume we are * inside of the window, due to the clamp, and can drag. * 6) update remaining distance and continue to loop. */ //rise / run float slope=(float)amt_y_movement_remaining/(float)amt_x_movement_remaining; float total_distance_needed = sqrt(pow(amt_x_movement_remaining, 2) + pow (amt_y_movement_remaining, 2)); //remaining distance needed. float remaining_distance_needed = total_distance_needed; int action_start_x = (start_location == "current") ? start_mouse_x : x_middle; int action_start_y = (start_location == "current") ? start_mouse_y : y_middle; std::cout << "start x " << start_mouse_x << " our x " << action_start_x; std::cout << "start y " << start_mouse_y << " our y " << action_start_y; //The functions called within this loop will not fire if the window doesn't // exist. This check just short circuits to avoid additional printing. while(remaining_distance_needed >= 1 && windowExists(window_name)){ int curr_x = action_start_x; int curr_y = action_start_y; int moved_mouse_x, moved_mouse_y; //reset the mouse to the start location. mouse_move(window_name, action_start_x, action_start_y, x_start, x_end, y_start, y_end, false); //determine how far we've come. float fraction_of_distance_remaining = remaining_distance_needed / total_distance_needed; //project in the direction of the move to find the end of our line segment. float projected_x = action_start_x + (amt_x_movement_remaining * fraction_of_distance_remaining); float projected_y = action_start_y + (amt_y_movement_remaining * fraction_of_distance_remaining); //we are using vectors as 2d points. std::vector<int> current_point, projected_point; current_point.push_back(curr_x); current_point.push_back(curr_y); projected_point.push_back(projected_x); projected_point.push_back(projected_y); std::vector<float> intersection_point; intersection_point=getLineIntersectionPoint(current_point,projected_point, upper_left, upper_right); /** * TODO make this block smaller. * These if statements just test all edges of the window against our * projected line. */ //found is just a quick short-circuit to keep the code from ballooning. bool found = false; if(intersection_point.size() != 0){ //TOP std::cout << "intersected top" << std::endl; moved_mouse_x = (int)intersection_point[0]; moved_mouse_y = (int)intersection_point[1]; found = true; } if(!found) //RIGHT { intersection_point = getLineIntersectionPoint(current_point, projected_point, upper_right, lower_right); if(intersection_point.size() != 0){ std::cout << "intersected right" << std::endl; moved_mouse_x = (int)intersection_point[0]; moved_mouse_y = (int)intersection_point[1]; found = true; } } if(!found) //BOTTOM { intersection_point = getLineIntersectionPoint(current_point, projected_point, lower_right, lower_left); if(intersection_point.size() != 0){ std::cout << "intersected bottom" << std::endl; moved_mouse_x = (int)intersection_point[0]; moved_mouse_y = (int)intersection_point[1]; found = true; } } if(!found) //LEFT { intersection_point = getLineIntersectionPoint(current_point, projected_point, lower_left, upper_left); if(intersection_point.size() != 0){ std::cout << "intersected left" << std::endl; moved_mouse_x = (int)intersection_point[0]; moved_mouse_y = (int)intersection_point[1]; found = true; } } //if we didn't intersect, we are inside of the box (guaranteed by clamp) // so we can move freely. if(!found) { std::cout << "No intersection at all"<< std::endl; moved_mouse_x = projected_x; moved_mouse_y = projected_y; } //the distance we can move float distance_of_move = sqrt(pow(moved_mouse_x - action_start_x, 2) + pow (moved_mouse_y - action_start_y, 2)); //we are moving distance_of_move remaining_distance_needed -= distance_of_move; std::cout << "after the move, we had " << remaining_distance_needed << " distance left " << std::endl; mouseDown(window_name,mouse_button); //click mouse_move(window_name, moved_mouse_x, moved_mouse_y,x_start, x_end, //drag y_start, y_end, false); mouseUp(window_name,mouse_button); //release } //end loop. //to preserve backwards compatibility. if(start_location != "current"){ //put the mouse back where we found it. mouse_move(window_name, start_mouse_x, start_mouse_y, x_start, x_end, y_start, y_end,false); } return true; }
static int onRBUTTONDOWN(HWND win, BOOL dbl, int x, int y, UINT flacv) { return mouseDown(CVK_MOUSERIGHT); }
void FboMaskManager::mousePressed(ofMouseEventArgs &e){ mouseDown(e.x, e.y); }
/********************************************* per-frame logic goes here **********************************************/ void App::updateMain(){ //Get the mouse pointer pos in screen space SDL_GetMouseState(&iMouseX, &iMouseY); //Throw away any bad frames if(fTimeScale == infinity || fTimeScale == 0.0f){ return; } float fCamSpeed = fTimeScale * 10.0f; float fDragScale = 0.05f; if (!this->bGlobalDisableKeyMovement) { //Right button means we reset rotation and such //NOTE: I did have this as 'both left and right at once', which seemed //to make more sense, but it doesn't work great on systems that map this //to middle-mouse if(mouseDown(3)){ resetCam(); } //Rotation for the wall /* float camTime = fUptime * 0.1f; float fRotateSpeed = fCamSpeed; fRot[1] += fRotateSpeed; fRot[0] = (sinf(camTime) * 5); fCameraY = cosf(camTime) * 5; fZoom = (sinf(camTime) * 15) + 27; */ //LOG("%f, %f\n", fRot[1], fZoom); //fZoom = -10; //Keyboard rotation if(keyDown(SDLK_RSHIFT) || keyDown(SDLK_LSHIFT)){ fCamSpeed *= 10; } if(keyDown(SDLK_LEFT)) fRot[1] -= fCamSpeed; if(keyDown(SDLK_RIGHT)) fRot[1] += fCamSpeed; if(keyDown(SDLK_UP)) fRot[0] -= fCamSpeed; if(keyDown(SDLK_DOWN)) fRot[0] += fCamSpeed; if(keyDown(SDLK_w)) { fCameraZ -= fCamSpeed; //fRot[0] = 0.0; fRot[1] = 0.0; fRot[2] = 0.0; fLookZ -= fCamSpeed; } if(keyDown(SDLK_s)) { fCameraZ += fCamSpeed; //fRot[0] = 0.0; fRot[1] = 0.0; fRot[2] = 0.0; fLookZ += fCamSpeed; } if(keyDown(SDLK_a)) { fCameraX -= fCamSpeed; fLookX -= fCamSpeed; } if(keyDown(SDLK_d)) { fCameraX += fCamSpeed; fLookX += fCamSpeed; } if(keyDown(SDLK_SPACE)) resetCam(); //If we're actively dragging with the mouse if(bDrag){ //Figure out the drag vectors and stuff Vector2 drag = getMouse(); Vector2 diff = (dragStart - drag) * fDragScale; //Left mouse button means we modify the rotation if(mouseDown(1)){ fRot[1] -= diff.x; fRot[0] -= diff.y; } //Middle mouse means we modify the zoom else if(mouseDown(2)){ fZoom += diff.y; } dragVel = diff; dragStart = getMouse(); }else{ //fRot[1] -= dragVel.x; //fRot[0] -= dragVel.y; } } updateSocket(); //Hack! The shader system doesn't really play nice with the banner, so //we disable it here. if(!isConnected()){ if(ps()->getType() <= PARTICLE_SYSTEM_POINTSPRITES) generateTestData(); else fGUITimeout = 1.0f; } mParticleSystem->update(); }
/* Run a slider widget */ void W_SLIDER::run(W_CONTEXT *psContext) { if ((state & SLD_DRAG) && !mouseDown(MOUSE_LMB)) { state &= ~SLD_DRAG; screenPointer->setReturn(this); dirty = true; } else if (!(state & SLD_DRAG) && mouseDown(MOUSE_LMB)) { clicked(psContext, WKEY_NONE); } if (state & SLD_DRAG) { /* Figure out where the drag box should be */ int mx = psContext->mx - x(); int my = psContext->my - y(); int stopSize; switch (orientation) { case WSLD_LEFT: if (mx <= barSize / 2) { pos = 0; } else if (mx >= width() - barSize / 2) { pos = numStops; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (width() - barSize) / numStops; pos = (mx + stopSize / 2 - barSize / 2) * numStops / (width() - barSize); } break; case WSLD_RIGHT: if (mx <= barSize / 2) { pos = numStops; } else if (mx >= width() - barSize / 2) { pos = 0; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (width() - barSize) / numStops; pos = numStops - (mx + stopSize / 2 - barSize / 2) * numStops / (width() - barSize); } break; case WSLD_TOP: if (my <= barSize / 2) { pos = 0; } else if (my >= height() - barSize / 2) { pos = numStops; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (height() - barSize) / numStops; pos = (my + stopSize / 2 - barSize / 2) * numStops / (height() - barSize); } break; case WSLD_BOTTOM: if (my <= barSize / 2) { pos = numStops; } else if (my >= height() - barSize / 2) { pos = 0; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (height() - barSize) / numStops; pos = numStops - (my + stopSize / 2 - barSize / 2) * numStops / (height() - barSize); } break; } } }
// //////////////////////////////////////////////////////////////////////////// // process clicks made by user. void intProcessMultiMenu(UDWORD id) { UBYTE i; //close if (id == MULTIMENU_CLOSE) { intCloseMultiMenu(); } //alliance button if(id >=MULTIMENU_ALLIANCE_BASE && id<MULTIMENU_ALLIANCE_BASE+MAX_PLAYERS) { i =(UBYTE)( id - MULTIMENU_ALLIANCE_BASE); switch(alliances[selectedPlayer][i]) { case ALLIANCE_BROKEN: requestAlliance((UBYTE)selectedPlayer,i,true,true); // request an alliance break; case ALLIANCE_INVITATION: formAlliance((UBYTE)selectedPlayer,i,true,true,true); // form an alliance break; case ALLIANCE_REQUESTED: breakAlliance((UBYTE)selectedPlayer,i,true,true); // break an alliance break; case ALLIANCE_FORMED: breakAlliance((UBYTE)selectedPlayer,i,true,true); // break an alliance break; default: break; } } //channel opens. if(id >=MULTIMENU_CHANNEL && id<MULTIMENU_CHANNEL+MAX_PLAYERS) { i = id - MULTIMENU_CHANNEL; openchannels[i] = !openchannels[i]; if(mouseDown(MOUSE_RMB) && NetPlay.isHost) // both buttons.... { char buf[250]; // Allow the host to kick the AI only in a MP game, or if they activated cheats in a skirmish game if ((NetPlay.bComms || Cheated) && (NetPlay.players[i].allocated || (NetPlay.players[i].allocated == false && NetPlay.players[i].ai != AI_OPEN))) { inputLoseFocus(); ssprintf(buf, _("The host has kicked %s from the game!"), getPlayerName((unsigned int) i)); sendTextMessage(buf, true); ssprintf(buf, _("kicked %s : %s from the game, and added them to the banned list!"), getPlayerName((unsigned int) i), NetPlay.players[i].IPtextAddress); NETlogEntry(buf, SYNC_FLAG, (unsigned int) i); kickPlayer((unsigned int) i, "you are unwanted by the host.", ERROR_KICKED); return; } } } //radar gifts if(id >= MULTIMENU_GIFT_RAD && id< MULTIMENU_GIFT_RAD +MAX_PLAYERS) { sendGift(RADAR_GIFT, id - MULTIMENU_GIFT_RAD); } // research gift if(id >= MULTIMENU_GIFT_RES && id<MULTIMENU_GIFT_RES +MAX_PLAYERS) { sendGift(RESEARCH_GIFT, id - MULTIMENU_GIFT_RES); } //droid gift if(id >= MULTIMENU_GIFT_DRO && id< MULTIMENU_GIFT_DRO +MAX_PLAYERS) { sendGift(DROID_GIFT, id - MULTIMENU_GIFT_DRO); } //power gift if(id >= MULTIMENU_GIFT_POW && id< MULTIMENU_GIFT_POW +MAX_PLAYERS) { sendGift(POWER_GIFT, id - MULTIMENU_GIFT_POW); } }
void wdgSlider::mouseDragged(int x, int y, int dx, int dy, int button) { mouseDown(x, y); }
void CameraUi::mouseDown( app::MouseEvent &event ) { mouseDown( event.getPos() ); event.setHandled(); }
void wdgSlider::mouseDragged(float x, float y, float dx, float dy, int button) { mouseDown(x, y); }
void wdgSlider::mousePressed(float x, float y, int button) { mouseMoved(x, y); mouseDown(x, y); wdgBase::mousePressed(x, y, button); }
/* Run a slider widget */ void sliderRun(W_SLIDER *psWidget, W_CONTEXT *psContext) { SDWORD mx,my; UDWORD stopSize; if ((psWidget->state & SLD_DRAG) && !mouseDown(MOUSE_LMB)) { psWidget->state &= ~SLD_DRAG; widgSetReturn(psContext->psScreen, (WIDGET *)psWidget); } else if (!(psWidget->state & SLD_DRAG) && mouseDown(MOUSE_LMB)) { sliderClicked(psWidget, psContext); } if (psWidget->state & SLD_DRAG) { /* Figure out where the drag box should be */ mx = psContext->mx - psWidget->x; my = psContext->my - psWidget->y; switch (psWidget->orientation) { case WSLD_LEFT: if (mx <= psWidget->barSize/2) { psWidget->pos = 0; } else if (mx >= psWidget->width - psWidget->barSize/2) { psWidget->pos = psWidget->numStops; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (psWidget->width - psWidget->barSize) / psWidget->numStops; psWidget->pos = (UWORD)((mx + stopSize/2 - psWidget->barSize/2) * psWidget->numStops / (psWidget->width - psWidget->barSize)); } break; case WSLD_RIGHT: if (mx <= psWidget->barSize/2) { psWidget->pos = psWidget->numStops; } else if (mx >= psWidget->width - psWidget->barSize/2) { psWidget->pos = 0; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (psWidget->width - psWidget->barSize) / psWidget->numStops; psWidget->pos = (UWORD)(psWidget->numStops - (mx + stopSize/2 - psWidget->barSize/2) * psWidget->numStops / (psWidget->width - psWidget->barSize)); } break; case WSLD_TOP: if (my <= psWidget->barSize/2) { psWidget->pos = 0; } else if (my >= psWidget->height - psWidget->barSize/2) { psWidget->pos = psWidget->numStops; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (psWidget->height - psWidget->barSize) / psWidget->numStops; psWidget->pos = (UWORD)((my + stopSize/2 - psWidget->barSize/2) * psWidget->numStops / (psWidget->height - psWidget->barSize)); } break; case WSLD_BOTTOM: if (my <= psWidget->barSize/2) { psWidget->pos = psWidget->numStops; } else if (my >= psWidget->height - psWidget->barSize/2) { psWidget->pos = 0; } else { /* Mouse is in the middle of the slider, calculate which stop */ stopSize = (psWidget->height - psWidget->barSize) / psWidget->numStops; psWidget->pos = (UWORD)(psWidget->numStops - (my + stopSize/2 - psWidget->barSize/2) * psWidget->numStops / (psWidget->height - psWidget->barSize)); } break; } } }
// // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; switch (message) { case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_ABOUT: DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About); break; case IDM_EXIT: DestroyWindow(hWnd); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_CREATE: break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); { RECT cr; GetClientRect(hWnd, &cr); int width = cr.right - cr.left; int height = cr.bottom - cr.top; HDC bufDC; HBITMAP bufBMP; bufDC = CreateCompatibleDC(hdc); bufBMP = CreateCompatibleBitmap(hdc, width, height); SelectObject(bufDC, bufBMP); setPaintDC(bufDC); RECT r = {0}; r.right = width; r.bottom = height; FillRect(bufDC, &r, GetStockBrush(WHITE_BRUSH)); paint(); setPaintDC(NULL); BitBlt(hdc, 0, 0, width, height, bufDC, 0, 0, SRCCOPY); DeleteObject(bufBMP); DeleteDC(bufDC); } EndPaint(hWnd, &ps); break; case WM_MOUSEMOVE: { int x = GET_X_LPARAM(lParam); int y = GET_Y_LPARAM(lParam); mouseMove(x, y); } break; case WM_LBUTTONDOWN: SetCapture(hWnd); mouseDown(); break; case WM_LBUTTONUP: ReleaseCapture(); mouseUp(); break; case WM_KEYDOWN: { int vk = wParam; char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR); keyDown(ch, vk); } break; case WM_KEYUP: { int vk = wParam; char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR); keyUp(ch, vk); } break; case WM_TIMER: switch(wParam) { case IDT_TIMER0: timerTick(); break; } break; case WM_DESTROY: finalize(); PostQuitMessage(0); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; }
static int onMBUTTONDOWN(HWND win, BOOL dbl, int x, int y, UINT flacv) { return mouseDown(CVK_MOUSEMIDDLE); }
StaticFrameGui::StaticFrameGui(QWidget* parent): FrameGui(parent) { setTitle("Static Frame"); group = new QButtonGroup (this); grid = new QGridLayout (this); dewellSwitch = new QRadioButton (this); dewellSwitch->setText("Dewell (ms)"); dewellSwitch->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Fixed); repeatSwitch = new QRadioButton (this); repeatSwitch->setText("Repeat (frames)"); repeatSwitch->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Fixed); group->addButton(dewellSwitch,1); group->addButton(repeatSwitch,2); grid->addWidget(dewellSwitch,2,0,1,1); grid->addWidget(repeatSwitch,3,0,1,1); QLabel * pointsLabel = new QLabel ("Points",this); pointsLabel->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Fixed); pointsDisplay = new QLabel ("0",this); pointsDisplay->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Fixed); grid->addWidget(pointsLabel,1,0,1,1); grid->addWidget(pointsDisplay,1,1,1,1); dewellEntry = new QSpinBox (this); dewellEntry->setMinimum (40); dewellEntry->setMaximum (600000); repeatEntry = new QSpinBox (this); repeatEntry->setMinimum (1); repeatEntry->setMaximum (1000); grid->addWidget(dewellEntry,2,1,1,1); grid->addWidget(repeatEntry,3,1,1,1); QLabel *l = new QLabel (this); l->setText("ArcBall"); l->setFrameShape(QFrame::Panel); l->setFrameShadow(QFrame::Raised); l->setAlignment(Qt::AlignHCenter); arcball = new ArcBall(this); connect (arcball,SIGNAL(angleChanged(QQuaternion)),this,SLOT(angleChangedData(QQuaternion))); connect (arcball,SIGNAL(mouseDown()),this,SLOT(arcballDown())); connect (arcball,SIGNAL(mouseUp()),this,SLOT(arcballUp())); grid->addWidget(l,4,0); grid->addWidget(arcball,5,0); l = new QLabel (this); l->setText ("Size"); l->setFrameShape(QFrame::Panel); l->setFrameShadow(QFrame::Raised); l->setAlignment(Qt::AlignHCenter); grid->addWidget(l,4,1); size = new QSlider(Qt::Vertical,this); size->setRange(-200,100); size->setSliderPosition(0); grid->addWidget(size,5,1); setLayout(grid); }
void Gdc2005Demo::handleUserInput(struct GdcStateInput& stateInput) { const hkgKeyboard& keys = m_env->m_window->getKeyboard(); // Show help on the keys if the user asks for it if ( keys.getKeyState('H') || keys.getKeyState(HKG_VKEY_F1) || ( m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_L1) && m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_R1) && m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_0) ) ) { showKeys(); } // For reference, on PC keyboard: // HKG_VKEY_DELETE == HKG_PAD_BUTTON_L1 // HKG_VKEY_END == HKG_PAD_BUTTON_R1 // HKG_VKEY_INSERT == HKG_PAD_BUTTON_L2 // HKG_VKEY_HOME == HKG_PAD_BUTTON_R2 // See if we want to chuck anything into the scene if ( m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_2) ) { hkVector4 startPos; m_env->m_window->getCurrentViewport()->getCamera()->getFrom( (float*)&startPos ); hkVector4 velocity; m_env->m_window->getCurrentViewport()->getCamera()->getDir( (float*)&velocity ); velocity.mul4( m_options.m_Physics.m_launchVelocity ); chuckSomething( startPos, velocity ); } // See if we want to shot the guy (right click or L2) if ( m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_L2) || (m_env->m_window->getMouse().getButtonState() & HKG_MOUSE_RIGHT_BUTTON) ) { hkVector4 rayStart; hkVector4 rayEnd; // unproject current 'mouse' pos. hkgCamera* cam = m_env->m_window->getViewport(0)->getCamera(); int xPos = m_env->m_window->getMouse().getPosX(); int yPos = m_env->m_window->getMouse().getPosY(); cam->unProject( xPos, yPos, 0, m_env->m_window->getWidth(), m_env->m_window->getHeight(), (float*)&rayStart); cam->unProject( xPos, yPos, 1, m_env->m_window->getWidth(), m_env->m_window->getHeight(), (float*)&rayEnd); fireShot( rayStart, rayEnd, m_options.m_Physics.m_shotStrength ); // num == strength } // See if we want to drag objects around if( !m_mouseActive && ( m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_R1) || keys.getKeyState(HKG_VKEY_SPACE)) ) // Space == Button0 on PC == jump { mouseDown(); // pick object under cursor } else if ( m_mouseActive ) { if( !m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_R1) && !m_env->m_window->getKeyboard().getKeyState(HKG_VKEY_SPACE) ) { mouseUp(); // default physics game impl : delete mouse spring } else { mouseDrag(); // default physics game impl : unproject mouse and move spring. } } // Desired direction // If we are on a console we are using a stick and want that to dictate // the desired direction. Otherwise we will use the dpad ( keyboard dir keys ) updateUserControl(); // Die ? Get up? Jump? { const hkUint32 currentAnimationState = m_animationStateMachine->getCurrentState(); const bool usingGamepad = m_env->m_window->hasGamePads() && !m_env->m_options->m_forceKeyboardGamepad; // DIE? if (m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_1) && currentAnimationState != GDC_DYING_STATE && currentAnimationState != GDC_DEAD_STATE && currentAnimationState != GDC_GETTING_UP_STATE) { stateInput.m_shouldDie = true; } else { stateInput.m_shouldDie = false; } // DIVE? if (m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_3) && currentAnimationState != GDC_DYING_STATE && currentAnimationState != GDC_DEAD_STATE && currentAnimationState != GDC_GETTING_UP_STATE) { stateInput.m_shouldDive = true; } else { stateInput.m_shouldDive = false; } // GET UP? if (m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_1) && currentAnimationState == GDC_DEAD_STATE) { stateInput.m_shouldGetUp = true; } else { stateInput.m_shouldGetUp = false; } // JUMP? bool jumpPressed; if (usingGamepad) { jumpPressed = m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_0); } else { jumpPressed = keys.wasKeyPressed('4'); } if (jumpPressed && currentAnimationState!=GDC_DYING_STATE && currentAnimationState!=GDC_IN_AIR_STATE && currentAnimationState!=GDC_DEAD_STATE && currentAnimationState!=GDC_JUMP_STATE) { stateInput.m_shouldJump = true; } else { stateInput.m_shouldJump = false; } } }
void DemoMediaPlugin::receiveMessage(const char *message_string) { // std::cerr << "DemoMediaPlugin::receiveMessage: received message: \"" << message_string << "\"" << std::endl; LLPluginMessage message_in; if(message_in.parse(message_string) >= 0) { std::string message_class = message_in.getClass(); std::string message_name = message_in.getName(); if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE) { if(message_name == "init") { LLPluginMessage message("base", "init_response"); LLSD versions = LLSD::emptyMap(); versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION; versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION; // Normally a plugin would only specify one of these two subclasses, but this is a demo... versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION; versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION; message.setValueLLSD("versions", versions); sendMessage(message); // Plugin gets to decide the texture parameters to use. mDepth = 3; message.setMessage(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params"); message.setValueS32("depth", mDepth); message.setValueU32("internalformat", GL_RGB); message.setValueU32("format", GL_RGB); message.setValueU32("type", GL_UNSIGNED_BYTE); message.setValueBoolean("coords_opengl", false); // true == use OpenGL-style coordinates, false == (0,0) is upper left. sendMessage(message); } else if(message_name == "idle") { // no response is necessary here. update(); } else if(message_name == "shutdown") { sendMessage(LLPluginMessage("base", "shutdown_response")); mDeleteMe = true; } else if(message_name == "shm_added") { SharedSegmentInfo info; info.mAddress = (void*)message_in.getValueU32("address"); info.mSize = (size_t)message_in.getValueS32("size"); std::string name = message_in.getValue("name"); std::cerr << "DemoMediaPlugin::receiveMessage: shared memory added, name: " << name << ", size: " << info.mSize << ", address: " << info.mAddress << std::endl; mSharedSegments.insert(SharedSegmentMap::value_type(name, info)); } else if(message_name == "shm_remove") { std::string name = message_in.getValue("name"); std::cerr << "DemoMediaPlugin::receiveMessage: shared memory remove, name = " << name << std::endl; SharedSegmentMap::iterator iter = mSharedSegments.find(name); if(iter != mSharedSegments.end()) { if(mPixels == iter->second.mAddress) { // This is the currently active pixel buffer. Make sure we stop drawing to it. mPixels = NULL; } mSharedSegments.erase(iter); } else { std::cerr << "DemoMediaPlugin::receiveMessage: unknown shared memory region!" << std::endl; } // Send the response so it can be cleaned up. LLPluginMessage message("base", "shm_remove_response"); message.setValue("name", name); sendMessage(message); } else { std::cerr << "DemoMediaPlugin::receiveMessage: unknown base message: " << message_name << std::endl; } } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA) { if(message_name == "size_change") { std::string name = message_in.getValue("name"); S32 width = message_in.getValueS32("width"); S32 height = message_in.getValueS32("height"); S32 texture_width = message_in.getValueS32("texture_width"); S32 texture_height = message_in.getValueS32("texture_height"); LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response"); message.setValue("name", name); message.setValueS32("width", width); message.setValueS32("height", height); message.setValueS32("texture_width", texture_width); message.setValueS32("texture_height", texture_height); sendMessage(message); if(!name.empty()) { // Find the shared memory region with this name SharedSegmentMap::iterator iter = mSharedSegments.find(name); if(iter != mSharedSegments.end()) { std::cerr << "Got size change, new size is " << width << " by " << height << std::endl; std::cerr << " texture size is " << texture_width << " by " << texture_height << std::endl; mPixels = (unsigned char*)iter->second.mAddress; mWidth = width; mHeight = height; mTextureWidth = texture_width; mTextureHeight = texture_height; clear(); } } } else if(message_name == "mouse_event") { std::string event = message_in.getValue("event"); S32 x = message_in.getValueS32("x"); S32 y = message_in.getValueS32("y"); // std::string modifiers = message.getValue("modifiers"); // std::cerr << "DemoMediaPlugin::receiveMessage: mouse event \"" << event // << "\", coords " << x << ", " << y // << std::endl; if(event == "down") { mouseDown(x, y); } else if(event == "up") { mouseUp(x, y); } else if(event == "move") { mouseMove(x, y); } } else { std::cerr << "DemoMediaPlugin::receiveMessage: unknown media message: " << message_string << std::endl; } } else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER) { if(message_name == "focus") { // foo = message_in.getValueBoolean("focused"); } else if(message_name == "clear_cache") { } else if(message_name == "clear_cookies") { } else if(message_name == "enable_cookies") { // foo = message_in.getValueBoolean("enable"); } else if(message_name == "proxy_setup") { // foo = message_in.getValueBoolean("enable"); // bar = message_in.getValue("host"); // baz = message_in.getValueS32("port"); } else if(message_name == "browse_stop") { } else if(message_name == "browse_reload") { // foo = message_in.getValueBoolean("ignore_cache"); } else if(message_name == "browse_forward") { } else if(message_name == "browse_back") { } else if(message_name == "set_status_redirect") { // foo = message_in.getValueS32("code"); // bar = message_in.getValue("url"); } else { std::cerr << "DemoMediaPlugin::receiveMessage: unknown media_browser message: " << message_string << std::endl; } } else { std::cerr << "DemoMediaPlugin::receiveMessage: unknown message class: " << message_class << std::endl; } } }