C++ reconfigure函数代码示例

CoverSwitchEffect::CoverSwitchEffect()
    : mActivated(0)
    , angle(60.0)
    , animation(false)
    , start(false)
    , stop(false)
    , stopRequested(false)
    , startRequested(false)
    , zPosition(900.0)
    , scaleFactor(0.0)
    , direction(Left)
    , selected_window(0)
    , captionFrame(NULL)
    , primaryTabBox(false)
    , secondaryTabBox(false)
{
    reconfigure(ReconfigureAll);

    // Caption frame
    captionFont.setBold(true);
    captionFont.setPointSize(captionFont.pointSize() * 2);

    if (effects->compositingType() == OpenGL2Compositing) {
        m_reflectionShader = ShaderManager::instance()->generateShaderFromResources(ShaderTrait::MapTexture, QString(), QStringLiteral("coverswitch-reflection.glsl"));
    } else {
        m_reflectionShader = NULL;
    }
    connect(effects, SIGNAL(windowClosed(KWin::EffectWindow*)), this, SLOT(slotWindowClosed(KWin::EffectWindow*)));
    connect(effects, SIGNAL(tabBoxAdded(int)), this, SLOT(slotTabBoxAdded(int)));
    connect(effects, SIGNAL(tabBoxClosed()), this, SLOT(slotTabBoxClosed()));
    connect(effects, SIGNAL(tabBoxUpdated()), this, SLOT(slotTabBoxUpdated()));
    connect(effects, SIGNAL(tabBoxKeyEvent(QKeyEvent*)), this, SLOT(slotTabBoxKeyEvent(QKeyEvent*)));
}

int Piano::process_realtime(int64_t size, double *input_ptr, double *output_ptr)
{


	need_reconfigure |= load_configuration();
	if(need_reconfigure) reconfigure();

	double wetness = DB::fromdb(config.wetness);
	if(EQUIV(config.wetness, INFINITYGAIN)) wetness = 0;

	for(int j = 0; j < size; j++)
		output_ptr[j] = input_ptr[j] * wetness;

	int64_t fragment_len;
	for(int64_t i = 0; i < size; i += fragment_len)
	{
		fragment_len = size;
		if(i + fragment_len > size) fragment_len = size - i;

//printf("Piano::process_realtime 1 %d %d %d\n", i, fragment_len, size);
		fragment_len = overlay_synth(i, fragment_len, input_ptr, output_ptr);
//printf("Piano::process_realtime 2\n");
	}
	
	
	return 0;
}

DimScreenEffect::DimScreenEffect()
    : mActivated( false )
    , activateAnimation( false )
    , deactivateAnimation( false )
    {
    reconfigure( ReconfigureAll );
    }

CoverSwitchEffect::CoverSwitchEffect()
    : mActivated(0)
    , angle(60.0)
    , animation(false)
    , start(false)
    , stop(false)
    , stopRequested(false)
    , startRequested(false)
    , zPosition(900.0)
    , scaleFactor(0.0)
    , direction(Left)
    , selected_window(0)
    , captionFrame(NULL)
    , primaryTabBox(false)
    , secondaryTabBox(false)
{
    reconfigure(ReconfigureAll);

    // Caption frame
    captionFont.setBold(true);
    captionFont.setPointSize(captionFont.pointSize() * 2);

    const QString fragmentshader = KGlobal::dirs()->findResource("data", "kwin/coverswitch-reflection.glsl");
    m_reflectionShader = ShaderManager::instance()->loadFragmentShader(ShaderManager::GenericShader, fragmentshader);
    connect(effects, SIGNAL(windowClosed(KWin::EffectWindow*)), this, SLOT(slotWindowClosed(KWin::EffectWindow*)));
    connect(effects, SIGNAL(tabBoxAdded(int)), this, SLOT(slotTabBoxAdded(int)));
    connect(effects, SIGNAL(tabBoxClosed()), this, SLOT(slotTabBoxClosed()));
    connect(effects, SIGNAL(tabBoxUpdated()), this, SLOT(slotTabBoxUpdated()));
    connect(effects, SIGNAL(tabBoxKeyEvent(QKeyEvent*)), this, SLOT(slotTabBoxKeyEvent(QKeyEvent*)));
}

NetChannel::NetChannel(const std::string& name, const NetConfig& config): 
	_name(name), 
	_config(config),
	_pSocket(0)
{
	reconfigure(_config);
}

