chartpos.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include "rangelst.hxx"
#include <tools/solar.h>
#include <memory>
#include <map>
 
// map of row number to ScAddress*
typedef std::map<SCROW, std::unique_ptr<ScAddress>> RowMap;
// map of column number to RowMap
typedef std::map<SCCOL, RowMap>    ColumnMap;
 
class ScChartPositionMap
{
    friend class ScChartPositioner;
 
            std::unique_ptr<std::unique_ptr<ScAddress>[]> ppData;
            std::unique_ptr<std::unique_ptr<ScAddress>[]> ppColHeader;
            std::unique_ptr<std::unique_ptr<ScAddress>[]> ppRowHeader;
            sal_uInt64          nCount;
            SCCOL               nColCount;
            SCROW               nRowCount;
 
                                ScChartPositionMap( SCCOL nChartCols, SCROW nChartRows,
                                    SCCOL nColAdd,      // header columns
                                    SCROW nRowAdd,      // header rows
                                    ColumnMap& rCols        // table with col tables with address*
                                    );
 
                                ScChartPositionMap( const ScChartPositionMap& ) = delete;
            ScChartPositionMap& operator=( const ScChartPositionMap& ) = delete;
 
public:
                                ~ScChartPositionMap();  
 
            SCCOL               GetColCount() const { return nColCount; }
            SCROW               GetRowCount() const { return nRowCount; }
 
            bool                IsValid( SCCOL nCol, SCROW nRow ) const
                                    { return nCol < nColCount && nRow < nRowCount; }
                                // data column by column
            sal_uInt64          GetIndex( SCCOL nCol, SCROW nRow ) const
                                    { return static_cast<sal_uInt64>(nCol) * nRowCount + nRow; }
 
            const ScAddress*    GetPosition( sal_uInt64 nIndex ) const
                                    {
                                        if ( nIndex < nCount )
                                            return ppData[ nIndex ].get();
                                        return nullptr;
                                    }
 
            const ScAddress*    GetPosition( SCCOL nChartCol, SCROW nChartRow ) const
                                    {
                                        if ( IsValid( nChartCol, nChartRow ) )
                                            return ppData[ GetIndex( nChartCol, nChartRow ) ].get();
                                        return nullptr;
                                    }
            const ScAddress*    GetColHeaderPosition( SCCOL nChartCol ) const
                                    {
                                        if ( nChartCol < nColCount )
                                            return ppColHeader[ nChartCol ].get();
                                        return nullptr;
                                    }
            const ScAddress*    GetRowHeaderPosition( SCROW nChartRow ) const
                                    {
                                        if ( nChartRow < nRowCount )
                                            return ppRowHeader[ nChartRow ].get();
                                        return nullptr;
                                    }
};
 
enum class ScChartGlue {
    NA,
    NONE,      // old mimic
    Cols,      // old mimic
    Rows,
    Both
};
 
class ScDocument;
 
class ScChartPositioner final             // only parameter struct
{
    ScRangeListRef  aRangeListRef;
    ScDocument& rDocument;
    std::unique_ptr<ScChartPositionMap> pPositionMap;
    ScChartGlue eGlue;
    SCCOL       nStartCol;
    SCROW       nStartRow;
    bool        bColHeaders;
    bool        bRowHeaders;
    bool        bDummyUpperLeft;
 
    void        CheckColRowHeaders();
 
    void        GlueState();        // summarised areas
    void        CreatePositionMap();
 
public:
    ScChartPositioner( ScDocument& rDoc, SCTAB nTab,
                    SCCOL nStartColP, SCROW nStartRowP,
                    SCCOL nEndColP, SCROW nEndRowP );
    ScChartPositioner( ScDocument& rDoc, ScRangeListRef xRangeList );
    ScChartPositioner( const ScChartPositioner& rPositioner );
 
    ~ScChartPositioner();
 
    const ScRangeListRef&   GetRangeList() const { return aRangeListRef; }
    void    SetRangeList( const ScRange& rNew );
 
    void    SetHeaders(bool bCol, bool bRow) { bColHeaders=bCol; bRowHeaders=bRow; }
    bool    HasColHeaders() const            { return bColHeaders; }
    bool    HasRowHeaders() const            { return bRowHeaders; }
 
    void                        InvalidateGlue();
    const ScChartPositionMap*   GetPositionMap();
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */