Exemple #1
0
void Client::demandAttention( bool set )
    {
    if( isActive())
        set = false;
    if( demands_attention == set )
        return;
    demands_attention = set;
    if( demands_attention )
        {
        // Demand attention flag is often set right from manage(), when focus stealing prevention
        // steps in. At that time the window has no taskbar entry yet, so KNotify cannot place
        // e.g. the passive popup next to it. So wait up to 1 second for the icon geometry
        // to be set.
        // Delayed call to KNotify also solves the problem of having X server grab in manage(),
        // which may deadlock when KNotify (or KLauncher when launching KNotify) need to access X.

        // Setting the demands attention state needs to be done directly in KWin, because
        // KNotify would try to set it, resulting in a call to KNotify again, etc.

        info->setState( set ? NET::DemandsAttention : 0, NET::DemandsAttention );

        if( demandAttentionKNotifyTimer == NULL )
            {
            demandAttentionKNotifyTimer = new QTimer( this );
            demandAttentionKNotifyTimer->setSingleShot( true );
            connect( demandAttentionKNotifyTimer, SIGNAL( timeout()), SLOT( demandAttentionKNotify()));
            }
        demandAttentionKNotifyTimer->start( 1000 );
        }
    else
        info->setState( set ? NET::DemandsAttention : 0, NET::DemandsAttention );
    workspace()->clientAttentionChanged( this, set );
    }
int main()
{
  Flexlay flexlay;
  flexlay.init();

  Editor editor;

  GUIManager* gui = editor.get_gui_manager();

  new CL_Button(CL_Rect(CL_Point(50, 50), 
                        CL_Size(100, 25)),
                "Hello World", gui->get_component());

  EditorMap m;
  Tileset tileset(32);
  TilemapLayer tilemap(tileset, 20, 10);
  
  m.add_layer(tilemap.to_layer());

  TilemapLayer::set_current(tilemap);

  EditorMapComponent editor_map(CL_Rect(0, 0, 799, 599), gui->get_component());
  Workspace workspace(799, 599);
  editor_map.set_workspace(workspace);
  workspace.set_map(m);
 
  new CL_Button(CL_Rect(CL_Point(50, 150), 
                        CL_Size(100, 25)),
                "Quit", gui->get_component());

  gui->run();
 
  flexlay.deinit();
}
Exemple #3
0
 static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
         MatrixZ& z, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAB >::type uplo;
     bindings::detail::array< real_type > tmp_work( min_size_work(
             bindings::size_column(ab) ) );
     return invoke( jobz, ab, w, z, workspace( tmp_work ) );
 }
Exemple #4
0
 static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
         minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
     bindings::detail::array< real_type > tmp_work( min_size_work( norm,
             bindings::size_column(ap) ) );
     return invoke( norm, ap, workspace( tmp_work ) );
 }
Exemple #5
0
 static std::ptrdiff_t invoke( const fortran_int_t n,
                               const fortran_int_t ilo, const fortran_int_t ihi,
                               MatrixA& a, const VectorTAU& tau, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     bindings::detail::array< real_type > tmp_work( min_size_work( ihi,
             ilo ) );
     return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) );
 }
Exemple #6
0
 static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
         VectorBERR& berr, integer_t& info, minimal_workspace work ) {
     traits::detail::array< value_type > tmp_work( min_size_work( n ) );
     traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
     invoke( n, ap, afp, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
             tmp_rwork ) );
 }
Exemple #7
0
 static void invoke( char const jobz, MatrixA& a, VectorW& w,
         integer_t& info, minimal_workspace work ) {
     traits::detail::array< real_type > tmp_work( min_size_work( jobz,
             traits::matrix_num_columns(a) ) );
     traits::detail::array< integer_t > tmp_iwork( min_size_iwork( jobz,
             traits::matrix_num_columns(a) ) );
     invoke( jobz, a, w, info, workspace( tmp_work, tmp_iwork ) );
 }
Exemple #8
0
 static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
         real_type& est, fortran_int_t& kase, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     bindings::detail::array< real_type > tmp_v( min_size_v( n ) );
     bindings::detail::array<
             fortran_int_t > tmp_isgn( min_size_isgn( n ) );
     return invoke( n, x, est, kase, workspace( tmp_v, tmp_isgn ) );
 }
Exemple #9
0
 static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
         const real_type anorm, real_type& rcond, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
     bindings::detail::array< value_type > tmp_work( min_size_work(
             bindings::size_column(ap) ) );
     return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work ) );
 }
Exemple #10
0
 static void invoke( char const compz, integer_t const n, VectorD& d,
         VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
     traits::detail::array< real_type > tmp_work( min_size_work(
             $CALL_MIN_SIZE ) );
     traits::detail::array< integer_t > tmp_iwork( min_size_iwork( compz,
             n ) );
     invoke( compz, n, d, e, z, info, workspace( tmp_work, tmp_iwork ) );
 }
Exemple #11
0
Deleted::~Deleted()
{
    if (delete_refcount != 0)
        kError(1212) << "Deleted client has non-zero reference count (" << delete_refcount << ")";
    assert(delete_refcount == 0);
    workspace()->removeDeleted(this);
    deleteEffectWindow();
}
Exemple #12
0
 static void invoke( char const job, integer_t const n, MatrixA& a,
         MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
         VectorRSCALE& rscale, integer_t& info, minimal_workspace work ) {
     traits::detail::array< real_type > tmp_work( min_size_work(
             $CALL_MIN_SIZE ) );
     invoke( job, n, a, b, ilo, ihi, lscale, rscale, info,
             workspace( tmp_work ) );
 }
Exemple #13
0
void
WorkspacesView::_DrawWorkspace(DrawingEngine* drawingEngine,
	BRegion& redraw, int32 index)
{
	BRect rect = _WorkspaceAt(index);

	Workspace workspace(*Window()->Desktop(), index);
	bool active = workspace.IsCurrent();
	if (active) {
		// draw active frame
		rgb_color black = (rgb_color){ 0, 0, 0, 255 };
		drawingEngine->StrokeRect(rect, black);
	} else if (index == fSelectedWorkspace) {
		rgb_color gray = (rgb_color){ 80, 80, 80, 255 };
		drawingEngine->StrokeRect(rect, gray);
	}

	rect.InsetBy(1, 1);

	rgb_color color = workspace.Color();
	if (!active)
		_DarkenColor(color);

	// draw windows

	BRegion backgroundRegion = redraw;

	// TODO: would be nice to get the real update region here

	BRect screenFrame = _ScreenFrame(index);

	BRegion workspaceRegion(rect);
	backgroundRegion.IntersectWith(&workspaceRegion);
	drawingEngine->ConstrainClippingRegion(&backgroundRegion);

	ServerFont font = fDrawState->Font();
	font.SetSize(fWindow->ServerWindow()->App()->PlainFont().Size());
	float reducedSize = ceilf(max_c(8.0f,
		min_c(Frame().Height(), Frame().Width()) / 15));
	if (font.Size() > reducedSize)
		font.SetSize(reducedSize);
	fDrawState->SetFont(font);
	drawingEngine->SetFont(font);

	// We draw from top down and cut the window out of the clipping region
	// which reduces the flickering
	::Window* window;
	BPoint leftTop;
	while (workspace.GetPreviousWindow(window, leftTop) == B_OK) {
		_DrawWindow(drawingEngine, rect, screenFrame, window,
			leftTop, backgroundRegion, active);
	}

	// draw background
	drawingEngine->FillRect(rect, color);

	drawingEngine->ConstrainClippingRegion(&redraw);
}
Exemple #14
0
 static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
         VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     bindings::detail::array< real_type > tmp_work( min_size_work( jobz,
             n ) );
     bindings::detail::array< fortran_int_t > tmp_iwork(
             min_size_iwork( jobz, n ) );
     return invoke( jobz, n, d, e, z, workspace( tmp_work, tmp_iwork ) );
 }
Exemple #15
0
 static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::data_order< MatrixC >::type order;
     typedef typename result_of::trans_tag< MatrixA, order >::type trans;
     bindings::detail::array< real_type > tmp_work( min_size_work( side,
             bindings::size_row(c), bindings::size_column(c) ) );
     return invoke( side, a, tau, c, workspace( tmp_work ) );
 }
