static void handle_message(struct cfw_message *msg, void *param) { switch (CFW_MESSAGE_ID(msg)) { case MSG_ID_CIRCULAR_STORAGE_PUSH_REQ: handle_push(msg); break; case MSG_ID_CIRCULAR_STORAGE_POP_REQ: handle_pop(msg); break; case MSG_ID_CIRCULAR_STORAGE_PEEK_REQ: handle_peek(msg); break; case MSG_ID_CIRCULAR_STORAGE_CLEAR_REQ: handle_clear(msg); break; case MSG_ID_LL_CIRCULAR_STORAGE_SHUTDOWN_REQ: cfw_send_message(CFW_MESSAGE_PRIV(msg)); break; case MSG_ID_CIRCULAR_STORAGE_GET_REQ: handle_get(msg); default: cfw_print_default_handle_error_msg(LOG_MODULE_MAIN, CFW_MESSAGE_ID( msg)); break; } cfw_msg_free(msg); }
cell_t *invoke(cell_t *fun, cell_t *args, environ_t *env) { int argslen, paramlen; environ_t *new_env; function_t *func = fun->slot2.fun; cell_t *ret; cell_t *code; handle_t *hc; argslen = proper_list_length(args,0); paramlen = proper_list_length(func->param_list, 0); if (argslen != paramlen) return NULL; /* error */ create_empty_environment(&new_env); extend(func->lexical_env, new_env, func->param_list, args); code = func->code; hc = handle_push(code); while (NULL != code && !NILP(code)) { ret = evaluate(CAR(code), new_env); // code handled code = handle_get(hc); code = CDR(code); handle_set(hc, code); } handle_pop(hc); return ret; }
cell_t *evargs(cell_t *args, environ_t *env) { #define MAX_LISP_ARGS 16 handle_t *harray[MAX_LISP_ARGS]; int length; int i; cell_t *tmp, *head = nil_cell, *tail = nil_cell; handle_t *hhandle, *thandle; if ((length = proper_list_length(args, 0)) < 0) return NULL; /* error */ if (length > MAX_LISP_ARGS) return NULL; /* can only handle 16 args atm */ for (i = 0; i < length; i++, args = CDR(args)) { harray[i] = handle_push(CAR(args)); } for (i = 0; i < length; i++) { cell_t *t = handle_get(harray[i]); handle_set(harray[i], evaluate(t, env)); // everything handled } hhandle = handle_push(head); thandle = handle_push(tail); for (i = length - 1; i >= 0; i--) { tmp = new(cell_t); // head and tail protected by handles head = handle_get(hhandle); tail = handle_get(thandle); tail = head; head = handle_get(harray[i]); CONS(tmp, head, tail); head = tmp; handle_set(hhandle, head); handle_set(thandle, tail); } handle_pop(thandle); handle_pop(hhandle); for (i = length - 1; i >= 0; i--) { handle_pop(harray[i]); } return head; }
void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object) { LOGGER_DEBUG(m->log, "Got msi message"); MSISession *session = (MSISession *)object; MSIMessage msg; if (msg_parse_in(m->log, &msg, data, length) == -1) { LOGGER_WARNING(m->log, "Error parsing message"); send_error(m, friend_number, msi_EInvalidMessage); return; } LOGGER_DEBUG(m->log, "Successfully parsed message"); pthread_mutex_lock(session->mutex); MSICall *call = get_call(session, friend_number); if (call == NULL) { if (msg.request.value != requ_init) { send_error(m, friend_number, msi_EStrayMessage); pthread_mutex_unlock(session->mutex); return; } call = new_call(session, friend_number); if (call == NULL) { send_error(m, friend_number, msi_ESystem); pthread_mutex_unlock(session->mutex); return; } } switch (msg.request.value) { case requ_init: handle_init(call, &msg); break; case requ_push: handle_push(call, &msg); break; case requ_pop: handle_pop(call, &msg); /* always kills the call */ break; } pthread_mutex_unlock(session->mutex); }
int Fl_Dial::handle(int event) { int X = 0; int Y = 0; int W = w(); int H = h(); box()->inset(X,Y,W,H); switch (event) { case FL_PUSH: handle_push(); case FL_DRAG: { int mx = Fl::event_x()-X-W/2; int my = Fl::event_y()-Y-H/2; if (!mx && !my) return 1; double angle = 270-atan2((float)-my, (float)mx)*180/M_PI; double oldangle = (a2-a1)*(value()-minimum())/(maximum()-minimum()) + a1; while (angle < oldangle-180) angle += 360; while (angle > oldangle+180) angle -= 360; double val; if ((a1<a2) ? (angle <= a1) : (angle >= a1)) { val = minimum(); } else if ((a1<a2) ? (angle >= a2) : (angle <= a2)) { val = maximum(); } else { val = minimum() + (maximum()-minimum())*(angle-a1)/(a2-a1); } handle_drag(val); } return 1; case FL_RELEASE: if (!Fl::pushed()) handle_release(); return 1; default: return Fl_Valuator::handle(event); } }
int Fl_Roller::handle(int event) { static int ipos; int newpos = type()==HORIZONTAL ? Fl::event_x() : -Fl::event_y(); switch (event) { case FL_PUSH: handle_push(); ipos = newpos; return 1; case FL_DRAG: handle_drag(previous_value()+(newpos-ipos)*(step()?step():.01)); return 1; case FL_RELEASE: handle_release(); return 1; case FL_KEY: // Only arrows in the correct direction are used. This allows the // opposite arrows to be used to navigate between a set of parellel // rollers. switch (Fl::event_key()) { case FL_Up: case FL_Down: case FL_Home: case FL_End: if (type()==HORIZONTAL) return 0; break; case FL_Left: case FL_Right: if (type() != HORIZONTAL) return 0; } // else fall through... default: return Fl_Valuator::handle(event); } }
static void handle_message(struct cfw_message * msg, void * param) { switch (CFW_MESSAGE_ID(msg)) { case MSG_ID_LL_ERASE_BLOCK_REQ: handle_erase_block(msg); break; case MSG_ID_LL_READ_PARTITION_REQ: handle_read_partition(msg); break; case MSG_ID_LL_WRITE_PARTITION_REQ: handle_write_partition(msg); break; #ifdef CONFIG_SERVICES_QUARK_SE_STORAGE_CIRCULAR case MSG_ID_LL_CIR_STOR_INIT_REQ: handle_cir_stor_init(msg); break; case MSG_ID_LL_PUSH_REQ: handle_push(msg); break; case MSG_ID_LL_POP_REQ: handle_pop(msg); break; case MSG_ID_LL_PEEK_REQ: handle_peek(msg); break; case MSG_ID_LL_CLEAR_REQ: handle_clear(msg); break; #endif default: cfw_print_default_handle_error_msg(LOG_MODULE_MAIN, CFW_MESSAGE_ID(msg)); break; } cfw_msg_free(msg); }
cell_t *evaluate(cell_t *exp, environ_t *env) { ++__tl_eval_level; // push a frame eval_stack_t s; s.next = eval_stack; s.value = env; eval_stack = &s; if (DFLAG) { printf("Eval (%d) got : ", __tl_eval_level); pretty_print(exp); } if (NULL == exp) { DRETURN(RET_VAL, NULL); } else if (NILP(exp)) { DRETURN(RET_VAL, nil_cell); } else if (ATOMP(exp)) { if (SYMBOLP(exp)) { DRETURN(RET_VAL, find_value(env, exp)); } else if (STRINGP(exp) || NUMBERP(exp)) { DRETURN(RET_VAL, exp); } else { DEBUGPRINT_("Expression not valid.\n"); pretty_print(orig_sexpr); GOTO_TOPLEVEL(); return NULL; /* unreachable */ } } else { /* list */ handle_t *he = handle_push(exp); cell_t *first = evaluate(CAR(exp), env); // exp handled exp = handle_get(he); handle_pop(he); cell_t *rest = CDR(exp); if (DFLAG) { printf("First is: "); pretty_print(first); printf("Rest is: "); pretty_print(rest); } if (NULL == first) { fast_error(" malformed expression."); /* This is unreachable */ } else if (PRIMITIVEP(first)) { cell_t *(*f)(cell_t *, environ_t *) = CELL_PRIMITIVE(first); DRETURN(RET_PRIM, (*f)(rest, env)); } else if (FUNCTIONP(first)) { /* function call */ cell_t *t; handle_t *hf; hf = handle_push(first); t = evargs(rest, env); // first handled first = handle_get(hf); handle_pop(hf); DRETURN(RET_FUNCALL, invoke(first, t, env)); // no need for handles } undefun_error(first, exp); /* Not primitive or funcall, error.*/ return NULL; /* Unreachable, undefun_error() does not return. */ } }
int Flu_Spinner::handle(int event) { int W = w()*15/100; if( W < h()/2 ) W = h()/2; int X = x()+w()-W, Y = y(); if( (align() & FL_ALIGN_INSIDE) || !_editable ) { _input.readonly( true ); _input.cursor_color( FL_WHITE ); } else { _input.readonly( false ); _input.cursor_color( FL_BLACK ); } switch( event ) { case FL_PUSH: _dragging = true; if (Fl::visible_focus() && handle(FL_FOCUS)) Fl::focus(this); _lastValue = value(); _lastY = Fl::event_y(); Fl::remove_timeout( repeat_callback, this ); if( Fl::event_inside( X, Y, W, h()/2 ) ) // up button { _pushed = true; _valbox[0] = FL_DOWN_BOX; _up = true; } if( Fl::event_inside( X, Y+h()/2, W, h()/2 ) ) // down button { _pushed = true; _valbox[1] = FL_DOWN_BOX; _up = false; } if( _pushed ) { increment_cb(); _totalTime = _initialDelay; if( _doRepeat ) Fl::add_timeout( _initialDelay, repeat_callback, this); handle_push(); take_focus(); redraw(); return 1; } break; case FL_DRAG: { // only do the dragging if the last Y differs from the current Y by more than 3 pixels if( ABS(_lastY-Fl::event_y()) < 3 ) break; _dragging = true; _pushed = false; Fl::remove_timeout( repeat_callback, this ); int oldWhen = when(); _setvalue(increment(_lastValue,(_lastY-Fl::event_y())*(Fl::event_state(FL_SHIFT|FL_CTRL|FL_ALT)?10:1))); _valbox[0] = _valbox[1] = FL_DOWN_BOX; when( oldWhen ); fl_cursor((Fl_Cursor)22); _input.redraw(); redraw(); } break; case FL_RELEASE: { bool doCB = ( ( when() & FL_WHEN_RELEASE ) || ( when() & FL_WHEN_RELEASE_ALWAYS ) ) && ( _pushed || ( _valbox[0] == FL_DOWN_BOX ^ _valbox[1] == FL_DOWN_BOX ) ); _pushed = false; _dragging = false; Fl::remove_timeout( repeat_callback, this ); _valbox[0] = _valbox[1] = FL_UP_BOX; fl_cursor(FL_CURSOR_DEFAULT); redraw(); handle_release(); if( doCB ) do_callback(); _input.take_focus(); } break; case FL_FOCUS: case FL_UNFOCUS: redraw(); _input.take_focus(); return 0; case FL_ENTER: if( Fl::event_inside( &_input ) ) return _input.handle(event); else if( active_r() ) { fl_cursor(FL_CURSOR_DEFAULT); return 1; } break; case FL_LEAVE: if( Fl::event_inside( &_input ) ) return _input.handle(event); else if( active_r() ) { fl_cursor(FL_CURSOR_DEFAULT); return 1; } break; case FL_KEYBOARD: switch( Fl::event_key() ) { case FL_Down: { int oldWhen = when(); when( FL_WHEN_CHANGED ); _setvalue(increment(value(),-1*(Fl::event_state(FL_SHIFT|FL_CTRL|FL_ALT)?10:1))); when( oldWhen ); redraw(); return 1; } case FL_Up: { int oldWhen = when(); when( FL_WHEN_CHANGED ); _setvalue(increment(value(),1*(Fl::event_state(FL_SHIFT|FL_CTRL|FL_ALT)?10:1))); when( oldWhen ); redraw(); return 1; } } break; } return _input.handle(event); }
int Fl_Slider::handle(int event, int x, int y, int w, int h) { switch (event) { case FL_FOCUS: case FL_UNFOCUS: redraw(FL_DAMAGE_ALL); return 1; case FL_PUSH: redraw(FL_DAMAGE_HIGHLIGHT); handle_push(); case FL_DRAG: { // figure out the space the slider moves in and where the event is: int mx; if (horizontal()) { w = w-box()->dw(); mx = Fl::event_x()-x-box()->dx(); } else { w = h-box()->dh(); mx = Fl::event_y()-y-box()->dy(); } if (w <= slider_size_) return 1; static int offcenter; int X = slider_position(value(), w); if (event == FL_PUSH) { offcenter = mx-X; // we are done if they clicked on the slider: if (offcenter >= (slider_size() ? 0 : -8) && offcenter <= slider_size_) return 1; if (Fl::event_button() > 1) { // Move the near end of the slider to the cursor. This is good // for scrollbars. offcenter = (offcenter < 0) ? 0 : slider_size_; } else { // Center the slider under the cursor, what most toolkits do offcenter = slider_size_/2; } } double v; RETRY: X = mx-offcenter; if (X < 0) { X = 0; offcenter = mx; if (offcenter < 0) offcenter = 0; } else if (X > (w-slider_size_)) { X = w-slider_size_; offcenter = mx-X; if (offcenter > slider_size_) offcenter = slider_size_; } v = position_value(X, w); handle_drag(v); // make sure a click outside the sliderbar moves it: if (event == FL_PUSH && value() == previous_value()) { offcenter = slider_size_/2; event = FL_DRAG; goto RETRY; } return 1; } case FL_RELEASE: handle_release(); redraw(FL_DAMAGE_HIGHLIGHT); return 1; case FL_KEY: // Only arrows in the correct direction are used. This allows the // opposite arrows to be used to navigate between a set of parellel // sliders. switch (Fl::event_key()) { case FL_Up: case FL_Down: if (horizontal()) return 0; break; case FL_Left: case FL_Right: if (!horizontal()) return 0; } default: return Fl_Valuator::handle(event); } }
int Fl_Scrollbar::handle(int event) { // area of scrollbar: int X=0; int Y=0; int W=w(); int H=h(); box()->inset(X,Y,W,H); // adjust slider area to be inside the arrow buttons: if (vertical()) { if (H >= 3*W) {Y += W; H -= 2*W;} } else { if (W >= 3*H) {X += H; W -= 2*H;} } // which widget part is highlighted? int mx = Fl::event_x(); int my = Fl::event_y(); int which_part; if (!Fl::event_inside(0, 0, w(), h())) which_part = NOTHING; else if (vertical()) { if (my < Y) which_part = UP_ARROW; else if (my >= Y+H) which_part = DOWN_ARROW; else { int slidery = slider_position(value(), H); if (my < Y+slidery) which_part = ABOVE_SLIDER; else if (my >= Y+slidery+slider_size()) which_part = BELOW_SLIDER; else which_part = SLIDER; } } // horizontal else { if (mx < X) which_part = UP_ARROW; else if (mx >= X+W) which_part = DOWN_ARROW; else { int sliderx = slider_position(value(), W); if (mx < X+sliderx) which_part = ABOVE_SLIDER; else if (mx >= X+sliderx+slider_size()) which_part = BELOW_SLIDER; else which_part = SLIDER; } } switch (event) { case FL_FOCUS: return 0; case FL_ENTER: case FL_MOVE: if (!highlight_color()) return 1; if (which_part != which_highlight) { which_highlight = which_part; redraw(FL_DAMAGE_HIGHLIGHT); } return 1; case FL_LEAVE: if (which_highlight) { which_highlight = 0; redraw(FL_DAMAGE_HIGHLIGHT); } return 1; case FL_PUSH: // Clicking on the slider or middle or right click on the trough // gives us normal slider behavior: if (which_part == SLIDER || Fl::event_button() > 1 && which_part > DOWN_ARROW) { which_pushed = SLIDER; return Fl_Slider::handle(event, X,Y,W,H); } handle_push(); goto J1; case FL_DRAG: if (which_pushed==SLIDER) return Fl_Slider::handle(event, X,Y,W,H); if (which_part == SLIDER) which_part = NOTHING; // it is okay to switch between arrows and nothing, but no other // changes are allowed: if (!which_pushed && which_part <= DOWN_ARROW) ; else if (!which_part && which_pushed <= DOWN_ARROW) ; else which_part = which_pushed; J1: if (which_part != which_pushed) { Fl::remove_timeout(timeout_cb, this); which_highlight = which_pushed = which_part; redraw(FL_DAMAGE_HIGHLIGHT); if (which_part) { Fl::add_timeout(INITIALREPEAT, timeout_cb, this); increment_cb(); } } return 1; case FL_RELEASE: if (which_pushed == SLIDER) { Fl_Slider::handle(event, X,Y,W,H); } else if (which_pushed) { Fl::remove_timeout(timeout_cb, this); handle_release(); redraw(FL_DAMAGE_HIGHLIGHT); } which_pushed = NOTHING; return 1; case FL_MOUSEWHEEL: { float n = (vertical() ? Fl::event_dy() : Fl::event_dx()) * Fl_Style::wheel_scroll_lines * linesize(); if (fabsf(n) > pagesize()) n = (n<0)?-pagesize():pagesize(); handle_drag(value()+n); return 1; } case FL_KEY: if (vertical()) switch(Fl::event_key()) { case FL_Home: handle_drag(maximum()); return 1; case FL_End: handle_drag(minimum()); return 1; case FL_Page_Up: handle_drag(value()-pagesize()); return 1; case FL_Page_Down: handle_drag(value()+pagesize()); return 1; } // else fall through... default: return Fl_Slider::handle(event); } }
int Fl_Value_Input_Spin::handle(int event) { double v; int olddelta; int mx = Fl::event_x(); int my = Fl::event_y(); int sxx = x(), syy = y(), sww = w(), shh = h(); sxx += sww - buttonssize(); sww = buttonssize(); if(!indrag && ( !sldrag || !((mx>=sxx && mx<=(sxx+sww)) && (my>=syy && my<=(syy+shh)))) ) { indrag=0; switch(event) { case FL_PUSH: case FL_DRAG: sldrag=1; break; case FL_FOCUS: input.take_focus(); break; case FL_UNFOCUS: redraw(); break; default: sldrag=0; } input.type(step()>=1.0 ? FL_INT_INPUT : FL_FLOAT_INPUT); return input.handle(event); } switch (event) { case FL_PUSH: // if (!step()) goto DEFAULT; iy = my; ix = mx; drag = Fl::event_button(); handle_push(); indrag=1; mouseobj=1; Fl::add_timeout(.5, repeat_callback, this); delta=0; if(Fl::event_inside(sxx,syy,sww,shh/2)) { deltadir=1; } else if (Fl::event_inside(sxx,syy+shh/2,sww,shh/2)) { deltadir=-1; } else { deltadir=0; } increment_cb(); redraw(); return 1; case FL_DRAG: if(mouseobj) { mouseobj=0; Fl::remove_timeout(repeat_callback, this); } // if (!step()) goto DEFAULT; olddelta=delta; delta = - (Fl::event_y()-iy); if ((delta>5) || (delta<-5) ) { deltadir=((olddelta-delta)>0)?-1:(((olddelta-delta)<0)?1:0); } else { deltadir=0; delta = olddelta;} switch (drag) { case 3: v = increment(value(), deltadir*100); break; case 2: v = increment(value(), deltadir*10); break; default:v = increment(value(), deltadir); break; } v = round(v); handle_drag(soft()?softclamp(v):clamp(v)); indrag=1; return 1; case FL_RELEASE: if(mouseobj) { Fl::remove_timeout(repeat_callback, this); } // if (!step()) goto DEFAULT; indrag=0; delta=0; deltadir=0; mouseobj=0; handle_release(); redraw(); return 1; case FL_FOCUS: indrag=0; return input.take_focus(); default: indrag=0; input.type(step()>=1.0 ? FL_INT_INPUT : FL_FLOAT_INPUT); return 1; } }
int main(int argc, char *argv[]) { const char *filename; bool skip_hs = false; bool with_dump_headers = false; int fd, c; setvbuf(stdout, NULL, _IOLBF, 0); while (-1 != (c = getopt(argc, argv, "DHh"))) { switch (c) { case 'h': usage(EXIT_SUCCESS); break; case 'H': skip_hs = true; break; case 'D': with_dump_headers = true; break; default: fprintf(stderr, "Unsupported option: -- %c\n", c); usage(EXIT_FAILURE); } } argc -= optind; argv += optind; if (argc > 1) { fprintf(stderr, "Error: " "Specify exactly one filename or none to read from the standard input." "\n"); usage(EXIT_FAILURE); } filename = argv[0]; if (filename) { fd = open(filename, O_RDONLY, 0); if (fd < 0) { fprintf(stderr, "open(\"%s\", O_RDONLY, 0) failed: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } } else { fd = STDIN_FILENO; } /* Discard the handshake */ if (skip_hs) { if (0 != skip_handshake(fd)) { fprintf(stderr, "Failed to skip handshake\n"); exit(EXIT_FAILURE); } printf("Skipped handshake\n"); } for (;;) { struct gnutella_header header; static char *payload; size_t ret; uint32_t payload_size; STATIC_ASSERT(23 == sizeof header); if (!payload) { payload = malloc(GNUTELLA_MAX_PAYLOAD); if (!payload) { fprintf(stderr, "malloc(%lu) failed: %s", (unsigned long) GNUTELLA_MAX_PAYLOAD, strerror(errno)); return -1; } } if (with_dump_headers) { struct dump_header dh; safe_read(fd, &dh, sizeof dh); if (dh.flags & DH_F_TO) { struct dump_header dh_from; safe_read(fd, &dh_from, sizeof dh_from); print_dump_from_header(&dh_from); print_dump_to_header(&dh); } else { print_dump_from_header(&dh); } } ret = fill_buffer_from_fd(fd, &header, sizeof header); switch (ret) { case 0: fprintf(stderr, "Error: Unexpected end of file.\n"); exit(EXIT_FAILURE); case (size_t) -1: fprintf(stderr, "Error: Could not fill packet buffer: %s\n", strerror(errno)); exit(EXIT_FAILURE); case 1: break; default: RUNTIME_ASSERT(0); } payload_size = peek_le32(header.size); if (payload_size > GNUTELLA_MAX_PAYLOAD) { fprintf(stderr, "Error: Message is too large.\n"); return -1; } if (payload_size > 0) { ret = fill_buffer_from_fd(fd, payload, payload_size); switch (ret) { case 0: case (size_t) -1: exit(EXIT_FAILURE); case 1: break; default: RUNTIME_ASSERT(0); } } printf("GUID: %08lx-%08lx-%08lx-%08lx\n", (unsigned long) peek_be32(&header.guid.data[0]), (unsigned long) peek_be32(&header.guid.data[4]), (unsigned long) peek_be32(&header.guid.data[8]), (unsigned long) peek_be32(&header.guid.data[12])); if (header.type != GPT_DHT) { printf("Type: %s\n", packet_type_to_string(header.type)); printf("TTL : %u\n", (unsigned char) header.ttl); printf("Hops: %u\n", (unsigned char) header.hops); printf("Size: %lu\n", (unsigned long) payload_size); } else { printf("Type: %s\n", kademlia_type_to_string(header.type)); printf("V : %u.%u\n", (unsigned char) header.ttl, (unsigned char) header.hops); printf("Size: %lu\n", (unsigned long) payload_size + 23 - 61); } printf("--\n"); switch ((enum gnutella_packet_type) header.type) { case GPT_PING: handle_ping(payload, payload_size); break; case GPT_PONG: handle_pong(payload, payload_size); break; case GPT_QRP: handle_qrp(payload, payload_size); break; case GPT_VMSG_PRIV: handle_vmsg_priv(&header, payload, payload_size); break; case GPT_VMSG_STD: handle_vmsg_std(payload, payload_size); break; case GPT_PUSH: handle_push(payload, payload_size); break; case GPT_RUDP: handle_rudp(payload, payload_size); break; case GPT_DHT: handle_dht(payload, payload_size); break; case GPT_QUERY: handle_query(&header, payload, payload_size); break; case GPT_QHIT: handle_qhit(payload, payload_size); break; case GPT_HSEP: handle_hsep(payload, payload_size); break; } printf("==========\n"); } return 0; }
bool Cache::push_local(const std::string& key, uint32_t node_id) { return handle_push(key, node_id, PUSH_LOCAL); }
int Fl_Spin::handle(int event) { double v; int olddelta; int mx = Fl::event_x(); int my = Fl::event_y(); int sxx = x(), syy = y(), sww = w(), shh = h(); switch (event) { case FL_PUSH: // if (!step()) goto DEFAULT; iy = my; ix = mx; drag = Fl::event_button(); handle_push(); indrag=1; mouseobj=1; Fl::add_timeout(.5, repeat_callback, this); delta=0; if(Fl::event_inside(sxx,syy,sww,shh/2)) { deltadir=1; } else if (Fl::event_inside(sxx,syy+shh/2,sww,shh/2)) { deltadir=-1; } else { deltadir=0; } increment_cb(); redraw(); return 1; case FL_DRAG: if(mouseobj) { mouseobj=0; Fl::remove_timeout(repeat_callback, this); } // if (!step()) goto DEFAULT; olddelta=delta; delta = - (Fl::event_y()-iy); if ((delta>5) || (delta<-5) ) { deltadir=((olddelta-delta)>0)?-1:(((olddelta-delta)<0)?1:0); } else { deltadir=0; delta = olddelta;} switch (drag) { case 3: v = increment(value(), deltadir*100); break; case 2: v = increment(value(), deltadir*10); break; default:v = increment(value(), deltadir); break; } v = round(v); handle_drag(soft()?softclamp(v):clamp(v)); indrag=1; return 1; case FL_RELEASE: if(mouseobj) { Fl::remove_timeout(repeat_callback, this); } // if (!step()) goto DEFAULT; indrag=0; delta=0; deltadir=0; mouseobj=0; handle_release(); redraw(); return 1; default: indrag=0; return Fl_Valuator::handle(event); } }