void tcontainer_::set_active(const bool active) { // Not all our children might have the proper state so let them run // unconditionally. grid_.set_active(active); if(active == get_active()) { return; } set_dirty(); set_self_active(active); }
// --------------------------------------------------------------------------- // // ----------- void bToolMove::set_modifiers(int k){ bStdToolGeom::set_modifiers(k); if(!get_active()){ return; } if(is_modifiers(optionKey)){ set_curs(_ccopy); _copy=true; } else{ set_curs(); _copy=false; } _srep=!is_modifiers(shiftKey); }
void trepeating_button::signal_handler_left_button_up( const event::tevent event, bool& handled) { DBG_GUI_E << LOG_HEADER << ' ' << event << ".\n"; if(repeat_timer_) { remove_timer(repeat_timer_); repeat_timer_ = 0; } if(get_active()) { set_state(FOCUSSED); } handled = true; }
void chooser::on_changed () { if (inhibit_callback_) return; const std::string& udi = get_active ()->get_value (cols_->udi); type_id type = get_active ()->get_value (cols_->type); if (cache_ && udi == cache_->get_value (cols_->udi)) return; /**/ if (ACTION == type) dropdown::on_changed (); else if (CUSTOM == type) on_custom (udi); else if (SYSTEM == type) on_system (udi); else if (MESSAGE == type) { inhibit_callback_ = true; if (cache_) set_active (cache_); inhibit_callback_ = false; } else { // FIXME log unsupported type error } }
std::string ValueComboBox::getActive() { Gtk::TreeModel::iterator iter = get_active(); if(iter) { Gtk::TreeModel::Row row = *iter; if(row) { Glib::ustring aValue = row[_columns._name]; return aValue; } } return ""; }
void plot_history::new_page() { if (!_replaying) { auto previous_plot = get_active(); if (previous_plot != nullptr) { pGEDevDesc ge_dev_desc = Rf_desc2GEDesc(_device_desc); util::protected_sexp snapshot(ge_dev_desc->savedSnapshot); if (previous_plot->has_pending_render()) { previous_plot->set_snapshot(snapshot); previous_plot->render(false); } } // Create a plot object for this new page append(std::make_unique<plot>(_device_desc)); } }
// --------------------------------------------------------------------------- // // ----------- void bToolJustification::set_modifiers(int k){ bStdToolPres::set_modifiers(k); if(!get_active()){ return; } if(is_modifiers(cmdKey)){ set_curs(_cright); _umode=kJustificationUserModeRight; set_use_track(false); set_use_drag(false); } else if(is_modifiers(optionKey)){ set_curs(_cmiddle); _umode=kJustificationUserModeCenter; set_use_track(false); set_use_drag(false); } else if(is_modifiers(controlKey)){ set_curs(_cleft); _umode=kJustificationUserModeLeft; set_use_track(false); set_use_drag(false); } else if(is_modifiers(shiftKey)){ if(_fspc){ set_curs(_cspace); _umode=kJustificationUserModeSpace; set_use_track(true); set_use_drag(true); } else{ set_curs(); _umode=kJustificationUserModeStd; set_use_track(true); set_use_drag(true); } } else{ set_curs(); _umode=kJustificationUserModeStd; if(get_on_drag()){ set_use_track(true); set_use_drag(true); } } }
/** * Checks to see if we have signatures of the active authorites of * the accounts specified in authority or the keys specified. */ bool check_authority( const authority* au, uint32_t depth = 0 ) { if( au == nullptr ) return false; const authority& auth = *au; uint32_t total_weight = 0; for( const auto& k : auth.key_auths ) if( signed_by( k.first ) ) { total_weight += k.second; if( total_weight >= auth.weight_threshold ) return true; } for( const auto& k : auth.address_auths ) if( signed_by( k.first ) ) { total_weight += k.second; if( total_weight >= auth.weight_threshold ) return true; } for( const auto& a : auth.account_auths ) { if( approved_by.find(a.first) == approved_by.end() ) { if( depth == max_recursion ) return false; if( check_authority( get_active( a.first ), depth+1 ) ) { approved_by.insert( a.first ); total_weight += a.second; if( total_weight >= auth.weight_threshold ) return true; } } else { total_weight += a.second; if( total_weight >= auth.weight_threshold ) return true; } } return total_weight >= auth.weight_threshold; }
static void g_socket_service_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GSocketService *service = G_SOCKET_SERVICE (object); switch (prop_id) { case PROP_ACTIVE: g_value_set_boolean (value, get_active (service)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void set_enable_screen_part_ui (GtkWidget *widget, ZoomOptionsPrivate *priv) { gboolean screen_part; /* If the "screen part" radio is not checked, then the "follow mouse" radio * is checked (== lens mode). Set mouse tracking back to the default. */ screen_part = get_active (priv->screen_part_radio); if (!screen_part) { g_settings_set_string (priv->settings, "mouse-tracking", "proportional"); } set_sensitive (priv->centered_radio, screen_part); set_sensitive (priv->push_radio, screen_part); set_sensitive (priv->proportional_radio, screen_part); set_sensitive (priv->extend_beyond_checkbox, screen_part); }
void control::on_toggled() { if(m_data.get()) { // If the value hasn't changed, we're done ... const bool new_value = get_active(); if(new_value != m_data->value()) { // Turn this into an undo/redo -able event ... if(m_data->state_recorder) m_data->state_recorder->start_recording(k3d::create_state_change_set(K3D_CHANGE_SET_CONTEXT), K3D_CHANGE_SET_CONTEXT); // Update everything with the new value ... m_data->set_value(new_value); // Turn this into an undo/redo -able event ... if(m_data->state_recorder) m_data->state_recorder->commit_change_set(m_data->state_recorder->stop_recording(K3D_CHANGE_SET_CONTEXT), new_value ? m_data->change_message + " \"On\"" : m_data->change_message + " \"Off\"", K3D_CHANGE_SET_CONTEXT); } } base::on_toggled(); }
void control::on_list_changed() { Gtk::TreeIter active = get_active(); return_if_fail(active != m_implementation->m_list_model->children().end()); Gtk::TreeRow row = *active; const k3d::string_t value = row[m_implementation->m_columns.value]; return_if_fail(m_implementation->m_model.get()); if(value == m_implementation->m_model->value()) return; if(m_implementation->m_state_recorder) m_implementation->m_state_recorder->start_recording(k3d::create_state_change_set(K3D_CHANGE_SET_CONTEXT), K3D_CHANGE_SET_CONTEXT); m_implementation->m_model->set_value(value); if(m_implementation->m_state_recorder) { const k3d::string_t change_message = k3d::string_cast(boost::format(_("Change %1% to %2%")) % m_implementation->m_model->label().raw() % value); m_implementation->m_state_recorder->commit_change_set(m_implementation->m_state_recorder->stop_recording(K3D_CHANGE_SET_CONTEXT), change_message, K3D_CHANGE_SET_CONTEXT); } }
bool sign_state::check_authority( const authority& auth, uint32_t depth ) { uint32_t total_weight = 0; for( const auto& k : auth.key_auths ) { if( signed_by( k.first ) ) { total_weight += k.second; if( total_weight >= auth.weight_threshold ) return true; } } for( const auto& a : auth.account_auths ) { if( approved_by.find(a.first) == approved_by.end() ) { if( depth == max_recursion ) continue; if( check_authority( get_active( a.first ), depth+1 ) ) { approved_by.insert( a.first ); total_weight += a.second; if( total_weight >= auth.weight_threshold ) return true; } } else { total_weight += a.second; if( total_weight >= auth.weight_threshold ) return true; } } return total_weight >= auth.weight_threshold; }
// --------------------------------------------------------------------------- // // ----------- void bToolRedraw::update(bool global){ if(get_active()){ if(!global){ clearTempPathContext(false); } if(get_use_locs()){ if(_ec>1){ i2dvertex bck; get_cur(&bck); if(bck.h!=LONG_MIN){ get_locs()->add(&bck); get_locs()->add(&_vxb); draw_poly(true,false); get_locs()->rmv(get_locs()->count()); get_locs()->rmv(get_locs()->count()); } } } bToolGeomWithJoin::update(global); if(!global){ validTempPathContext(); } } }
void repeating_button::set_active(const bool active) { if(get_active() != active) { set_state(active ? ENABLED : DISABLED); } }
static struct lcrtc_user *lcrt_serial_create(struct lcrt_qconnect *lqconnect) { lcrt_protocol_t protocol = lqconnect->nproto; struct lcrt_window *lwindow = lqconnect->parent; struct lcrt_serial_if *lserial = (struct lcrt_serial_if *)lqconnect->private_data; struct lcrt_serial_map serial_buad_rate[] = {LCRT_SERIAL_BAUD_RATE_TABLE}; struct lcrt_serial_map serial_databit[] = {LCRT_SERIAL_DATA_BITS_TABLE}; struct lcrtc_user *user; char password[PASSWORD_LEN]; char s_port[USERNAME_LEN]; char name[HOSTNAME_LEN]; char hostname[HOSTNAME_LEN]; #define get_text(widget) (gtk_combo_box_get_active_text(GTK_COMBO_BOX(lserial->widget))) #define get_active(widget) (gtk_combo_box_get_active(GTK_COMBO_BOX(lserial->widget))) snprintf(s_port, USERNAME_LEN, "%s", get_text(port)); debug_where(); if (access(s_port, F_OK|R_OK|W_OK) == -1) { switch (errno) { case ENOENT: debug_print("device %s is not exist.\n", s_port); break; case EPERM: debug_print("you have no permition to open %s.\n", s_port); break; case EIO: debug_print("device %s is not ready.\n", s_port); break; default: debug_print("unknown error,error code is %d\n", errno); break; } return NULL; } int baud_rate,s_baud_rate; baud_rate = get_active(baud_rate); s_baud_rate = serial_buad_rate[baud_rate].data; debug_where(); int databit, s_databit; databit = atoi(get_text(data_bits)); databit = get_active(data_bits); s_databit = serial_databit[databit].data; debug_where(); int s_parity; s_parity = get_active(parity); debug_where(); int s_stopbits; s_stopbits = get_active(stop_bits); debug_where(); int s_software, s_hardware; s_software = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lserial->software)); s_hardware = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lserial->hardware)); /* port baud_rate databit parity stopbit software_control hardware_control*/ snprintf(password, PASSWORD_LEN, "%s %d %d %d %d %d %d", s_port, s_baud_rate, s_databit, s_parity, s_stopbits, s_software, s_hardware); strcpy(hostname, basename(s_port)); if (lqconnect->flag != LCRT_QCONNECT_SESSION_OPTION) { if ((user = lcrtc_user_create()) == NULL) { /* * FIXME: There is no more memory, how can * we handle this exception ? */ return NULL; } lcrt_user_find_unused_label(lwindow, hostname, name); lcrtc_user_set_data( user, name, hostname, protocol, NULL, password, gtk_entry_get_text(GTK_ENTRY(lqconnect->q_et_default_command)), 0, TRUE, lqconnect->folder, 0 ); lcrtc_user_ref(user); lcrt_user_add(&lwindow->u_config, user); lcrt_window_set_current_user(lwindow, user); if (lqconnect->flag == LCRT_QCONNECT_IN_TAB) { lcrt_create_terminal(lwindow->w_notebook); } } else { if ((user = lcrt_user_find_by_name(&lwindow->u_config, lqconnect->uname)) != NULL) { lcrtc_user_set_data( user, lqconnect->uname, hostname, protocol, NULL, password, gtk_entry_get_text(GTK_ENTRY(lqconnect->q_et_default_command)), 0, TRUE, NULL, -1 ); } } lcrtc_user_dump(user, __func__); return user; #undef get_text #undef get_active }
void ttrack::set_active(const bool active) { if (get_active() != active) { set_state(active ? ENABLED : DISABLED); } };
/** Inherited from tcontrol. */ void set_active(const bool active) { if(get_active() != active) set_state(active ? ENABLED : DISABLED); }
bool MineToggleButton::on_button_release_event(GdkEventButton *event) { if (get_active()) { return true; } int i = row, j = column; Size sz = game->get_size(); Tile *tile = game->get_board()[sz.width*i+j]; if (event->button == 3) { // RMB click => toggle flag tile->set_marked(!tile->is_marked()); delete get_image(); auto img = new Gtk::Image(tile->is_marked() ? "res/flag.png" : "res/0.png"); set_image(*img); img->show(); return true; } if (event->button == 1 && tile->is_marked()) { // LMB click on flagged tile => ignore return true; } set_active(true); delete get_image(); game->sweep_tile(row, column); int val = tile->get_value(); std::string img_path; if (val < 0) { img_path = "res/mine_e.png"; } else { std::ostringstream convert; convert << val; img_path = "res/" + convert.str() + ".png"; } auto img = new Gtk::Image(img_path); set_image(*img); img->show(); // update all the rest of tiles for (int i = 0; i < sz.height; i++) { for (int j = 0; j < sz.width; j++) { int loc = sz.width*i+j; if (tiles->at(loc) == this) { continue; } Tile *board_tile = game->get_board()[loc]; if (game->is_over() || (!board_tile->is_marked() && board_tile->is_swept() && !tiles->at(loc)->get_active())) { if (!game->is_over()) { tiles->at(loc)->set_active(true); } delete tiles->at(loc)->get_image(); val = board_tile->get_value(); if (val < 0) { img_path = "res/mine.png"; } else { std::ostringstream convert; convert << val; img_path = "res/" + convert.str() + ".png"; } img = new Gtk::Image(img_path); tiles->at(loc)->set_image(*img); img->show(); } } } if (game->is_over()) { std::string msg = game->get_unsafe_tile_count() == 0 ? "You win!" : "You lose."; Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK); dialog.run(); game->get_window()->reset(game->get_game_difficulty()); } return true; }
bool tcontrol::disable_click_dismiss() const { return get_visible() == twidget::VISIBLE && get_active(); }
bool sign_state::check_authority( string id ) { if( approved_by.find(id) != approved_by.end() ) return true; return check_authority( get_active(id) ); }
/** * Replaces the currently active quadrant with a process' buffer. * * @param buffer_num The window (user process) to make active */ Uint8 replace_active( Uint32 buffer_num ) { return set_active( buffer_num, get_active() ); }
/** * Handles processing of interrupts from the PS/2 controller. * * @param vec The number of the interrupt code that triggered this * call. */ void _ps2_keyboard_isr( int vec, int code ){ // temp vars Uint quad; Uint key = __inb( PS2_PORT ); // Handle extended keys first if( await_next ){ if( key == 0xFE ){ _ps2_ack_int(); return; } else{ // Check if we are going to perform an active window switch if( win_pressed ){ quad = get_active(); // Determine offset arrow-keys to change active window switch( key ){ case PS2_KEY_UP_P: if( quad > 1 ) quad -= 2; break; case PS2_KEY_DOWN_P: if( quad < 2 ) quad += 2; break; case PS2_KEY_LEFT_P: if( quad % 2 == 1 ) quad -= 1; break; case PS2_KEY_RIGHT_P: if( quad % 2 == 0 ) quad += 1; } switch_active( quad ); } // resolve the extended key switch( key ){ case PS2_KEY_LWIN_P: case PS2_KEY_RWIN_P: win_pressed = 1; break; case PS2_KEY_CTRL_P: ctrl_pressed = 1; break; case PS2_KEY_CTRL_R: ctrl_pressed = 0; break; case PS2_KEY_ALT_P: alt_pressed = 1; break; case PS2_KEY_ALT_R: alt_pressed = 0; break; } await_next = 0; } } // Next, handle special keys switch( key ){ case PS2_KEY_LSHIFT_P: case PS2_KEY_RSHIFT_P: shift_pressed = 1; return; case PS2_KEY_LSHIFT_R: case PS2_KEY_RSHIFT_R: shift_pressed = 0; return; case PS2_KEY_CAPLCK_P: caps_lock = 1; return; case PS2_KEY_CAPLCK_R: caps_lock = 0; return; case PS2_KEY_CTRL_P: ctrl_pressed = 1; return; case PS2_KEY_ALT_P: alt_pressed = 1; return; case PS2_KEY_ALT_R: alt_pressed = 0; return; } // normal ASCII characters if( key < 0x80 ){ // check if function-key if( key >= PS2_KEY_F1_P && key <= PS2_KEY_F10_P ){ replace_active( key - PS2_KEY_F1_P ); } else if( key == PS2_KEY_F11_P || key == PS2_KEY_F12_P ){ replace_active( key - PS2_KEY_F11_P + 10 ); } else{ // otherwise give the character to the waiting focused process char letter = _ps2_scan_code[ shift_pressed ][ key ]; if( letter != '\377' && letter != '\033' && letter != '\b' && letter != '\t'){ _ps2_write_to_active( letter ); } } } // Just the ASCII characters being released else if( key >= 0x80 && key <= 0xD8){ // key released! } else{ // If we get this byte then that means we should expect an extended key if( key == 0xE0 ){ await_next = 1; __outb( PS2_PORT, 0x0 ); } } _ps2_ack_int(); }
/** Inherited from twidget.*/ const twidget* find(const std::string& id, const bool must_be_active) const { return (twidget::find(id, must_be_active) && (!must_be_active || get_active())) ? this : 0; }
/** Inherited from twidget. */ const twidget* find_at(const tpoint& coordinate, const bool must_be_active) const { return (twidget::find_at(coordinate, must_be_active) && (!must_be_active || get_active())) ? this : 0; }
void chooser::create_device (const std::set<scanner::info>& devices, const std::string& udi) { std::set<scanner::info>::const_iterator it = devices.begin (); while (devices.end () != it && udi != it->udi ()) { ++it; } if (devices.end () != it) { Glib::RefPtr< Gdk::Window > window = get_window (); if (window) { window->set_cursor (Gdk::Cursor (Gdk::WATCH)); Gdk::flush (); } scanner::ptr ptr; std::string why; try { // FIXME This is a bit clunky but scanner creation may be time // consuming and cannot be put in a separate thread if // the scanner object is run via process separation. // The child process would exit at thread end. while (Gtk::Main::events_pending ()) Gtk::Main::iteration (); ptr = scanner::create (*it); } catch (const std::exception& e) { why = e.what (); } catch (...) { // FIXME set a why we failed to create a device } if (window) { window->set_cursor (); } if (ptr) { cache_ = get_active (); set_tooltip_text (it->udi ()); signal_device_changed_.emit (ptr); } else { const std::string& name = get_active ()->get_value (cols_->name); const std::string& udi = get_active ()->get_value (cols_->udi); inhibit_callback_ = true; if (cache_) set_active (cache_); inhibit_callback_ = false; BOOST_THROW_EXCEPTION (std::runtime_error ((format (SEC_("Cannot access %1%\n(%2%)\n%3%")) % name % udi % _(why) ).str ())); } } }
void chooser::on_run () { set_active (0); cache_ = get_active (); }
void tscrollbar_::set_active(const bool active) { if(get_active() != active) { set_state(active ? ENABLED : DISABLED); } }
void VOMS_server_list::activate_handler(){ VOMS_menu_item *m_item = dynamic_cast<VOMS_menu_item*>(get_active()); if ( m_item ) { client_engine->renew(*m_item); } }
void tstate_default::set_active(const bool active) { if(get_active() != active) { state_ = active ? ENABLED : DISABLED; } }