Exemple #16
0
void MainWindow::saveSettings()
{
	QSettings settings("Blooming Flower", "Blooming Flower");

	QString workspace(workspace_.c_str());
	settings.setValue("workspace", workspace);

	return;
}
Exemple #17
0
void Group::lostLeader()
{
    assert(!_members.contains(leader_client));
    leader_client = NULL;
    if (_members.isEmpty()) {
        workspace()->removeGroup(this);
        delete this;
    }
}
Exemple #18
0
 static std::ptrdiff_t invoke( const fortran_int_t itype,
         const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
         MatrixZ& z, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
     bindings::detail::array< real_type > tmp_work( min_size_work(
             bindings::size_column(ap) ) );
     return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work ) );
 }
Exemple #19
0
 static std::ptrdiff_t invoke( const Side side, const char uplo,
         const VectorAP& ap, const VectorTAU& tau, MatrixC& c,
         minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef tag::column_major order;
     typedef typename result_of::trans_tag< VectorAP, order >::type trans;
     bindings::detail::array< real_type > tmp_work( min_size_work( side,
             bindings::size_row(c), bindings::size_column(c) ) );
     return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) );
 }
Exemple #20
0
 static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
         const real_type anorm, real_type& rcond, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     bindings::detail::array< value_type > tmp_work( min_size_work(
             bindings::size_column(a) ) );
     bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
             bindings::size_column(a) ) );
     return invoke( norm, a, anorm, rcond, workspace( tmp_work,
             tmp_rwork ) );
 }
void CanvasTabWidget::insertCanvas(int index, Canvas *canvas)
{
	if (canvas->workspace() != workspace())
	{
		auto originalCanvas = canvas;
		canvas = new Canvas(canvas, workspace());
		originalCanvas->closeCanvas();
	}
	
	canvas->memorizeNavigation();
	
	workspace()->addCanvas(canvas);
	if (!canvas->viewController())
		new CanvasViewController(canvas);
	
	DockTabWidget::insertTab(index, canvas->view(), canvasTabText(canvas));
	
	canvas->restoreNavigation();
}
Exemple #22
0
/*!
  Create list of desktops, starting with desktop start
*/
void TabBox::createDesktopList(QList< int > &list, int start, SortOrder order)
    {
    list.clear();

    int iDesktop = start;

    for( int i = 1; i <= workspace()->numberOfDesktops(); i++ )
        {
        list.append( iDesktop );
        if ( order == StaticOrder )
            {
            iDesktop = workspace()->nextDesktopStatic( iDesktop );
            }
        else
            { // MostRecentlyUsedOrder
            iDesktop = workspace()->nextDesktopFocusChain( iDesktop );
            }
        }
    }
Exemple #23
0
 static std::ptrdiff_t invoke( const char uplo, const char compq,
         const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u,
         MatrixVT& vt, VectorQ& q, VectorIQ& iq, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     bindings::detail::array< real_type > tmp_work( min_size_work( compq,
             n ) );
     bindings::detail::array< fortran_int_t > tmp_iwork(
             min_size_iwork( n ) );
     return invoke( uplo, compq, n, d, e, u, vt, q, iq,
             workspace( tmp_work, tmp_iwork ) );
 }
Exemple #24
0
/*
* Square a BigInt
*/
BigInt square(const BigInt& x)
   {
   const size_t x_sw = x.sig_words();

   BigInt z(BigInt::Positive, round_up<size_t>(2*x_sw, 16));
   SecureVector<word> workspace(z.size());

   bigint_sqr(z.get_reg(), z.size(), workspace,
              x.data(), x.size(), x_sw);
   return z;
   }
Exemple #25
0
 static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
         optimal_workspace work ) {
     value_type opt_size_work;
     detail::geqrf( traits::matrix_num_rows(a),
             traits::matrix_num_columns(a), traits::matrix_storage(a),
             traits::leading_dimension(a), traits::vector_storage(tau),
             &opt_size_work, -1, info );
     traits::detail::array< value_type > tmp_work(
             traits::detail::to_int( opt_size_work ) );
     invoke( a, tau, info, workspace( tmp_work ) );
 }