bool CCommonFilters::set_bloom(const SetBloomParameters& params)
   {
   const LVector4f& blend = params.blend;
   float mintrigger = params.mintrigger;
   float maxtrigger = params.maxtrigger;
   float desat = params.desat;
   float intensity = params.intensity;
   const string& size = params.size;

   if(size == "off")
      {
      return del_bloom();
      }
   if(maxtrigger == 0) { maxtrigger = mintrigger + 0.8; }
   BloomConfiguration* config =
         static_cast<BloomConfiguration*>(m_configuration["Bloom"]);
   bool fullrebuild = true;
   if(config == NULL)
      {
      config = new BloomConfiguration();
      }
   else if(config->size == size)
      {
      fullrebuild = false;
      }
   config->blend = blend;
   config->maxtrigger = maxtrigger;
   config->mintrigger = mintrigger;
   config->desat = desat;
   config->intensity = intensity;
   config->size = size;
   m_configuration["Bloom"] = config;
   return reconfigure(fullrebuild, "Bloom");
   }

static int handle_reconfigure(int argc, char **argv){
	int ret, c;
	unsigned int minor;
	unsigned long cache_size = 0;

	//get cache size and fallocated space params, if given
	while((c = getopt(argc, argv, "c:")) != -1){
		switch(c){
		case 'c':
			ret = parse_ul(optarg, &cache_size);
			if(ret) goto handle_reconfigure_error;
			break;
		default:
			errno = EINVAL;
			goto handle_reconfigure_error;
		}
	}

	if(argc - optind != 1){
		errno = EINVAL;
		goto handle_reconfigure_error;
	}

	ret = parse_ui(argv[optind], &minor);
	if(ret) goto handle_reconfigure_error;

	return reconfigure(minor, cache_size);

handle_reconfigure_error:
	perror("error interpreting reconfigure parameters");
	print_help(-1);
	return 0;
}

void
MatrixElement::reconfigure()
{
    timeT time = event()->getAbsoluteTime();
    timeT duration = event()->getDuration();
    reconfigure(time, duration);
}

TrackMouseEffect::TrackMouseEffect()
    : m_active(false)
    , m_angle(0)
{
    m_texture[0] = m_texture[1] = 0;
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
    m_picture[0] = m_picture[1] = 0;
    if ( effects->compositingType() == XRenderCompositing)
        m_angleBase = 1.57079632679489661923; // Pi/2
#endif
    if ( effects->isOpenGLCompositing() || effects->compositingType() == QPainterCompositing)
        m_angleBase = 90.0;
    m_mousePolling = false;

    m_action = new QAction(this);
    m_action->setObjectName(QStringLiteral("TrackMouse"));
    m_action->setText(i18n("Track mouse"));
    KGlobalAccel::self()->setDefaultShortcut(m_action, QList<QKeySequence>());
    KGlobalAccel::self()->setShortcut(m_action, QList<QKeySequence>());
    effects->registerGlobalShortcut(QKeySequence(), m_action);

    connect(m_action, SIGNAL(triggered(bool)), this, SLOT(toggle()));

    connect(effects, SIGNAL(mouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)),
                     SLOT(slotMouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)));
    reconfigure(ReconfigureAll);
}

bool VideoEncoderX264or5::doProcessFrame(Frame *org, Frame *dst)
{
    if (!(org && dst)) {
        utils::errorMsg("Error encoding video frame: org or dst are NULL");
        return false;
    }

    VideoFrame* rawFrame = dynamic_cast<VideoFrame*> (org);
    VideoFrame* codedFrame = dynamic_cast<VideoFrame*> (dst);

    if (!rawFrame || !codedFrame) {
        utils::errorMsg("Error encoding video frame: org and dst MUST be VideoFrame");
        return false;
    }

    if (!reconfigure(rawFrame, codedFrame)) {
        utils::errorMsg("Error encoding video frame: reconfigure failed");
        return false;
    }

    if (!fill_x264or5_picture(rawFrame)){
        utils::errorMsg("Could not fill x264_picture_t from frame");
        return false;
    }

    if (!encodeFrame(codedFrame)) {
        utils::errorMsg("Could not encode video frame");
        return false;
    }

    codedFrame->setSize(rawFrame->getWidth(), rawFrame->getHeight());

    return true;
}

    //____________________________________________________________________________________
    Button::Button(KDecoration2::DecorationButtonType type, Decoration* decoration, QObject* parent):
        KDecoration2::DecorationButton(type, decoration, parent)
        , m_animation( new QPropertyAnimation( this ) )
        , m_opacity(0)
    {

        // setup animation
        m_animation->setStartValue( 0 );
        m_animation->setEndValue( 1.0 );
        m_animation->setTargetObject( this );
        m_animation->setPropertyName( "opacity" );
        m_animation->setEasingCurve( QEasingCurve::InOutQuad );

        // setup default geometry
        const int height = decoration->buttonHeight();
        setGeometry(QRect(0, 0, height, height));
        setIconSize(QSize( height, height ));

        reconfigure();

        // setup connections
        if( isMenuButton() )
        { connect(decoration->client().data(), SIGNAL(iconChanged(QIcon)), this, SLOT(update())); }

        connect(decoration->settings().data(), &KDecoration2::DecorationSettings::reconfigured, this, &Button::reconfigure);
        connect( this, &KDecoration2::DecorationButton::hoveredChanged, this, &Button::updateAnimationState );

    }