Exemple #26
0
 static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
         optimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     value_type opt_size_work;
     detail::geqrf( bindings::size_row(a), bindings::size_column(a),
             bindings::begin_value(a), bindings::stride_major(a),
             bindings::begin_value(tau), &opt_size_work, -1 );
     bindings::detail::array< value_type > tmp_work(
             traits::detail::to_int( opt_size_work ) );
     return invoke( a, tau, workspace( tmp_work ) );
 }
Exemple #27
0
 static std::ptrdiff_t invoke( const Side side, const char eigsrc,
         const char initv, VectorSELECT& select, const MatrixH& h,
         VectorWR& wr, const VectorWI& wi, MatrixVL& vl, MatrixVR& vr,
         const fortran_int_t mm, fortran_int_t& m,
         VectorIFAILL& ifaill, VectorIFAILR& ifailr, minimal_workspace ) {
     namespace bindings = ::boost::numeric::bindings;
     bindings::detail::array< real_type > tmp_work( min_size_work(
             bindings::size_column(h) ) );
     return invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m,
             ifaill, ifailr, workspace( tmp_work ) );
 }
Exemple #28
0
 static void invoke( char const vect, integer_t const m, integer_t const n,
         integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
         optimal_workspace work ) {
     value_type opt_size_work;
     detail::ungbr( vect, m, n, k, traits::matrix_storage(a),
             traits::leading_dimension(a), traits::vector_storage(tau),
             &opt_size_work, -1, info );
     traits::detail::array< value_type > tmp_work(
             traits::detail::to_int( opt_size_work ) );
     invoke( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
 }
Exemple #29
0
Montgomery_Exponentation_State::Montgomery_Exponentation_State(const BigInt& g,
                                                               const BigInt& p,
                                                               const Modular_Reducer& mod_p,
                                                               size_t window_bits) :
   m_p(p),
   m_p_words(p.sig_words()),
   m_window_bits(window_bits)
   {
   if(p.is_positive() == false || p.is_even())
      throw Invalid_Argument("Cannot use Montgomery reduction on even or negative integer");

   if(window_bits > 12) // really even 8 is too large ...
      throw Invalid_Argument("Montgomery window bits too large");

   m_mod_prime = monty_inverse(m_p.word_at(0));

   const BigInt r = BigInt::power_of_2(m_p_words * BOTAN_MP_WORD_BITS);
   m_R_mod = mod_p.reduce(r);
   m_R2_mod = mod_p.square(m_R_mod);

   m_g.resize(1U << m_window_bits);

   BigInt z(BigInt::Positive, 2 * (m_p_words + 1));
   secure_vector<word> workspace(z.size());

   m_g[0] = 1;

   bigint_monty_mul(z, m_g[0], m_R2_mod,
                    m_p.data(), m_p_words, m_mod_prime,
                    workspace.data());
   m_g[0] = z;

   m_g[1] = mod_p.reduce(g);

   bigint_monty_mul(z, m_g[1], m_R2_mod,
                    m_p.data(), m_p_words, m_mod_prime,
                    workspace.data());

   m_g[1] = z;

   const BigInt& x = m_g[1];

   for(size_t i = 2; i != m_g.size(); ++i)
      {
      const BigInt& y = m_g[i-1];

      bigint_monty_mul(z, x, y, m_p.data(), m_p_words, m_mod_prime,
                       workspace.data());

      m_g[i] = z;
      m_g[i].shrink_to_fit();
      m_g[i].grow_to(m_p_words);
      }
   }
Exemple #30
0
 static void invoke( char const fact, MatrixA& a, MatrixAF& af,
         char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
         VectorFERR& ferr, VectorBERR& berr, integer_t& info,
         minimal_workspace work ) {
     traits::detail::array< value_type > tmp_work( min_size_work(
             traits::matrix_num_columns(a) ) );
     traits::detail::array< real_type > tmp_rwork( min_size_rwork(
             traits::matrix_num_columns(a) ) );
     invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr, info,
             workspace( tmp_work, tmp_rwork ) );
 }