bool CCommonFilters::
set_volumetric_lighting(const SetVolumetricLightingParameters& params)
   {
   NodePath caster = params.caster;
   int numsamples = params.numsamples;
   float density = params.density;
   float decay = params.decay;
   float exposure = params.exposure;

   VolumetricLightingConfiguration* config =
         static_cast<VolumetricLightingConfiguration*>
         (m_configuration["VolumetricLighting"]);
   bool fullrebuild = true;
   if(config == NULL)
      {
      config = new VolumetricLightingConfiguration();
      }
   else if(config->caster == caster)
      {
      fullrebuild = false;
      }
   config->caster = caster;
   config->numsamples = numsamples;
   config->density = density;
   config->decay = decay;
   config->exposure = exposure;
   m_configuration["VolumetricLighting"] = config;
   return reconfigure(fullrebuild, "VolumetricLighting");
   }

bool CCommonFilters::
set_ambient_occlusion(const SetAmbientOcclusionParameters& params)
   {
   int numsamples = params.numsamples;
   float radius = params.radius;
   float amount = params.amount;
   float strength = params.strength;
   float falloff = params.falloff;

   AmbientOcclusionConfiguration* config =
         static_cast<AmbientOcclusionConfiguration*>
         (m_configuration["AmbientOcclusion"]);
   bool fullrebuild = (config == NULL);
   if(fullrebuild)
      {
      config = new AmbientOcclusionConfiguration();
      }
   config->numsamples = numsamples;
   config->radius = radius;
   config->amount = amount;
   config->strength = strength;
   config->falloff = falloff;
   m_configuration["AmbientOcclusion"] = config;
   return reconfigure(fullrebuild, "AmbientOcclusion");
   }

 gray_picker(int X, int Y, int ID, int start, int current, ifield *Next) : spicker(X, Y, ID, 1, 20, 0, 0, Next)
 {
     cur_sel = current;
     sc = start;
     reconfigure();
     cur_sel=current;
 }

LogoutEffect::LogoutEffect()
    : progress(0.0)
    , displayEffect(false)
    , logoutWindow(NULL)
    , logoutWindowClosed(true)
    , logoutWindowPassed(false)
    , canDoPersistent(false)
    , ignoredWindows()
    , m_vignettingShader(NULL)
    , m_blurShader(NULL)
{
    // Persistent effect
    logoutAtom = XInternAtom(display(), "_KDE_LOGGING_OUT", False);
    effects->registerPropertyType(logoutAtom, true);

    // Block KSMServer's effect
    char net_wm_cm_name[ 100 ];
    sprintf(net_wm_cm_name, "_NET_WM_CM_S%d", DefaultScreen(display()));
    Atom net_wm_cm = XInternAtom(display(), net_wm_cm_name, False);
    Window sel = XGetSelectionOwner(display(), net_wm_cm);
    Atom hack = XInternAtom(display(), "_KWIN_LOGOUT_EFFECT", False);
    XChangeProperty(display(), sel, hack, hack, 8, PropModeReplace, (unsigned char*)&hack, 1);
    // the atom is not removed when effect is destroyed, this is temporary anyway

    blurTexture = NULL;
    blurTarget = NULL;
    reconfigure(ReconfigureAll);
    connect(effects, SIGNAL(windowAdded(KWin::EffectWindow*)), this, SLOT(slotWindowAdded(KWin::EffectWindow*)));
    connect(effects, SIGNAL(windowClosed(KWin::EffectWindow*)), this, SLOT(slotWindowClosed(KWin::EffectWindow*)));
    connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), this, SLOT(slotWindowDeleted(KWin::EffectWindow*)));
    connect(effects, SIGNAL(propertyNotify(KWin::EffectWindow*,long)), this, SLOT(slotPropertyNotify(KWin::EffectWindow*,long)));
}