max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
369 | // Copyright (c) 2017-2021, <NAME>. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#include "DayLabel.hpp"
#include "MonthBox.hpp"
#include <application-calendar/widgets/CalendarStyle.hpp>
#include <windows/CalendarMainWindow.hpp>
namespace gui
{
MonthBox::MonthBox(app::ApplicationCommon *app,
gui::Item *parent,
const int &offsetTop,
const uint32_t &width,
const uint32_t &height,
const uint32_t &dayWidth,
const uint32_t &dayHeight,
const std::unique_ptr<MonthModel> &model,
std::array<bool, 31> &isDayEmpty)
: GridLayout(parent, style::window::default_left_margin, offsetTop, width, height, {dayWidth, dayHeight})
{
assert(parent);
parent->addWidget(this);
month = model->getMonthText();
monthFilterValue = model->getYear() / model->getMonth();
grid.x = dayWidth;
grid.y = dayHeight;
uint32_t firstDayOffset = model->getFirstWeekOffset();
uint32_t lastDay = model->getLastDay();
uint32_t iterations = style::window::calendar::week_days_number + firstDayOffset + lastDay;
uint32_t i;
for (i = 0; i < iterations; ++i) {
if (i < style::window::calendar::week_days_number + firstDayOffset) {
auto day = new DayLabel(app,
this,
i,
firstDayOffset,
style::window::calendar::day_cell_width,
style::window::calendar::day_cell_height,
true);
addWidget(day);
}
else {
auto day = new DayLabel(app,
this,
i,
firstDayOffset,
style::window::calendar::day_cell_width,
style::window::calendar::day_cell_height,
isDayEmpty[i - (style::window::calendar::week_days_number + firstDayOffset)]);
addWidget(day);
}
}
date::year_month_day actualDate = TimePointToYearMonthDay(TimePointNow());
if (model->getYear() == actualDate.year() && model->getMonth() == actualDate.month()) {
focusChangedCallback = [=](Item &item) {
setFocusOnElement(unsigned(actualDate.day()) - 1);
return true;
};
}
}
} /* namespace gui */
| 1,592 |
641 | /*********************************************************************************************************************
* DAVE APP Name : GUI_SEGGERLIBRARY APP Version: 4.1.8
*
* NOTE:
* This file is generated by DAVE. Any manual modification done to this file will be lost when the code is regenerated.
*********************************************************************************************************************/
/**
* @cond
***********************************************************************************************************************
*
* Copyright (c) 2015, Infineon Technologies AG
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,are permitted provided that the
* following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other materials provided with the distribution.
*
* Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY,OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* To improve the quality of the software, users are encouraged to share modifications, enhancements or bug fixes
* with Infineon Technologies AG (<EMAIL>).
***********************************************************************************************************************
*
* Change History
* --------------
*
* 2015-02-16:
* - Initial version<br>
*
* 2015-03-23:
* - Added macros for display configuration
* 2015-10-09:
* - Added macros for CMSIS_RTOS/FreeRTOS support
* @endcond
*
*/
#ifndef GUI_SEGGERLIBRARY_CONF_H
#define GUI_SEGGERLIBRARY_CONF_H
/***********************************************************************************************************************
* HEADER FILES
**********************************************************************************************************************/
/**********************************************************************************************************************
* MACROS
**********************************************************************************************************************/
#define GUI_SEGGERLIBRARY_RTOS_PRESENT 0
#define GUI_SEGGERLIBRARY_MOUSE_SUPPORT 1
#define GUI_SEGGERLIBRARY_WIN_SUPPORT 0
#define GUI_SEGGERLIBRARY_TOUCH_SUPPORT 0
#define GUI_SEGGERLIBRARY_NON_READ_SUPPORT 0
/* Default cache size is used when read support is enabled*/
#define CACHE_SIZE 4096
#define DEFAULT_DATA_SECTION
#define USER_DEFINED_LCD 0
#define SYNCOAM_LCD_ORIENTATION 0
#define GUI_LCD_XSIZE 160
#define GUI_LCD_YSIZE 128
#define SPI_INTERFACE 1
#define DISPLAY_8BPP 1
#if (!USER_DEFINED_LCD && SPI_INTERFACE == 1)
#define IOHandle (GUI_SEGGERLIBRARY_0_config)
#endif
#define GUI_SEGGERLIBRARY_MAJOR_VERSION (4U)
#define GUI_SEGGERLIBRARY_MINOR_VERSION (1U)
#define GUI_SEGGERLIBRARY_PATCH_VERSION (8U)
#endif
| 1,048 |
1,463 | //
// Copyright 2013 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include "../far/patchTableFactory.h"
#include "../far/patchBuilder.h"
#include "../far/error.h"
#include "../far/ptexIndices.h"
#include "../far/topologyRefiner.h"
#include "../vtr/level.h"
#include "../vtr/fvarLevel.h"
#include "../vtr/refinement.h"
#include "../vtr/stackBuffer.h"
#include <algorithm>
#include <cassert>
#include <cstring>
#include <cstdio>
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
namespace Far {
using Vtr::Array;
using Vtr::ConstArray;
using Vtr::IndexVector;
using Vtr::internal::Level;
using Vtr::internal::StackBuffer;
namespace {
//
// Helpers for compiler warnings and floating point equality tests
//
#ifdef __INTEL_COMPILER
#pragma warning (push)
#pragma warning disable 1572
#endif
inline bool isSharpnessEqual(float s1, float s2) { return (s1 == s2); }
#ifdef __INTEL_COMPILER
#pragma warning (pop)
#endif
inline int
assignSharpnessIndex(float sharpness, std::vector<float> & sharpnessValues) {
// linear search
for (int i=0; i<(int)sharpnessValues.size(); ++i) {
if (isSharpnessEqual(sharpnessValues[i], sharpness)) {
return i;
}
}
sharpnessValues.push_back(sharpness);
return (int)sharpnessValues.size()-1;
}
inline bool
isBoundaryFace(Level const & level, Index face) {
return (level.getFaceCompositeVTag(face)._boundary != 0);
}
inline void
offsetIndices(Index indices[], int size, int offset) {
for (int i = 0; i < size; ++i) {
indices[i] += offset;
}
}
} // namespace anon
//
// The main PatchTableBuilder class with context
//
// Helper class aggregating transient contextual data structures during the
// creation of a patch table. This helps keeping the factory class stateless.
//
class PatchTableBuilder {
public:
//
// Public interface intended for use by the PatchTableFactory -- all
// else is solely for internal use:
//
typedef PatchTableFactory::Options Options;
PatchTableBuilder(TopologyRefiner const & refiner, Options options,
ConstIndexArray selectedFaces);
~PatchTableBuilder();
bool UniformPolygonsSpecified() const { return _buildUniformLinear; }
void BuildUniformPolygons();
void BuildPatches();
PatchTable * GetPatchTable() const { return _table; };
private:
typedef PatchTable::StencilTablePtr StencilTablePtr;
// Simple struct to store <face,level> pair for a patch:
struct PatchTuple {
PatchTuple(Index face, int level) : faceIndex(face), levelIndex(level) { }
Index faceIndex;
int levelIndex;
};
typedef std::vector<PatchTuple> PatchTupleVector;
// Struct comprising a collection of topological properties for a patch that
// may be shared (between vertex and face-varying patches):
struct PatchInfo {
PatchInfo() : isRegular(false), isRegSingleCrease(false),
regBoundaryMask(0), regSharpness(0.0f),
paramBoundaryMask(0) { }
bool isRegular;
bool isRegSingleCrease;
int regBoundaryMask;
float regSharpness;
Level::VSpan irregCornerSpans[4];
int paramBoundaryMask;
SparseMatrix<float> fMatrix;
SparseMatrix<double> dMatrix;
};
private:
//
// Internal LocalPointHelper class
//
// A LocalPointHelper manages the number, sharing of and StencilTable for
// the local points of a patch or one of its face-varying channels. An
// instance of the helper does not know anything about the properties of
// the Builder classes that use it. It can combine local points for any
// patch types all in one, so the regular and irregular patch types can
// both be local and differ, e.g. Bezier for regular and Gregory for
// irregular, and points can be effectively shared, appropriate stencils
// created, etc.
//
// While not dependent on a particular patch type, some methods do require
// a patch type argument in order to know what can be done with its local
// points, e.g. which points can be shared with adjacent patches.
//
class LocalPointHelper {
public:
struct Options {
Options() : shareLocalPoints(false),
reuseSourcePoints(false),
createStencilTable(true),
createVaryingTable(false),
doubleStencilTable(false) { }
unsigned int shareLocalPoints : 1;
unsigned int reuseSourcePoints : 1;
unsigned int createStencilTable : 1;
unsigned int createVaryingTable : 1;
unsigned int doubleStencilTable : 1;
};
public:
LocalPointHelper(TopologyRefiner const & refiner,
Options const & options,
int fvarChannel,
int numLocalPointsExpected);
~LocalPointHelper();
public:
int GetNumLocalPoints() const { return _numLocalPoints; }
template <typename REAL>
int AppendLocalPatchPoints(int levelIndex, Index faceIndex,
SparseMatrix<REAL> const & conversionMatrix,
PatchDescriptor::Type patchType,
Index const sourcePoints[],
int sourcePointOffset,
Index patchPoints[]);
StencilTablePtr AcquireStencilTable() {
return _options.doubleStencilTable
? acquireStencilTable<double>(_stencilTable)
: acquireStencilTable<float>(_stencilTable);
}
private:
// Internal methods:
template <typename REAL>
void initializeStencilTable(int numLocalPointsExpected);
template <typename REAL>
void appendLocalPointStencil(SparseMatrix<REAL> const & conversionMatrix,
int stencilRow,
Index const sourcePoints[],
int sourcePointOffset);
template <typename REAL>
void appendLocalPointStencils(SparseMatrix<REAL> const & conversionMatrix,
Index const sourcePoints[],
int sourcePointOffset);
// Methods for local point Varying stencils
// XXXX -- hope to get rid of these...
template <typename REAL>
void appendLocalPointVaryingStencil(int const * varyingIndices,
int patchPointIndex,
Index const sourcePoints[],
int sourcePointOffset);
template <typename REAL>
StencilTablePtr acquireStencilTable(StencilTablePtr& stencilTableMember);
Index findSharedCornerPoint(int levelIndex, Index valueIndex,
Index newIndex);
Index findSharedEdgePoint(int levelIndex, Index edgeIndex, int edgeEnd,
Index newIndex);
private:
// Member variables:
TopologyRefiner const& _refiner;
Options _options;
int _fvarChannel;
int _numLocalPoints;
int _localPointOffset;
std::vector<IndexVector> _sharedCornerPoints;
std::vector<IndexVector> _sharedEdgePoints;
StencilTablePtr _stencilTable;
// This was hopefully transitional but will persist -- the should be
// no need for Varying local points or stencils associated with them.
public:
StencilTablePtr AcquireStencilTableVarying() {
return _options.doubleStencilTable
? acquireStencilTable<double>(_stencilTableVarying)
: acquireStencilTable<float>(_stencilTableVarying);
}
StencilTablePtr _stencilTableVarying;
};
private:
//
// Internal LegacyGregoryHelper class
//
// This local class helps to populate the arrays in the PatchTable
// associated with legacy-Gregory patches, i.e. the quad-offset and
// vertex-valence tables. These patches are always associated with
// faces at the last level of refinement, so only the face index in
// that level is required to identify them.
//
class LegacyGregoryHelper {
public:
LegacyGregoryHelper(TopologyRefiner const & ref) : _refiner(ref) { }
~LegacyGregoryHelper() { }
public:
int GetNumBoundaryPatches() const { return (int)_boundaryFaceIndices.size(); }
int GetNumInteriorPatches() const { return (int)_interiorFaceIndices.size(); }
void AddPatchFace(int level, Index face);
void FinalizeQuadOffsets( PatchTable::QuadOffsetsTable & qTable);
void FinalizeVertexValence(PatchTable::VertexValenceTable & vTable,
int lastLevelVertOffset);
private:
TopologyRefiner const& _refiner;
std::vector<Index> _interiorFaceIndices;
std::vector<Index> _boundaryFaceIndices;
};
private:
// Builder methods for internal use:
// Simple queries:
int getRefinerFVarChannel(int fvcInTable) const {
return (fvcInTable >= 0) ? _fvarChannelIndices[fvcInTable] : -1;
}
bool isFVarChannelLinear(int fvcInTable) const {
if (_options.generateFVarLegacyLinearPatches) return true;
return (_refiner.GetFVarLinearInterpolation(
getRefinerFVarChannel(fvcInTable)) == Sdc::Options::FVAR_LINEAR_ALL);
}
bool doesFVarTopologyMatch(PatchTuple const & patch, int fvcInTable) {
return _patchBuilder->DoesFaceVaryingPatchMatch(
patch.levelIndex, patch.faceIndex,
getRefinerFVarChannel(fvcInTable));
}
// Methods for identifying and assigning patch-related data:
void identifyPatchTopology(PatchTuple const & patch, PatchInfo & patchInfo,
int fvcInTable = -1);
int assignPatchPointsAndStencils(PatchTuple const & patch,
PatchInfo const & patchInfo,
Index * patchPoints,
LocalPointHelper & localHelper,
int fvcInTable = -1);
int assignFacePoints(PatchTuple const & patch,
Index * patchPoints,
int fvcInTable = -1) const;
// High level methods for assembling the table:
void identifyPatches();
void appendPatch(int levelIndex, Index faceIndex);
void findDescendantPatches(int levelIndex, Index faceIndex, int targetLevel);
void populatePatches();
void allocateVertexTables();
void allocateFVarChannels();
int estimateLocalPointCount(LocalPointHelper::Options const & options,
int fvcInTable = -1) const;
private:
// Refiner and Options passed on construction:
TopologyRefiner const & _refiner;
Options const _options;
ConstIndexArray _selectedFaces;
// Flags indicating the need for processing based on provided options
unsigned int _requiresLocalPoints : 1;
unsigned int _requiresRegularLocalPoints : 1;
unsigned int _requiresIrregularLocalPoints : 1;
unsigned int _requiresSharpnessArray : 1;
unsigned int _requiresFVarPatches : 1;
unsigned int _requiresVaryingPatches : 1;
unsigned int _requiresVaryingLocalPoints : 1;
unsigned int _buildUniformLinear : 1;
// The PatchTable being constructed and classes to help its construction:
PatchTable * _table;
PatchBuilder * _patchBuilder;
PtexIndices const _ptexIndices;
// Vector of tuples for each patch identified during topology traversal
// and the numbers of irregular and irregular patches identifed:
PatchTupleVector _patches;
int _numRegularPatches;
int _numIrregularPatches;
// Vectors for remapping indices of vertices and fvar values as well
// as the fvar channels (when a subset is chosen)
std::vector<int> _levelVertOffsets;
std::vector< std::vector<int> > _levelFVarValueOffsets;
std::vector<int> _fvarChannelIndices;
// State and helpers for legacy features
bool _requiresLegacyGregoryTables;
LegacyGregoryHelper * _legacyGregoryHelper;
};
// Constructor
PatchTableBuilder::PatchTableBuilder(
TopologyRefiner const & refiner, Options opts, ConstIndexArray faces) :
_refiner(refiner), _options(opts), _selectedFaces(faces),
_table(0), _patchBuilder(0), _ptexIndices(refiner),
_numRegularPatches(0), _numIrregularPatches(0),
_legacyGregoryHelper(0) {
if (_options.generateFVarTables) {
// If client-code does not select specific channels, default to all
// the channels in the refiner.
if (_options.numFVarChannels==-1) {
_fvarChannelIndices.resize(_refiner.GetNumFVarChannels());
for (int fvc=0;fvc<(int)_fvarChannelIndices.size(); ++fvc) {
_fvarChannelIndices[fvc] = fvc; // std::iota
}
} else {
_fvarChannelIndices.assign(
_options.fvarChannelIndices,
_options.fvarChannelIndices + _options.numFVarChannels);
}
}
//
// Will need to translate PatchTableFactory options to the newer set of
// PatchBuilder options in the near future. And the state variables are
// a potentially complex combination of options and so are handled after
// the PatchBuilder construction (to potentially help) rather than in
// the initializer list.
//
PatchBuilder::Options patchOptions;
patchOptions.regBasisType = PatchBuilder::BASIS_REGULAR;
switch (_options.GetEndCapType()) {
case Options::ENDCAP_BILINEAR_BASIS:
patchOptions.irregBasisType = PatchBuilder::BASIS_LINEAR;
break;
case Options::ENDCAP_BSPLINE_BASIS:
patchOptions.irregBasisType = PatchBuilder::BASIS_REGULAR;
break;
case Options::ENDCAP_GREGORY_BASIS:
patchOptions.irregBasisType = PatchBuilder::BASIS_GREGORY;
break;
default:
// The PatchBuilder will infer if left un-specified
patchOptions.irregBasisType = PatchBuilder::BASIS_UNSPECIFIED;
break;
}
patchOptions.fillMissingBoundaryPoints = true;
patchOptions.approxInfSharpWithSmooth = !_options.useInfSharpPatch;
patchOptions.approxSmoothCornerWithSharp =
_options.generateLegacySharpCornerPatches;
_patchBuilder = PatchBuilder::Create(_refiner, patchOptions);
//
// Initialize member variables that capture specified options:
//
_requiresRegularLocalPoints =
(patchOptions.regBasisType != PatchBuilder::BASIS_REGULAR);
_requiresIrregularLocalPoints =
(_options.GetEndCapType() != Options::ENDCAP_LEGACY_GREGORY);
_requiresLocalPoints =
_requiresIrregularLocalPoints || _requiresRegularLocalPoints;
_requiresSharpnessArray = _options.useSingleCreasePatch;
_requiresFVarPatches = ! _fvarChannelIndices.empty();
_requiresVaryingPatches = _options.generateVaryingTables;
_requiresVaryingLocalPoints = _options.generateVaryingTables &&
_options.generateVaryingLocalPoints;
// Option to be made public in future:
bool options_generateNonLinearUniformPatches = false;
_buildUniformLinear = _refiner.IsUniform() && !options_generateNonLinearUniformPatches;
//
// Create and initialize the new PatchTable instance to be assembled:
//
_table = new PatchTable(_refiner.GetMaxValence());
_table->_numPtexFaces = _ptexIndices.GetNumFaces();
_table->_vertexPrecisionIsDouble = _options.patchPrecisionDouble;
_table->_varyingPrecisionIsDouble = _options.patchPrecisionDouble;
_table->_faceVaryingPrecisionIsDouble = _options.fvarPatchPrecisionDouble;
_table->_varyingDesc = PatchDescriptor(_patchBuilder->GetLinearPatchType());
// State and helper to support LegacyGregory arrays in the PatchTable:
_requiresLegacyGregoryTables = !_refiner.IsUniform() &&
(_options.GetEndCapType() == Options::ENDCAP_LEGACY_GREGORY);
if (_requiresLegacyGregoryTables) {
_legacyGregoryHelper = new LegacyGregoryHelper(_refiner);
}
}
PatchTableBuilder::~PatchTableBuilder() {
delete _patchBuilder;
delete _legacyGregoryHelper;
}
void
PatchTableBuilder::identifyPatchTopology(PatchTuple const & patch,
PatchInfo & patchInfo, int fvarInTable) {
int patchLevel = patch.levelIndex;
Index patchFace = patch.faceIndex;
int fvarInRefiner = getRefinerFVarChannel(fvarInTable);
patchInfo.isRegular = _patchBuilder->IsPatchRegular(
patchLevel, patchFace, fvarInTable);
bool useDoubleMatrix = (fvarInRefiner < 0)
? _options.patchPrecisionDouble
: _options.fvarPatchPrecisionDouble;
if (patchInfo.isRegular) {
patchInfo.regBoundaryMask = _patchBuilder->GetRegularPatchBoundaryMask(
patchLevel, patchFace, fvarInRefiner);
patchInfo.isRegSingleCrease = false;
patchInfo.regSharpness = 0.0f;
patchInfo.paramBoundaryMask = patchInfo.regBoundaryMask;
// If converting to another basis, get the change-of-basis matrix:
if (_requiresRegularLocalPoints) {
// _patchBuilder->GetRegularConversionMatrix(...);
}
//
// Test regular interior patches for a single-crease patch when it
// was specified.
//
// Note that the PatchTable clamps the sharpness of single-crease
// patches to that of the maximimu refinement level, so any single-
// crease patches at the last level will be reduced to regular
// patches (maintaining continuity with other semi-sharp patches
// also reduced to regular).
//
if (_requiresSharpnessArray &&
(patchInfo.regBoundaryMask == 0) && (fvarInRefiner < 0)) {
if (patchLevel < (int) _options.maxIsolationLevel) {
PatchBuilder::SingleCreaseInfo creaseInfo;
if (_patchBuilder->IsRegularSingleCreasePatch(
patchLevel, patchFace, creaseInfo)) {
creaseInfo.creaseSharpness =
std::min(creaseInfo.creaseSharpness,
(float)(_options.maxIsolationLevel - patchLevel));
patchInfo.isRegSingleCrease = true;
patchInfo.regSharpness = creaseInfo.creaseSharpness;
patchInfo.paramBoundaryMask = (1 << creaseInfo.creaseEdgeInFace);
}
}
}
} else if (_requiresIrregularLocalPoints) {
_patchBuilder->GetIrregularPatchCornerSpans(
patchLevel, patchFace, patchInfo.irregCornerSpans, fvarInRefiner);
if (useDoubleMatrix) {
_patchBuilder->GetIrregularPatchConversionMatrix(
patchLevel, patchFace, patchInfo.irregCornerSpans, patchInfo.dMatrix);
} else {
_patchBuilder->GetIrregularPatchConversionMatrix(
patchLevel, patchFace, patchInfo.irregCornerSpans, patchInfo.fMatrix);
}
patchInfo.paramBoundaryMask = 0;
}
}
int
PatchTableBuilder::assignPatchPointsAndStencils(PatchTuple const & patch,
PatchInfo const & patchInfo, Index * patchPoints,
LocalPointHelper & localHelper, int fvarInTable) {
//
// This is where the interesting/complicated new work will take place
// when a change-of-basis is determined necessary and previously assigned
// to the PatchInfo
//
// No change-of-basis means no local points or stencils associated with
// them, which should be trivial but should also only be true in the
// regular case. (It is also the case that no local points will be
// generated for irregular patches when the LegacyGregory option is
// used -- so that possibility is still accounted for here.)
//
// Regarding the return result, it should just be the size of the patch
// associated with the regular/irregular patch type chosen. This could
// be retrieved from the PatchBuilder or PatchDescriptors -- alternatively
// a return value could be removed and the client left to increment by
// such a fixed step (which is already the case for FVar channels)
//
// The more interesting size here is the number of local points/stencils
// added.
//
int fvarInRefiner = getRefinerFVarChannel(fvarInTable);
int sourcePointOffset = (fvarInTable < 0)
? _levelVertOffsets[patch.levelIndex]
: _levelFVarValueOffsets[fvarInTable][patch.levelIndex];
bool useDoubleMatrix = (fvarInTable < 0)
? _options.patchPrecisionDouble
: _options.fvarPatchPrecisionDouble;
int numPatchPoints = 0;
if (patchInfo.isRegular) {
if (!_requiresRegularLocalPoints) {
numPatchPoints = _patchBuilder->GetRegularPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.regBoundaryMask, patchPoints, fvarInRefiner);
// PatchBuilder set to fill missing boundary points so offset all
offsetIndices(patchPoints, numPatchPoints, sourcePointOffset);
} else {
//
// Future support for regular patches converted to another basis.
// Note the "source points" are not returned in the same
// orientation and there may be fewer than expected number in the
// case of boundaries:
/*
StackBuffer<Index,64,true> sourcePoints(
patchInfo.matrix.GetNumColumns());
_patchBuilder->GetRegularPatchSourcePoints(
patch.levelIndex, patch.faceIndex,
patchInfo.regBoundaryMask, sourcePoints, fvarInRefiner);
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.matrix, _patchBuilder->GetRegularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
numPatchPoints = patchInfo.matrix.GetNumRows();
*/
}
} else if (_requiresIrregularLocalPoints) {
int numSourcePoints = 0;
if (useDoubleMatrix) {
numSourcePoints = patchInfo.dMatrix.GetNumColumns();
numPatchPoints = patchInfo.dMatrix.GetNumRows();
} else {
numSourcePoints = patchInfo.fMatrix.GetNumColumns();
numPatchPoints = patchInfo.fMatrix.GetNumRows();
}
StackBuffer<Index,64,true> sourcePoints(numSourcePoints);
_patchBuilder->GetIrregularPatchSourcePoints(
patch.levelIndex, patch.faceIndex,
patchInfo.irregCornerSpans, sourcePoints, fvarInRefiner);
if (useDoubleMatrix) {
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.dMatrix, _patchBuilder->GetIrregularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
} else {
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.fMatrix, _patchBuilder->GetIrregularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
}
}
return numPatchPoints;
}
int
PatchTableBuilder::assignFacePoints(PatchTuple const & patch,
Index * patchPoints,
int fvarInTable) const {
Level const & level = _refiner.getLevel(patch.levelIndex);
int facePointOffset = (fvarInTable < 0)
? _levelVertOffsets[patch.levelIndex]
: _levelFVarValueOffsets[fvarInTable][patch.levelIndex];
int fvarInRefiner = getRefinerFVarChannel(fvarInTable);
ConstIndexArray facePoints = (fvarInRefiner < 0)
? level.getFaceVertices(patch.faceIndex)
: level.getFaceFVarValues(patch.faceIndex, fvarInRefiner);
for (int i = 0; i < facePoints.size(); ++i) {
patchPoints[i] = facePoints[i] + facePointOffset;
}
return facePoints.size();
}
//
// Reserves tables based on contents of the PatchArrayVector in the PatchTable:
//
void
PatchTableBuilder::allocateVertexTables() {
int ncvs = 0, npatches = 0;
for (int i=0; i<_table->GetNumPatchArrays(); ++i) {
npatches += _table->GetNumPatches(i);
ncvs += _table->GetNumControlVertices(i);
}
if (ncvs==0 || npatches==0)
return;
_table->_patchVerts.resize( ncvs );
_table->_paramTable.resize( npatches );
if (_requiresVaryingPatches && !_buildUniformLinear) {
_table->allocateVaryingVertices(
PatchDescriptor(_patchBuilder->GetLinearPatchType()), npatches);
}
if (_requiresSharpnessArray) {
_table->_sharpnessIndices.resize( npatches, Vtr::INDEX_INVALID );
}
}
//
// Allocate face-varying tables
//
void
PatchTableBuilder::allocateFVarChannels() {
int npatches = _table->GetNumPatchesTotal();
_table->allocateFVarPatchChannels((int)_fvarChannelIndices.size());
// Initialize each channel
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
int refinerChannel = _fvarChannelIndices[fvc];
Sdc::Options::FVarLinearInterpolation interpolation =
_refiner.GetFVarLinearInterpolation(refinerChannel);
_table->setFVarPatchChannelLinearInterpolation(interpolation, fvc);
PatchDescriptor::Type regPatchType = _patchBuilder->GetLinearPatchType();
PatchDescriptor::Type irregPatchType = regPatchType;
if (_buildUniformLinear) {
if (_options.triangulateQuads) {
regPatchType = PatchDescriptor::TRIANGLES;
irregPatchType = regPatchType;
}
} else {
if (!isFVarChannelLinear(fvc)) {
regPatchType = _patchBuilder->GetRegularPatchType();
irregPatchType = _patchBuilder->GetIrregularPatchType();
}
}
_table->allocateFVarPatchChannelValues(
PatchDescriptor(regPatchType), PatchDescriptor(irregPatchType),
npatches, fvc);
}
}
void
PatchTableBuilder::BuildUniformPolygons() {
// Default behavior is to include base level vertices in the patch vertices
// for vertex and varying patches, but not face-varying. Consider exposing
// these as public options in future so that clients can create consistent
// behavior:
bool includeBaseLevelIndices = _options.includeBaseLevelIndices;
bool includeBaseLevelFVarIndices = _options.includeFVarBaseLevelIndices;
// ensure that triangulateQuads is only set for quadrilateral schemes
bool triangulateQuads =
_options.triangulateQuads && (_patchBuilder->GetRegularFaceSize() == 4);
// level=0 may contain n-gons, which are not supported in PatchTable.
// even if generateAllLevels = true, we start from level 1.
int maxlevel = _refiner.GetMaxLevel(),
firstlevel = _options.generateAllLevels ? 1 : maxlevel,
nlevels = maxlevel-firstlevel+1;
PatchDescriptor::Type ptype = triangulateQuads
? PatchDescriptor::TRIANGLES
: _patchBuilder->GetLinearPatchType();
//
// Allocate and initialize the table's members.
//
_table->_isUniformLinear = true;
_table->reservePatchArrays(nlevels);
PatchDescriptor desc(ptype);
// generate patch arrays
for (int level=firstlevel, poffset=0, voffset=0; level<=maxlevel; ++level) {
TopologyLevel const & refLevel = _refiner.GetLevel(level);
int npatches = refLevel.GetNumFaces();
if (_refiner.HasHoles()) {
for (int i = npatches - 1; i >= 0; --i) {
npatches -= refLevel.IsFaceHole(i);
}
}
assert(npatches>=0);
if (triangulateQuads)
npatches *= 2;
_table->pushPatchArray(desc, npatches, &voffset, &poffset, 0);
}
// Allocate various tables
allocateVertexTables();
if (_requiresFVarPatches) {
allocateFVarChannels();
}
//
// Now populate the patches:
//
Index * iptr = &_table->_patchVerts[0];
PatchParam * pptr = &_table->_paramTable[0];
Index ** fptr = 0;
PatchParam ** fpptr = 0;
Index levelVertOffset = includeBaseLevelIndices
? _refiner.GetLevel(0).GetNumVertices() : 0;
Index * levelFVarVertOffsets = 0;
if (_requiresFVarPatches) {
levelFVarVertOffsets =
(Index *)alloca(_fvarChannelIndices.size()*sizeof(Index));
memset(levelFVarVertOffsets, 0, _fvarChannelIndices.size()*sizeof(Index));
fptr = (Index **)alloca(_fvarChannelIndices.size()*sizeof(Index *));
fpptr = (PatchParam **)alloca(_fvarChannelIndices.size()*sizeof(PatchParam *));
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
fptr[fvc] = _table->getFVarValues(fvc).begin();
fpptr[fvc] = _table->getFVarPatchParams(fvc).begin();
if (includeBaseLevelFVarIndices) {
int refinerChannel = _fvarChannelIndices[fvc];
levelFVarVertOffsets[fvc] =
_refiner.GetLevel(0).GetNumFVarValues(refinerChannel);
}
}
}
for (int level=1; level<=maxlevel; ++level) {
TopologyLevel const & refLevel = _refiner.GetLevel(level);
int nfaces = refLevel.GetNumFaces();
if (level>=firstlevel) {
for (int face=0; face<nfaces; ++face) {
if (_refiner.HasHoles() && refLevel.IsFaceHole(face)) {
continue;
}
ConstIndexArray fverts = refLevel.GetFaceVertices(face);
for (int vert=0; vert<fverts.size(); ++vert) {
*iptr++ = levelVertOffset + fverts[vert];
}
PatchParam pparam = _patchBuilder->ComputePatchParam(
level, face, _ptexIndices);
*pptr++ = pparam;
if (_requiresFVarPatches) {
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
int refinerChannel = _fvarChannelIndices[fvc];
ConstIndexArray fvalues =
refLevel.GetFaceFVarValues(face, refinerChannel);
for (int vert=0; vert<fvalues.size(); ++vert) {
assert((levelFVarVertOffsets[fvc] + fvalues[vert])
< (int)_table->getFVarValues(fvc).size());
fptr[fvc][vert] =
levelFVarVertOffsets[fvc] + fvalues[vert];
}
fptr[fvc]+=fvalues.size();
*fpptr[fvc]++ = pparam;
}
}
if (triangulateQuads) {
// Triangulate the quadrilateral:
// {v0,v1,v2,v3} -> {v0,v1,v2},{v3,v0,v2}.
*iptr = *(iptr - 4); // copy v0 index
++iptr;
*iptr = *(iptr - 3); // copy v2 index
++iptr;
*pptr++ = pparam;
if (_requiresFVarPatches) {
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
*fptr[fvc] = *(fptr[fvc]-4); // copy fv0 index
++fptr[fvc];
*fptr[fvc] = *(fptr[fvc]-3); // copy fv2 index
++fptr[fvc];
*fpptr[fvc]++ = pparam;
}
}
}
}
}
if (_options.generateAllLevels) {
levelVertOffset += _refiner.GetLevel(level).GetNumVertices();
if (_requiresFVarPatches) {
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
int refinerChannel = _fvarChannelIndices[fvc];
levelFVarVertOffsets[fvc] +=
_refiner.GetLevel(level).GetNumFVarValues(refinerChannel);
}
}
}
}
}
void
PatchTableBuilder::BuildPatches() {
identifyPatches();
populatePatches();
}
//
// Identify all patches required for faces at all levels -- appending the
// <level,face> pairs to identify each patch for later construction, while
// accumulating the number of regular vs irregular patches to size tables.
//
inline void
PatchTableBuilder::appendPatch(int levelIndex, Index faceIndex) {
_patches.push_back(PatchTuple(faceIndex, levelIndex));
// Count the patches here to simplify subsequent allocation.
if (_patchBuilder->IsPatchRegular(levelIndex, faceIndex)) {
++_numRegularPatches;
} else {
++_numIrregularPatches;
// LegacyGregory needs to distinguish boundary vs interior
if (_requiresLegacyGregoryTables) {
_legacyGregoryHelper->AddPatchFace(levelIndex, faceIndex);
}
}
}
inline void
PatchTableBuilder::findDescendantPatches(int levelIndex, Index faceIndex, int targetLevel) {
//
// If we have reached the target level or a leaf, append the patch (if
// the face qualifies), otherwise recursively search the children:
//
if ((levelIndex == targetLevel) || _patchBuilder->IsFaceALeaf(levelIndex, faceIndex)) {
if (_patchBuilder->IsFaceAPatch(levelIndex, faceIndex)) {
appendPatch(levelIndex, faceIndex);
}
} else {
TopologyLevel const & level = _refiner.GetLevel(levelIndex);
ConstIndexArray childFaces = level.GetFaceChildFaces(faceIndex);
for (int i = 0; i < childFaces.size(); ++i) {
if (Vtr::IndexIsValid(childFaces[i])) {
findDescendantPatches(levelIndex + 1, childFaces[i], targetLevel);
}
}
}
}
void
PatchTableBuilder::identifyPatches() {
//
// First initialize the offsets for all levels
//
_levelVertOffsets.push_back(0);
_levelFVarValueOffsets.resize(_fvarChannelIndices.size());
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
_levelFVarValueOffsets[fvc].push_back(0);
}
for (int levelIndex=0; levelIndex<_refiner.GetNumLevels(); ++levelIndex) {
Level const & level = _refiner.getLevel(levelIndex);
_levelVertOffsets.push_back(
_levelVertOffsets.back() + level.getNumVertices());
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
int refinerChannel = _fvarChannelIndices[fvc];
_levelFVarValueOffsets[fvc].push_back(
_levelFVarValueOffsets[fvc].back()
+ level.getNumFVarValues(refinerChannel));
}
}
//
// If a set of selected base faces is present, identify the patches
// depth first. Otherwise search breadth first through the levels:
//
int uniformLevel = _refiner.IsUniform() ? _options.maxIsolationLevel : -1;
_patches.reserve(_refiner.GetNumFacesTotal());
if (_selectedFaces.size()) {
for (int i = 0; i < (int)_selectedFaces.size(); ++i) {
findDescendantPatches(0, _selectedFaces[i], uniformLevel);
}
} else if (uniformLevel >= 0) {
int numFaces = _refiner.getLevel(uniformLevel).getNumFaces();
for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
if (_patchBuilder->IsFaceAPatch(uniformLevel, faceIndex)) {
appendPatch(uniformLevel, faceIndex);
}
}
} else {
for (int levelIndex=0; levelIndex<_refiner.GetNumLevels(); ++levelIndex) {
int numFaces = _refiner.getLevel(levelIndex).getNumFaces();
for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
if (_patchBuilder->IsFaceAPatch(levelIndex, faceIndex) &&
_patchBuilder->IsFaceALeaf(levelIndex, faceIndex)) {
appendPatch(levelIndex, faceIndex);
}
}
}
}
}
//
// Populate patches that were previously identified.
//
void
PatchTableBuilder::populatePatches() {
// State needed to populate an array in the patch table.
// Pointers in this structure are initialized after the patch array
// data buffers have been allocated and are then incremented as we
// populate data into the patch table. Currently, we'll have at
// most 3 patch arrays: Regular, Irregular, and IrregularBoundary.
struct PatchArrayBuilder {
PatchArrayBuilder()
: patchType(PatchDescriptor::NON_PATCH), numPatches(0)
, iptr(NULL), pptr(NULL), sptr(NULL), vptr(NULL) { }
PatchDescriptor::Type patchType;
int numPatches;
Index *iptr;
PatchParam *pptr;
Index *sptr;
Index *vptr;
StackBuffer<Index*,1> fptr; // fvar indices
StackBuffer<PatchParam*,1> fpptr; // fvar patch-params
private:
// Non-copyable
PatchArrayBuilder(PatchArrayBuilder const &) {}
PatchArrayBuilder & operator=(PatchArrayBuilder const &) {return *this;}
} arrayBuilders[3];
// Regular patches patches will be packed into the first patch array
// Irregular patches will be packed into arrays according to optional
// specification -- sharing the array with regular patches or packed
// into an array of their own.
int ARRAY_REGULAR = 0;
int ARRAY_IRREGULAR = 1;
int ARRAY_BOUNDARY = 2; // only used by LegacyGregory
arrayBuilders[ARRAY_REGULAR].patchType = _patchBuilder->GetRegularPatchType();
arrayBuilders[ARRAY_REGULAR].numPatches = _numRegularPatches;
int numPatchArrays = (_numRegularPatches > 0);
if (_numIrregularPatches > 0) {
if (!_requiresLegacyGregoryTables) {
//
// Pack irregular patches into same array as regular or separately:
//
if (_patchBuilder->GetRegularPatchType() ==
_patchBuilder->GetIrregularPatchType()) {
ARRAY_IRREGULAR = ARRAY_REGULAR;
numPatchArrays = 1; // needed in case no regular patches
} else {
ARRAY_IRREGULAR = numPatchArrays;
numPatchArrays ++;
}
arrayBuilders[ARRAY_IRREGULAR].patchType =
_patchBuilder->GetIrregularPatchType();
arrayBuilders[ARRAY_IRREGULAR].numPatches += _numIrregularPatches;
} else {
//
// Arrays for Legacy-Gregory tables -- irregular patches are split
// into two arrays for interior and boundary patches
//
ARRAY_IRREGULAR = numPatchArrays;
arrayBuilders[ARRAY_IRREGULAR].patchType =
PatchDescriptor::GREGORY;
arrayBuilders[ARRAY_IRREGULAR].numPatches =
_legacyGregoryHelper->GetNumInteriorPatches();
numPatchArrays += (arrayBuilders[ARRAY_IRREGULAR].numPatches > 0);
ARRAY_BOUNDARY = numPatchArrays;
arrayBuilders[ARRAY_BOUNDARY].patchType =
PatchDescriptor::GREGORY_BOUNDARY;
arrayBuilders[ARRAY_BOUNDARY].numPatches =
_legacyGregoryHelper->GetNumBoundaryPatches();
numPatchArrays += (arrayBuilders[ARRAY_BOUNDARY].numPatches > 0);
}
}
// Create patch arrays
_table->reservePatchArrays(numPatchArrays);
int voffset=0, poffset=0, qoffset=0;
for (int arrayIndex=0; arrayIndex<numPatchArrays; ++arrayIndex) {
PatchArrayBuilder & arrayBuilder = arrayBuilders[arrayIndex];
_table->pushPatchArray(PatchDescriptor(arrayBuilder.patchType),
arrayBuilder.numPatches, &voffset, &poffset, &qoffset );
}
// Allocate patch array data buffers
allocateVertexTables();
if (_requiresFVarPatches) {
allocateFVarChannels();
}
// Initialize pointers used while populating patch array data buffers
for (int arrayIndex=0; arrayIndex<numPatchArrays; ++arrayIndex) {
PatchArrayBuilder & arrayBuilder = arrayBuilders[arrayIndex];
arrayBuilder.iptr = _table->getPatchArrayVertices(arrayIndex).begin();
arrayBuilder.pptr = _table->getPatchParams(arrayIndex).begin();
if (_requiresSharpnessArray) {
arrayBuilder.sptr = _table->getSharpnessIndices(arrayIndex);
}
if (_requiresVaryingPatches) {
arrayBuilder.vptr = _table->getPatchArrayVaryingVertices(arrayIndex).begin();
}
if (_requiresFVarPatches) {
arrayBuilder.fptr.SetSize((int)_fvarChannelIndices.size());
arrayBuilder.fpptr.SetSize((int)_fvarChannelIndices.size());
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
Index pidx = _table->getPatchIndex(arrayIndex, 0);
int ofs = pidx * _table->GetFVarValueStride(fvc);
arrayBuilder.fptr[fvc] = &_table->getFVarValues(fvc)[ofs];
arrayBuilder.fpptr[fvc] = &_table->getFVarPatchParams(fvc)[pidx];
}
}
}
//
// Initializing StencilTable and other helpers. Note Varying local points
// are managed by the LocalPointHelper for Vertex patches (as Varying local
// points are tightly coupled to their local points)
//
LocalPointHelper * vertexLocalPointHelper = 0;
StackBuffer<LocalPointHelper*,4> fvarLocalPointHelpers;
if (_requiresLocalPoints) {
LocalPointHelper::Options opts;
opts.createStencilTable = true;
opts.createVaryingTable = _requiresVaryingLocalPoints;
opts.doubleStencilTable = _options.patchPrecisionDouble;
opts.shareLocalPoints = _options.shareEndCapPatchPoints;
opts.reuseSourcePoints = (_patchBuilder->GetIrregularPatchType() ==
_patchBuilder->GetNativePatchType() );
vertexLocalPointHelper = new LocalPointHelper(
_refiner, opts, -1, estimateLocalPointCount(opts, -1));
if (_requiresFVarPatches) {
opts.createStencilTable = true;
opts.createVaryingTable = false;
opts.doubleStencilTable = _options.fvarPatchPrecisionDouble;
fvarLocalPointHelpers.SetSize((int)_fvarChannelIndices.size());
for (int fvc = 0; fvc < (int)_fvarChannelIndices.size(); ++fvc) {
fvarLocalPointHelpers[fvc] = new LocalPointHelper(
_refiner, opts, getRefinerFVarChannel(fvc),
estimateLocalPointCount(opts, fvc));
}
}
}
// Populate patch data buffers
//
// Intentionally declare local vairables to contain patch topology info
// outside the loop to avoid repeated memory de-allocation/re-allocation
// associated with a change-of-basis.
PatchInfo patchInfo;
PatchInfo fvarPatchInfo;
bool fvarPrecisionMatches = (_options.patchPrecisionDouble ==
_options.fvarPatchPrecisionDouble);
for (int patchIndex = 0; patchIndex < (int)_patches.size(); ++patchIndex) {
PatchTuple const & patch = _patches[patchIndex];
//
// Identify and assign points, stencils, sharpness, etc. for this patch:
//
identifyPatchTopology(patch, patchInfo);
PatchArrayBuilder * arrayBuilder = &arrayBuilders[ARRAY_REGULAR];
if (!patchInfo.isRegular) {
arrayBuilder = &arrayBuilders[ARRAY_IRREGULAR];
}
if (_requiresLegacyGregoryTables && !patchInfo.isRegular) {
if (isBoundaryFace(
_refiner.getLevel(patch.levelIndex), patch.faceIndex)) {
arrayBuilder = &arrayBuilders[ARRAY_BOUNDARY];
}
arrayBuilder->iptr += assignFacePoints(patch, arrayBuilder->iptr);
} else {
arrayBuilder->iptr += assignPatchPointsAndStencils(patch,
patchInfo, arrayBuilder->iptr, *vertexLocalPointHelper);
}
if (_requiresSharpnessArray) {
*arrayBuilder->sptr++ = assignSharpnessIndex(patchInfo.regSharpness,
_table->_sharpnessValues);
}
//
// Identify the PatchParam -- which may vary slightly for face-varying
// channels but will still be used to initialize them when so to avoid
// recomputing from scratch
//
PatchParam patchParam =
_patchBuilder->ComputePatchParam(patch.levelIndex, patch.faceIndex,
_ptexIndices, patchInfo.isRegular, patchInfo.paramBoundaryMask,
true/* condition to compute transition mask */);
*arrayBuilder->pptr++ = patchParam;
//
// Assignment of face-varying patches is split between the comon/trivial
// case of linear patches and the more complex non-linear cases:
//
assert((_fvarChannelIndices.size() > 0) == _requiresFVarPatches);
for (int fvc = 0; fvc < (int)_fvarChannelIndices.size(); ++fvc) {
if (isFVarChannelLinear(fvc)) {
assignFacePoints(patch, arrayBuilder->fptr[fvc], fvc);
*arrayBuilder->fpptr[fvc] = patchParam;
} else {
//
// For non-linear patches, reuse patch information when the
// topology of the face in face-varying space matches the
// original patch:
//
bool fvcTopologyMatches = fvarPrecisionMatches &&
doesFVarTopologyMatch(patch, fvc);
PatchInfo & fvcPatchInfo = fvcTopologyMatches
? patchInfo : fvarPatchInfo;
if (!fvcTopologyMatches) {
identifyPatchTopology(patch, fvcPatchInfo, fvc);
}
assignPatchPointsAndStencils(patch, fvcPatchInfo,
arrayBuilder->fptr[fvc], *fvarLocalPointHelpers[fvc], fvc);
// Initialize and assign the face-varying PatchParam:
PatchParam & fvcPatchParam = *arrayBuilder->fpptr[fvc];
fvcPatchParam.Set(
patchParam.GetFaceId(),
patchParam.GetU(), patchParam.GetV(),
patchParam.GetDepth(),
patchParam.NonQuadRoot(),
fvcPatchInfo.paramBoundaryMask,
patchParam.GetTransition(),
fvcPatchInfo.isRegular);
}
arrayBuilder->fpptr[fvc] ++;
arrayBuilder->fptr[fvc] += _table->GetFVarValueStride(fvc);
}
if (_requiresVaryingPatches) {
arrayBuilder->vptr += assignFacePoints(patch, arrayBuilder->vptr);
}
}
//
// Finalizing and destroying StencilTable and other helpers:
//
if (_requiresLocalPoints) {
_table->_localPointStencils =
vertexLocalPointHelper->AcquireStencilTable();
if (_requiresVaryingLocalPoints) {
_table->_localPointVaryingStencils =
vertexLocalPointHelper->AcquireStencilTableVarying();
}
delete vertexLocalPointHelper;
if (_requiresFVarPatches) {
_table->_localPointFaceVaryingStencils.resize(_fvarChannelIndices.size());
for (int fvc=0; fvc<(int)_fvarChannelIndices.size(); ++fvc) {
_table->_localPointFaceVaryingStencils[fvc] =
fvarLocalPointHelpers[fvc]->AcquireStencilTable();
delete fvarLocalPointHelpers[fvc];
}
}
}
if (_requiresLegacyGregoryTables) {
_legacyGregoryHelper->FinalizeQuadOffsets(_table->_quadOffsetsTable);
_legacyGregoryHelper->FinalizeVertexValence(_table->_vertexValenceTable,
_levelVertOffsets[_refiner.GetMaxLevel()]);
}
}
int
PatchTableBuilder::estimateLocalPointCount(
LocalPointHelper::Options const & options,
int fvarChannel) const {
if ((fvarChannel >= 0) && isFVarChannelLinear(fvarChannel)) return 0;
//
// Estimate the local points required for the Vertex topology in all cases
// as it may be used in the estimates for face-varying channels:
//
int estLocalPoints = 0;
if (_requiresRegularLocalPoints) {
//
// Either all regular patches are being converted to a non-native
// basis, or boundary points are being extrapolated in the regular
// basis. The latter case typically involves a small fraction of
// patches and points, so we don't estimate any local points and
// leave it up to incremental allocation later to account for them.
//
int numPointsPerPatch = PatchDescriptor(
_patchBuilder->GetRegularPatchType()).GetNumControlVertices();
if (_patchBuilder->GetRegularPatchType() !=
_patchBuilder->GetNativePatchType()) {
estLocalPoints += _numRegularPatches * numPointsPerPatch;
}
}
if (_requiresIrregularLocalPoints) {
bool oldEstimate = false;
int numIrregularPatches = oldEstimate ?
_refiner.GetLevel(_refiner.GetMaxLevel()).GetNumFaces() :
_numIrregularPatches;
//
// If converting to a basis other than regular, its difficult to
// predict the degree of point-sharing that may occur, and in general,
// the maximal benefit is small so we don't attempt to compensate for
// it here. If converting to the same basis as regular, roughly half
// of the points of the patch are involved in approximating the
// irregularity (and cannot be shared) so don't include the source
// points that will be used in such patches.
//
int numPointsPerPatch = PatchDescriptor(
_patchBuilder->GetIrregularPatchType()).GetNumControlVertices();
if (options.reuseSourcePoints && (_patchBuilder->GetIrregularPatchType() ==
_patchBuilder->GetNativePatchType())) {
numPointsPerPatch /= 2;
}
estLocalPoints += numIrregularPatches * numPointsPerPatch;
}
//
// Its difficult to estimate the differences in number of irregularities
// between the vertex topology and a face-varying channel without more
// detailed inspection.
//
// A much higher number of fvar-values than vertices is an indication that
// the number of differences increases, and that generally lowers the
// number of irregular patches due to more regular patches on face-varying
// boundaries, but not always. The use of some interpolation types, e.g.
// LINEAR_BOUNDARIES, combined with inf-sharp patches can increase the
// number of irregularities significantly.
//
if ((fvarChannel >= 0) && (_refiner.GetNumLevels() > 1)) {
//
// We're seeing face-varying stencil table sizes about 1/4 the size of
// the vertex stencil table for what seem like typical cases...
//
// Identify the ratio of fvar-values to vertices that typically leads
// to these reductions and reduce the number of expected local points
// proportionally. Use the number of fvar-values at level 1: level 0
// can be misleading as there can be many FEWER than the number of
// vertices, but subsequent levels will have at least one unique
// fvar-value per vertex, and later levels will have a much higher
// percentage shared as a result of refinement.
//
int fvc = getRefinerFVarChannel(fvarChannel);
if (_refiner.GetLevel(1).GetNumFVarValues(fvc) >
_refiner.GetLevel(1).GetNumVertices()) {
// Scale this based on ratio of fvar-values to vertices...
float fvarReduction = 0.5;
estLocalPoints = (int) ((float)estLocalPoints * fvarReduction);
}
}
return estLocalPoints;
}
//
// Member function definitions for the LocalPointHelper class:
//
PatchTableBuilder::LocalPointHelper::LocalPointHelper(
TopologyRefiner const & refiner, Options const & options,
int fvarChannel, int numLocalPointsExpected) :
_refiner(refiner), _options(options), _fvarChannel(fvarChannel),
_numLocalPoints(0), _stencilTable(), _stencilTableVarying() {
_localPointOffset = (_fvarChannel < 0)
? _refiner.GetNumVerticesTotal()
: _refiner.GetNumFVarValuesTotal(_fvarChannel);
if (_options.createStencilTable) {
if (_options.doubleStencilTable) {
initializeStencilTable<double>(numLocalPointsExpected);
} else {
initializeStencilTable<float>(numLocalPointsExpected);
}
}
}
template <typename REAL>
void
PatchTableBuilder::LocalPointHelper::initializeStencilTable(int numLocalPointsExpected) {
//
// Reserving space for the local-point stencils has been a source of
// problems in the past so we rely on the PatchTableBuilder to provide
// a reasonable estimate to the LocalPointHelper on construction. For
// large meshes a limit on the size initially reserve is capped.
//
// The average number of entries per stencil has been historically set
// at 16, which seemed high and was reduced on further investigation.
//
StencilTableReal<REAL> * stencilTable = new StencilTableReal<REAL>(0);
StencilTableReal<REAL> * varyingTable = _options.createVaryingTable
? new StencilTableReal<REAL>(0) : 0;
// Historic note: limits to 100M (=800M bytes) entries for reserved size
size_t const MaxEntriesToReserve = 100 * 1024 * 1024;
size_t const AvgEntriesPerStencil = 9; // originally 16
size_t numStencilsExpected = numLocalPointsExpected;
size_t numStencilEntriesExpected = numStencilsExpected * AvgEntriesPerStencil;
size_t numEntriesToReserve = std::min(numStencilEntriesExpected,
MaxEntriesToReserve);
if (numEntriesToReserve) {
stencilTable->reserve(
(int)numStencilsExpected, (int)numEntriesToReserve);
if (varyingTable) {
// Varying stencils have only one entry per point
varyingTable->reserve(
(int)numStencilsExpected, (int)numStencilsExpected);
}
}
_stencilTable.Set(stencilTable);
_stencilTableVarying.Set(varyingTable);
}
template <typename REAL>
PatchTableBuilder::StencilTablePtr
PatchTableBuilder::LocalPointHelper::acquireStencilTable(
StencilTablePtr& stencilTableMember) {
StencilTableReal<REAL> * stencilTable = stencilTableMember.Get<REAL>();
if (stencilTable) {
if (stencilTable->GetNumStencils() > 0) {
stencilTable->finalize();
} else {
delete stencilTable;
stencilTable = 0;
}
}
stencilTableMember.Set();
return StencilTablePtr(stencilTable);
}
PatchTableBuilder::LocalPointHelper::~LocalPointHelper() {
if (_options.doubleStencilTable) {
delete _stencilTable.Get<double>();
delete _stencilTableVarying.Get<double>();
} else {
delete _stencilTable.Get<float>();
delete _stencilTableVarying.Get<float>();
}
}
Index
PatchTableBuilder::LocalPointHelper::findSharedCornerPoint(int levelIndex,
Index vertIndex, Index localPointIndex) {
if (_sharedCornerPoints.empty()) {
_sharedCornerPoints.resize(_refiner.GetNumLevels());
}
IndexVector & vertexPoints = _sharedCornerPoints[levelIndex];
if (vertexPoints.empty()) {
Level const & level = _refiner.getLevel(levelIndex);
if (_fvarChannel < 0) {
vertexPoints.resize(level.getNumVertices(), INDEX_INVALID);
} else {
vertexPoints.resize(level.getNumFVarValues(_fvarChannel), INDEX_INVALID);
}
}
Index & assignedIndex = vertexPoints[vertIndex];
if (!IndexIsValid(assignedIndex)) {
assignedIndex = localPointIndex;
}
return assignedIndex;
}
Index
PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int levelIndex,
Index edgeIndex, int edgeEnd, Index localPointIndex) {
if (_sharedEdgePoints.empty()) {
_sharedEdgePoints.resize(_refiner.GetNumLevels());
}
IndexVector & edgePoints = _sharedEdgePoints[levelIndex];
if (edgePoints.empty()) {
edgePoints.resize(
2 * _refiner.GetLevel(levelIndex).GetNumEdges(), INDEX_INVALID);
}
Index & assignedIndex = edgePoints[2 * edgeIndex + edgeEnd];
if (!IndexIsValid(assignedIndex)) {
assignedIndex = localPointIndex;
} else {
}
return assignedIndex;
}
template <typename REAL>
void
PatchTableBuilder::LocalPointHelper::appendLocalPointStencil(
SparseMatrix<REAL> const & conversionMatrix,
int stencilRow,
Index const sourcePoints[],
int sourcePointOffset) {
int stencilSize = conversionMatrix.GetRowSize(stencilRow);
ConstArray<int> matrixColumns = conversionMatrix.GetRowColumns(stencilRow);
ConstArray<REAL> matrixWeights = conversionMatrix.GetRowElements(stencilRow);
StencilTableReal<REAL>* stencilTable = _stencilTable.Get<REAL>();
stencilTable->_sizes.push_back(stencilSize);
for (int i = 0; i < stencilSize; ++i) {
stencilTable->_weights.push_back(matrixWeights[i]);
stencilTable->_indices.push_back(
sourcePoints[matrixColumns[i]] + sourcePointOffset);
}
}
template <typename REAL>
void
PatchTableBuilder::LocalPointHelper::appendLocalPointStencils(
SparseMatrix<REAL> const & conversionMatrix,
Index const sourcePoints[],
int sourcePointOffset) {
//
// Resize the StencilTable members to accomodate all rows and elements from
// the given set of points represented by the matrix
//
StencilTableReal<REAL>* stencilTable = _stencilTable.Get<REAL>();
int numNewStencils = conversionMatrix.GetNumRows();
int numNewElements = conversionMatrix.GetNumElements();
size_t numOldStencils = stencilTable->_sizes.size();
size_t numOldElements = stencilTable->_indices.size();
// Assign the sizes for the new stencils:
stencilTable->_sizes.resize(numOldStencils + numNewStencils);
int * newSizes = &stencilTable->_sizes[numOldStencils];
for (int i = 0; i < numNewStencils; ++i) {
newSizes[i] = conversionMatrix.GetRowSize(i);
}
// Assign remapped indices for the stencils:
stencilTable->_indices.resize(numOldElements + numNewElements);
int const * mtxIndices = &conversionMatrix.GetColumns()[0];
int * newIndices = &stencilTable->_indices[numOldElements];
for (int i = 0; i < numNewElements; ++i) {
newIndices[i] = sourcePoints[mtxIndices[i]] + sourcePointOffset;
}
// Copy the stencil weights direct from the matrix elements:
stencilTable->_weights.resize(numOldElements + numNewElements);
REAL const * mtxWeights = &conversionMatrix.GetElements()[0];
REAL * newWeights = &stencilTable->_weights[numOldElements];
std::memcpy(newWeights, mtxWeights, numNewElements * sizeof(REAL));
}
//
// Its unfortunate that varying stencils for local points were ever created
// and external dependency on them forces a certain coordination here. Each
// patch type is expected to have a varying value computed for each patch
// point and shaders retrieve the varying value associated with particular
// points. So we need to store that mapping from control point to varying
// point (or corner of the patch) somewhere. We are trying to avoid adding
// more to the PatchDescriptor interface, so we'll keep it here for now in
// the hope we may be able to eliminate the need for it.
//
namespace {
inline int const *
GetVaryingIndicesPerType(PatchDescriptor::Type type) {
// Note that we can use the linear and gregory vectors here for
// both quads and tris
static int const linearIndices[4] = { 0, 1, 2, 3 };
static int const bsplineIndices[] =
{ 0, 0, 1, 1, 0, 0, 1, 1, 3, 3, 2, 2, 3, 3, 2, 2 };
static int const boxsplineIndices[] =
{ 0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 2, 2 };
static int const gregoryIndices[] =
{ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
static int const gregoryTriIndices[] =
{ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 1, 2 };
if (type == PatchDescriptor::GREGORY_BASIS) {
return gregoryIndices;
} else if (type == PatchDescriptor::GREGORY_TRIANGLE) {
return gregoryTriIndices;
} else if (type == PatchDescriptor::REGULAR) {
return bsplineIndices;
} else if (type == PatchDescriptor::LOOP) {
return boxsplineIndices;
} else if (type == PatchDescriptor::QUADS) {
return linearIndices;
} else if (type == PatchDescriptor::TRIANGLES) {
return linearIndices;
}
return 0;
}
}
template <typename REAL>
void
PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil(
int const * varyingIndices, int patchPointIndex,
Index const sourcePoints[], int sourcePointOffset) {
Index varyingPoint =
sourcePoints[varyingIndices[patchPointIndex]] + sourcePointOffset;
StencilTableReal<REAL>* t = _stencilTableVarying.Get<REAL>();
t->_sizes.push_back(1);
t->_indices.push_back(varyingPoint);
t->_weights.push_back((REAL) 1.0);
}
namespace {
typedef short ShareBits;
static ShareBits const SHARE_CORNER = 0x10;
static ShareBits const SHARE_EDGE_BEGIN = 0x20;
static ShareBits const SHARE_EDGE_END = 0x40;
static ShareBits const SHARE_EDGE = SHARE_EDGE_BEGIN | SHARE_EDGE_END;
static ShareBits const SHARE_INDEX_MASK = 0x0f;
inline ShareBits const *
GetShareBitsPerType(PatchDescriptor::Type type) {
static ShareBits const linearQuadBits[5] = { 0x10, 0x11, 0x12, 0x13,
SHARE_CORNER };
static ShareBits const gregoryQuadBits[21] = { 0x10, 0x20, 0x43, 0, 0,
0x11, 0x21, 0x40, 0, 0,
0x12, 0x22, 0x41, 0, 0,
0x13, 0x23, 0x42, 0, 0,
SHARE_CORNER | SHARE_EDGE };
if (type == PatchDescriptor::QUADS) {
return linearQuadBits;
} else if (type == PatchDescriptor::GREGORY_BASIS) {
return gregoryQuadBits;
}
return 0;
}
}
template <typename REAL>
int
PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints(
int levelIndex, Index faceIndex,
SparseMatrix<REAL> const & matrix,
PatchDescriptor::Type patchType,
Index const sourcePoints[],
int sourcePointOffset,
Index patchPoints[]) {
//
// If sharing local points, verify the type of this patch supports
// sharing and disable it if not:
//
int numPatchPoints = matrix.GetNumRows();
int firstNewLocalPoint = _localPointOffset + _numLocalPoints;
int nextNewLocalPoint = firstNewLocalPoint;
ShareBits const* shareBitsPerPoint = _options.shareLocalPoints ?
GetShareBitsPerType(patchType) : 0;
bool shareLocalPointsForThisPatch = (shareBitsPerPoint != 0);
int const * varyingIndices = 0;
if (_stencilTableVarying) {
varyingIndices = GetVaryingIndicesPerType(patchType);
}
bool applyVertexStencils = (_stencilTable.Get<REAL>() != 0);
bool applyVaryingStencils = (varyingIndices != 0);
//
// When point-sharing is not enabled, all patch points are generally
// new local points -- the exception to this occurs when "re-using"
// source points, i.e. the resulting patch can be a mixture of source
// and local points (typically when the irregular patch type is the
// same as the regular patch type native to the scheme).
//
if (!shareLocalPointsForThisPatch) {
if (!_options.reuseSourcePoints) {
if (applyVertexStencils) {
appendLocalPointStencils(
matrix, sourcePoints, sourcePointOffset);
if (applyVaryingStencils) {
for (int i = 0; i < numPatchPoints; ++i) {
appendLocalPointVaryingStencil<REAL>(
varyingIndices, i, sourcePoints, sourcePointOffset);
}
}
}
for (int i = 0; i < numPatchPoints; ++i) {
patchPoints[i] = nextNewLocalPoint ++;
}
} else {
for (int i = 0; i < numPatchPoints; ++i) {
if (_options.reuseSourcePoints && (matrix.GetRowSize(i) == 1)) {
patchPoints[i] = sourcePoints[matrix.GetRowColumns(i)[0]]
+ sourcePointOffset;
continue;
}
if (applyVertexStencils) {
appendLocalPointStencil(
matrix, i, sourcePoints, sourcePointOffset);
if (applyVaryingStencils) {
appendLocalPointVaryingStencil<REAL>(
varyingIndices, i, sourcePoints, sourcePointOffset);
}
}
patchPoints[i] = nextNewLocalPoint ++;
}
}
} else {
// Gather topology info according to the sharing for this patch type
//
Level const & level = _refiner.getLevel(levelIndex);
ConstIndexArray fCorners;
ConstIndexArray fVerts;
ConstIndexArray fEdges;
bool fEdgeReversed[4];
bool fEdgeBoundary[4];
ShareBits const shareBitsForType = shareBitsPerPoint[numPatchPoints];
if (shareBitsForType) {
if (shareBitsForType & SHARE_CORNER) {
fCorners = (_fvarChannel < 0)
? level.getFaceVertices(faceIndex)
: level.getFaceFVarValues(faceIndex, _fvarChannel);
}
if (shareBitsForType & SHARE_EDGE) {
fEdges = level.getFaceEdges(faceIndex);
fVerts = (_fvarChannel < 0) ? fCorners
: level.getFaceVertices(faceIndex);
Level::ETag fEdgeTags[4];
level.getFaceETags(faceIndex, fEdgeTags, _fvarChannel);
for (int i = 0; i < fEdges.size(); ++i) {
fEdgeReversed[i] = level.getEdgeVertices(fEdges[i])[0] != fVerts[i];
fEdgeBoundary[i] = fEdgeTags[i]._boundary;
}
}
}
// Inspect the sharing bits for each point -- if set, see if a local
// point for the corresponding vertex/fvar-value or edge was
// previously used:
//
for (int i = 0; i < numPatchPoints; ++i) {
if (_options.reuseSourcePoints && (matrix.GetRowSize(i) == 1)) {
patchPoints[i] = sourcePoints[matrix.GetRowColumns(i)[0]]
+ sourcePointOffset;
continue;
}
int patchPoint = nextNewLocalPoint;
if (shareBitsPerPoint[i]) {
int index = shareBitsPerPoint[i] & SHARE_INDEX_MASK;
if (shareBitsPerPoint[i] & SHARE_CORNER) {
patchPoint = findSharedCornerPoint(
levelIndex, fCorners[index], nextNewLocalPoint);
} else if (!fEdgeBoundary[index]) {
int edgeEnd = (((shareBitsPerPoint[i] & SHARE_EDGE_END) > 0) !=
fEdgeReversed[index]);
patchPoint = findSharedEdgePoint(
levelIndex, fEdges[index], edgeEnd, nextNewLocalPoint);
}
}
if (patchPoint == nextNewLocalPoint) {
if (applyVertexStencils) {
appendLocalPointStencil(
matrix, i, sourcePoints, sourcePointOffset);
if (applyVaryingStencils) {
appendLocalPointVaryingStencil<REAL>(
varyingIndices, i, sourcePoints, sourcePointOffset);
}
}
nextNewLocalPoint ++;
}
patchPoints[i] = patchPoint;
}
}
int numNewLocalPoints = nextNewLocalPoint - firstNewLocalPoint;
_numLocalPoints += numNewLocalPoints;
return numNewLocalPoints;
}
//
// Member function definitions for the LegacyGregoryHelper class:
//
void
PatchTableBuilder::LegacyGregoryHelper::AddPatchFace(int level, Index face) {
if (_refiner.getLevel(level).getFaceCompositeVTag(face)._boundary) {
_boundaryFaceIndices.push_back(face);
} else {
_interiorFaceIndices.push_back(face);
}
}
void
PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(
PatchTable::QuadOffsetsTable & qTable) {
size_t numInteriorPatches = _interiorFaceIndices.size();
size_t numBoundaryPatches = _boundaryFaceIndices.size();
size_t numTotalPatches = numInteriorPatches + numBoundaryPatches;
struct QuadOffset {
static int Assign(Level const& level, Index faceIndex,
unsigned int offsets[]) {
ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
for (int i = 0; i < 4; ++i) {
ConstIndexArray vFaces = level.getVertexFaces(fVerts[i]);
int faceInVFaces = vFaces.FindIndex(faceIndex);
// we have to use number of incident edges to modulo the local
// index as there could be 2 consecutive edges in the face
// belonging to the patch
int vOffset0 = faceInVFaces;
int vOffset1 = (faceInVFaces + 1) %
level.getVertexEdges(fVerts[i]).size();
offsets[i] = vOffset0 | (vOffset1 << 8);
}
return 4;
}
};
if (numTotalPatches > 0) {
qTable.resize(numTotalPatches*4);
// all patches assumed to be at the last level
Level const &maxLevel = _refiner.getLevel(_refiner.GetMaxLevel());
PatchTable::QuadOffsetsTable::value_type *p = &(qTable[0]);
for (size_t i = 0; i < numInteriorPatches; ++i) {
p += QuadOffset::Assign(maxLevel, _interiorFaceIndices[i], p);
}
for (size_t i = 0; i < numBoundaryPatches; ++i) {
p += QuadOffset::Assign(maxLevel, _boundaryFaceIndices[i], p);
}
}
}
void
PatchTableBuilder::LegacyGregoryHelper::FinalizeVertexValence(
PatchTable::VertexValenceTable & vTable, int lastLevelOffset) {
// Populate the "vertex valence" table for Gregory patches -- this table
// contains the one-ring of vertices around each vertex. Currently it is
// extremely wasteful for the following reasons:
// - it allocates 2*maxvalence+1 for ALL vertices
// - it initializes the one-ring for ALL vertices
// We use the full size expected (not sure what else relies on that) but
// we avoid initializing the vast majority of vertices that are not
// associated with gregory patches -- only populating those in the last
// level (an older version attempted to avoid vertices not involved with
// Gregory patches)
//
int vWidth = 2*_refiner.GetMaxValence() + 1;
vTable.resize((long)_refiner.GetNumVerticesTotal() * vWidth);
Level const & lastLevel = _refiner.getLevel(_refiner.GetMaxLevel());
int * vTableEntry = &vTable[lastLevelOffset * vWidth];
for (int vIndex = 0; vIndex < lastLevel.getNumVertices(); ++vIndex) {
// Gather the one-ring around the vertex and set its resulting size
// (note negative size used to distinguish between boundary/interior):
//
int *ringDest = vTableEntry + 1;
int ringSize =
lastLevel.gatherQuadRegularRingAroundVertex(vIndex, ringDest);
for (int j = 0; j < ringSize; ++j) {
ringDest[j] += lastLevelOffset;
}
if (ringSize & 1) {
// boundary: duplicate end vertex index and store negative valence
ringSize++;
vTableEntry[ringSize]=vTableEntry[ringSize-1];
vTableEntry[0] = -ringSize/2;
} else {
vTableEntry[0] = ringSize/2;
}
vTableEntry += vWidth;
}
}
//
// The sole public PatchTableFactory method to create a PatchTable -- deferring
// to the PatchTableBuilder implementation
//
PatchTable *
PatchTableFactory::Create(TopologyRefiner const & refiner,
Options options,
ConstIndexArray selectedFaces) {
PatchTableBuilder builder(refiner, options, selectedFaces);
if (builder.UniformPolygonsSpecified()) {
builder.BuildUniformPolygons();
} else {
builder.BuildPatches();
}
return builder.GetPatchTable();
}
//
// Implementation of PatchTableFactory::PatchFaceTag -- unintentionally
// exposed to the public interface, no longer internally used and so
// planned for deprecation
//
void
PatchTableFactory::PatchFaceTag::clear() {
std::memset(this, 0, sizeof(*this));
}
void
PatchTableFactory::PatchFaceTag::assignTransitionPropertiesFromEdgeMask(
int tMask) {
_transitionMask = tMask;
}
void
PatchTableFactory::PatchFaceTag::assignBoundaryPropertiesFromEdgeMask(
int eMask) {
static int const edgeMaskToCount[16] =
{ 0, 1, 1, 2, 1, -1, 2, -1, 1, 2, -1, -1, 2, -1, -1, -1 };
static int const edgeMaskToIndex[16] =
{ -1, 0, 1, 1, 2, -1, 2, -1, 3, 0, -1, -1, 3, -1, -1,-1 };
assert(edgeMaskToCount[eMask] != -1);
assert(edgeMaskToIndex[eMask] != -1);
_boundaryMask = eMask;
_hasBoundaryEdge = (eMask > 0);
_boundaryCount = edgeMaskToCount[eMask];
_boundaryIndex = edgeMaskToIndex[eMask];
}
void
PatchTableFactory::PatchFaceTag::assignBoundaryPropertiesFromVertexMask(
int vMask) {
// This is only intended to support the case of a single boundary vertex
// with no boundary edges, which can only occur with an irregular vertex
static int const singleBitVertexMaskToCount[16] =
{ 0, 1, 1, -1, 1, -1 , -1, -1, 1, -1 , -1, -1, -1, -1 , -1, -1 };
static int const singleBitVertexMaskToIndex[16] =
{ 0, 0, 1, -1, 2, -1 , -1, -1, 3, -1 , -1, -1, -1, -1 , -1, -1 };
assert(_hasBoundaryEdge == false);
assert(singleBitVertexMaskToCount[vMask] != -1);
assert(singleBitVertexMaskToIndex[vMask] != -1);
_boundaryMask = vMask;
_boundaryCount = singleBitVertexMaskToCount[vMask];
_boundaryIndex = singleBitVertexMaskToIndex[vMask];
}
} // end namespace Far
} // end namespace OPENSUBDIV_VERSION
} // end namespace OpenSubdiv
| 33,966 |
511 | <gh_stars>100-1000
/****************************************************************************
* include/tinyara/bluetooth/bluetooth.h
*
* Copyright (C) 2018 <NAME>. All rights reserved.
* Author: <NAME> <<EMAIL>>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_TINYARA_BLUETOOTH_BLUETOOTH_H
#define __INCLUDE_TINYARA_BLUETOOTH_BLUETOOTH_H
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
#include <tinyara/config.h>
#include <stdio.h>
#include <tinyara/bluetooth/bt_hci.h>
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/** @def BT_ID_DEFAULT
*
* Convenience macro for specifying the default identity. This helps
* make the code more readable, especially when only one identity is
* supported.
*/
#define BT_ID_DEFAULT 0
/* BLUETOOTH_MAX_FRAMELEN
* Maximum amount of data that can fit in a buffer.
*
* The biggest foreseeable buffer size requirement right now comes from
* the Bluetooth 4.2 SMP MTU which is 65. This then become 65 + 4 (L2CAP
* header) + 4 (ACL header) + 1 (H4 header) = 74. This also covers the
* biggest HCI commands and events which are a bit under the 70 byte
* mark.
*/
#define BLUETOOTH_L2CAP_HDRLEN 4 /* Size of L2CAP header */
#define BLUETOOTH_ACL_HDRLEN 4 /* Size of ACL header */
#define BLUETOOTH_H4_HDRLEN 1 /* Size of H4 header */
#define BLUETOOTH_MAX_HDRLEN \
(BLUETOOTH_L2CAP_HDRLEN + BLUETOOTH_ACL_HDRLEN + BLUETOOTH_H4_HDRLEN)
#define BLUETOOTH_SMP_MTU 65
#define BLUETOOTH_MAX_MTU 70
#define BLUETOOTH_MAX_FRAMELEN (BLUETOOTH_MAX_MTU + BLUETOOTH_MAX_HDRLEN)
#define BLUETOOTH_ADDRSIZE 6
#define BLUETOOTH_ADDRCOPY(d, s) memcpy((d), (s), BLUETOOTH_ADDRSIZE)
#define BLUETOOTH_ADDRCMP(a, b) (memcmp((a), (b), BLUETOOTH_ADDRSIZE) == 0)
/****************************************************************************
* Public Types
****************************************************************************/
/* This is the form of the meta-data that accompanies frames received from
* the Bluetooth stack.
*/
struct bluetooth_frame_meta_s {
bt_addr_t bm_raddr; /* Connected remote address */
uint8_t bm_channel; /* Connection channel */
};
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/****************************************************************************
* Name: bluetooth_input
*
* Description:
* Handle incoming Bluetooth input
*
* This function is called when the radio device driver has received an
* frame from the network. The frame from the device driver must be
* provided in by the IOB frame argument of the function call:
*
* - The frame data is in the IOB io_data[] buffer,
* - The length of the frame is in the IOB io_len field, and
* - The offset past and radio MAC header is provided in the io_offset
* field.
*
* The frame argument may refer to a single frame (a list of length one)
* or may it be the head of a list of multiple frames.
*
* - The io_flink field points to the next frame in the list (if enable)
* - The last frame in the list will have io_flink == NULL.
*
* Input Parameters:
* radio The radio network driver interface.
* framelist - The head of an incoming list of frames. Normally this
* would be a single frame. A list may be provided if
* appropriate, however.
* meta - Meta data characterizing the received frame.
*
* If there are multiple frames in the list, this metadata
* must apply to all of the frames in the list.
*
* Returned Value:
* OK The Bluetooth has been processed and can be deleted
* ERROR Hold the Bluetooth and try again later. There is a listening
* socket but no recv in place to catch the Bluetooth yet.
* Useful when a packet arrives before a recv call is in place.
*
* Assumptions:
* Called from the network diver with the network locked.
*
****************************************************************************/
struct radio_driver_s; /* Forward reference */
struct bluetooth_data_ind_s; /* Forward reference */
struct iob_s; /* Forward reference */
int bluetooth_input(FAR struct radio_driver_s *radio, FAR struct iob_s *framelist, FAR struct bluetooth_frame_meta_s *meta);
/** Advertising options */
enum {
/** Convenience value when no options are specified. */
BT_LE_ADV_OPT_NONE = 0,
/** Advertise as connectable. Type of advertising is determined by
* providing SCAN_RSP data and/or enabling local privacy support.
*/
BT_LE_ADV_OPT_CONNECTABLE = BIT(0),
/** Don't try to resume connectable advertising after a connection.
* This option is only meaningful when used together with
* BT_LE_ADV_OPT_CONNECTABLE. If set the advertising will be stopped
* when bt_le_adv_stop() is called or when an incoming (slave)
* connection happens. If this option is not set the stack will
* take care of keeping advertising enabled even as connections
* occur.
*/
BT_LE_ADV_OPT_ONE_TIME = BIT(1),
/** Advertise using the identity address as the own address.
* @warning This will compromise the privacy of the device, so care
* must be taken when using this option.
*/
BT_LE_ADV_OPT_USE_IDENTITY = BIT(2),
/* Advertise using GAP device name */
BT_LE_ADV_OPT_USE_NAME = BIT(3),
/** Use low duty directed advertising mode, otherwise high duty mode
* will be used. This option is only effective when used with
* bt_conn_create_slave_le().
*/
BT_LE_ADV_OPT_DIR_MODE_LOW_DUTY = BIT(4),
/** Enable use of Resolvable Private Address (RPA) as the target address
* in directed advertisements when CONFIG_BT_PRIVACY is not enabled.
* This is required if the remote device is privacy-enabled and
* supports address resolution of the target address in directed
* advertisement.
* It is the responsibility of the application to check that the remote
* device supports address resolution of directed advertisements by
* reading its Central Address Resolution characteristic.
*/
BT_LE_ADV_OPT_DIR_ADDR_RPA = BIT(5),
};
/** Description of different data types that can be encoded into
* advertising data. Used to form arrays that are passed to the
* bt_le_adv_start() function.
*/
struct bt_data {
uint8_t type;
uint8_t data_len;
const uint8_t *data;
};
/** LE Advertising Parameters. */
struct bt_le_adv_param {
/** Local identity */
uint8_t id;
/** Bit-field of advertising options */
uint8_t options;
/** Minimum Advertising Interval (N * 0.625) */
uint16_t interval_min;
/** Maximum Advertising Interval (N * 0.625) */
uint16_t interval_max;
};
/** LE scan parameters */
struct bt_le_scan_param {
/** Scan type (BT_HCI_LE_SCAN_ACTIVE or BT_HCI_LE_SCAN_PASSIVE) */
uint8_t type;
/** Duplicate filtering (BT_HCI_LE_SCAN_FILTER_DUP_ENABLE or
* BT_HCI_LE_SCAN_FILTER_DUP_DISABLE)
*/
uint8_t filter_dup;
/** Scan interval (N * 0.625 ms) */
uint16_t interval;
/** Scan window (N * 0.625 ms) */
uint16_t window;
};
/** @brief Helper to declare elements of bt_data arrays
*
* This macro is mainly for creating an array of struct bt_data
* elements which is then passed to bt_le_adv_start().
*
* @param _type Type of advertising data field
* @param _data Pointer to the data field payload
* @param _data_len Number of bytes behind the _data pointer
*/
#define BT_DATA(_type, _data, _data_len) \
{ \
.type = (_type), \
.data_len = (_data_len), \
.data = (const unsigned char *)(_data), \
}
/** OOB data that is specific for LE SC pairing method. */
struct bt_le_oob_sc_data {
/** Random Number. */
uint8_t r[16];
/** Confirm Value. */
uint8_t c[16];
};
/** General OOB data. */
struct bt_le_oob {
/** LE address. If local privacy is enabled this is Resolvable Private
* Address.
*/
bt_addr_le_t addr;
/** OOB data that are relevant for LESC pairing. */
struct bt_le_oob_sc_data le_sc_data;
};
/** @brief BR/EDR discovery result structure */
struct bt_br_discovery_result {
/** private */
uint8_t _priv[4];
/** Remote device address */
bt_addr_t addr;
/** RSSI from inquiry */
int8_t rssi;
/** Class of Device */
uint8_t cod[3];
/** Extended Inquiry Response */
uint8_t eir[240];
};
/** BR/EDR discovery parameters */
struct bt_br_discovery_param {
/** Maximum length of the discovery in units of 1.28 seconds.
* Valid range is 0x01 - 0x30.
*/
uint8_t length;
/** True if limited discovery procedure is to be used. */
bool limited;
};
struct bt_br_oob {
/** BR/EDR address. */
bt_addr_t addr;
};
/** Information about a bond with a remote device. */
struct bt_bond_info {
/** Address of the remote device. */
bt_addr_le_t addr;
};
/**
* @brief Simple network buffer representation.
*
* This is a simpler variant of the net_buf object (in fact net_buf uses
* net_buf_simple internally). It doesn't provide any kind of reference
* counting, user data, dynamic allocation, or in general the ability to
* pass through kernel objects such as FIFOs.
*
* The main use of this is for scenarios where the meta-data of the normal
* net_buf isn't needed and causes too much overhead. This could be e.g.
* when the buffer only needs to be allocated on the stack or when the
* access to and lifetime of the buffer is well controlled and constrained.
*/
struct net_buf_simple {
/** Pointer to the start of data in the buffer. */
uint8_t *data;
/** Length of the data behind the data pointer. */
uint8_t len;
/** Amount of data that this buffer can store. */
uint16_t size;
/** Start of the data storage. Not to be accessed directly
* (the data pointer should be used instead).
*/
uint8_t *__buf;
};
/**
* @typedef bt_ready_cb_t
* @brief Callback for notifying that Bluetooth has been enabled.
*
* @param err zero on success or (negative) error code otherwise.
*/
typedef void (*bt_ready_cb_t)(int err);
/** @brief Enable Bluetooth
*
* Enable Bluetooth. Must be the called before any calls that
* require communication with the local Bluetooth hardware.
*
* @param cb Callback to notify completion or NULL to perform the
* enabling synchronously.
*
* @return Zero on success or (negative) error code otherwise.
*/
int bt_enable(bt_ready_cb_t cb);
/** @brief Set Bluetooth Device Name
*
* Set Bluetooth GAP Device Name.
*
* @param name New name
*
* @return Zero on success or (negative) error code otherwise.
*/
int bt_set_name(const char *name);
/** @brief Get Bluetooth Device Name
*
* Get Bluetooth GAP Device Name.
*
* @return Bluetooth Device Name
*/
const char *bt_get_name(void);
/** @brief Set the local Identity Address
*
* Allows setting the local Identity Address from the application.
* This API must be called before calling bt_enable(). Calling it at any
* other time will cause it to fail. In most cases the application doesn't
* need to use this API, however there are a few valid cases where
* it can be useful (such as for testing).
*
* At the moment, the given address must be a static random address. In the
* future support for public addresses may be added.
*
* @return Zero on success or (negative) error code otherwise.
*/
int bt_set_id_addr(const bt_addr_le_t *addr);
/** @brief Get the currently configured identities.
*
* Returns an array of the currently configured identity addresses. To
* make sure all available identities can be retrieved, the number of
* elements in the @a addrs array should be CONFIG_BT_ID_MAX. The identity
* identifier that some APIs expect (such as advertising parameters) is
* simply the index of the identity in the @a addrs array.
*
* Note: Deleted identities may show up as BT_LE_ADDR_ANY in the returned
* array.
*
* @param addrs Array where to store the configured identities.
* @param count Should be initialized to the array size. Once the function
* returns it will contain the number of returned identities.
*/
void bt_id_get(bt_addr_le_t *addrs, size_t *count);
/** @brief Create a new identity.
*
* Create a new identity using the given address and IRK. This function
* can be called before calling bt_enable(), in which case it can be used
* to override the controller's public address (in case it has one). However,
* the new identity will only be stored persistently in flash when this API
* is used after bt_enable(). The reason is that the persistent settings
* are loaded after bt_enable() and would therefore cause potential conflicts
* with the stack blindly overwriting what's stored in flash. The identity
* will also not be written to flash in case a pre-defined address is
* provided, since in such a situation the app clearly has some place it got
* the address from and will be able to repeat the procedure on every power
* cycle, i.e. it would be redundant to also store the information in flash.
*
* If the application wants to have the stack randomly generate identities
* and store them in flash for later recovery, the way to do it would be
* to first initialize the stack (using bt_enable), then call settings_load(),
* and after that check with bt_id_get() how many identities were recovered.
* If an insufficient amount of identities were recovered the app may then
* call bt_id_create() to create new ones.
*
* @param addr Address to use for the new identity. If NULL or initialized
* to BT_ADDR_LE_ANY the stack will generate a new static
* random address for the identity and copy it to the given
* parameter upon return from this function (in case the
* parameter was non-NULL).
* @param irk Identity Resolving Key (16 bytes) to be used with this
* identity. If set to all zeroes or NULL, the stack will
* generate a random IRK for the identity and copy it back
* to the parameter upon return from this function (in case
* the parameter was non-NULL). If privacy support
* (CONFIG_BT_PRIVACY) is not enabled this parameter must
* be NULL.
*
* @return Identity identifier (>= 0) in case of success, or a negative
* error code on failure.
*/
int bt_id_create(bt_addr_le_t *addr, uint8_t *irk);
/** @brief Reset/reclaim an identity for reuse.
*
* The semantics of the @a addr and @a irk parameters of this function
* are the same as with bt_id_create(). The difference is the first
* @a id parameter that needs to be an existing identity (if it doesn't
* exist this function will return an error). When given an existing
* identity this function will disconnect any connections created using it,
* remove any pairing keys or other data associated with it, and then create
* a new identity in the same slot, based on the @a addr and @a irk
* parameters.
*
* Note: the default identity (BT_ID_DEFAULT) cannot be reset, i.e. this
* API will return an error if asked to do that.
*
* @param id Existing identity identifier.
* @param addr Address to use for the new identity. If NULL or initialized
* to BT_ADDR_LE_ANY the stack will generate a new static
* random address for the identity and copy it to the given
* parameter upon return from this function (in case the
* parameter was non-NULL).
* @param irk Identity Resolving Key (16 bytes) to be used with this
* identity. If set to all zeroes or NULL, the stack will
* generate a random IRK for the identity and copy it back
* to the parameter upon return from this function (in case
* the parameter was non-NULL). If privacy support
* (CONFIG_BT_PRIVACY) is not enabled this parameter must
* be NULL.
*
* @return Identity identifier (>= 0) in case of success, or a negative
* error code on failure.
*/
int bt_id_reset(uint8_t id, bt_addr_le_t *addr, uint8_t *irk);
/** @brief Delete an identity.
*
* When given a valid identity this function will disconnect any connections
* created using it, remove any pairing keys or other data associated with
* it, and then flag is as deleted, so that it can not be used for any
* operations. To take back into use the slot the identity was occupying the
* bt_id_reset() API needs to be used.
*
* Note: the default identity (BT_ID_DEFAULT) cannot be deleted, i.e. this
* API will return an error if asked to do that.
*
* @param id Existing identity identifier.
*
* @return 0 in case of success, or a negative error code on failure.
*/
int bt_id_delete(uint8_t id);
/* Advertising API */
/** @brief Start advertising
*
* Set advertisement data, scan response data, advertisement parameters
* and start advertising.
*
* @param param Advertising parameters.
* @param ad Data to be used in advertisement packets.
* @param ad_len Number of elements in ad
* @param sd Data to be used in scan response packets.
* @param sd_len Number of elements in sd
*
* @return Zero on success or (negative) error code otherwise.
* @return -ECONNREFUSED When connectable advertising is requested and there
* is already maximum number of connections established.
* This error code is only guaranteed when using Zephyr
* controller, for other controllers code returned in
* this case may be -EIO.
*/
int bt_le_adv_start(const struct bt_le_adv_param *param, const struct bt_data *ad, size_t ad_len, const struct bt_data *sd, size_t sd_len);
/** @brief Update advertising
*
* Update advertisement and scan response data.
*
* @param ad Data to be used in advertisement packets.
* @param ad_len Number of elements in ad
* @param sd Data to be used in scan response packets.
* @param sd_len Number of elements in sd
*
* @return Zero on success or (negative) error code otherwise.
*/
int bt_le_adv_update_data(const struct bt_data *ad, size_t ad_len, const struct bt_data *sd, size_t sd_len);
/** @brief Stop advertising
*
* Stops ongoing advertising.
*
* @return Zero on success or (negative) error code otherwise.
*/
int bt_le_adv_stop(void);
/** @typedef bt_le_scan_cb_t
* @brief Callback type for reporting LE scan results.
*
* A function of this type is given to the bt_le_scan_start() function
* and will be called for any discovered LE device.
*
* @param addr Advertiser LE address and type.
* @param rssi Strength of advertiser signal.
* @param adv_type Type of advertising response from advertiser.
* @param buf Buffer containing advertiser data.
*/
typedef void bt_le_scan_cb_t(const bt_addr_le_t *addr, int8_t rssi, uint8_t adv_type, struct net_buf_simple *buf);
/** @brief Start (LE) scanning
*
* Start LE scanning with given parameters and provide results through
* the specified callback.
*
* @param param Scan parameters.
* @param cb Callback to notify scan results.
*
* @return Zero on success or error code otherwise, positive in case
* of protocol error or negative (POSIX) in case of stack internal error
*/
int bt_le_scan_start(const struct bt_le_scan_param *param, bt_le_scan_cb_t cb);
/** @brief Stop (LE) scanning.
*
* Stops ongoing LE scanning.
*
* @return Zero on success or error code otherwise, positive in case
* of protocol error or negative (POSIX) in case of stack internal error
*/
int bt_le_scan_stop(void);
/** @brief Set (LE) channel map.
*
* @param chan_map Channel map.
*
* @return Zero on success or error code otherwise, positive in case
* of protocol error or negative (POSIX) in case of stack internal error
*/
int bt_le_set_chan_map(uint8_t chan_map[5]);
/** @brief Helper for parsing advertising (or EIR or OOB) data.
*
* A helper for parsing the basic data types used for Extended Inquiry
* Response (EIR), Advertising Data (AD), and OOB data blocks. The most
* common scenario is to call this helper on the advertising data
* received in the callback that was given to bt_le_scan_start().
*
* @param ad Advertising data as given to the bt_le_scan_cb_t callback.
* @param func Callback function which will be called for each element
* that's found in the data. The callback should return
* true to continue parsing, or false to stop parsing.
* @param user_data User data to be passed to the callback.
*/
void bt_data_parse(struct net_buf_simple *ad, bool(*func)(struct bt_data *data, void *user_data), void *user_data);
/**
* @brief Get LE local Out Of Band information
*
* This function allows to get local information that are useful for Out Of Band
* pairing or connection creation process.
*
* If privacy is enabled this will result in generating new Resolvable Private
* Address that is valid for CONFIG_BT_RPA_TIMEOUT seconds. This address
* will be used for advertising, active scanning and connection creation.
*
* @param id Local identity, in most cases BT_ID_DEFAULT.
* @param oob LE related information
*
* @return Zero on success or error code otherwise, positive in case
* of protocol error or negative (POSIX) in case of stack internal error
*/
int bt_le_oob_get_local(uint8_t id, struct bt_le_oob *oob);
/** @typedef bt_br_discovery_cb_t
* @brief Callback type for reporting BR/EDR discovery (inquiry)
* results.
*
* A callback of this type is given to the bt_br_discovery_start()
* function and will be called at the end of the discovery with
* information about found devices populated in the results array.
*
* @param results Storage used for discovery results
* @param count Number of valid discovery results.
*/
typedef void bt_br_discovery_cb_t(struct bt_br_discovery_result *results, size_t count);
/** @brief Start BR/EDR discovery
*
* Start BR/EDR discovery (inquiry) and provide results through the specified
* callback. When bt_br_discovery_cb_t is called it indicates that discovery
* has completed. If more inquiry results were received during session than
* fits in provided result storage, only ones with highest RSSI will be
* reported.
*
* @param param Discovery parameters.
* @param results Storage for discovery results.
* @param count Number of results in storage. Valid range: 1-255.
* @param cb Callback to notify discovery results.
*
* @return Zero on success or error code otherwise, positive in case
* of protocol error or negative (POSIX) in case of stack internal error
*/
int bt_br_discovery_start(const struct bt_br_discovery_param *param, struct bt_br_discovery_result *results, size_t count, bt_br_discovery_cb_t cb);
/** @brief Stop BR/EDR discovery.
*
* Stops ongoing BR/EDR discovery. If discovery was stopped by this call
* results won't be reported
*
* @return Zero on success or error code otherwise, positive in case
* of protocol error or negative (POSIX) in case of stack internal error
*/
int bt_br_discovery_stop(void);
/**
* @brief Get BR/EDR local Out Of Band information
*
* This function allows to get local controller information that are useful
* for Out Of Band pairing or connection creation process.
*
* @param oob Out Of Band information
*/
int bt_br_oob_get_local(struct bt_br_oob *oob);
/** @brief Enable/disable set controller in discoverable state.
*
* Allows make local controller to listen on INQUIRY SCAN channel and responds
* to devices making general inquiry. To enable this state it's mandatory
* to first be in connectable state.
*
* @param enable Value allowing/disallowing controller to become discoverable.
*
* @return Negative if fail set to requested state or requested state has been
* already set. Zero if done successfully.
*/
int bt_br_set_discoverable(bool enable);
/** @brief Enable/disable set controller in connectable state.
*
* Allows make local controller to be connectable. It means the controller
* start listen to devices requests on PAGE SCAN channel. If disabled also
* resets discoverability if was set.
*
* @param enable Value allowing/disallowing controller to be connectable.
*
* @return Negative if fail set to requested state or requested state has been
* already set. Zero if done successfully.
*/
int bt_br_set_connectable(bool enable);
/** Clear pairing information.
*
* @param id Local identity (mostly just BT_ID_DEFAULT).
* @param addr Remote address, NULL or BT_ADDR_LE_ANY to clear all remote
* devices.
*
* @return 0 on success or negative error value on failure.
*/
int bt_unpair(uint8_t id, const bt_addr_le_t *addr);
/** Iterate through all existing bonds.
*
* @param id Local identity (mostly just BT_ID_DEFAULT).
* @param func Function to call for each bond.
* @param user_data Data to pass to the callback function.
*/
void bt_foreach_bond(uint8_t id, void (*func)(const struct bt_bond_info *info, void *user_data), void *user_data);
#endif /* __INCLUDE_TINYARA_BLUETOOTH_BLUETOOTH_H */
| 8,277 |
2,151 | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_GPU_FAKE_COMMAND_BUFFER_HELPER_H_
#define MEDIA_GPU_FAKE_COMMAND_BUFFER_HELPER_H_
#include <map>
#include <set>
#include "base/macros.h"
#include "base/memory/scoped_refptr.h"
#include "base/single_thread_task_runner.h"
#include "media/gpu/command_buffer_helper.h"
namespace media {
class FakeCommandBufferHelper : public CommandBufferHelper {
public:
explicit FakeCommandBufferHelper(
scoped_refptr<base::SingleThreadTaskRunner> task_runner);
// Signal stub destruction. All textures will be deleted. Listeners will
// be notified that we have a current context unless one calls ContextLost
// before this.
void StubLost();
// Signal context loss. MakeContextCurrent() fails after this.
void ContextLost();
// Signal that the context is no longer current.
void CurrentContextLost();
// Complete a pending SyncToken wait.
void ReleaseSyncToken(gpu::SyncToken sync_token);
// Test whether a texture exists (has not been destroyed).
bool HasTexture(GLuint service_id);
// CommandBufferHelper implementation.
gl::GLContext* GetGLContext() override;
bool MakeContextCurrent() override;
bool IsContextCurrent() const override;
GLuint CreateTexture(GLenum target,
GLenum internal_format,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type) override;
void DestroyTexture(GLuint service_id) override;
void SetCleared(GLuint service_id) override;
bool BindImage(GLuint service_id,
gl::GLImage* image,
bool can_bind_to_sampler) override;
gpu::Mailbox CreateMailbox(GLuint service_id) override;
void WaitForSyncToken(gpu::SyncToken sync_token,
base::OnceClosure done_cb) override;
void SetWillDestroyStubCB(WillDestroyStubCB will_destroy_stub_cb) override;
private:
~FakeCommandBufferHelper() override;
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
bool has_stub_ = true;
bool is_context_lost_ = false;
bool is_context_current_ = false;
GLuint next_service_id_ = 1;
std::set<GLuint> service_ids_;
std::map<gpu::SyncToken, base::OnceClosure> waits_;
WillDestroyStubCB will_destroy_stub_cb_;
DISALLOW_COPY_AND_ASSIGN(FakeCommandBufferHelper);
};
} // namespace media
#endif // MEDIA_GPU_FAKE_COMMAND_BUFFER_HELPER_H_
| 923 |
363 | /* Copyright 2015 predic8 GmbH, www.predic8.com
Licensed 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
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
package com.predic8.membrane.core.cloud;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ExponentialBackoff {
private static final Logger LOG = LoggerFactory.getLogger(ExponentialBackoff.class);
public interface Job {
boolean run() throws Exception;
}
public static void retryAfter(long initialDelay, long maxDelay, double factor, String jobDescription, Job job)
throws InterruptedException {
long delay = initialDelay;
while (true) {
Exception f = null;
try {
if (job.run())
break;
} catch (InterruptedException e) {
throw e;
} catch (Exception e) {
f = e;
}
if (f != null)
LOG.error(jobDescription + " failed. Retrying in " + (delay / 1000) + "s.", f);
else
LOG.info(jobDescription + " failed. Retrying in " + (delay / 1000) + "s.");
Thread.sleep(delay);
delay = Math.min(maxDelay, (long) (delay * factor));
}
LOG.debug(jobDescription + " succeeded.");
}
}
| 578 |
470 | #ifndef _QWEATHER_H
#define _QWEATHER_H
#include <Arduino.h>
#include <Vector>
#include <ArduinoJson.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <WiFiClientSecure.h>
#include <string>
using namespace std;
/**
* @brief 按小时预测天气。。。和按天预测一样，请求越多需求内存越高
*
*/
enum HourlyPredictionType
{
/**
* @brief 1天的
*
*/
H24 = 24,
/**
* @brief 3天的
*
*/
H72 = 72,
/**
* @brief 7天的
*
*/
H128 = 128
};
/**
* @brief 按天获取预报的类型，同时请求的数据越多，对于处理数据的内存也越高。。。所以，能少请求就少请求
*
*/
enum DailyPredictionType
{
/**
* @brief 3天
*
*/
D3 = 3,
/**
* @brief 7天
*
*/
D7 = 7,
/**
* @brief 10天
*
*/
D10 = 10, //6144
/**
* @brief 15天
*
*/
D15 = 15
};
/**
* @brief 度量单位
*
*/
enum UnitType
{
/**
* @brief 公制
*
*/
METRIC,
/**
* @brief 英制
*
*/
IMPERIAL
};
/**
* @brief API类型
*
*/
enum APIVersion
{
/**
* @brief 商业版本
*
*/
COMMERCIAL,
/**
* @brief 开发版本
*
*/
DEV
};
/**
* @brief 基本天气信息
*
*/
struct BasicWeatherData
{
/**
* @brief 天气状况图标
*
*/
String icon;
/**
* @brief 天气状况文字描述
*
*/
String text;
};
/**
* @brief 风力数据
*
*/
struct WindData{
/**
* @brief 风向360角度
*
*/
String wind360;
/**
* @brief 风向
*
*/
String windDir;
/**
* @brief 风力等级
*
*/
String windScale;
/**
* @brief 风速
*
*/
String windSpeed;
};
/**
* @brief 扩展天气数据
*
*/
struct ExtendedWeatherData
{
/**
* @brief 相对湿度
*
*/
String humidity;
/**
* @brief 降水量
*
*/
String precip;
/**
* @brief 大气压强
*
*/
String pressure;
/**
* @brief 能见度
*
*/
String vis;
/**
* @brief 云量
*
*/
String cloud;
/**
* @brief 实况露点温度
*
*/
String dew;
/**
* @brief 紫外线强度
*
*/
String uvIndex;
};
/**
* @brief 按日请求时每天的综合数据组合
*
*/
struct DailyCommonData: BasicWeatherData, WindData
{
};
/**
* @brief 按小时预报的天气情况
*
*/
struct HourlyWeather: BasicWeatherData,WindData,ExtendedWeatherData
{
/**
* @brief 预报时间
*
*/
String fxTime;
/**
* @brief 温度
*
*/
String temp;
/**
* @brief 降水概率
*
*/
String pop;
};
/**
* @brief 当前天气
*
*/
struct CurrentWeather : BasicWeatherData, ExtendedWeatherData, WindData
{
/**
* @brief 实况观测时间
*
*/
String obsTime;
/**
* @brief 温度
*
*/
String temp;
/**
* @brief 体感温度
*
*/
String feelsLike;
};
/**
* @brief 按天预报的气象数据
*
*/
struct DailyWeather: ExtendedWeatherData
{
/**
* @brief 预报时间
*
*/
String fxDate;
/**
* @brief 日出时间
*
*/
String sunrise;
/**
* @brief 日落时间
*
*/
String sunset;
/**
* @brief 月升时间
*
*/
String moonrise;
/**
* @brief 月落时间
*
*/
String moonset;
/**
* @brief 月相名称
*
*/
String moonPhase;
/**
* @brief 当天最高温度
*
*/
String tempMax;
/**
* @brief 当天最低温度
*
*/
String tempMin;
/**
* @brief 白天的天气数据
*
*/
DailyCommonData Day;
/**
* @brief 晚上的天气数据
*
*/
DailyCommonData Night;
};
/**
* @brief 和风天气API中位置信息
*
*/
struct GeoInfo
{
/**
* @brief 地区/城市名称
*
*/
String name;
/**
* @brief 地区/城市ID
*
*/
String id;
/**
* @brief 地区/城市维度
*
*/
String lat;
/**
* @brief 地区/城市经度
*
*/
String lon;
/**
* @brief 该地区/城市的上级行政区划名称
*
*/
String adm2;
/**
* @brief 该地区/城市所属一级行政区域
*
*/
String adm1;
/**
* @brief 该地区/城市所属国家名称
*
*/
String country;
/**
* @brief 时区
*
*/
String tz;
/**
* @brief UTC时区偏移
*
*/
String utcOffset;
/**
* @brief 当时是否处于夏令时
*
*/
String isDst;
/**
* @brief 属性
*
*/
String type;
/**
* @brief 评分
*
*/
String rank;
/**
* @brief 天气预报链接
*
*/
String fxLink;
};
/**
* @brief 空气质量基础数据
*
*/
struct AirQualityData
{
/**
* @brief 空气质量发布时间
*
*/
String pubTime;
/**
* @brief 空气质量指数
*
*/
String aqi;
/**
* @brief 空气质量等级
*
*/
String level;
/**
* @brief 空气质量级别
*
*/
String category;
/**
* @brief 主要污染物
*
*/
String primary;
/**
* @brief PM10
*
*/
String pm10;
/**
* @brief PM2.5
*
*/
String pm2p5;
/**
* @brief 二氧化碳
*
*/
String no2;
/**
* @brief 二氧化硫
*
*/
String so2;
/**
* @brief 一氧化碳
*
*/
String co;
/**
* @brief 臭氧
*
*/
String o3;
};
/**
* @brief 空气质量监测站数据
*
*/
struct AirStationData : AirQualityData
{
/**
* @brief 站点名称
*
*/
String name;
/**
* @brief 站点ID
*
*/
String id;
};
/**
* @brief 当前空气质量
*
*/
struct CurrentAirQuality: AirQualityData
{
/**
* @brief 当前城市各个空气监测站数据
*
*/
vector<AirStationData> Stations;
};
/**
* @brief 和风天气API
*
*/
class QWeather
{
private:
String _key;
String _lang;
UnitType _unitType;
String GetLanguage();
APIVersion _apiVersion;
public:
/**
* @brief Set the User Key
*
* @param key User key
*/
void SetUserKey(String key);
/**
* @brief Set the content Language
*
* @param l 语言，参见 https://dev.qweather.com/docs/start/language
*/
void SetLanguage(String l);
/**
* @brief 设置API版本
*
* @param apiVersion
*/
void SetAPIVersion(APIVersion apiVersion);
/**
* @brief 设置度量单位
*
* @param unitType 度量单位
*/
void SetUnitType(UnitType unitType);
/**
* @brief 按照查询条件返回可能的城市信息列表
*
* @param location 输入需要查询的城市名称，可使用Location ID、多语言文字、以逗号分隔的经度/纬度坐标、ADCode（仅限中国城市）。例如location=beijing， location=116.4,39.1
* @param adm 城市所属行政区划，只支持多语言文字，默认不限定行政区划。 可设定只在某个行政区划范围内进行搜索，用于出现重名城市或需要对结果进行过滤的时候使用。例如adm=beijing
* @param range 搜索范围，默认搜索全球城市。 可设定只在某个国家范围内进行搜索，国家名称需使用ISO 3166 所定义的国家代码。例如 range=us 或者 range=world 查询全球
* @param maxNumber 返回城市的数量，取值范围1-20，默认返回10个结果。
* @return vector<GeoInfo>
*/
vector<GeoInfo> GetGeoInfoList(String location, String adm = "", String range = "cn", uint8_t maxNumber = 10);
/**
* @brief 按照查询条件返回最有可能的一个城市
*
* @param location 输入需要查询的城市名称，可使用Location ID、多语言文字、以逗号分隔的经度/纬度坐标、ADCode（仅限中国城市）。例如location=beijing， location=116.4,39.1
* @param adm 城市所属行政区划，只支持多语言文字，默认不限定行政区划。 可设定只在某个行政区划范围内进行搜索，用于出现重名城市或需要对结果进行过滤的时候使用。例如adm=beijing
* @param range 搜索范围，默认搜索全球城市。 可设定只在某个国家范围内进行搜索，国家名称需使用ISO 3166 所定义的国家代码。例如 range=us 或者 range=world 查询全球
* @return GeoInfo
*/
GeoInfo GetGeoInfo(String location, String adm = "", String range = "cn");
/**
* @brief 获取指定地区当前天气情况
*
* @param location 需要查询地区的LocationID或以逗号分隔的经度/纬度坐标（十进制），LocationID可通过GetGeoInfo获取。例如： location=101010100 或 location=116.41,39.92
* @return CurrentWeather
*/
CurrentWeather GetCurrentWeather(String location);
/**
* @brief 获取几天的天气预测
*
* @param location 需要查询地区的LocationID或以逗号分隔的经度/纬度坐标（十进制），LocationID可通过GetGeoInfo获取。例如： location=101010100 或 location=116.41,39.92
* @param dailyPredictionType 按天查询的类型
* @return vector<DailyWeather>
*/
vector<DailyWeather> GetDailyWeather(String location, DailyPredictionType dailyPredictionType = DailyPredictionType::D7);
/**
* @brief 按小时获取天气预测
*
* @param location 需要查询地区的LocationID或以逗号分隔的经度/纬度坐标（十进制），LocationID可通过GetGeoInfo获取。例如： location=101010100 或 location=116.41,39.92
* @param hourlyPredictionType 按小时查询的类型
* @return vector<HourlyWeather>
*/
vector<HourlyWeather> GetHourlyWeather(String location, HourlyPredictionType hourlyPredictionType = HourlyPredictionType::H24);
/**
* @brief 获取当前空气质量
*
* @param location 需要查询地区的LocationID或以逗号分隔的经度/纬度坐标（十进制），LocationID可通过GetGeoInfo获取。例如： location=101010100 或 location=116.41,39.92
* @return CurrentAirQuality
*/
CurrentAirQuality GetCurrentAirQuality(String location);
/**
* @brief 配置和风API参数
*
* @param key User key
* @param l Language, Refer to: https://dev.qweather.com/docs/start/language
* @param unitType 度量单位
* @param apiVersion API请求类型
*/
void Config(String key, String l = "zh", UnitType unitType = UnitType::METRIC, APIVersion apiVersion = APIVersion::DEV);
};
#endif | 6,452 |
679 | /**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#ifndef _VCLCANVAS_CANVASHELPER_HXX_
#define _VCLCANVAS_CANVASHELPER_HXX_
#include <com/sun/star/rendering/XCanvas.hpp>
#include <com/sun/star/rendering/XIntegerBitmap.hpp>
#include <vcl/outdev.hxx>
#include <canvas/vclwrapper.hxx>
#include "cachedbitmap.hxx"
#include "outdevprovider.hxx"
#include <boost/utility.hpp>
namespace vclcanvas
{
class SpriteCanvas;
/** Helper class for basic canvas functionality. Also offers
optional backbuffer painting, when providing it with a second
OutputDevice to render into.
*/
class CanvasHelper : private ::boost::noncopyable
{
public:
/** Create canvas helper
*/
CanvasHelper();
/// Release all references
void disposing();
/** Initialize canvas helper
This method late-initializes the canvas helper, providing
it with the necessary device and output objects. Note that
the CanvasHelper does <em>not</em> take ownership of the
passed rDevice reference, nor does it perform any
reference counting. Thus, to prevent the reference counted
SpriteCanvas object from deletion, the user of this class
is responsible for holding ref-counted references itself!
@param rDevice
Reference device this canvas is associated with
@param rOutDev
Set primary output device for this canvas. That's where
all content is output to.
@param bProtect
When true, all output operations preserve outdev
state. When false, outdev state might change at any time.
@param bHaveAlpha
When true, hasAlpha() will always return true, otherwise, false.
*/
void init( ::com::sun::star::rendering::XGraphicDevice& rDevice,
const OutDevProviderSharedPtr& rOutDev,
bool bProtect,
bool bHaveAlpha );
/** Set primary output device
This changes the primary output device, where rendering is
sent to.
*/
void setOutDev( const OutDevProviderSharedPtr& rOutDev,
bool bProtect);
/** Set secondary output device
Used for sprites, to generate mask bitmap.
*/
void setBackgroundOutDev( const OutDevProviderSharedPtr& rOutDev );
// CanvasHelper functionality
// ==========================
// XCanvas (only providing, not implementing the
// interface. Also note subtle method parameter differences)
void clear();
void drawPoint( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::geometry::RealPoint2D& aPoint,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
void drawLine( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::geometry::RealPoint2D& aStartPoint,
const ::com::sun::star::geometry::RealPoint2D& aEndPoint,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
void drawBezier( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::geometry::RealBezierSegment2D& aBezierSegment,
const ::com::sun::star::geometry::RealPoint2D& aEndPoint,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
drawPolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
strokePolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
strokeTexturedPolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::uno::Sequence<
::com::sun::star::rendering::Texture >& textures,
const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
strokeTextureMappedPolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::uno::Sequence<
::com::sun::star::rendering::Texture >& textures,
const ::com::sun::star::uno::Reference<
::com::sun::star::geometry::XMapping2D >& xMapping,
const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D >
queryStrokeShapes( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
fillPolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
fillTexturedPolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::uno::Sequence<
::com::sun::star::rendering::Texture >& textures );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
fillTextureMappedPolyPolygon( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::uno::Sequence<
::com::sun::star::rendering::Texture >& textures,
const ::com::sun::star::uno::Reference<
::com::sun::star::geometry::XMapping2D >& xMapping );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCanvasFont >
createFont( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::rendering::FontRequest& fontRequest,
const ::com::sun::star::uno::Sequence<
::com::sun::star::beans::PropertyValue >& extraFontProperties,
const ::com::sun::star::geometry::Matrix2D& fontMatrix );
::com::sun::star::uno::Sequence< ::com::sun::star::rendering::FontInfo >
queryAvailableFonts( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::rendering::FontInfo& aFilter,
const ::com::sun::star::uno::Sequence<
::com::sun::star::beans::PropertyValue >& aFontProperties );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
drawText( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::rendering::StringContext& text,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XCanvasFont >& xFont,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
sal_Int8 textDirection );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
drawTextLayout( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XTextLayout >& layoutetText,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
drawBitmap( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XBitmap >& xBitmap,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
drawBitmapModulated( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XBitmap >& xBitmap,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState );
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XGraphicDevice >
getDevice();
// BitmapCanvasHelper functionality
// ================================
void copyRect( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XBitmapCanvas >& sourceCanvas,
const ::com::sun::star::geometry::RealRectangle2D& sourceRect,
const ::com::sun::star::rendering::ViewState& sourceViewState,
const ::com::sun::star::rendering::RenderState& sourceRenderState,
const ::com::sun::star::geometry::RealRectangle2D& destRect,
const ::com::sun::star::rendering::ViewState& destViewState,
const ::com::sun::star::rendering::RenderState& destRenderState );
::com::sun::star::geometry::IntegerSize2D getSize();
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XBitmapCanvas > queryBitmapCanvas();
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XBitmap >
getScaledBitmap( const ::com::sun::star::geometry::RealSize2D& newSize,
sal_Bool beFast );
::com::sun::star::uno::Sequence< sal_Int8 >
getData( ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
const ::com::sun::star::geometry::IntegerRectangle2D& rect );
void setData( const ::com::sun::star::uno::Sequence< sal_Int8 >& data,
const ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
const ::com::sun::star::geometry::IntegerRectangle2D& rect );
void setPixel( const ::com::sun::star::uno::Sequence< sal_Int8 >& color,
const ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
const ::com::sun::star::geometry::IntegerPoint2D& pos );
::com::sun::star::uno::Sequence< sal_Int8 >
getPixel( ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
const ::com::sun::star::geometry::IntegerPoint2D& pos );
::com::sun::star::rendering::IntegerBitmapLayout getMemoryLayout();
/// Repaint a cached bitmap
bool repaint( const GraphicObjectSharedPtr& rGrf,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::Point& rPt,
const ::Size& rSz,
const GraphicAttr& rAttr ) const;
/** Flush drawing queue.
This only works for Window canvases, and ensures that all
pending render operations are flushed to the
driver/hardware.
*/
void flush() const;
enum ColorType
{
LINE_COLOR, FILL_COLOR, TEXT_COLOR, IGNORE_COLOR
};
// returns transparency of color
int setupOutDevState( const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
ColorType eColorType ) const;
/** Called from XCanvas base classes, to notify that content
is _about_ to change
*/
void modifying() {}
bool hasAlpha() const { return mbHaveAlpha; }
protected:
/** Phyical output device
Deliberately not a refcounted reference, because of
potential circular references for spritecanvas.
*/
::com::sun::star::rendering::XGraphicDevice* mpDevice;
/// Rendering to this outdev preserves its state
OutDevProviderSharedPtr mpProtectedOutDev;
/// Rendering to this outdev does not preserve its state
OutDevProviderSharedPtr mpOutDev;
/// Rendering to this outdev does not preserve its state
OutDevProviderSharedPtr mp2ndOutDev;
/// When true, content is able to represent alpha
bool mbHaveAlpha;
private:
::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCachedPrimitive >
implDrawBitmap( const ::com::sun::star::rendering::XCanvas* rCanvas,
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XBitmap >& xBitmap,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
bool bModulateColors );
bool setupTextOutput( ::Point& o_rOutPos,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCanvasFont >& xFont ) const;
};
}
#endif /* _VCLCANVAS_CANVASHELPER_HXX_ */
| 9,670 |
451 | <filename>src/TpMMPD/ExchangeLib/PhotoScan/ConvTiePointPSMM/cAppliConvertTiePPs2MM.cpp
#include "ConvertTiePPs2MM.h"
/*===================================================*/
cHomolPS::cHomolPS( std::string aImgName,
int aId,
Pt2dr aCoord,
int aIdImg
):
mImgName(aImgName),
mId(aId),
mCoord(aCoord),
mIdImg (aIdImg)
{}
/*===================================================*/
cOneImg::cOneImg(string aImgName):
mImgName(aImgName),
mVIsIdExist (1000000, false), //initializer avec 2 milion items ? trop con
mVCoor (1000000, Pt2dr(0,0)),
mIdMax (0)
{}
/*===================================================*/
cAppliConvertTiePPs2MM::cAppliConvertTiePPs2MM():
mIdMaxGlobal (0)
{}
bool cAppliConvertTiePPs2MM::readPSTxtFile(string aPSHomol, vector<cHomolPS*> & VHomolPS)
{
std::string aImCurrent = " ";
int counter = 0;
//read input file : file format to read :
// Name Im Id Pt Coord X Coord Y
//D0003736.JPG 0 7.997 -1.199
//File trié par Name Im
ifstream aFichier(aPSHomol.c_str());
if(aFichier)
{
std::string aLine;
cOneImg * aImgUnique = NULL;
while(!aFichier.eof())
{
getline(aFichier,aLine,'\n');
if(aLine.size() != 0)
{
//parse
char *aBuffer = strdup((char*)aLine.c_str());
std::string aName = strtok(aBuffer," ");
char *aId = strtok( NULL, " " );
char *aI = strtok( NULL, " " );
char *aJ = strtok( NULL, " " );
Pt2dr aC(atof(aI),atof(aJ));
//creat item PS
int aIdint = atoi(aId);
// cHomolPS * aItemPS = new cHomolPS( aName,
// aIdint,
// aC
// );
// VHomolPS.push_back(aItemPS);
//Get name Im Unique (uniquement pour fichier trie par name Im)
if (strcmp(aImCurrent.c_str() , aName.c_str()))
{
aImCurrent = aName;
aImgUnique = new cOneImg(aName);
mImgUnique.push_back(aImgUnique);
}
if (aImgUnique != NULL)
{
aImgUnique->VIsIdExist()[aIdint] = true;
aImgUnique->VCoor()[aIdint] = aC;
if (aIdint >= aImgUnique->IdMax()) aImgUnique->IdMax() = aIdint;
}
counter++;
}
}
aFichier.close();
}
else
{
std::cout<< "Error While opening file" << '\n';
return false;
}
//==== Affichier Result Import Homol PS =====//
cout<<"Nb Imgs Uniq : " << mImgUnique.size()<< endl;
cout<<"Nb Item : " << counter<< endl;
cout<<" ++ => Import PS Homol Finish" <<endl;
//cout<<endl<<"Result Import : "<<endl;
for (uint aKImg=0; aKImg<mImgUnique.size(); aKImg++)
{
//cout<<" ++ Img : "<<mImgUnique[aKImg]->ImgName()<<endl;
//cout<<" ++ IdMax : "<<mImgUnique[aKImg]->IdMax()<<endl;
if (mImgUnique[aKImg]->IdMax() >= mIdMaxGlobal)
{
mIdMaxGlobal = mImgUnique[aKImg]->IdMax();
}
}
cout<<endl<<" ** IdMaxGlobal = "<<mIdMaxGlobal<<endl;
//============================================//
for (uint aKImg=0; aKImg<mImgUnique.size(); aKImg++)
{
mImgUnique[aKImg]->VIsIdExist().resize(mIdMaxGlobal+1);
mImgUnique[aKImg]->VCoor().resize(mIdMaxGlobal+1);
}
return true;
}
int cAppliConvertTiePPs2MM::getId (int aId, vector<cHomolPS*> & aVRItem)
{
int counter = 0;
for (uint aKImg=0; aKImg < mImgUnique.size(); aKImg++)
{
if (mImgUnique[aKImg]->VIsIdExist()[aId])
{
cHomolPS * aItem = new cHomolPS(mImgUnique[aKImg]->ImgName(), aId, mImgUnique[aKImg]->VCoor()[aId], aKImg);
aVRItem.push_back(aItem);
counter++;
}
}
return counter;
}
void cAppliConvertTiePPs2MM::initAllPackHomol(vector<cOneImg*> VImg)
{
cout<<"Init Pack Homol ...";
for (uint aKImg=0; aKImg<VImg.size(); aKImg++)
{
for (uint aKImg=0; aKImg<VImg.size(); aKImg++)
{
ElPackHomologue * aPack = new ElPackHomologue();
VImg[aKImg]->Pack().push_back(aPack);
}
}
cout<<"done"<<endl;
}
void cAppliConvertTiePPs2MM::addToHomol(vector<cHomolPS*> aVItemHaveSameId, Pt2dr aCPS, Pt2dr aSizePS)
{
for (uint i=0; i<aVItemHaveSameId.size(); i++)
{
for (uint j=i+1; j<aVItemHaveSameId.size(); j++)
{
int aIdImg1 = aVItemHaveSameId[i]->IdImg();
int aIdImg2 = aVItemHaveSameId[j]->IdImg();
Pt2dr aCoorImg1 = aVItemHaveSameId[i]->Coord();
Pt2dr aCoorImg2 = aVItemHaveSameId[j]->Coord();
aCoorImg1.x = aCPS.x+(aCoorImg1.x/aSizePS.x);
aCoorImg1.y = aCPS.y - (aCoorImg1.y/aSizePS.y);
aCoorImg2.x = aCPS.x+(aCoorImg2.x/aSizePS.x);
aCoorImg2.y = aCPS.y - (aCoorImg2.y/aSizePS.y);
ElCplePtsHomologues aCpl (aCoorImg1, aCoorImg2);
mImgUnique[aIdImg1]->Pack()[aIdImg2]->Cple_Add(aCpl);
}
}
}
void cAppliConvertTiePPs2MM::writeToDisk(string aOut, bool a2W, string mDir)
{
std::string aKHOutDat = std::string("NKS-Assoc-CplIm2Hom@")
+ aOut
+ std::string("@")
+ std::string("dat");
cInterfChantierNameManipulateur * aICNM=cInterfChantierNameManipulateur::BasicAlloc(mDir);
for (uint i=0; i<mImgUnique.size(); i++)
{
if (mImgUnique.size()>100)
{
if (i % (mImgUnique.size()/100) == 0)
cout<<" ++ ["<<(i*100.0/mImgUnique.size())<<" %] - write"<<endl;
}
vector<ElPackHomologue*> aVPack = mImgUnique[i]->Pack();
for (uint j=0; j<aVPack.size(); j++)
{
std::string clePack = aICNM->Assoc1To2(
aKHOutDat,
mImgUnique[i]->ImgName(),
mImgUnique[j]->ImgName(),
true
);
if (aVPack[j]->size()>0)
aVPack[j]->StdPutInFile(clePack);
}
}
}
| 3,909 |
6,541 | #!/usr/bin/env python2
# Copyright 2012 The Emscripten Authors. All rights reserved.
# Emscripten is available under two separate licenses, the MIT license and the
# University of Illinois/NCSA Open Source License. Both these licenses can be
# found in the LICENSE file.
from __future__ import print_function
import os
def generate(env, emscripten_path=None, **kw):
""" SCons tool entry point """
if emscripten_path is None:
emscripten_path = os.environ.get('EMSCRIPTEN_ROOT')
if not emscripten_path:
raise 'Unable to find emscripten. Please set EMSCRIPTEN_ROOT'
# SCons does not by default invoke the compiler with the
# environment variabls from the parent calling process,
# so manually route all environment variables referenced
# by Emscripten to the child.
for var in ['EM_CACHE', 'EMCC_DEBUG', 'EMTEST_BROWSER',
'EMMAKEN_JUST_CONFIGURE', 'EMCC_CFLAGS', 'EMCC_TEMP_DIR',
'EMCC_AUTODEBUG', 'EM_COMPILER_WRAPPER',
'EMMAKEN_COMPILER', 'EMMAKEN_CFLAGS',
'MOZ_DISABLE_AUTO_SAFE_MODE', 'EMCC_STDERR_FILE',
'EMSCRIPTEN_SUPPRESS_USAGE_WARNING', 'NODE_PATH', 'EMCC_JSOPT_MIN_CHUNK_SIZE',
'EMCC_JSOPT_MAX_CHUNK_SIZE', 'EMCC_SAVE_OPT_TEMP', 'EMCC_CORES', 'EMCC_NO_OPT_SORT',
'EMCC_BUILD_DIR', 'EMCC_DEBUG_SAVE', 'EMCC_SKIP_SANITY_CHECK',
'EMMAKEN_NO_SDK', 'EM_PKG_CONFIG_PATH', 'EMCC_CLOSURE_ARGS', 'JAVA_HEAP_SIZE',
'EMCC_FORCE_STDLIBS', 'EMCC_ONLY_FORCED_STDLIBS', 'EM_PORTS', 'IDL_CHECKS', 'IDL_VERBOSE',
'EMTEST_SAVE_DIR']:
if os.environ.get(var):
env['ENV'][var] = os.environ.get(var)
try:
emscPath = emscripten_path.abspath
except:
emscPath = emscripten_path
env.Replace(CC=os.path.join(emscPath, "emcc"))
env.Replace(CXX=os.path.join(emscPath, "em++"))
# LINK uses smark_link by default which will choose
# either emcc or em++ depending on if there are any C++ sources
# in the program, so no need to change that.
# SHLINK and LDMODULE should use LINK so no
# need to change them here
env.Replace(AR=os.path.join(emscPath, "emar"))
env.Replace(RANLIB=os.path.join(emscPath, "emranlib"))
env.Replace(OBJSUFFIX=[".js", ".bc", ".o"][2])
env.Replace(LIBSUFFIX=[".js", ".bc", ".o"][2])
env.Replace(PROGSUFFIX=[".html", ".js"][1])
def exists(env):
""" NOOP method required by SCons """
return 1
| 1,043 |
1,020 | package org.robobinding.codegen.presentationmodel;
import org.robobinding.presentationmodel.AbstractPresentationModelObject;
import com.helger.jcodemodel.AbstractJClass;
import com.helger.jcodemodel.JBlock;
import com.helger.jcodemodel.JExpr;
import com.helger.jcodemodel.JFieldVar;
import com.helger.jcodemodel.JInvocation;
import com.helger.jcodemodel.JMethod;
import com.helger.jcodemodel.JMod;
import com.helger.jcodemodel.JVar;
/**
* @since 1.0
* @author <NAME>
*
*/
public class PresentationModelObjectClassGen extends AbstractPresentationModelObjectClassGen {
private AbstractJClass presentationModelClass;
public PresentationModelObjectClassGen(PresentationModelInfo presentationModelInfo) {
super(presentationModelInfo);
presentationModelClass = codeModel.ref(presentationModelInfo.getPresentationModelTypeName());
}
/**
* Note: not private in order to improve performance.
*
* final PresentationModelType presentationModel;
*/
@Override
public void defineFields() {
JFieldVar var = definedClass.field(JMod.FINAL, presentationModelClass, "presentationModel");
presentationModelField = JExpr.refthis(var.name());
presentationModelFieldWithoutThis = JExpr.ref(var.name());
}
/**
* public PresentationModelType_PM(PresentationModelType presentationModel) {
* super(presentationModel);
* this.presentationModel = presentationModel;
* }
*
*/
@Override
public void defineConstructor() {
/*
public class PresentationModelType_PM extends AbstractPresentationModelObject {
*/
definedClass._extends(AbstractPresentationModelObject.class);
JMethod constructor = definedClass.constructor(JMod.PUBLIC);
JVar presentationModelParam = constructor.param(presentationModelClass, "presentationModel");
JBlock block = constructor.body();
JInvocation superInvocation = JExpr.invoke("super").arg(presentationModelParam);
block.add(superInvocation);
block.assign(presentationModelField, presentationModelParam);
}
}
| 635 |
6,497 | <gh_stars>1000+
package com.sohu.cache.schedule.impl;
import com.sohu.cache.dao.QuartzDao;
import com.sohu.cache.entity.TriggerInfo;
import com.sohu.cache.schedule.TriggerCenter;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* trigger管理接口的实现
*
* @author: lingguo
* @time: 2014/10/13 14:03
*/
@Service("triggerCenter")
public class TriggerCenterImpl implements TriggerCenter {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private Scheduler clusterScheduler;
@Autowired
private QuartzDao quartzDao;
/**
* 暂停trigger
*
* @param triggerKey
* @return 操作成功返回true，否则返回false；
*/
@Override
public boolean pauseTrigger(TriggerKey triggerKey) {
boolean opResult = true;
try {
clusterScheduler.pauseTrigger(triggerKey);
} catch (SchedulerException e) {
logger.error(e.getMessage(), e);
opResult = false;
}
return opResult;
}
/**
* 恢复暂停的trigger
*
* @param triggerKey
*/
@Override
public boolean resumeTrigger(TriggerKey triggerKey) {
boolean opResult = true;
try {
clusterScheduler.resumeTrigger(triggerKey);
} catch (SchedulerException e) {
logger.error(e.getMessage(), e);
opResult = false;
}
return opResult;
}
/**
* 删除一个trigger
*
* @param triggerKey
* @return
*/
@Override
public boolean removeTrigger(TriggerKey triggerKey) {
boolean opResult = true;
try {
clusterScheduler.unscheduleJob(triggerKey);
} catch (SchedulerException e) {
logger.error(e.getMessage(), e);
opResult = false;
}
return opResult;
}
/**
* 查询特定job类型下的所有trigger
*
* @param jobGroup job类型：redis/machine/machineMonitor
* @return
*/
@Override
public List<TriggerInfo> getTriggersByJobGroup(String jobGroup) {
List<TriggerInfo> triggersOfGroup = null;
try {
triggersOfGroup = quartzDao.getTriggersByJobGroup(jobGroup);
} catch (Exception e) {
logger.error("jobGroup: {}", jobGroup, e);
}
return triggersOfGroup;
}
/**
* 返回所有的trigger
*
* @return
*/
@Override
public List<TriggerInfo> getAllTriggers() {
List<TriggerInfo> allTriggers = null;
try {
allTriggers = quartzDao.getAllTriggers();
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return allTriggers;
}
/**
* 查询trigger，模糊匹配trigger name或trigger group
*
* @param queryString trigger name或trigger group的关键字
* @return
*/
@Override
public List<TriggerInfo> searchTriggerByNameOrGroup(String queryString) {
List<TriggerInfo> matchTriggers = null;
try {
matchTriggers = quartzDao.searchTriggerByNameOrGroup(queryString);
} catch (Exception e) {
logger.error("queryString: {}", queryString, e);
}
return matchTriggers;
}
}
| 1,734 |
502 | package com.github.kubeflow.arena.model.nodes;
import com.alibaba.fastjson.JSON;
public class NormalNode extends Node {
public NormalNode(){
super();
}
@Override
public String toString() {
return JSON.toJSONString(this,true);
}
}
| 106 |
348 | <reponame>chamberone/Leaflet.PixiOverlay<gh_stars>100-1000
{"nom":"<NAME>","circ":"1ère circonscription","dpt":"Savoie","inscrits":1890,"abs":1002,"votants":888,"blancs":10,"nuls":4,"exp":874,"res":[{"nuance":"LR","nom":"M. <NAME>","voix":225},{"nuance":"REM","nom":"Mme <NAME>","voix":201},{"nuance":"FN","nom":"<NAME>","voix":137},{"nuance":"FI","nom":"M. <NAME>","voix":95},{"nuance":"DIV","nom":"Mme <NAME>","voix":78},{"nuance":"SOC","nom":"Mme <NAME>","voix":44},{"nuance":"ECO","nom":"<NAME>","voix":30},{"nuance":"ECO","nom":"M. <NAME>","voix":17},{"nuance":"DIV","nom":"Mme <NAME>","voix":15},{"nuance":"DIV","nom":"Mme <NAME>","voix":10},{"nuance":"DIV","nom":"Mme <NAME>","voix":8},{"nuance":"DIV","nom":"<NAME>","voix":7},{"nuance":"EXG","nom":"Mme <NAME>","voix":7}]} | 318 |
2,757 | <filename>StdLib/EfiSocketLib/DxeSupport.c
/** @file
SocketDxe support routines
Copyright (c) 2011, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "Socket.h"
/**
Creates a child handle and installs gEfiSocketProtocolGuid.
This routine creates a child handle for the socket driver and
installs the ::gEfiSocketProtocolGuid on that handle with a pointer
to the ::EFI_SOCKET_PROTOCOL structure address.
This routine is called by ::EslServiceGetProtocol in UseSocketDxe
when the socket application is linked with UseSocketDxe.
@param [in] pThis Address of the EFI_SERVICE_BINDING_PROTOCOL structure.
@param [in] pChildHandle Pointer to the handle of the child to create. If it is NULL,
then a new handle is created. If it is a pointer to an existing UEFI handle,
then the protocol is added to the existing UEFI handle.
@retval EFI_SUCCESS The protocol was added to ChildHandle.
@retval EFI_INVALID_PARAMETER ChildHandle is NULL.
@retval EFI_OUT_OF_RESOURCES There are not enough resources available to create
the child
@retval other The child handle was not created
**/
EFI_STATUS
EFIAPI
EslDxeCreateChild (
IN EFI_SERVICE_BINDING_PROTOCOL * pThis,
IN OUT EFI_HANDLE * pChildHandle
)
{
ESL_SOCKET * pSocket;
EFI_STATUS Status;
DBG_ENTER ( );
//
// Create a socket structure
//
Status = EslSocketAllocate ( pChildHandle,
DEBUG_SOCKET,
&pSocket );
//
// Return the operation status
//
DBG_EXIT_STATUS ( Status );
return Status;
}
/**
Removes gEfiSocketProtocolGuid and destroys the child handle.
This routine uninstalls ::gEfiSocketProtocolGuid from the child handle
and destroys the child handle if necessary.
This routine is called from ???.
@param [in] pThis Address of the EFI_SERVICE_BINDING_PROTOCOL structure.
@param [in] ChildHandle Handle of the child to destroy
@retval EFI_SUCCESS The protocol was removed from ChildHandle.
@retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
@retval EFI_INVALID_PARAMETER Child handle is not a valid UEFI Handle.
@retval EFI_ACCESS_DENIED The protocol could not be removed from the ChildHandle
because its services are being used.
@retval other The child handle was not destroyed
**/
EFI_STATUS
EFIAPI
EslDxeDestroyChild (
IN EFI_SERVICE_BINDING_PROTOCOL * pThis,
IN EFI_HANDLE ChildHandle
)
{
ESL_LAYER * pLayer;
EFI_SOCKET_PROTOCOL * pSocketProtocol;
EFI_STATUS Status;
DBG_ENTER ( );
//
// Locate the socket control structure
//
pLayer = &mEslLayer;
Status = gBS->OpenProtocol (
ChildHandle,
&gEfiSocketProtocolGuid,
(VOID **)&pSocketProtocol,
pLayer->ImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if ( !EFI_ERROR ( Status )) {
//
// Free the socket resources
//
Status = EslSocketFree ( pSocketProtocol, NULL );
}
else {
DEBUG (( DEBUG_ERROR,
"ERROR - Failed to open socket protocol on 0x%08x, Status; %r\r\n",
ChildHandle,
Status ));
}
//
// Return the operation status
//
DBG_EXIT_STATUS ( Status );
return Status;
}
/**
Install the socket service
This routine installs the ::gEfiSocketServiceBindingProtocolGuid
on the SocketDxe image handle to announce the availability
of the socket layer to the rest of EFI.
SocketDxe's EntryPoint routine calls this routine to
make the socket layer available.
@param [in] pImageHandle Address of the image handle
@retval EFI_SUCCESS Service installed successfully
**/
EFI_STATUS
EFIAPI
EslDxeInstall (
IN EFI_HANDLE * pImageHandle
)
{
EFI_STATUS Status;
//
// Install the socket service binding protocol
//
Status = gBS->InstallMultipleProtocolInterfaces (
pImageHandle,
&gEfiSocketServiceBindingProtocolGuid,
mEslLayer.pServiceBinding,
NULL
);
if ( !EFI_ERROR ( Status )) {
DEBUG (( DEBUG_POOL | DEBUG_INIT | DEBUG_INFO,
"Installed: gEfiSocketServiceBindingProtocolGuid on 0x%08x\r\n",
*pImageHandle ));
}
else {
DEBUG (( DEBUG_ERROR | DEBUG_POOL | DEBUG_INIT,
"ERROR - InstallMultipleProtocolInterfaces failed, Status: %r\r\n",
Status ));
}
//
// Return the operation status
//
return Status;
}
/**
Uninstall the socket service
This routine removes the gEfiSocketServiceBindingProtocolGuid from
the SocketDxe image handle to notify EFI that the socket layer
is no longer available.
SocketDxe's DriverUnload routine calls this routine to remove the
socket layer.
@param [in] ImageHandle Handle for the image.
@retval EFI_SUCCESS Service installed successfully
**/
EFI_STATUS
EFIAPI
EslDxeUninstall (
IN EFI_HANDLE ImageHandle
)
{
EFI_STATUS Status;
//
// Install the socket service binding protocol
//
Status = gBS->UninstallMultipleProtocolInterfaces (
ImageHandle,
&gEfiSocketServiceBindingProtocolGuid,
mEslLayer.pServiceBinding,
NULL
);
if ( !EFI_ERROR ( Status )) {
DEBUG (( DEBUG_POOL | DEBUG_INIT,
"Removed: gEfiSocketServiceBindingProtocolGuid from 0x%08x\r\n",
ImageHandle ));
}
else {
DEBUG (( DEBUG_ERROR | DEBUG_POOL | DEBUG_INIT,
"ERROR - Failed to remove gEfiSocketServiceBindingProtocolGuid from 0x%08x, Status: %r\r\n",
ImageHandle,
Status ));
}
//
// Return the operation status
//
return Status;
}
| 2,830 |
729 | package com.chinalwb.are.activities;
import android.app.Activity;
import android.content.Intent;
import android.os.AsyncTask;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ListView;
import com.chinalwb.are.R;
import com.chinalwb.are.adapters.AtListAdapter;
import com.chinalwb.are.models.AtItem;
import com.chinalwb.are.styles.ARE_At;
import java.util.ArrayList;
import java.util.Random;
import static android.os.AsyncTask.THREAD_POOL_EXECUTOR;
public class Are_AtPickerActivity extends AppCompatActivity {
private ListView mListView;
private ArrayList<AtItem> mAtItems;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.are_activity_at_picker);
this.mListView = this.findViewById(R.id.are_view_at_listview);
setTitle("@");
setupListeners();
}
@Override
protected void onStart() {
super.onStart();
prepareData();
}
@Override
protected void onResume() {
super.onResume();
}
private void setupListeners() {
this.mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
AtItem atItem = mAtItems.get(position);
Intent data = new Intent();
data.putExtra(ARE_At.EXTRA_TAG, atItem);
Are_AtPickerActivity.this.setResult(Activity.RESULT_OK, data);
Are_AtPickerActivity.this.finish();
}
});
}
private void prepareData() {
new DataLoadTask().executeOnExecutor(THREAD_POOL_EXECUTOR, "");
}
private void showData(ArrayList<AtItem> itemsList) {
if (this.mListView.getAdapter() == null) {
AtListAdapter listAdapter = new AtListAdapter(this, itemsList);
this.mListView.setAdapter(listAdapter);
} else {
AtListAdapter listAdapter = (AtListAdapter) this.mListView.getAdapter();
listAdapter.setData(itemsList);
listAdapter.notifyDataSetChanged();
}
this.mAtItems = itemsList;
}
private ArrayList<AtItem> makeDummyData() {
ArrayList<AtItem> itemsList = new ArrayList<AtItem>();
int[] iconIds = {
R.drawable.at_1,
R.drawable.at_2,
R.drawable.at_3,
R.drawable.at_4,
R.drawable.at_5,
R.drawable.at_6,
R.drawable.at_7,
R.drawable.at_8,
R.drawable.at_9,
R.drawable.at_10,
};
String[] names = {
"<NAME>",
"<NAME>",
"Country Side",
"Dummy Name",
"<NAME>",
"Family Mart",
"Glide Ant",
"Gradle Maven",
"<NAME>",
"<NAME>",
};
for (int i = 0; i < 20; i++) {
int index = new Random().nextInt(10);
if (index > 9) index = 9;
if (index < 0) index = 0;
AtItem atItem = new AtItem(String.valueOf(iconIds[index]), names[index]);
itemsList.add(atItem);
}
return itemsList;
}
private class DataLoadTask extends AsyncTask<String, String, ArrayList<AtItem>> {
@Override
protected ArrayList<AtItem> doInBackground(String... strings) {
ArrayList<AtItem> dummyList = makeDummyData();
return dummyList;
}
@Override
protected void onPostExecute(ArrayList<AtItem> itemsList) {
super.onPostExecute(itemsList);
showData(itemsList);
}
}
}
| 1,878 |
513 | {
"family": "Bonbon",
"variants": ["regular"],
"subsets": ["latin"],
"version": "v14",
"lastModified": "2021-03-19",
"files": { "regular": "http://fonts.gstatic.com/s/bonbon/v14/0FlVVPeVlFec4ee_cDEAbQY5-A.ttf" },
"category": "handwriting",
"kind": "webfonts#webfont"
}
| 131 |
679 | <filename>main/autodoc/source/ary/idl/i_function.cxx
/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#include <precomp.h>
#include <ary/idl/i_function.hxx>
// NOT FULLY DECLARED SERVICES
#include <cosv/tpl/processor.hxx>
#include <sci_impl.hxx>
namespace ary
{
namespace idl
{
Function::Function( const String & i_sName,
Ce_id i_nOwner,
Ce_id i_nNameRoom,
Type_id i_nReturnType,
bool i_bOneWay )
: sName(i_sName),
nOwner(i_nOwner),
nNameRoom(i_nNameRoom),
nReturnType(i_nReturnType),
aParameters(),
aExceptions(),
bOneWay(i_bOneWay),
bEllipse(false)
{
}
Function::Function( const String & i_sName,
Ce_id i_nOwner,
Ce_id i_nNameRoom )
: sName(i_sName),
nOwner(i_nOwner),
nNameRoom(i_nNameRoom),
nReturnType(0),
aParameters(),
aExceptions(),
bOneWay(false),
bEllipse(false)
{
}
Function::~Function()
{
}
void
Function::do_Accept( csv::ProcessorIfc & io_processor ) const
{
csv::CheckedCall(io_processor, *this);
}
ClassId
Function::get_AryClass() const
{
return class_id;
}
const String &
Function::inq_LocalName() const
{
return sName;
}
Ce_id
Function::inq_NameRoom() const
{
return nNameRoom;
}
Ce_id
Function::inq_Owner() const
{
return nOwner;
}
E_SightLevel
Function::inq_SightLevel() const
{
return sl_Member;
}
namespace ifc_function
{
inline const Function &
function_cast( const CodeEntity & i_ce )
{
csv_assert( i_ce.AryClass() == Function::class_id );
return static_cast< const Function& >(i_ce);
}
Type_id
attr::ReturnType( const CodeEntity & i_ce )
{
return function_cast(i_ce).nReturnType;
}
bool
attr::IsOneway( const CodeEntity & i_ce )
{
return function_cast(i_ce).bOneWay;
}
bool
attr::HasEllipse( const CodeEntity & i_ce )
{
return function_cast(i_ce).bEllipse;
}
void
attr::Get_Parameters( Dyn_StdConstIterator<ary::idl::Parameter> & o_result,
const CodeEntity & i_ce )
{
o_result
= new SCI_Vector<Parameter>( function_cast(i_ce).aParameters );
}
void
attr::Get_Exceptions( Dyn_TypeIterator & o_result,
const CodeEntity & i_ce )
{
o_result
= new SCI_Vector<Type_id>( function_cast(i_ce).aExceptions );
}
} // namespace ifc_function
} // namespace idl
} // namespace ary
| 1,478 |
334 | # ----------------------------------------------------------------------------
# Copyright (c) 2016-2021, QIIME 2 development team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file LICENSE, distributed with this software.
# ----------------------------------------------------------------------------
import unittest
from qiime2.core.type import (
is_collection_type, is_primitive_type, is_semantic_type, Set, List,
SemanticType, Int, Metadata, MetadataColumn, Categorical, Numeric, Range)
class TestIsTypes(unittest.TestCase):
def test_list_semantic_type(self):
Foo = SemanticType('Foo')
self.assertTrue(is_collection_type(List[Foo]))
self.assertTrue(is_semantic_type(List[Foo]))
self.assertFalse(is_primitive_type(List[Foo]))
def test_set_semantic_type(self):
Foo = SemanticType('Foo')
self.assertTrue(is_collection_type(Set[Foo]))
self.assertTrue(is_semantic_type(Set[Foo]))
self.assertFalse(is_primitive_type(Set[Foo]))
def test_list_primitive_type(self):
self.assertTrue(is_collection_type(List[Int % Range(5)]))
self.assertTrue(is_primitive_type(List[Int % Range(5)]))
self.assertFalse(is_semantic_type(List[Int % Range(5)]))
def test_set_primitive_type(self):
self.assertTrue(is_collection_type(Set[Int % Range(5)]))
self.assertTrue(is_primitive_type(Set[Int % Range(5)]))
self.assertFalse(is_semantic_type(Set[Int % Range(5)]))
class TestCollectionBase(unittest.TestCase):
def test_no_list_metadata(self):
with self.assertRaisesRegex(TypeError, 'metadata'):
List[Metadata]
def test_no_set_metadata(self):
with self.assertRaisesRegex(TypeError, 'metadata'):
List[Metadata]
def test_no_list_metadata_column(self):
with self.assertRaisesRegex(TypeError, 'metadata'):
List[MetadataColumn[Categorical]]
with self.assertRaisesRegex(TypeError, 'metadata'):
List[MetadataColumn[Numeric]]
def test_no_set_metadata_column(self):
with self.assertRaisesRegex(TypeError, 'metadata'):
Set[MetadataColumn[Categorical]]
with self.assertRaisesRegex(TypeError, 'metadata'):
Set[MetadataColumn[Numeric]]
def test_no_nesting_list_list(self):
with self.assertRaisesRegex(TypeError, 'nest'):
List[List[Int]]
def test_no_nesting_set_set(self):
with self.assertRaisesRegex(TypeError, 'nest'):
Set[Set[Int]]
def test_no_nesting_mixed(self):
with self.assertRaisesRegex(TypeError, 'nest'):
List[Set[Int]]
class TestCollectionExpression(unittest.TestCase):
def test_bad_union(self):
with self.assertRaisesRegex(TypeError, 'not union'):
List[Int] | Set[Int]
def test_union_inside_collection(self):
Foo = SemanticType('Foo')
Bar = SemanticType('Bar')
self.assertTrue(List[Foo] <= List[Foo | Bar])
def test_no_predicate(self):
with self.assertRaisesRegex(TypeError, 'cannot be applied'):
List[Int] % Range(5)
def is_concrete(self):
Foo = SemanticType('Foo')
self.assertFalse(List[Foo].is_concrete())
self.assertFalse(Set[Int].is_concrete())
def test_to_ast_semantic(self):
Foo = SemanticType('Foo')
ast = List[Foo].to_ast()
self.assertEqual(ast['fields'][0], Foo.to_ast())
def test_to_ast_primitive(self):
ast = List[Int % Range(5)].to_ast()
self.assertEqual(ast['fields'][0], (Int % Range(5)).to_ast())
def test_contains_list_primitive(self):
self.assertTrue([1, 2, 3] in List[Int])
self.assertTrue([-1, 2, 3] in List[Int])
self.assertFalse([-1, 2, 3] in List[Int % Range(0, 5)])
self.assertFalse([1, 1.1, 1.11] in List[Int])
self.assertFalse({1, 2, 3} in List[Int])
self.assertFalse(object() in List[Int])
def test_contains_set_primitive(self):
self.assertTrue({1, 2, 3} in Set[Int])
self.assertTrue({-1, 2, 3} in Set[Int])
self.assertFalse({-1, 2, 3} in Set[Int % Range(0, 5)])
self.assertFalse({1, 1.1, 1.11} in Set[Int])
self.assertFalse([1, 2, 3] in Set[Int])
self.assertFalse(object() in Set[Int])
def test_variant_of_field_members(self):
Bar = SemanticType('Bar')
Foo = SemanticType('Foo', field_names='foo',
field_members={'foo': List[Bar]})
with self.assertRaisesRegex(TypeError, 'is not a variant'):
Foo[List[Bar]]
def test_variant_of_alt(self):
Foo = SemanticType('Foo', field_names='foo')
Bar = SemanticType('Bar', variant_of=Foo.field['foo'])
with self.assertRaisesRegex(TypeError, 'is not a variant'):
Foo[Set[Bar]]
def test_encode_decode_set(self):
value = List[Int].decode("[1, 2, 3]")
self.assertEqual(value, [1, 2, 3])
json = List[Int].encode(value)
self.assertEqual(json, "[1, 2, 3]")
def test_encode_decode_list(self):
value = Set[Int].decode("[1, 2, 3]")
self.assertEqual(value, {1, 2, 3})
json = Set[Int].encode(value)
self.assertEqual(json, "[1, 2, 3]")
if __name__ == '__main__':
unittest.main()
| 2,360 |
1,233 | from datetime import datetime
BUILD_NUMBER = 'DEV'
BUILD_DATE = datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
BUILD_VCS_NUMBER = 'HEAD'
| 67 |
385 | <reponame>1b00/corrade<filename>src/Corrade/Utility/ConfigurationGroup.h
#ifndef Corrade_Utility_ConfigurationGroup_h
#define Corrade_Utility_ConfigurationGroup_h
/*
This file is part of Corrade.
Copyright © 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016,
2017, 2018, 2019, 2020, 2021
<NAME> <<EMAIL>>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
/** @file
* @brief Class @ref Corrade::Utility::ConfigurationGroup
*/
#include <utility>
#include <string>
#include <vector>
#include "Corrade/Containers/StringStl.h"
#include "Corrade/Utility/ConfigurationValue.h"
#include "Corrade/Utility/Utility.h"
#include "Corrade/Utility/visibility.h"
namespace Corrade { namespace Utility {
/**
@brief Group of values in configuration file
Provides access to values and subgroups. See @ref Configuration class
documentation for usage example.
@todo Faster access to elements via multimap, find() and equal_range()
*/
class CORRADE_UTILITY_EXPORT ConfigurationGroup {
friend Configuration;
public:
template<class T> class BasicGroupIterator;
/**
* @brief Mutable configuration group iterator
* @m_since_latest
*/
typedef BasicGroupIterator<ConfigurationGroup> MutableGroupIterator;
/**
* @brief Configuration group iterator
* @m_since_latest
*/
typedef BasicGroupIterator<const ConfigurationGroup> GroupIterator;
template<class T> class BasicGroups;
/**
* @brief Mutable iterator access to configuration groups
* @m_since_latest
*/
typedef BasicGroups<ConfigurationGroup> MutableGroups;
/**
* @brief Iterator access to configuration groups
* @m_since_latest
*/
typedef BasicGroups<const ConfigurationGroup> Groups;
class ValueIterator;
class Values;
/**
* @brief Default constructor
*
* Pointer to enclosing configuration is set to @cpp nullptr @ce, call
* @ref addGroup() to add it somewhere.
*/
explicit ConfigurationGroup();
/**
* @brief Copy constructor
*
* Pointer to enclosing configuration is set to @cpp nullptr @ce, call
* @ref addGroup() to add it somewhere.
*/
ConfigurationGroup(const ConfigurationGroup& other);
/**
* @brief Move constructor
*
* Pointer to enclosing configuration is set to @cpp nullptr @ce, call
* @ref addGroup() to add it somewhere.
*/
ConfigurationGroup(ConfigurationGroup&& other);
~ConfigurationGroup();
/**
* @brief Copy assignment
*
* Pointer to enclosing configuration stays the same as in original
* object.
* @see @ref configuration()
*/
ConfigurationGroup& operator=(const ConfigurationGroup& other);
/**
* @brief Move assignment
*
* Pointer to enclosing configuration stays the same as in original
* object.
* @see @ref configuration()
*/
ConfigurationGroup& operator=(ConfigurationGroup&& other);
/**
* @brief Enclosing configuration
*
* Returns @cpp nullptr @ce if the group is not part of any
* configuration.
* @see @ref addGroup(const std::string&, ConfigurationGroup*)
*/
Configuration* configuration() { return _configuration; }
const Configuration* configuration() const { return _configuration; } /**< @overload */
/**
* @brief Whether the group is empty
*
* If the group is empty, there aren't any values, subgroups, empty
* lines or comments.
* @see @ref hasGroups(), @ref hasValues()
*/
bool isEmpty() const { return _values.empty() && _groups.empty(); }
/** @{ @name Group operations */
/**
* @brief Iterate through subgroups
* @m_since_latest
*
* See @ref Utility-Configuration-iteration for more information.
*/
MutableGroups groups();
/**
* @overload
* @m_since_latest
*/
Groups groups() const;
/**
* @brief Whether this group has subgroups
*
* @see @ref isEmpty(), @ref hasGroup(), @ref groupCount(),
* @ref hasValues()
*/
bool hasGroups() const { return !_groups.empty(); }
/**
* @brief Count of all subgroups
*
* @see @ref hasGroups(), @ref valueCount()
*/
unsigned int groupCount() const {
return static_cast<unsigned int>(_groups.size());
}
/**
* @brief Whether given group exists
* @param name Name
* @param index Group index. Default is first found group.
*
* @see @ref isEmpty(), @ref hasGroups(), @ref groupCount(),
* @ref hasValue()
*/
bool hasGroup(const std::string& name, unsigned int index = 0) const;
/**
* @brief Count of groups with given name
*
* @see @ref hasGroup(), @ref valueCount()
*/
unsigned int groupCount(const std::string& name) const;
/**
* @brief Group of given name
* @param name Name
* @param index Group index. Default is first found group.
*
* Returns pointer to group on success, @cpp nullptr @ce otherwise.
* @see @ref groups()
*/
ConfigurationGroup* group(const std::string& name, unsigned int index = 0);
const ConfigurationGroup* group(const std::string& name, unsigned int index = 0) const; /**< @overload */
/** @brief All groups with given name */
std::vector<ConfigurationGroup*> groups(const std::string& name);
std::vector<const ConfigurationGroup*> groups(const std::string& name) const; /**< @overload */
/**
* @brief Add new group
* @param name Name. The name must not be empty and must not
* contain newline or any of `[]/` characters.
* @param group Existing group.
*
* Adds given group at the end of current group. The group must not be
* part of any existing configuration.
* @see @ref configuration()
*/
void addGroup(const std::string& name, ConfigurationGroup* group);
/**
* @brief Add new group
* @param name Name. The name must not be empty and must not
* contain newline or any of `[]/` characters.
*
* Adds new group at the end of file, returns newly created group.
*/
ConfigurationGroup* addGroup(const std::string& name);
/**
* @brief Remove group
* @param name Name of the group
* @param index Group index. Default is first found group.
*
* Returns @cpp true @ce if given group was found and removed,
* @cpp false @ce otherwise.
* @see @ref removeAllGroups(), @ref clear()
*/
bool removeGroup(const std::string& name, unsigned int index = 0);
/**
* @brief Remove group
*
* Returns @cpp true @ce if given group was found and removed,
* @cpp false @ce otherwise.
* @see @ref removeAllGroups(), @ref clear()
*/
bool removeGroup(ConfigurationGroup* group);
/**
* @brief Remove all groups with given name
*
* @see @ref removeGroup(), @ref clear()
*/
void removeAllGroups(const std::string& name);
/* Since 1.8.17, the original short-hand group closing doesn't work
anymore. FFS. */
/**
* @}
*/
/** @{ @name Value operations */
/**
* @brief Iterate through values
* @m_since_latest
*
* See @ref Utility-Configuration-iteration for more information.
*/
Values values() const;
/**
* @brief Whether this group has any values
*
* @see @ref isEmpty(), @ref hasValue(), @ref valueCount(),
* @ref hasGroups()
*/
bool hasValues() const;
/**
* @brief Count of all values in the group
*
* @see @ref hasValues(), @ref groupCount()
*/
unsigned int valueCount() const;
/**
* @brief Whether value exists
* @param key Key
* @param index Value index. Default is first found value.
*
* @see @ref isEmpty(), @ref hasValues(), @ref valueCount(),
* @ref hasGroup()
*/
bool hasValue(const std::string& key, unsigned int index = 0) const;
/**
* @brief Count of values with given key
*
* @see @ref hasValue(), @ref groupCount()
*/
unsigned int valueCount(const std::string& key) const;
/**
* @brief Value
* @param key Key
* @param index Value index. Default is first found value.
* @param flags Flags
*
* Directly returns the value. If the key is not found, returns
* default constructed value. If @p T is not @ref std::string, uses
* @ref ConfigurationValue::fromString() to convert the value to given
* type.
* @see @ref hasValue()
*/
template<class T = std::string> T value(const std::string& key, unsigned int index = 0, ConfigurationValueFlags flags = ConfigurationValueFlags()) const;
/** @overload
* Calls the above with @p index set to `0`.
*/
template<class T = std::string> T value(const std::string& key, ConfigurationValueFlags flags) const {
return value<T>(key, 0, flags);
}
/**
* @brief All values with given key
* @param key Key
* @param flags Flags
*
* If @p T is not @ref std::string, uses
* @ref ConfigurationValue::fromString() to convert the value to given
* type.
*/
template<class T = std::string> std::vector<T> values(const std::string& key, ConfigurationValueFlags flags = ConfigurationValueFlags()) const;
/**
* @brief Set string value
* @param key Key. The key must not be empty and must not contain
* newline or `=` character.
* @param value Value
* @param index Value index. Default is first found value.
* @param flags Flags
*
* If the key already exists, changes it to new value. If the key
* doesn't exist, adds a new key with given name. Returns
* @cpp false @ce if @p index is larger than actual value count,
* @cpp true @ce otherwise.
*/
bool setValue(const std::string& key, std::string value, unsigned int index = 0, ConfigurationValueFlags flags = ConfigurationValueFlags()) {
return setValueInternal(key, std::move(value), index, flags);
}
/** @overload */
bool setValue(const std::string& key, const char* value, unsigned int index = 0, ConfigurationValueFlags flags = ConfigurationValueFlags()) {
return setValueInternal(key, value, index, flags);
}
/** @overload
* Calls the above with @p index set to `0`.
*/
bool setValue(const std::string& key, std::string value, ConfigurationValueFlags flags) {
return setValue(key, std::move(value), 0, flags);
}
/** @overload
* Calls the above with @p index set to `0`.
*/
bool setValue(const std::string& key, const char* value, ConfigurationValueFlags flags) {
return setValue(key, value, 0, flags);
}
/**
* @brief Set value converted from given type
*
* Uses @ref ConfigurationValue::toString() to convert the value from
* given type. See @ref setValue(const std::string&, std::string, unsigned int, ConfigurationValueFlags)
* for more information.
*/
template<class T> bool setValue(const std::string& key, const T& value, unsigned int index = 0, ConfigurationValueFlags flags = ConfigurationValueFlags()) {
return setValueInternal(key, ConfigurationValue<T>::toString(value, flags), index, flags);
}
/** @overload
* Calls the above with @p index set to `0`.
*/
template<class T> bool setValue(const std::string& key, const T& value, ConfigurationValueFlags flags) {
return setValue<T>(key, value, 0, flags);
}
/**
* @brief Add new value
* @param key Key. The key must not be empty and must not contain
* newline or `=` character.
* @param value Value
* @param flags Flags
*
* Adds new key/value pair at the end of current group (it means also
* after all comments).
*/
void addValue(std::string key, std::string value, ConfigurationValueFlags flags = ConfigurationValueFlags()) {
addValueInternal(std::move(key), std::move(value), flags);
}
/** @overload */
void addValue(std::string key, const char* value, ConfigurationValueFlags flags = ConfigurationValueFlags()) {
addValueInternal(std::move(key), value, flags);
}
/**
* @brief Add new value
*
* Uses @ref ConfigurationValue::toString() to convert the value from
* given type. See @ref addValue(std::string, std::string, ConfigurationValueFlags)
* for more information.
*/
template<class T> void addValue(std::string key, const T& value, ConfigurationValueFlags flags = ConfigurationValueFlags()) {
addValueInternal(std::move(key), ConfigurationValue<T>::toString(value, flags), flags);
}
/**
* @brief Remove value
* @param key Key
* @param index Value index. Default is first found value.
*
* Returns @cpp true @ce if given value was found and removed,
* @cpp false @ce otherwise.
* @see @ref removeAllValues(), @ref clear()
*/
bool removeValue(const std::string& key, unsigned int index = 0);
/**
* @brief Remove all values with given key
*
* @see @ref removeValue(), @ref clear()
*/
void removeAllValues(const std::string& key);
/* Since 1.8.17, the original short-hand group closing doesn't work
anymore. FFS. */
/**
* @}
*/
/**
* @brief Clear group
*
* Removes all values and subgroups.
* @see @ref removeAllValues(), @ref removeAllGroups()
*/
void clear();
private:
struct CORRADE_UTILITY_LOCAL Value {
std::string key, value;
};
struct CORRADE_UTILITY_LOCAL Group {
std::string name;
ConfigurationGroup* group;
};
CORRADE_UTILITY_LOCAL explicit ConfigurationGroup(Configuration* configuration);
CORRADE_UTILITY_LOCAL std::vector<Group>::iterator findGroup(const std::string& name, unsigned int index);
CORRADE_UTILITY_LOCAL std::vector<Group>::const_iterator findGroup(const std::string& name, unsigned int index) const;
CORRADE_UTILITY_LOCAL std::vector<Value>::iterator findValue(const std::string& key, unsigned int index);
CORRADE_UTILITY_LOCAL std::vector<Value>::const_iterator findValue(const std::string& key, unsigned int index) const;
/* Returns nullptr in case the key is not found */
const std::string* valueInternal(const std::string& key, unsigned int index, ConfigurationValueFlags flags) const;
std::vector<std::string> valuesInternal(const std::string& key, ConfigurationValueFlags flags) const;
bool setValueInternal(const std::string& key, std::string value, unsigned int number, ConfigurationValueFlags flags);
void addValueInternal(std::string key, std::string value, ConfigurationValueFlags flags);
std::vector<Value> _values;
std::vector<Group> _groups;
Configuration* _configuration;
};
/**
@brief Base for configuration group iterators
@m_since_latest
Used through the @ref GroupIterator / @ref MutableGroupIterator typedefs and
returned when iterating @ref ConfigurationGroup::groups(). See
@ref Utility-Configuration-iteration for more information.
*/
template<class T> class CORRADE_UTILITY_EXPORT ConfigurationGroup::BasicGroupIterator {
public:
#ifndef DOXYGEN_GENERATING_OUTPUT
typedef typename std::conditional<std::is_const<T>::value, const ConfigurationGroup::Group, ConfigurationGroup::Group>::type Group;
constexpr explicit BasicGroupIterator(Group* group) noexcept: _group{group} {}
#endif
/**
* @brief Dereference the iterator
*
* Returns a pair of a group name and a (mutable or @cpp const @ce)
* @ref ConfigurationGroup reference. The string view is owned by the
* originating @ref ConfigurationGroup, isn't guaranteed to be
* @ref Containers::StringViewFlag::NullTerminated and may get
* invalidated when groups are added or removed. The group reference is
* invalidated only if given group is removed.
*/
Containers::Pair<Containers::StringView, Containers::Reference<T>> operator*() const;
/* Ah, C++, why the hell does operator->() have to return a pointer?!
I can't thus implement things like it->first() because the
ConfigurationGroup itself would need to store those pairs already.
FFS. */
/** @brief Equality comparison */
bool operator==(const BasicGroupIterator<T>& other) const {
return _group == other._group;
}
/** @brief Non-equality comparison */
bool operator!=(const BasicGroupIterator<T>& other) const {
return !operator==(other);
}
/** @brief Increment the iterator */
BasicGroupIterator<T>& operator++() {
++_group;
return *this;
}
/** @brief Post-increment the iterator */
BasicGroupIterator<T> operator++(int);
private:
Group* _group;
};
/**
@brief Base for iterator access to configuration groups
@m_since_latest
Used through the @ref GroupIterator / @ref MutableGroupIterator typedefs and
returned from @ref ConfigurationGroup::groups(). See
@ref Utility-Configuration-iteration for more information.
*/
template<class T> class ConfigurationGroup::BasicGroups {
public:
#ifndef DOXYGEN_GENERATING_OUTPUT
typedef typename std::conditional<std::is_const<T>::value, const ConfigurationGroup::Group, ConfigurationGroup::Group>::type Group;
constexpr explicit BasicGroups(Group* begin, Group* end) noexcept: _begin{begin}, _end{end} {}
#endif
/** @brief First subgroup */
BasicGroupIterator<T> begin() const {
return BasicGroupIterator<T>{_begin};
}
/** @overload */
BasicGroupIterator<const T> cbegin() const {
return BasicGroupIterator<const T>{_begin};
}
/** @brief (One item after) last subgroup */
BasicGroupIterator<T> end() const {
return BasicGroupIterator<T>{_end};
}
/** @overload */
BasicGroupIterator<const T> cend() const {
return BasicGroupIterator<const T>{_end};
}
private:
Group* _begin;
Group* _end;
};
/**
@brief Configuration value iterator
@m_since_latest
Returned when iterating @ref ConfigurationGroup::values(). See
@ref Utility-Configuration-iteration for more information.
*/
class CORRADE_UTILITY_EXPORT ConfigurationGroup::ValueIterator {
public:
#ifndef DOXYGEN_GENERATING_OUTPUT
/* Needs to have the end pointer as well as it's skipping over comment
entries when iterating and needs to know when to stop */
constexpr explicit ValueIterator(const Value* value, const Value* end) noexcept: _value{value}, _end{end} {}
#endif
/**
* @brief Dereference the iterator
*
* Returns a key/value pair. The string views are owned by the
* originating @ref ConfigurationGroup, aren't guaranteed to be
* @ref Containers::StringViewFlag::NullTerminated and may get
* invalidated when values are added or removed.
*/
Containers::Pair<Containers::StringView, Containers::StringView> operator*() const;
/* Ah, C++, why the hell does operator->() have to return a pointer?!
I can't thus implement things like it->first() because the
ConfigurationGroup itself would need to store those pairs already.
FFS. */
/** @brief Equality comparison */
bool operator==(const ValueIterator& other) const {
return _value == other._value;
}
/** @brief Non-equality comparison */
bool operator!=(const ValueIterator& other) const {
return !operator==(other);
}
/** @brief Pre-increment the iterator */
ValueIterator& operator++();
/** @brief Post-increment the iterator */
ValueIterator operator++(int);
private:
const Value* _value;
const Value* _end;
};
/**
@brief Iterator access to configuration values
@m_since_latest
Returned from @ref ConfigurationGroup::values(). See
@ref Utility-Configuration-iteration for more information.
*/
class ConfigurationGroup::Values {
public:
#ifndef DOXYGEN_GENERATING_OUTPUT
explicit Values(const Value* begin, const Value* end) noexcept;
#endif
/** @brief First value */
ValueIterator begin() const {
return ValueIterator{_begin, _end};
}
/** @overload */
ValueIterator cbegin() const {
return ValueIterator{_begin, _end};
}
/** @brief (One item after) last value */
ValueIterator end() const {
return ValueIterator{_end, _end};
}
/** @overload */
ValueIterator cend() const {
return ValueIterator{_end, _end};
}
private:
const Value* _begin;
const Value* _end;
};
#ifndef DOXYGEN_GENERATING_OUTPUT
/* Shorthand template specialization for string values, delete unwanted ones */
template<> bool ConfigurationGroup::setValue(const std::string&, const std::string&, unsigned int, ConfigurationValueFlags) = delete;
template<> void ConfigurationGroup::addValue(std::string, const std::string&, ConfigurationValueFlags) = delete;
template<> inline std::string ConfigurationGroup::value(const std::string& key, unsigned int index, const ConfigurationValueFlags flags) const {
const std::string* value = valueInternal(key, index, flags);
return value ? *value : std::string{};
}
template<> inline std::vector<std::string> ConfigurationGroup::values(const std::string& key, const ConfigurationValueFlags flags) const {
return valuesInternal(key, flags);
}
#endif
template<class T> inline T ConfigurationGroup::value(const std::string& key, const unsigned int index, const ConfigurationValueFlags flags) const {
const std::string* value = valueInternal(key, index, flags);
/* Can't do value ? *value : std::string{} BECAUSE THAT MAKES A COPY! C++
YOU'RE FIRED */
const std::string empty;
return ConfigurationValue<T>::fromString(value ? *value : empty, flags);
}
template<class T> std::vector<T> ConfigurationGroup::values(const std::string& key, const ConfigurationValueFlags flags) const {
std::vector<std::string> stringValues = valuesInternal(key, flags);
std::vector<T> values;
values.reserve(stringValues.size());
for(std::vector<std::string>::const_iterator it = stringValues.begin(); it != stringValues.end(); ++it)
values.push_back(ConfigurationValue<T>::fromString(*it, flags));
return values;
}
}}
#endif
| 10,021 |
1,702 | package com.example.validator;
import javax.validation.constraints.Pattern;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
@ConfigurationProperties("app")
@Validated
class Foo {
@Pattern(regexp = "[A-Z][a-z]+", message = "Invalid lastname")
private String value;
public Foo() {
}
public Foo(String value) {
this.value = value;
}
public String getValue() {
return this.value;
}
public void setValue(String value) {
this.value = value;
}
@Override
public String toString() {
return "Foo [value=" + this.value + "]";
}
}
| 215 |
6,036 | <reponame>toothache/onnxruntime<gh_stars>1000+
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
#include <vector>
#include "core/common/common.h"
#include "core/graph/graph_utils.h" // TODO: Minimize usage of this given we want to use Actions in a minimal build
#include "core/optimizer/selectors_actions/helpers.h"
namespace onnxruntime {
class Graph;
class Node;
// actions that are applied to a set of nodes identified during selection
struct Action {
virtual Status Run(Graph&, const NodesToOptimize& selected_nodes) const = 0;
virtual ~Action() = default;
protected:
Action() = default;
};
// helper to assemble multiple actions into a single instance.
struct MultiAction : public Action {
MultiAction(std::vector<std::unique_ptr<Action>>&& actions) : actions_{std::move(actions)} {}
Status Run(Graph& graph, const NodesToOptimize& selected_nodes) const override {
for (const auto& action : actions_) {
ORT_RETURN_IF_ERROR(action->Run(graph, selected_nodes));
}
return Status::OK();
}
// can't copy/assign actions_
ORT_DISALLOW_COPY_AND_ASSIGNMENT(MultiAction);
private:
std::vector<std::unique_ptr<Action>> actions_;
};
// Safely remove nodes that the Action applies to which no longer produce consumed outputs.
// Output edges to nodes in selected_nodes are ignored when determining if it's safe to remove a node.
// Set `preserve_target_node` for the NodesToOptimize::Target node to not be removed.
struct RemoveNodes : public Action {
RemoveNodes(bool preserve_target_node = false) : preserve_target_node_{preserve_target_node} {
}
Status Run(Graph& graph, const NodesToOptimize& selected_nodes) const override;
private:
bool preserve_target_node_;
};
// Merge one input and/or one output node into the target node.
// - inputs from the input node, if present, will become the inputs of the target node
// - outputs from the output node, if present, will become the outputs of the target node
// The input and/or output node will be removed after the merge. The target node will not.
struct MergeIntoTarget : public Action {
MergeIntoTarget(std::vector<NodeAndMoveInfo>&& value_moves) : value_moves_{std::move(value_moves)} {}
private:
Status Run(Graph&, const NodesToOptimize& selected_nodes) const override;
std::vector<NodeAndMoveInfo> value_moves_;
RemoveNodes node_remover_{true}; // preserve target node when removing selected_nodes
};
// replace the selected_nodes with a new node. the inputs and outputs values for the replaced nodes should be
// moved to the new node using value_moves. all nodes in selected_nodes will be removed.
struct ReplaceWithNew : public Action {
ReplaceWithNew(const std::string& domain,
const std::string& op_name,
std::vector<NodeAndMoveInfo>&& value_moves);
Status Run(Graph&, const NodesToOptimize& selected_nodes) const override;
private:
// support usage where operator name is determined at runtime from the selected nodes
virtual std::string OpType(const NodesToOptimize&) const { return op_; }
const std::string domain_;
const std::string op_;
std::vector<NodeAndMoveInfo> value_moves_;
RemoveNodes node_remover_;
};
} // namespace onnxruntime
| 996 |
1,428 | <reponame>saurabhcommand/Hello-world
#include <stdio.h>
void main(){
printf("\n*****Check wether a year is a leap year or not*****\n\n\n");
int year;
printf("Enter a year\n");
scanf("%d", &year);
if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
printf("--->This year is a leap year");
else
printf("--->This year is not a leap year");
}
| 146 |
409 | /*
* https://github.com/jamesbarlow/icmptunnel
*
* The MIT License (MIT)
*
* Copyright (c) 2016 <NAME>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/if_tun.h>
#include "tun-device.h"
int open_tun_device(struct tun_device *device, int mtu)
{
struct ifreq ifr;
const char *clonedev = "/dev/net/tun";
/* open the clone device. */
if ((device->fd = open(clonedev, O_RDWR)) < 0) {
fprintf(stderr, "unable to open %s: %s\n", clonedev, strerror(errno));
fprintf(stderr, "is the tun kernel module loaded?\n");
return 1;
}
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
/* try to create the device, the kernel will choose a name. */
if (ioctl(device->fd, TUNSETIFF, &ifr) < 0) {
fprintf(stderr, "unable to create a tunnel device: %s\n", strerror(errno));
return 1;
}
/* copy out the device name and mtu. */
strncpy(device->name, ifr.ifr_name, sizeof(device->name));
device->mtu = mtu;
fprintf(stderr, "opened tunnel device: %s\n", ifr.ifr_name);
return 0;
}
int write_tun_device(struct tun_device *device, const char *buf, int size)
{
/* write to the tunnel device. */
if (write(device->fd, buf, size) != size) {
fprintf(stderr, "unable to write to tunnel device: %s\n", strerror(errno));
return 1;
}
return 0;
}
int read_tun_device(struct tun_device *device, char *buf, int *size)
{
/* read from the tunnel device. */
if ((*size = read(device->fd, buf, device->mtu)) < 0) {
fprintf(stderr, "unable to read from tunnel device: %s\n", strerror(errno));
return 1;
}
return 0;
}
void close_tun_device(struct tun_device *device)
{
if (device->fd >= 0) {
close(device->fd);
}
}
| 1,118 |
678 | /**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/Message.framework/MailServices/POP.framework/POP
*/
#import <Foundation/NSThread.h>
#import <POP/POP-Structs.h>
@class MFPOP3Connection;
@interface MFLibraryPOPStore : NSThread {
MFPOP3Connection *_connection; // 124 = 0x7c
}
@property(assign) unsigned serverMessageCount; // G=0xfe1; S=0x1109; converted property
@property(assign) unsigned serverUnreadCount; // G=0xffd; S=0x1081; converted property
- (id)initWithMailboxUid:(id)mailboxUid readOnly:(BOOL)only; // 0x102d
- (void)openSynchronouslyUpdatingMetadata:(BOOL)metadata; // 0xfdd
- (id)dataForMimePart:(id)mimePart inRange:(NSRange)range isComplete:(BOOL *)complete downloadIfNecessary:(BOOL)necessary didDownload:(BOOL *)download; // 0x19f1
- (id)bodyDataForMessage:(id)message isComplete:(BOOL *)complete isPartial:(BOOL *)partial downloadIfNecessary:(BOOL)necessary; // 0x192d
- (id)fullBodyDataForMessage:(id)message andHeaderDataIfReadilyAvailable:(id *)available isComplete:(BOOL *)complete downloadIfNecessary:(BOOL)necessary usePartDatas:(BOOL)datas; // 0x1909
- (id)_fetchHeaderDataForMessage:(id)message downloadIfNecessary:(BOOL)necessary; // 0x17e1
- (id)_fetchBodyDataForMessage:(id)message andHeaderDataIfReadilyAvailable:(id *)available downloadIfNecessary:(BOOL)necessary partial:(BOOL *)partial; // 0x1565
- (void)purgeMessages:(id)messages; // 0x1535
- (int)fetchNumMessages:(unsigned)messages preservingUID:(id)uid fetchType:(int)type synchronize:(BOOL)synchronize compact:(BOOL)compact; // 0x1401
- (void)dealloc; // 0x13d5
- (id)messageForRemoteID:(id)remoteID; // 0x135d
- (void)messagesWereDeleted:(id)deleted; // 0x12b1
- (void)_handleFlagsChangedForMessages:(id)messages flags:(id)flags oldFlagsByMessage:(id)message; // 0x1191
// converted property setter: - (void)setServerMessageCount:(unsigned)count; // 0x1109
// converted property getter: - (unsigned)serverMessageCount; // 0xfe1
// converted property setter: - (void)setServerUnreadCount:(unsigned)count; // 0x1081
- (unsigned)serverUnreadOnlyOnServerCount; // 0xff5
// converted property getter: - (unsigned)serverUnreadCount; // 0xffd
- (BOOL)hasMoreMessages:(unsigned)messages; // 0x1011
@end
| 791 |
370 | <filename>cuda_dxt/rgb2dxt1.c
#include <stdio.h>
#include <stdlib.h>
#include "cuda_dxt.h"
#define DDS_HEADER_SIZE 128
static void usage(const char * const name, const char * const message) {
printf("ERROR: %s\n", message);
printf("Usage: %s width height input.rgb output.dds\n", name);
}
int main(int argc, char** argv) {
FILE *in_file, *out_file;
size_t in_size, out_size, dds_size;
int size_x, size_y;
void *in_host = 0, *out_host = 0, *out_gpu = 0, *in_gpu = 0;
unsigned int * header;
cudaEvent_t event_begin, event_end;
float kernel_time_ms;
/* check arguments */
if(5 != argc) {
usage(argv[0], "Incorrect argument count.");
return -1;
}
/* get image size */
size_x = atoi(argv[1]);
size_y = atoi(argv[2]);
if(size_x <= 0 || (size_x & 3) || size_y == 0 || (abs(size_y) & 3)) {
usage(argv[0], "Image sizes must be positive numbers divisible by 4.");
return -1;
}
/* Check CUDA device */
if(cudaSuccess != cudaSetDevice(0)) {
usage(argv[0], "Cannot set CUDA device #0.");
return -1;
}
/* allocate buffers (both GPU and host buffers) */
in_size = size_x * abs(size_y) * 3;
out_size = in_size / 6;
dds_size = out_size + DDS_HEADER_SIZE;
cudaMallocHost(&in_host, in_size);
cudaMallocHost(&out_host, dds_size);
cudaMalloc(&in_gpu, in_size);
cudaMalloc(&out_gpu, out_size);
if(!in_host || !out_host || !out_gpu || !in_gpu) {
usage(argv[0], "Cannot allocate buffers.\n");
return -1;
}
/* open input file */
in_file = fopen(argv[3], "r");
if(!in_file) {
usage(argv[0], "Could not open input file.");
return -1;
}
#if 0
/* check file size */
fseek(in_file, 0, SEEK_END);
if(ftell(in_file) != (long int)in_size) {
usage(argv[0], "Input file size does not match.");
return -1;
}
fseek(in_file, 0, SEEK_SET);
#endif
/* load data */
if(1 != fread(in_host, in_size, 1, in_file)) {
usage(argv[0], "Could not read from input file.");
return -1;
}
fclose(in_file);
/* copy data into GPU buffer */
if(cudaSuccess != cudaMemcpy(in_gpu, in_host, in_size, cudaMemcpyHostToDevice)) {
usage(argv[0], "Could not copy input to GPU.");
return -1;
}
/* prepare envents for time emasurement and begin */
cudaEventCreate(&event_end);
cudaEventCreate(&event_begin);
cudaEventRecord(event_begin, 0);
/* compress */
if(cuda_rgb_to_dxt1(in_gpu, out_gpu, size_x, size_y, 0)) {
usage(argv[0], "DXT Encoder error.");
return -1;
}
/* measure kernel time */
cudaEventRecord(event_end, 0);
/* check kernel call */
if(cudaSuccess != cudaDeviceSynchronize()) {
usage(argv[0], cudaGetErrorString(cudaGetLastError()));
return -1;
}
/* print the time */
cudaEventElapsedTime(&kernel_time_ms, event_begin, event_end);
printf("DXT1 compression time: %.3f ms.\n", kernel_time_ms);
/* copy back to host memory */
if(cudaSuccess != cudaMemcpy((char*)out_host + DDS_HEADER_SIZE, out_gpu, out_size, cudaMemcpyDeviceToHost)) {
usage(argv[0], "Could not copy output to host memory.");
return -1;
}
/*
* fill in DDS header
* http://www.team-blur-games.com/wiki/index.php?title=DDS_%28file_format%29
* http://msdn.microsoft.com/en-us/library/windows/desktop/bb943982%28v=vs.85%29.aspx
*/
header = (unsigned int*)out_host;
*(header++) = 0x20534444; /* magic */
*(header++) = 124; /* header size */
*(header++) = 0xA1007; /* flags */
*(header++) = abs(size_y); /* height */
*(header++) = size_x; /* width */
*(header++) = size_x * 2; /* pitch (row size) in bytes */
*(header++) = 1; /* unused 3D depth */
*(header++) = 1; /* unused mipmap count */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 0; /* reserved */
*(header++) = 32; /* pixel format size */
*(header++) = 4; /* pixel format flags */
((char*)header)[0] = 'D';
((char*)header)[1] = 'X';
((char*)header)[2] = 'T';
((char*)header)[3] = '1';
header++; /* skip the four character code */
*(header++) = 0; /* pixel format (unused) */
*(header++) = 0; /* pixel format (unused) */
*(header++) = 0; /* pixel format (unused) */
*(header++) = 0; /* pixel format (unused) */
*(header++) = 0; /* pixel format (unused) */
*(header++) = 0x1000; /* flags */
*(header++) = 0; /* 3D flags */
*(header++) = 0; /* unused */
*(header++) = 0; /* unused */
*(header++) = 0; /* reserved */
/* open output file */
out_file = fopen(argv[4], "w");
if(!out_file) {
usage(argv[0], "Could not open output file for writing.");
return -1;
}
/* write output into the file */
if(1 != fwrite(out_host, dds_size, 1, out_file)) {
usage(argv[0], "Could not write into output file.");
return -1;
}
fclose(out_file);
/* free buffers */
cudaFreeHost(in_host);
cudaFreeHost(out_host);
cudaFree(in_gpu);
cudaFree(out_gpu);
/* indicate success */
return 0;
}
| 2,828 |
432 | <filename>examples/tutorials/rpc-kv-storage/src/main/java/KeyValueStore.java
import java.util.HashMap;
import java.util.Map;
// [START EXAMPLE]
public class KeyValueStore {
private final Map<String, String> store = new HashMap<>();
public String put(String key, String value) {
return store.put(key, value);
}
public String get(String key) {
return store.get(key);
}
}
// [END EXAMPLE]
| 143 |
3,882 | <reponame>OrBin/pytype<gh_stars>1000+
# pylint: skip-file
#- @a defines/binding VarA
#- @b defines/binding VarB
#- @c defines/binding VarC
a = b = c = 1
# TODO(b/137314416): @a ref VarA does not work
#- @x defines/binding VarX
x = (a +
#- @b ref VarB
b +
#- @c ref VarC
c)
#- @y defines/binding VarY
#- @a ref VarA
y = list(a,
#- @b ref VarB
b,
#- @c ref VarC
c)
#- @x ref VarX
#- @y ref VarY
#- @z defines/binding VarZ
z = (x, y)
#- @z ref VarZ
z[1] = (1,
2)
#- @foo defines/binding Foo
#- Foo.node/kind function
def foo(x,
y,
z):
pass
| 309 |
506 | <reponame>Ashindustry007/competitive-programming
#!/usr/bin/env python2
# https://open.kattis.com/problems/twostones
if input() % 2 == 0:
print 'Bob'
else:
print 'Alice'
| 71 |
721 | <filename>apkanalyser/src/mereflect/info/ClassInfo.java
/*
* Copyright (C) 2012 Sony Mobile Communications AB
*
* This file is part of ApkAnalyser.
*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package mereflect.info;
public interface ClassInfo
{
public static final int CONSTANT_Class = 7;
public static final int CONSTANT_Fieldref = 9;
public static final int CONSTANT_Methodref = 10;
public static final int CONSTANT_InterfaceMethodref = 11;
public static final int CONSTANT_String = 8;
public static final int CONSTANT_Integer = 3;
public static final int CONSTANT_Float = 4;
public static final int CONSTANT_Long = 5;
public static final int CONSTANT_Double = 6;
public static final int CONSTANT_NameAndType = 12;
public static final int CONSTANT_Utf8 = 1;
public int getTag();
public int getLength();
}
| 414 |
13,111 | /*
* 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.skywalking.oap.log.analyzer.dsl.spec;
import groovy.lang.Closure;
import groovy.lang.DelegatesTo;
import groovy.util.DelegatingScript;
import org.apache.skywalking.oap.log.analyzer.dsl.spec.filter.FilterSpec;
public class LALDelegatingScript extends DelegatingScript {
@Override
public Object run() {
return null;
}
public void filter(@DelegatesTo(value = FilterSpec.class, strategy = Closure.DELEGATE_ONLY) Closure<?> closure) {
closure.setDelegate(getDelegate());
closure.call();
}
public void json(@DelegatesTo(value = FilterSpec.class) Closure<?> closure) {
closure.setDelegate(getDelegate());
closure.call();
}
public void text(@DelegatesTo(value = FilterSpec.class) Closure<?> closure) {
closure.setDelegate(getDelegate());
closure.call();
}
public void extractor(@DelegatesTo(value = FilterSpec.class) Closure<?> closure) {
closure.setDelegate(getDelegate());
closure.call();
}
public void sink(@DelegatesTo(value = FilterSpec.class) Closure<?> closure) {
closure.setDelegate(getDelegate());
closure.call();
}
}
| 650 |
317 | package com.googlecode.totallylazy.parser;
import com.googlecode.totallylazy.Segment;
import java.util.ArrayList;
import java.util.List;
import static com.googlecode.totallylazy.parser.Success.success;
class ManyParser<A> implements Parser<List<A>> {
private final Parser<? extends A> parser;
private ManyParser(Parser<? extends A> parser) {
this.parser = parser;
}
static <A> ManyParser<A> many(Parser<? extends A> parser) {
return new ManyParser<A>(parser);
}
public Result<List<A>> parse(Segment<Character> characters) {
Segment<Character> segment = characters;
List<A> list = new ArrayList<A>();
while (!segment.isEmpty()) {
Result<? extends A> result = parser.parse(segment);
if (result instanceof Failure) break;
list.add(result.value());
segment = result.remainder();
}
return success(list, segment);
}
@Override
public String toString() {
return String.format("many %s", parser);
}
}
| 413 |
2,151 | <gh_stars>1000+
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/chromeos/extensions/gfx_utils.h"
#include "base/macros.h"
#include "base/stl_util.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/extensions/extension_service_test_base.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/app_list/arc/arc_app_test.h"
#include "chrome/test/base/testing_profile.h"
#include "components/arc/test/fake_app_instance.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_builder.h"
namespace extensions {
namespace {
constexpr char kGmailArcPackage[] = "com.google.android.gm";
constexpr char kGmailArcActivity[] =
"com.google.android.gm.ConversationListActivityGmail";
constexpr char kGmailExtensionId1[] = "pjkljhegncpnkpknbcohdijeoejaedia";
constexpr char kGmailExtensionId2[] = "bjdhhokmhgelphffoafoejjmlfblpdha";
constexpr char kDriveArcPackage[] = "com.google.android.apps.docs";
constexpr char kKeepExtensionId[] = "hmjkmjkepdijhoojdojkdfohbdgmmhki";
} // namespace
class DualBadgeMapTest : public ExtensionServiceTestBase {
public:
DualBadgeMapTest() {}
~DualBadgeMapTest() override { profile_.reset(); }
void SetUp() override {
extensions::ExtensionServiceTestBase::SetUp();
InitializeEmptyExtensionService();
arc_test_.SetUp(profile_.get());
}
void TearDown() override {
arc_test_.TearDown();
extensions::ExtensionServiceTestBase::TearDown();
}
Profile* profile() { return profile_.get(); }
protected:
arc::mojom::ArcPackageInfo CreateArcPackage(const std::string& package_name) {
arc::mojom::ArcPackageInfo package;
package.package_name = package_name;
package.package_version = 1;
package.last_backup_android_id = 1;
package.last_backup_time = 1;
package.sync = false;
return package;
}
void AddArcPackage(const arc::mojom::ArcPackageInfo& package) {
arc_test_.AddPackage(package);
arc_test_.app_instance()->SendPackageAdded(package);
}
void RemoveArcPackage(const arc::mojom::ArcPackageInfo& package) {
arc_test_.RemovePackage(package);
arc_test_.app_instance()->SendPackageUninstalled(package.package_name);
}
arc::mojom::AppInfo CreateArcApp(const std::string& name,
const std::string& package,
const std::string& activity) {
arc::mojom::AppInfo info;
info.name = name;
info.package_name = package;
info.activity = activity;
info.sticky = false;
info.notifications_enabled = false;
return info;
}
void AddArcApp(const arc::mojom::AppInfo& app) {
arc_test_.app_instance()->SendAppAdded(app);
}
scoped_refptr<Extension> CreateExtension(const std::string& id) {
return ExtensionBuilder("test").SetID(id).Build();
}
void AddExtension(const Extension* extension) {
service()->AddExtension(extension);
}
void RemoveExtension(const Extension* extension) {
service()->UninstallExtension(
extension->id(), extensions::UNINSTALL_REASON_FOR_TESTING, NULL);
}
private:
ArcAppTest arc_test_;
DISALLOW_COPY_AND_ASSIGN(DualBadgeMapTest);
};
TEST_F(DualBadgeMapTest, ExtensionToArcAppMapTest) {
// Install two Gmail extension apps.
AddExtension(CreateExtension(kGmailExtensionId1).get());
AddExtension(CreateExtension(kGmailExtensionId2).get());
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId1));
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId2));
// Install Gmail Playstore app.
const arc::mojom::ArcPackageInfo app_info =
CreateArcPackage(kGmailArcPackage);
AddArcPackage(app_info);
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId1));
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId2));
AddArcApp(CreateArcApp("gmail", kGmailArcPackage, kGmailArcActivity));
EXPECT_TRUE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId1));
EXPECT_TRUE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId2));
RemoveArcPackage(app_info);
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId1));
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId2));
// Install an unrelated Playstore app.
AddArcPackage(CreateArcPackage(kDriveArcPackage));
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId1));
EXPECT_FALSE(extensions::util::HasEquivalentInstalledArcApp(
profile(), kGmailExtensionId2));
}
TEST_F(DualBadgeMapTest, ArcAppToExtensionMapTest) {
// Install Gmail Playstore app.
AddArcPackage(CreateArcPackage(kGmailArcPackage));
AddArcApp(CreateArcApp("gmail", kGmailArcPackage, kGmailArcActivity));
std::vector<std::string> extension_ids =
extensions::util::GetEquivalentInstalledExtensions(profile(),
kGmailArcPackage);
EXPECT_TRUE(0 == extension_ids.size());
// Install Gmail extension app.
scoped_refptr<Extension> extension1 = CreateExtension(kGmailExtensionId1);
AddExtension(extension1.get());
extension_ids = extensions::util::GetEquivalentInstalledExtensions(
profile(), kGmailArcPackage);
EXPECT_TRUE(1 == extension_ids.size());
EXPECT_TRUE(base::ContainsValue(extension_ids, kGmailExtensionId1));
// Install another Gmail extension app.
scoped_refptr<Extension> extension2 = CreateExtension(kGmailExtensionId2);
AddExtension(extension2.get());
extension_ids = extensions::util::GetEquivalentInstalledExtensions(
profile(), kGmailArcPackage);
EXPECT_TRUE(2 == extension_ids.size());
EXPECT_TRUE(base::ContainsValue(extension_ids, kGmailExtensionId1));
EXPECT_TRUE(base::ContainsValue(extension_ids, kGmailExtensionId2));
RemoveExtension(extension1.get());
extension_ids = extensions::util::GetEquivalentInstalledExtensions(
profile(), kGmailArcPackage);
EXPECT_TRUE(1 == extension_ids.size());
EXPECT_FALSE(base::ContainsValue(extension_ids, kGmailExtensionId1));
EXPECT_TRUE(base::ContainsValue(extension_ids, kGmailExtensionId2));
RemoveExtension(extension2.get());
extension_ids = extensions::util::GetEquivalentInstalledExtensions(
profile(), kGmailArcPackage);
EXPECT_TRUE(0 == extension_ids.size());
// Install an unrelated Google Keep extension app.
scoped_refptr<Extension> extension = CreateExtension(kKeepExtensionId);
AddExtension(extension.get());
extension_ids = extensions::util::GetEquivalentInstalledExtensions(
profile(), kGmailArcPackage);
EXPECT_TRUE(0 == extension_ids.size());
}
} // namespace extensions
| 2,494 |
2,293 | """Interface to the compiler's internal symbol tables"""
import _symtable
from _symtable import (USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM,
DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC,
SCOPE_OFF, SCOPE_MASK, FREE, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
import warnings
import weakref
__all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]
def symtable(code, filename, compile_type):
raw = _symtable.symtable(code, filename, compile_type)
for top in raw.itervalues():
if top.name == 'top':
break
return _newSymbolTable(top, filename)
class SymbolTableFactory:
def __init__(self):
self.__memo = weakref.WeakValueDictionary()
def new(self, table, filename):
if table.type == _symtable.TYPE_FUNCTION:
return Function(table, filename)
if table.type == _symtable.TYPE_CLASS:
return Class(table, filename)
return SymbolTable(table, filename)
def __call__(self, table, filename):
key = table, filename
obj = self.__memo.get(key, None)
if obj is None:
obj = self.__memo[key] = self.new(table, filename)
return obj
_newSymbolTable = SymbolTableFactory()
class SymbolTable(object):
def __init__(self, raw_table, filename):
self._table = raw_table
self._filename = filename
self._symbols = {}
def __repr__(self):
if self.__class__ == SymbolTable:
kind = ""
else:
kind = "%s " % self.__class__.__name__
if self._table.name == "global":
return "<{0}SymbolTable for module {1}>".format(kind, self._filename)
else:
return "<{0}SymbolTable for {1} in {2}>".format(kind,
self._table.name,
self._filename)
def get_type(self):
if self._table.type == _symtable.TYPE_MODULE:
return "module"
if self._table.type == _symtable.TYPE_FUNCTION:
return "function"
if self._table.type == _symtable.TYPE_CLASS:
return "class"
assert self._table.type in (1, 2, 3), \
"unexpected type: {0}".format(self._table.type)
def get_id(self):
return self._table.id
def get_name(self):
return self._table.name
def get_lineno(self):
return self._table.lineno
def is_optimized(self):
return bool(self._table.type == _symtable.TYPE_FUNCTION
and not self._table.optimized)
def is_nested(self):
return bool(self._table.nested)
def has_children(self):
return bool(self._table.children)
def has_exec(self):
"""Return true if the scope uses exec"""
return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
def has_import_star(self):
"""Return true if the scope uses import *"""
return bool(self._table.optimized & OPT_IMPORT_STAR)
def get_identifiers(self):
return self._table.symbols.keys()
def lookup(self, name):
sym = self._symbols.get(name)
if sym is None:
flags = self._table.symbols[name]
namespaces = self.__check_children(name)
sym = self._symbols[name] = Symbol(name, flags, namespaces)
return sym
def get_symbols(self):
return [self.lookup(ident) for ident in self.get_identifiers()]
def __check_children(self, name):
return [_newSymbolTable(st, self._filename)
for st in self._table.children
if st.name == name]
def get_children(self):
return [_newSymbolTable(st, self._filename)
for st in self._table.children]
class Function(SymbolTable):
# Default values for instance variables
__params = None
__locals = None
__frees = None
__globals = None
def __idents_matching(self, test_func):
return tuple([ident for ident in self.get_identifiers()
if test_func(self._table.symbols[ident])])
def get_parameters(self):
if self.__params is None:
self.__params = self.__idents_matching(lambda x:x & DEF_PARAM)
return self.__params
def get_locals(self):
if self.__locals is None:
self.__locals = self.__idents_matching(lambda x:x & DEF_BOUND)
return self.__locals
def get_globals(self):
if self.__globals is None:
glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
self.__globals = self.__idents_matching(test)
return self.__globals
def get_frees(self):
if self.__frees is None:
is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE
self.__frees = self.__idents_matching(is_free)
return self.__frees
class Class(SymbolTable):
__methods = None
def get_methods(self):
if self.__methods is None:
d = {}
for st in self._table.children:
d[st.name] = 1
self.__methods = tuple(d)
return self.__methods
class Symbol(object):
def __init__(self, name, flags, namespaces=None):
self.__name = name
self.__flags = flags
self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()
self.__namespaces = namespaces or ()
def __repr__(self):
return "<symbol {0!r}>".format(self.__name)
def get_name(self):
return self.__name
def is_referenced(self):
return bool(self.__flags & _symtable.USE)
def is_parameter(self):
return bool(self.__flags & DEF_PARAM)
def is_global(self):
return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))
def is_vararg(self):
warnings.warn("is_vararg() is obsolete and will be removed",
DeprecationWarning, 2)
return False
def is_keywordarg(self):
warnings.warn("is_keywordarg() is obsolete and will be removed",
DeprecationWarning, 2)
return False
def is_declared_global(self):
return bool(self.__scope == GLOBAL_EXPLICIT)
def is_local(self):
return bool(self.__flags & DEF_BOUND)
def is_free(self):
return bool(self.__scope == FREE)
def is_imported(self):
return bool(self.__flags & DEF_IMPORT)
def is_assigned(self):
return bool(self.__flags & DEF_LOCAL)
def is_in_tuple(self):
warnings.warn("is_in_tuple() is obsolete and will be removed",
DeprecationWarning, 2)
def is_namespace(self):
"""Returns true if name binding introduces new namespace.
If the name is used as the target of a function or class
statement, this will be true.
Note that a single name can be bound to multiple objects. If
is_namespace() is true, the name may also be bound to other
objects, like an int or list, that does not introduce a new
namespace.
"""
return bool(self.__namespaces)
def get_namespaces(self):
"""Return a list of namespaces bound to this name"""
return self.__namespaces
def get_namespace(self):
"""Returns the single namespace bound to this name.
Raises ValueError if the name is bound to multiple namespaces.
"""
if len(self.__namespaces) != 1:
raise ValueError, "name is bound to multiple namespaces"
return self.__namespaces[0]
if __name__ == "__main__":
import os, sys
src = open(sys.argv[0]).read()
mod = symtable(src, os.path.split(sys.argv[0])[1], "exec")
for ident in mod.get_identifiers():
info = mod.lookup(ident)
print info, info.is_local(), info.is_namespace()
| 3,541 |
2,777 | <gh_stars>1000+
#pragma once
#include <QDateTime>
#include <QString>
#include <QFileInfo>
#include <memory>
struct ScreenShot {
using Ptr = std::shared_ptr<ScreenShot>;
ScreenShot(QFileInfo file) {
m_file = file;
}
QFileInfo m_file;
QString m_url;
QString m_imgurId;
QString m_imgurDeleteHash;
};
| 146 |
831 | <filename>Python/02. Basic Data Types/002. Find the Runner-Up Score!.py
# Problem: https://www.hackerrank.com/challenges/find-second-maximum-number-in-a-list/problem
# Score: 10
n = int(input())
arr = list(map(int, input().split()))
print(max([x for x in arr if x != max(arr)]))
| 99 |
578 | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "cachelib/allocator/tests/MultiAllocatorTest.h"
#include <algorithm>
#include <future>
#include <mutex>
#include <thread>
#include "cachelib/allocator/CacheAllocator.h"
#include "cachelib/allocator/tests/TestBase.h"
namespace facebook {
namespace cachelib {
namespace tests {
using LruTo2QTest = MultiAllocatorTest<LruAllocator, Lru2QAllocator>;
TEST_F(LruTo2QTest, InvalidAttach) { testInCompatibility(); }
using TwoQToLruTest = MultiAllocatorTest<Lru2QAllocator, LruAllocator>;
TEST_F(TwoQToLruTest, InvalidAttach) { testInCompatibility(); }
} // namespace tests
} // namespace cachelib
} // namespace facebook
| 389 |
30,785 | <reponame>zhongqingsong/jadx<filename>jadx-plugins/jadx-plugins-api/src/main/java/jadx/api/plugins/input/data/annotations/EncodedValue.java
package jadx.api.plugins.input.data.annotations;
import java.util.Objects;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
public class EncodedValue implements IJadxAttribute {
public static final EncodedValue NULL = new EncodedValue(EncodedType.ENCODED_NULL, null);
private final EncodedType type;
private final Object value;
public EncodedValue(EncodedType type, Object value) {
this.type = type;
this.value = value;
}
public EncodedType getType() {
return type;
}
public Object getValue() {
return value;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
EncodedValue that = (EncodedValue) o;
return type == that.getType() && Objects.equals(value, that.getValue());
}
@Override
public IJadxAttrType<? extends IJadxAttribute> getAttrType() {
return JadxAttrType.CONSTANT_VALUE;
}
@Override
public int hashCode() {
return Objects.hash(getType(), getValue());
}
@Override
public String toString() {
switch (type) {
case ENCODED_NULL:
return "null";
case ENCODED_STRING:
return (String) value;
case ENCODED_ARRAY:
return "[" + value + "]";
default:
return "{" + type + ": " + value + '}';
}
}
}
| 593 |
1,238 | # coding:utf-8
from sogou_mrc.utils.tokenizer import SpacyTokenizer
from sogou_mrc.dataset.base_dataset import BaseReader, BaseEvaluator
import json
from collections import OrderedDict, Counter
from tqdm import tqdm
import logging
import re
import collections
import string
import sys
class SquadV2Reader(BaseReader):
def __init__(self):
self.tokenizer = SpacyTokenizer()
def read(self, file_path):
logging.info("Reading file at %s", file_path)
logging.info("Processing the dataset.")
instances = self._read(file_path)
instances = [instance for instance in tqdm(instances)]
return instances
def _read(self, file_path):
with open(file_path) as dataset_file:
dataset_json = json.load(dataset_file)
dataset = dataset_json['data']
for article in dataset:
for paragraph in article['paragraphs']:
context = paragraph["context"]
context_tokens, context_token_spans = self.tokenizer.word_tokenizer(context)
for question_answer in paragraph['qas']:
question = question_answer["question"].strip()
question_tokens, _ = self.tokenizer.word_tokenizer(question)
answers, span_starts, span_ends = [], [], []
if "answers" in question_answer:
answers = [answer['text'] for answer in question_answer['answers']]
span_starts = [answer['answer_start']
for answer in question_answer['answers']]
span_ends = [start + len(answer)
for start, answer in zip(span_starts, answers)]
if 'is_impossible' in question_answer and question_answer['is_impossible']:
span_starts = [0]
span_ends = [0]
answer_char_spans = zip(span_starts, span_ends) if len(
span_starts) > 0 and len(span_ends) > 0 else None
answers = answers if len(answers) > 0 else [""]
is_impossible = None if 'is_impossible' not in question_answer else question_answer[
'is_impossible'] * 1
qid = question_answer['id']
yield self._make_instance(context, context_tokens, context_token_spans,
question, question_tokens, answer_char_spans, answers, is_impossible, qid)
def _make_instance(self, context, context_tokens, context_token_spans, question, question_tokens,
answer_char_spans=None, answers=None, is_impossible=None, qid=None):
answer_token_starts, answer_token_ends = [], []
if answers is not None:
for answer_char_start, answer_char_end in answer_char_spans:
answer_token_span = []
for idx, span in enumerate(context_token_spans):
if not (answer_char_end <= span[0] or answer_char_start >= span[1]):
answer_token_span.append(idx)
if len(answer_token_span) == 0: break #print(is_impossible) #break #continue
answer_token_starts.append(answer_token_span[0])
answer_token_ends.append(answer_token_span[-1])
abstractive_answer_mask = [0]
if is_impossible is not None and is_impossible:
answer_token_starts=[]
answer_token_ends=[]
answer_token_starts.append(0)
answer_token_ends.append(0)
abstractive_answer_mask = [1]
return OrderedDict({
"context": context,
"context_tokens": context_tokens,
"context_token_spans": context_token_spans,
"is_impossible": is_impossible,
"question": question,
'qid': qid,
"question_tokens": question_tokens,
"answer": answers[0] if answers is not None else [],
"answer_start": answer_token_starts[0] if len(answer_token_starts) > 0 is not None else None,
"answer_end": answer_token_ends[0] if len(answer_token_ends) > 0 is not None else None,
"abstractive_answer_mask": abstractive_answer_mask
})
class SquadV2Evaluator(BaseEvaluator):
def __init__(self, file_path, monitor='best_f1', na_prob_thresh=1.0):
self.na_prob_thresh = na_prob_thresh
self.monitor = monitor
self.ground_dict = dict()
self.id_list = []
with open(file_path) as dataset_file:
dataset_json = json.load(dataset_file)
dataset = dataset_json['data']
self.has_ans_qids = set()
self.no_ans_qids = set()
for article in dataset:
for paragraph in article['paragraphs']:
for question_answer in paragraph['qas']:
id = question_answer["id"]
gold_answers = [a['text'] for a in question_answer['answers']
if SquadV2Evaluator.normalize_answer(a['text'])]
if not gold_answers:
gold_answers = ['']
self.no_ans_qids.add(id)
else:
self.has_ans_qids.add(id)
self.ground_dict[id] = gold_answers
def get_monitor(self):
return self.monitor
def get_score(self, input):
preds, na_proba = input
exact_raw, f1_raw = self.get_raw_score(preds)
na_prob_thresh = self.na_prob_thresh
exact_thresh = self.apply_no_ans_threshold(exact_raw, na_proba, na_prob_thresh)
f1_thresh = self.apply_no_ans_threshold(f1_raw, na_proba, na_prob_thresh)
out_eval = SquadV2Evaluator.make_eval_dict(exact_thresh, f1_thresh)
if len(self.has_ans_qids) > 0:
has_ans_eval = SquadV2Evaluator.make_eval_dict(exact_thresh, f1_thresh, qid_list=self.has_ans_qids)
SquadV2Evaluator.merge_eval(out_eval, has_ans_eval, 'HasAns')
if len(self.no_ans_qids) > 0:
no_ans_eval = SquadV2Evaluator.make_eval_dict(exact_thresh, f1_thresh, qid_list=self.no_ans_qids)
SquadV2Evaluator.merge_eval(out_eval, no_ans_eval, 'NoAns')
self.find_all_best_thresh(out_eval, preds, exact_raw, f1_raw, na_proba)
return dict(out_eval)
def find_all_best_thresh(self, main_eval, preds, exact_raw, f1_raw, na_probs):
best_exact, exact_thresh = self.find_best_thresh(preds, exact_raw, na_probs)
best_f1, f1_thresh = self.find_best_thresh(preds, f1_raw, na_probs)
main_eval['best_exact'] = best_exact
main_eval['best_exact_thresh'] = exact_thresh
main_eval['best_f1'] = best_f1
main_eval['best_f1_thresh'] = f1_thresh
@staticmethod
def merge_eval(main_eval, new_eval, prefix):
for k in new_eval:
main_eval['%s_%s' % (prefix, k)] = new_eval[k]
@staticmethod
def make_eval_dict(exact_scores, f1_scores, qid_list=None):
if not qid_list:
total = len(exact_scores)
return collections.OrderedDict([
('exact', 100.0 * sum(exact_scores.values()) / total),
('f1', 100.0 * sum(f1_scores.values()) / total),
('total', total),
])
else:
total = len(qid_list)
return collections.OrderedDict([
('exact', 100.0 * sum(exact_scores[k] for k in qid_list) / total),
('f1', 100.0 * sum(f1_scores[k] for k in qid_list) / total),
('total', total),
])
def find_best_thresh(self, preds, scores, na_probs):
num_no_ans = len(self.no_ans_qids)
cur_score = num_no_ans
best_score = cur_score
best_thresh = 0.0
qid_list = sorted(na_probs, key=lambda k: na_probs[k])
for i, qid in enumerate(qid_list):
if qid not in scores: continue
if qid in self.has_ans_qids:
diff = scores[qid]
else:
if preds[qid]:
diff = -1
else:
diff = 0
cur_score += diff
if cur_score > best_score:
best_score = cur_score
best_thresh = na_probs[qid]
return 100.0 * best_score / len(scores), best_thresh
def apply_no_ans_threshold(self, scores, na_probs, na_prob_thresh):
new_scores = {}
for qid, s in scores.items():
pred_na = na_probs[qid] > na_prob_thresh
if pred_na:
new_scores[qid] = float(not qid in self.has_ans_qids)
else:
new_scores[qid] = s
return new_scores
def get_raw_score(self, preds):
# assert len(self.ground_dict) == len(preds)
exact_scores = {}
f1_scores = {}
for qid in self.ground_dict:
if qid not in preds:
print('Missing prediction for %s' % qid)
continue
a_pred = preds[qid]
golden_answers = self.ground_dict[qid]
# Take max over all gold answers
exact_scores[qid] = max([SquadV2Evaluator.compute_exact(a, a_pred) for a in golden_answers])
f1_scores[qid] = max([SquadV2Evaluator.compute_f1(a, a_pred) for a in golden_answers])
return exact_scores, f1_scores
@staticmethod
def normalize_answer(s):
"""Lower text and remove punctuation, articles and extra whitespace."""
def remove_articles(text):
regex = re.compile(r'\b(a|an|the)\b', re.UNICODE)
return re.sub(regex, ' ', text)
def white_space_fix(text):
return ' '.join(text.split())
def remove_punc(text):
exclude = set(string.punctuation)
return ''.join(ch for ch in text if ch not in exclude)
def lower(text):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(s))))
@staticmethod
def compute_exact(a_gold, a_pred):
return int(SquadV2Evaluator.normalize_answer(a_gold) == SquadV2Evaluator.normalize_answer(a_pred))
@staticmethod
def get_tokens(s):
if not s: return []
return SquadV2Evaluator.normalize_answer(s).split()
@staticmethod
def compute_f1(a_gold, a_pred):
gold_toks = SquadV2Evaluator.get_tokens(a_gold)
pred_toks = SquadV2Evaluator.get_tokens(a_pred)
common = collections.Counter(gold_toks) & collections.Counter(pred_toks)
num_same = sum(common.values())
if len(gold_toks) == 0 or len(pred_toks) == 0:
# If either is no-answer, then F1 is 1 if they agree, 0 otherwise
return int(gold_toks == pred_toks)
if num_same == 0:
return 0
precision = 1.0 * num_same / len(pred_toks)
recall = 1.0 * num_same / len(gold_toks)
f1 = (2 * precision * recall) / (precision + recall)
return f1
| 5,684 |
1,874 | <filename>nova/tests/unit/api/openstack/compute/test_server_diagnostics.py<gh_stars>1000+
# Copyright 2011 <NAME>
# All Rights Reserved.
#
# Licensed 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
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import mock
from oslo_serialization import jsonutils
from oslo_utils.fixture import uuidsentinel as uuids
from nova.api.openstack import wsgi as os_wsgi
from nova.compute import api as compute_api
from nova import exception
from nova import objects
from nova import test
from nova.tests.unit.api.openstack import fakes
UUID = uuids.abc
def fake_instance_get(self, _context, instance_uuid, expected_attrs=None,
cell_down_support=False):
if instance_uuid != UUID:
raise Exception("Invalid UUID")
return objects.Instance(uuid=instance_uuid,
project_id=_context.project_id,
host='123')
class ServerDiagnosticsTestV21(test.NoDBTestCase):
mock_diagnostics_method = 'get_diagnostics'
api_version = '2.1'
def _setup_router(self):
self.router = fakes.wsgi_app_v21()
def _get_request(self):
return fakes.HTTPRequest.blank(
'/v2/%s/servers/%s/diagnostics' % (fakes.FAKE_PROJECT_ID, UUID),
version=self.api_version,
headers = {os_wsgi.API_VERSION_REQUEST_HEADER:
'compute %s' % self.api_version})
def setUp(self):
super(ServerDiagnosticsTestV21, self).setUp()
self._setup_router()
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def _test_get_diagnostics(self, expected, return_value):
req = self._get_request()
with mock.patch.object(compute_api.API, self.mock_diagnostics_method,
return_value=return_value):
res = req.get_response(self.router)
output = jsonutils.loads(res.body)
self.assertEqual(expected, output)
def test_get_diagnostics(self):
diagnostics = {'data': 'Some diagnostics info'}
self._test_get_diagnostics(diagnostics, diagnostics)
@mock.patch.object(compute_api.API, 'get',
side_effect=exception.InstanceNotFound(instance_id=UUID))
def test_get_diagnostics_with_non_existed_instance(self, mock_get):
req = self._get_request()
res = req.get_response(self.router)
self.assertEqual(res.status_int, 404)
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics_raise_conflict_on_invalid_state(self):
req = self._get_request()
with mock.patch.object(compute_api.API, self.mock_diagnostics_method,
side_effect=exception.InstanceInvalidState('fake message')):
res = req.get_response(self.router)
self.assertEqual(409, res.status_int)
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics_raise_instance_not_ready(self):
req = self._get_request()
with mock.patch.object(compute_api.API, self.mock_diagnostics_method,
side_effect=exception.InstanceNotReady('fake message')):
res = req.get_response(self.router)
self.assertEqual(409, res.status_int)
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics_raise_no_notimplementederror(self):
req = self._get_request()
with mock.patch.object(compute_api.API, self.mock_diagnostics_method,
side_effect=NotImplementedError):
res = req.get_response(self.router)
self.assertEqual(501, res.status_int)
class ServerDiagnosticsTestV248(ServerDiagnosticsTestV21):
mock_diagnostics_method = 'get_instance_diagnostics'
api_version = '2.48'
def test_get_diagnostics(self):
return_value = objects.Diagnostics(
config_drive=False,
state='running',
driver='libvirt',
uptime=5,
hypervisor='hypervisor',
# hypervisor_os is unset
cpu_details=[
objects.CpuDiagnostics(id=0, time=1111, utilisation=11),
objects.CpuDiagnostics(id=1, time=None, utilisation=22),
objects.CpuDiagnostics(id=2, time=3333, utilisation=None),
objects.CpuDiagnostics(id=None, time=4444, utilisation=44)],
nic_details=[objects.NicDiagnostics(
mac_address='de:ad:be:ef:00:01',
rx_drop=1,
rx_errors=2,
rx_octets=3,
rx_packets=4,
rx_rate=5,
tx_drop=6,
tx_errors=7,
tx_octets=8,
# tx_packets is unset
tx_rate=None)],
disk_details=[objects.DiskDiagnostics(
errors_count=1,
read_bytes=2,
read_requests=3,
# write_bytes is unset
write_requests=None)],
num_cpus=4,
num_disks=1,
num_nics=1,
memory_details=objects.MemoryDiagnostics(maximum=8192, used=3072))
expected = {
'config_drive': False,
'state': 'running',
'driver': 'libvirt',
'uptime': 5,
'hypervisor': 'hypervisor',
'hypervisor_os': None,
'cpu_details': [{'id': 0, 'time': 1111, 'utilisation': 11},
{'id': 1, 'time': None, 'utilisation': 22},
{'id': 2, 'time': 3333, 'utilisation': None},
{'id': None, 'time': 4444, 'utilisation': 44}],
'nic_details': [{'mac_address': 'de:ad:be:ef:00:01',
'rx_drop': 1,
'rx_errors': 2,
'rx_octets': 3,
'rx_packets': 4,
'rx_rate': 5,
'tx_drop': 6,
'tx_errors': 7,
'tx_octets': 8,
'tx_packets': None,
'tx_rate': None}],
'disk_details': [{'errors_count': 1,
'read_bytes': 2,
'read_requests': 3,
'write_bytes': None,
'write_requests': None}],
'num_cpus': 4,
'num_disks': 1,
'num_nics': 1,
'memory_details': {'maximum': 8192, 'used': 3072}}
self._test_get_diagnostics(expected, return_value)
| 3,595 |
453 | /* open for MMIXware.
Copyright (C) 2001, 2002 <NAME>
Permission to use, copy, modify, and distribute this software is
freely granted, provided that the above copyright notice, this notice
and the following disclaimer are preserved with no changes.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. */
#include <stdlib.h>
#include <fcntl.h>
#include <_ansi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "sys/syscall.h"
#include <errno.h>
/* Let's keep the filehandle array here, since this is a primary
initializer of it. */
unsigned char _MMIX_allocated_filehandle[32] =
{
1,
1,
1,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
int
_open (const char *path,
int flags, ...)
{
long fileno;
unsigned char mode;
long append_contents = 0;
unsigned long prev_contents_size = 0;
char *prev_contents = NULL;
long ret;
for (fileno = 0;
fileno < (sizeof (_MMIX_allocated_filehandle) /
sizeof (_MMIX_allocated_filehandle[0]));
fileno++)
if (_MMIX_allocated_filehandle[fileno] == 0)
break;
if (fileno == (sizeof (_MMIX_allocated_filehandle) /
sizeof (_MMIX_allocated_filehandle[0])))
{
errno = EMFILE;
return -1;
}
/* We map this to a fopen call. The flags parameter is stymied because
we don't support other than these flags. */
if (flags & ~(O_RDONLY | O_WRONLY | O_RDWR | O_CREAT | O_APPEND | O_TRUNC))
{
UNIMPLEMENTED (("path: %s, flags: %d", path, flags));
errno = ENOSYS;
return -1;
}
if ((flags & O_ACCMODE) == O_RDONLY)
mode = BinaryRead;
else if ((flags & (O_WRONLY | O_APPEND)) == (O_WRONLY | O_APPEND))
{
mode = BinaryReadWrite;
append_contents = 1;
}
else if ((flags & (O_RDWR | O_APPEND)) == (O_RDWR | O_APPEND))
{
mode = BinaryReadWrite;
append_contents = 1;
}
else if ((flags & (O_WRONLY | O_CREAT)) == (O_WRONLY | O_CREAT)
|| (flags & (O_WRONLY | O_TRUNC)) == (O_WRONLY | O_TRUNC))
mode = BinaryWrite;
else if ((flags & (O_RDWR | O_CREAT)) == (O_RDWR | O_CREAT))
mode = BinaryReadWrite;
else if (flags & O_RDWR)
mode = BinaryReadWrite;
else
{
errno = EINVAL;
return -1;
}
if (append_contents)
{
/* BinaryReadWrite is equal to "w+", so it truncates the file rather
than keeping the contents, as can be imagined if you're looking
for append functionality. The only way we can keep the contents
so we can append to it, is by first reading in and saving the
contents, then re-opening the file as BinaryReadWrite and write
the previous contents. This seems to work for the needs of
simple test-programs. */
long openexist = TRAP3f (SYS_Fopen, fileno, path, BinaryRead);
if (openexist == 0)
{
/* Yes, this file exists, now opened, so let's read it and keep
the contents. Better have the memory around for this to
work. */
long seekval = TRAP2f (SYS_Fseek, fileno, -1);
if (seekval == 0)
{
prev_contents_size = TRAP1f (SYS_Ftell, fileno);
/* If the file has non-zero size, we have something to
append to. */
if (prev_contents_size != 0)
{
/* Start reading from the beginning. Ignore the return
value from this call: we'll notice if we can't read
as much as we want. */
TRAP2f (SYS_Fseek, fileno, 0);
prev_contents = malloc (prev_contents_size);
if (prev_contents != 0)
{
/* I don't like the thought of trying to read the
whole file all at once, disregarding the size,
because the host system might not support that
and we'd get funky errors. Read in 32k at a
time. */
char *ptr = prev_contents;
unsigned long read_more = prev_contents_size;
unsigned long chunk_size = 1 << 15;
while (read_more >= chunk_size)
{
long readval
= TRAP3f (SYS_Fread, fileno, ptr, chunk_size);
if (readval != 0)
{
free (prev_contents);
TRAP1f (SYS_Fclose, fileno);
errno = EIO;
return -1;
}
read_more -= chunk_size;
ptr += chunk_size;
}
if (read_more != 0)
{
long readval
= TRAP3f (SYS_Fread, fileno, ptr, read_more);
if (readval != 0)
{
free (prev_contents);
TRAP1f (SYS_Fclose, fileno);
errno = EIO;
return -1;
}
}
}
else
{
/* Malloc of area to copy to failed. The glibc
manpage says its open can return ENOMEM due to
kernel memory failures, so let's do that too
here. */
errno = ENOMEM;
return -1;
}
}
}
else
{
/* Seek failed. Gotta be some I/O error. */
errno = EIO;
return -1;
}
TRAP1f (SYS_Fclose, fileno);
}
}
ret = TRAP3f (SYS_Fopen, fileno, path, mode);
if (ret < 0)
{
/* It's totally unknown what the error was. We'll just take our
chances and assume ENOENT. */
errno = ENOENT;
return -1;
}
if (prev_contents_size != 0)
{
/* Write out the previous contents, a chunk at a time. Leave the
file pointer at the end of the file. */
unsigned long write_more = prev_contents_size;
unsigned long chunk_size = 1 << 15;
char *ptr = prev_contents;
while (write_more >= chunk_size)
{
long writeval
= TRAP3f (SYS_Fwrite, fileno, ptr, chunk_size);
if (writeval != 0)
{
free (prev_contents);
TRAP1f (SYS_Fclose, fileno);
errno = EIO;
return -1;
}
write_more -= chunk_size;
ptr += chunk_size;
}
if (write_more != 0)
{
long writeval
= TRAP3f (SYS_Fwrite, fileno, ptr, write_more);
if (writeval != 0)
{
free (prev_contents);
TRAP1f (SYS_Fclose, fileno);
errno = EIO;
return -1;
}
}
free (prev_contents);
}
_MMIX_allocated_filehandle[fileno] = 1;
return fileno;
}
| 2,721 |
3,579 | <reponame>coder-hugo/querydsl<filename>querydsl-collections/src/test/java/com/querydsl/collections/QPerson.java
package com.querydsl.collections;
import com.querydsl.core.types.PathMetadata;
import com.querydsl.core.types.dsl.BeanPath;
import com.querydsl.core.types.dsl.StringPath;
public class QPerson extends BeanPath<Person> {
public final StringPath name = createString("name");
public static QPerson car = new QPerson(new BeanPath<Person>(Person.class, "person"));
public QPerson(BeanPath<? extends Person> entity) {
super(entity.getType(), entity.getMetadata());
}
public QPerson(PathMetadata metadata) {
super(Person.class, metadata);
}
}
| 248 |
17,965 | <filename>lib/weather_data.py
"""
Weather data source
"""
import json
import requests
from globals import WWO_KEY
def get_weather_data(location, lang):
"""
Get weather data for `location`
"""
key = WWO_KEY
url = ('/premium/v1/weather.ashx'
'?key=%s&q=%s&format=json'
'&num_of_days=3&tp=3&lang=%s') % (key, location, lang)
url = 'http://127.0.0.1:5001' + url
response = requests.get(url, timeout=10)
try:
data = json.loads(response.content)
except ValueError:
data = {}
return data
| 250 |
468 | from pick import Picker
def test_move_up_down():
title = "Please choose an option: "
options = ["option1", "option2", "option3"]
picker = Picker(options, title)
picker.move_up()
assert picker.get_selected() == ("option3", 2)
picker.move_down()
picker.move_down()
assert picker.get_selected() == ("option2", 1)
def test_default_index():
title = "Please choose an option: "
options = ["option1", "option2", "option3"]
picker = Picker(options, title, default_index=1)
assert picker.get_selected() == ("option2", 1)
def test_get_lines():
title = "Please choose an option: "
options = ["option1", "option2", "option3"]
picker = Picker(options, title, indicator="*")
lines, current_line = picker.get_lines()
assert lines == [title, "", "* option1", " option2", " option3"]
assert current_line == 3
def test_no_title():
options = ["option1", "option2", "option3"]
picker = Picker(options)
lines, current_line = picker.get_lines()
assert current_line == 1
def test_multi_select():
title = "Please choose an option: "
options = ["option1", "option2", "option3"]
picker = Picker(options, title, multiselect=True, min_selection_count=1)
assert picker.get_selected() == []
picker.mark_index()
assert picker.get_selected() == [("option1", 0)]
picker.move_down()
picker.mark_index()
assert picker.get_selected() == [("option1", 0), ("option2", 1)]
def test_options_map_func():
title = "Please choose an option: "
options = [{"label": "option1"}, {"label": "option2"}, {"label": "option3"}]
def get_label(option):
return option.get("label")
picker = Picker(options, title, indicator="*", options_map_func=get_label)
lines, current_line = picker.get_lines()
assert lines == [title, "", "* option1", " option2", " option3"]
assert picker.get_selected() == ({"label": "option1"}, 0)
| 725 |
778 | <reponame>lkusch/Kratos
#pragma once
#include "u_delphiClasses.h"
#include "Math3D.h"
//------ MENUS
#define SURFACE 1
#define VOLUME 2
#define COLORIZE 3
#define UPDATE_IDS 0
#define GENERATE_SURFACE 1
#define KEEP_ORIG_IDS 2
#define KRATOS
#define OPEN_MP
typedef char* String;
// Solution using a typedef: Define a pointer to a function which is taking
// two floats and returns a float
typedef float(*fncEvaluation)(TObject*);
const int TTetraFaces[] = {0,1,2, // Face 0
0,2,3,// Face 1
0,3,1,// Face 2
1,3,2 }; // Face 3]
bool sortByID(TObject* i, TObject* j);
bool sortByQuality(TObject* i, TObject* j);
struct object
{
virtual ~object() = 0;
};
class TValuedObject : public TObject
{
//protected :
public:
int id;
double fmetrica ,calidad;
bool marked, changed ,locked,isdestroyed;
int groupID,visited,flag , innerFlag;
void* linkSet ;
int _color ;
bool blockID;
//float4 rColor;
object* userData;
TValuedObject(void) ;
virtual ~TValuedObject(void) ;
float4 getCenter() ;
void setID(int nid);
int getID() ;
};
class TNeighboured : public TValuedObject{};
class TVertex: public TNeighboured
{
public:
float4 fPos ;
int fixed ;
TList<TObject*>* neighTr;
TList<TObject*>* elementsList;
TList<TVertex*>* neighV;
bool isSurface;
float4* normal ;
double expectedSize ;
TVertex(float x,float y, float z);
TVertex(float4 v);
~TVertex() override;
void calcNormal();
float4 pos();
TList<TVertex*> *getVertexNeighboursByElem(TList<TVertex*> *toL = nullptr , int depth = 1, int avoidLowerIds = false);
TList<TVertex*>* getVertexNeighboursByTriangle(TList<TVertex*>* toL = nullptr , int depth = 1);
};
class TVertex3D : public TVertex
{
};
typedef double(*TVertexesEvaluator)(TVertex*[]);
class TPolygon: public TNeighboured
{
private :
public :
TVertex* vertexes[3];
float4 normal;
};
class TTriangle: public TPolygon
{
public :
TTriangle(TVertex* v0,TVertex* v1,TVertex* v2);
void calcNormal();
void calcEdges();
bool verticesEncomun(TTriangle* otherT,TVertex* &v1,TVertex* &v2);
};
class TElement : public TNeighboured
{
public:
TVertex* vertexes[4];
float4* normals;
bool initialized ;
TElement();
TElement(TVertex v0,TVertex v1,TVertex v2,TVertex v3);
virtual BoundBox CalcBound() ;
~TElement() override;
};
class TTetra : public TElement
{
public :
double fVolume,fMinDiedralAngle, fMaxDiedralAngle, fFaceAngle,fSurface ;
//int ts[6];
TTriangle* triangles[4];
TList<TObject*>* NeighBourByFace;
TList<TValuedObject>* Neighbours;
float4 rColor;
double getVolume() ;
double getPerimeter() ;
double getQuadPerimeter() ;
double getminEdgeLength() ;
double getmaxEdgeLength() ;
double getSurface();
void copyFrom(TValuedObject e );
TTetra(TObject* owner);
void Create(TObject* owner, TVertex* v0,TVertex* v1,TVertex* v2,TVertex* v3, bool publish = true);
TTetra(TObject* owner, TVertex* v0,TVertex* v1,TVertex* v2,TVertex* v3, bool publish = true) ;
~TTetra() override ;
// Obtener el vecino que comparte estos 3 vertices
TTetra* getTetraNeighbour(int faceI, TVertex* v0,TVertex* v1,TVertex* v2, TList<TObject*>* tl);
// Obtener triangulos que sean de la superficie
TList<TObject*>* getSurfaceTriangle(bool bmpMode , TList<TObject*>* res, TList<TObject*>* ts);
// Verificar si comparte esta cara
bool hasFace(TVertex* v0,TVertex* v1,TVertex* v2) ;
TVertex* oppositeVertex(TVertex *v0,TVertex *v1,TVertex *v2);
bool hasEdge(TVertex *v0,TVertex *v1);
bool hasFace(TTetra* t1 );
int hasVertex(TTetra t1 );
bool hasVertex(TVertex v0 );
TTetra* getTetraNeighbour(int faceI ,TVertex v0,TVertex v1,TVertex v2, TList<TObject> *tl) ;
void coincidenteFace(TTetra t1, TList<TObject> *tl);
void replaceTriangle(TTriangle oldTr,TTriangle newTr ) ;
void replaceVertex(TVertex oldV, TVertex newV);
int isInside(float4 ps );
bool isInvalid() ;
TList<TObject*>* getNeighboursByFace(int depth ,TList<TObject*>* nFL= nullptr , bool ommitLowerIds = false) ;
TTetra* getNeighByFace(TVertex*v0, TVertex*v1,TVertex*v2);
TList<TObject>* getNeighbours(int depth) ;
void removeVertexRef();
void updateVertexRef();
void clearVertexRef();
void update();
/*
property Surface get getSurface set fSurface ;
property Volume : double read getVolume write fVolume ;
property Perimeter : double read getPerimeter ;
property QuadPerimeter : double read getQuadPerimeter ;
property diedralAngle : double read fDiedralAngle;
property FaceAngle : double read fFaceAngle;
property MinEdgeLength : double read getminEdgeLength;
property MaxEdgeLength : double read getmaxEdgeLength;
end;
*/
};
class TElementsPool
{
public :
TList<TTetra*>* availableElements;
TList<TTriangle*>* availableTriangles;
TList<TVertex*>* availableVertexes;
TTetra* getTetraInstance();
TTetra* getTetraInstance(TVertex *v0,TVertex *v1,TVertex *v2,TVertex *v3);
TTriangle* getTriangleInstance(TVertex *v0,TVertex *v1,TVertex *v2);
TVertex* getVertexInstance(float4 fpos);
TElementsPool();
~TElementsPool();
void releaseInstance(TTetra *t);
void releaseInstance(TTriangle *tr);
void releaseInstance(TVertex *v);
void releaseMemmory();
};
class TMesh
{
public:
TList<TVertex*>* vertexes ;
TList<TPolygon*>* fFaces;
TList<TObject*>* patchList;
TList<TObject*>* elements;
float4 fMassCenter;
float4 scale ;
TList<TObject*>* selectedElements;
TList<TObject*>* elementsToAdd;
TList<TObject*>* elementsToRemove;
TList<TVertex*>* vertexesToRemove;
TElementsPool* memPool;
TMesh(void)
{
patchList = nullptr;
selectedElements = new TList<TObject*>();
vertexes = new TList<TVertex*>();
fFaces = new TList<TPolygon*>();
vertexesToRemove = new TList<TVertex*>();
scale = Float4(1.0,1.0,1.0);
memPool = new TElementsPool();
};
virtual ~TMesh(void)
{
delete memPool;
delete selectedElements;
delete vertexes;
delete fFaces;
delete selectedElements;
delete vertexesToRemove;
};
void addTriangle(TPolygon* tr)
{
fFaces->Add(tr);
tr->setID( fFaces->Count() );
};
void addVertex(TVertex* v)
{
vertexes->Add(v);
};
float4 size()
{
float4 minS, maxS ;
minS = Float4(10000.0,10000.0,10000.0);
maxS = Float4(-10000.0,-10000.0,-10000.0);
for (int j=0 ; j<this->vertexes->Count();j++)
{
TVertex* v = this->vertexes->elementAt(j);
minS.x = (float) Min(v->fPos.x, minS.x);
minS.y = (float) Min(v->fPos.y, minS.y);
minS.z = (float) Min(v->fPos.z, minS.z);
maxS.x = (float) Max(v->fPos.x, maxS.x);
maxS.y = (float) Max(v->fPos.y, maxS.y);
maxS.z = (float) Max(v->fPos.z, maxS.z);
}
return maxS - minS ;
}
virtual void updateRefs() { };
TVertex* innerBinSearch( int key, int imin, int imax)
{
// test if array is empty
if (imax < imin)
// set is empty, so return value showing not found
return nullptr;
else
{
// calculate midpoint to cut set in half
int imid = (imin + imax) / 2;
if (imid>= vertexes->Count() )
return nullptr;
TVertex * v = vertexes->elementAt(imid);
if (v == nullptr )
return nullptr;
// three-way comparison
if (v->getID() > key)
// key is in lower subset
return innerBinSearch( key, imin, imid-1);
else if (v->getID() < key)
// key is in upper subset
return innerBinSearch( key, imid+1, imax);
else
// key has been found
return v;
}
}
TVertex* findVertexById(int id)
{
return innerBinSearch(id, 0, vertexes->Count());
}
void normalizeMesh(float normSize )
{
float4 sz;
float minSz;
sz = this->size();
//sz = getMeshSize(aMesh);
minSz =(float)Min( (float)Min((float)normSize/sz.x,(float)normSize/sz.y),(float)normSize/sz.z);
this->setScale(minSz,minSz,minSz);
// mn := getMeshCenter(aMesh);
// getMeshMinMAx(aMesh,mn,mx);
// aMesh.position :=-mn;
}
void setScale(float nx,float ny, float nz)
{
float4 nw = Float4(nx,ny,nz);
for (int i=0; i< this->vertexes->Count() ; i++)
{
TVertex* v = vertexes->elementAt(i);
v->fPos.x *= nw.x/scale.x;
v->fPos.y *= nw.y/scale.y;
v->fPos.z *= nw.z/scale.z;
}
scale = nw;
}
virtual void updateIndexes(int flag){};
void removeTriangle(TPolygon* tr)
{
// lremovedElements.add(tr);
fFaces->Extract(tr);
tr->isdestroyed = true;
};
void removeVertex(TVertex* v)
{
vertexes->Extract(v);
v->isdestroyed = true;
};
};
| 4,033 |
1,402 | """
A structure-from-motion example with landmarks
- The landmarks form a 10 meter cube
- The robot rotates around the landmarks, always facing towards the cube
"""
# pylint: disable=invalid-name, E1101
from typing import List
import numpy as np
import gtsam
from gtsam import Cal3_S2, Point3, Pose3
def createPoints() -> List[Point3]:
# Create the set of ground-truth landmarks
points = [
Point3(10.0, 10.0, 10.0),
Point3(-10.0, 10.0, 10.0),
Point3(-10.0, -10.0, 10.0),
Point3(10.0, -10.0, 10.0),
Point3(10.0, 10.0, -10.0),
Point3(-10.0, 10.0, -10.0),
Point3(-10.0, -10.0, -10.0),
Point3(10.0, -10.0, -10.0),
]
return points
def createPoses(K: Cal3_S2) -> List[Pose3]:
"""Generate a set of ground-truth camera poses arranged in a circle about the origin."""
radius = 40.0
height = 10.0
angles = np.linspace(0, 2 * np.pi, 8, endpoint=False)
up = gtsam.Point3(0, 0, 1)
target = gtsam.Point3(0, 0, 0)
poses = []
for theta in angles:
position = gtsam.Point3(radius * np.cos(theta), radius * np.sin(theta), height)
camera = gtsam.PinholeCameraCal3_S2.Lookat(position, target, up, K)
poses.append(camera.pose())
return poses
| 562 |
631 | /*****************************************************************************
* *
* OpenNI 1.x Alpha *
* Copyright (C) 2012 PrimeSense Ltd. *
* *
* This file is part of OpenNI. *
* *
* Licensed 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 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
* *
*****************************************************************************/
package org.openni;
/**
* Generates PCM audio data from a sensor's hardware microphones. <BR><BR>
*
* This generator is used to read the audio data from a sensor's microphones. Number
* of available channels is determined by number of available microphones. A variety of
* data formats are available, but the exact mix of supported formats will depend on the
* sensor being used.
*
* Defines the following events:
* waveOutputModeChanged -- Triggered when the audio format changes
*
*/
public class AudioGenerator extends Generator
{
/**
* Creates a new audio generator for the given OpenNI context
* @param context OpenNI context for this generator
* @param nodeHandle Native pointer to this object
* @param addRef Whether to register the native pointer to this object
* @throws GeneralException If underlying native code returns an error code, General Exception is thrown by this function
*/
public AudioGenerator(Context context, long nodeHandle, boolean addRef) throws GeneralException
{
super(context, nodeHandle, addRef);
this.waveOutputModeChanged = new StateChangedObservable()
{
@Override
protected int registerNative(String cb, OutArg<Long> phCallback)
{
return NativeMethods.xnRegisterToWaveOutputModeChanges(toNative(), this, cb, phCallback);
}
@Override
protected void unregisterNative(long hCallback)
{
NativeMethods.xnUnregisterFromWaveOutputModeChanges(toNative(), hCallback);
}
};
}
/**
* Creates a new audio generator
* @param context OpenNI context for this generator
* @param query Place to store query information
* @param errors Place to store error information
* @return A new audio generator, created according to the given query
* @throws GeneralException If underlying native code returns errors, General Exception is thrown by this function
*/
public static AudioGenerator create(Context context, Query query, EnumerationErrors errors) throws GeneralException
{
OutArg<Long> handle = new OutArg<Long>();
int status = NativeMethods.xnCreateAudioGenerator(context.toNative(), handle,
query == null ? 0 : query.toNative(),
errors == null ? 0 : errors.toNative());
WrapperUtils.throwOnError(status);
AudioGenerator result = (AudioGenerator)context.createProductionNodeObject(handle.value, NodeType.AUDIO);
NativeMethods.xnProductionNodeRelease(handle.value);
return result;
}
/**
* Creates a new audio generator, but does not store error values
* @param context OpenNI context for this generator
* @param query Place to store query information
* @return A new audio generator, created according to the given query
* @throws GeneralException If underlying native code returns errors, General Exception is thrown by this function
*/
public static AudioGenerator create(Context context, Query query) throws GeneralException
{
return create(context, query, null);
}
/**
* Creates a new audio generator, with a query value of 0, and no place to store any error values
* @param context OpenNI context for this generator
* @return A new audio generator
* @throws GeneralException If underlying native code returns errors, General Exception is thrown by this function
*/
public static AudioGenerator create(Context context) throws GeneralException
{
return create(context, null, null);
}
/**
* Generates a list of available output modes
* @return A list of WaveOutputModes, one for each available output mode
* @throws StatusException If underlying native code returns errors, Status Exception is thrown by this function
*/
public WaveOutputMode[] getSupportedMapOutputModes() throws StatusException
{
int count = NativeMethods.xnGetSupportedWaveOutputModesCount(this.toNative());
WaveOutputMode[] supportedModes = new WaveOutputMode[count];
int status = NativeMethods.xnGetSupportedWaveOutputModes(this.toNative(), supportedModes);
WrapperUtils.throwOnError(status);
return supportedModes;
}
/**
* Returns the current wave output mode of this audio generator
* @return Current wave output mode, represented as a WaveOutputMode object
* @throws StatusException If underlying native code returns errors, Status Exception is thrown by this function
*/
public WaveOutputMode getWaveOutputMode() throws StatusException
{
OutArg<Integer> sampleRate = new OutArg<Integer>();
OutArg<Short> bitsPerSample = new OutArg<Short>();
OutArg<Byte> numberOfChannels = new OutArg<Byte>();
int status = NativeMethods.xnGetWaveOutputMode(this.toNative(), sampleRate, bitsPerSample, numberOfChannels);
WrapperUtils.throwOnError(status);
return new WaveOutputMode(sampleRate.value, bitsPerSample.value, numberOfChannels.value);
}
/**
* Sets the current wave output mode of this node
* @param mode Desired new wave output mode of this node
* @throws StatusException If underlying native code returns errors, Status Exception is thrown by this function
*/
public void setWaveOutputMode(WaveOutputMode mode) throws StatusException
{
int status = NativeMethods.xnSetWaveOutputMode(this.toNative(), mode.getSampleRate(), mode.getBitsPerSample(), mode.getNumberOfChannels());
WrapperUtils.throwOnError(status);
}
/**
* Provides access to the Output Mode Changed event type
* @return
*/
public IStateChangedObservable getMapOutputModeChangedEvent() { return this.waveOutputModeChanged; }
/**
* Gets the current data from this node
* @param audioMD AudioMetaData object to store the data in
*/
public void getMetaData(AudioMetaData audioMD)
{
NativeMethods.xnGetAudioMetaData(this.toNative(), audioMD);
}
/**
* Gets the current data from this node
* @return AudioMeta data with the data stored in it
*/
public AudioMetaData getMetaData()
{
AudioMetaData audioMD = new AudioMetaData();
getMetaData(audioMD);
return audioMD;
}
private StateChangedObservable waveOutputModeChanged;
}
| 2,765 |
777 | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef IOS_CHROME_BROWSER_UI_BOOKMARKS_UNDO_MANAGER_BRIDGE_OBSERVER_H_
#define IOS_CHROME_BROWSER_UI_BOOKMARKS_UNDO_MANAGER_BRIDGE_OBSERVER_H_
#include "base/compiler_specific.h"
#include "components/undo/undo_manager_observer.h"
// The ObjC translations of the C++ observer callbacks are defined here.
@protocol UndoManagerBridgeObserver
// Invoked when the internal state of the undo manager has changed.
- (void)undoManagerChanged;
@end
namespace bookmarks {
// A bridge that translates UndoManagerObserver C++ callbacks into ObjC
// callbacks.
class UndoManagerBridge : public UndoManagerObserver {
public:
explicit UndoManagerBridge(id<UndoManagerBridgeObserver> observer);
~UndoManagerBridge() override{};
private:
void OnUndoManagerStateChange() override;
id<UndoManagerBridgeObserver> observer_;
};
} // namespace bookmarks
#endif // IOS_CHROME_BROWSER_UI_BOOKMARKS_UNDO_MANAGER_BRIDGE_OBSERVER_H_
| 363 |
7,897 | /***************************************************************************
* @file main.cpp
* @author Alan.W
* @date 3 Mar 2014
* @remark This code is for the exercises from C++ Primer 5th Edition
* @note
***************************************************************************/
//
// Exercise 16.65:
// In § 16.3 (p. 698) we defined overloaded two versions of debug_rep one
// had a const char* and the other a char* parameter. Rewrite these functions
// as specializations.
//
// Exercise 16.66:
// What are the advantages and disadvantages of overloading
// these debug_rep functions as compared to defining specializations?
//
// Overloading changes the function match.
//
// Exercise 16.67:
// Would defining these specializations affect function matching for debug_rep?
// If so, how? If not, why not?
//
// Won't change.
// Specializations instantiate a template; they do not overload it. As a result,
// specializations do not affect function matching.
//
#include <iostream>
#include <vector>
#include <cstring>
#include <sstream>
// template
template <typename T>
std::string debug_rep(T* t);
// template specialization T=const char* , char* respectively.
template<>
std::string debug_rep(const char* str);
template<>
std::string debug_rep( char *str);
int main()
{
char p[] = "alan";
std::cout << debug_rep(p) << "\n";
return 0;
}
template <typename T>
std::string debug_rep(T* t)
{
std::ostringstream ret;
ret << t;
return ret.str();
}
// template specialization
// T = const char*
template<>
std::string debug_rep(const char* str)
{
std::string ret(str);
return str;
}
// template specialization
// T = char*
template<>
std::string debug_rep( char *str)
{
std::string ret(str);
return ret;
}
| 582 |
6,114 | package com.baidu.disconf.web.service.user.bo;
import com.baidu.dsp.common.dao.Columns;
import com.baidu.dsp.common.dao.DB;
import com.baidu.unbiz.common.genericdao.annotation.Column;
import com.baidu.unbiz.common.genericdao.annotation.Table;
import com.github.knightliao.apollo.db.bo.BaseObject;
/**
* 用户表
*
* @author liaoqiqi
* @version 2013-11-28
*/
@Table(db = DB.DB_NAME, name = "user", keyColumn = Columns.USER_ID)
public class User extends BaseObject<Long> {
private static final long serialVersionUID = 1L;
// 唯一
@Column(value = Columns.NAME)
private String name;
// token
@Column(value = Columns.TOKEN)
private String token;
// 密码
@Column(value = Columns.PASSWORD)
private String password;
//
@Column(value = Columns.OWNAPPS)
private String ownApps;
/**
* 角色ID
*/
@Column(value = Columns.ROLE_ID)
private int roleId;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getOwnApps() {
return ownApps;
}
public void setOwnApps(String ownApps) {
this.ownApps = ownApps;
}
public int getRoleId() {
return roleId;
}
public void setRoleId(int roleId) {
this.roleId = roleId;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", token='" + token + '\'' +
", password='" + password + '\'' +
", ownApps='" + ownApps + '\'' +
", roleId=" + roleId +
'}';
}
}
| 893 |
14,668 | # Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Contains a set of Chrome-specific size queries."""
import logging
import re
import models
class _Grouper:
def __init__(self):
self.groups = []
def Add(self, name, group):
logging.debug('Computed %s (%d syms)', name, len(group))
if group:
sorted_group = group.Sorted()
sorted_group.SetName(name)
self.groups.append(sorted_group)
return group.Inverted()
def Finalize(self, remaining):
self.groups.sort(key=lambda s:(s.name.startswith('Other'), -abs(s.pss)))
if remaining:
stars = remaining.Filter(lambda s: s.name.startswith('*'))
if stars:
remaining = stars.Inverted()
stars = stars.Sorted()
stars.SetName('** Merged Symbols')
self.groups.append(stars)
others_by_path = remaining.GroupedByPath(depth=1).Sorted()
for subgroup in others_by_path:
subgroup.SetName('Other //' + subgroup.name)
self.groups.extend(others_by_path)
logging.debug('Finalized')
return models.SymbolGroup(self.groups)
def _CategorizeByChromeComponent(symbols):
g = _Grouper()
# Put things that filter out a lot of symbols at the beginning where possible
# to optimize speed.
symbols = g.Add('WebRTC', symbols.WhereMatches(r'(?i)webrtc'))
symbols = g.Add('v8', symbols.Filter(
lambda s: s.source_path.startswith('v8/')))
symbols = g.Add('Skia', symbols.Filter(lambda s: 'skia/' in s.source_path))
symbols = g.Add('net', symbols.Filter(
lambda s: s.source_path.startswith('net/')))
symbols = g.Add('media', symbols.Filter(
lambda s: s.source_path.startswith('media/')))
symbols = g.Add('gpu', symbols.Filter(
lambda s: s.source_path.startswith('gpu/')))
symbols = g.Add('cc', symbols.Filter(
lambda s: s.source_path.startswith('cc/')))
symbols = g.Add('base', symbols.Filter(
lambda s: s.source_path.startswith('base/')))
symbols = g.Add('viz', symbols.Filter(
lambda s: s.source_path.startswith('components/viz')))
symbols = g.Add('ui/gfx', symbols.Filter(
lambda s: s.source_path.startswith('ui/gfx/')))
# Next, put non-regex queries, since they're a bit faster.
symbols = g.Add('ICU', symbols.Filter(lambda s: '/icu/' in s.source_path))
symbols = g.Add('Prefetch', symbols.Filter(
lambda s: 'resource_prefetch' in s.source_path))
symbols = g.Add('Password Manager', symbols.Filter(
lambda s: 'password_manager' in s.source_path))
symbols = g.Add('Internals Pages', symbols.Filter(
lambda s: '_internals' in s.source_path))
symbols = g.Add('Autofill', symbols.WhereSourcePathMatches(r'(?i)autofill'))
symbols = g.Add('WebGL', symbols.WhereMatches(r'(?i)webgl'))
symbols = g.Add('WebBluetooth', symbols.WhereMatches(r'(?i)bluetooth'))
symbols = g.Add('WebUSB', symbols.WhereMatches(r'(?i)webusb|(\b|_)usb(\b|_)'))
symbols = g.Add('WebVR', symbols.WhereMatches(
r'{{_gvr_}}|{{_cwebvr_}}|{{_vr_}}'))
symbols = g.Add('FileSystem', symbols.WhereSourcePathMatches(
r'content/.*/fileapi|WebKit/.*/filesystem'))
symbols = g.Add('WebCrypto', symbols.WhereMatches(r'(?i)webcrypto'))
symbols = g.Add('Printing', symbols.WhereMatches(r'printing'))
symbols = g.Add('Cast', symbols.WhereSourcePathMatches(
r'(?i)(\b|_)cast(\b|_)'))
symbols = g.Add('Media Source', symbols.WhereMatches(
r'(?i)mediasource|blink::.*TrackDefault|blink::.*SourceBuffer'))
# XSLT must come before libxml.
symbols = g.Add('XSLT', symbols.WhereMatches(r'(?i)xslt'))
symbols = g.Add('libxml', symbols.Filter(
lambda s: 'libxml' in s.source_path))
# These have some overlap with above, so need to come afterwards.
blink_syms = symbols.WhereSourcePathMatches(r'\b(blink|WebKit)\b')
symbols = blink_syms.Inverted()
blink_generated = blink_syms.WhereSourceIsGenerated()
g.Add('Blink (generated)', blink_generated)
g.Add('Blink (non-generated)', blink_generated.Inverted())
symbols = g.Add('Codecs', symbols.WhereSourcePathMatches(
r'^third_party/(libweb[mp]|libpng|libjpeg_turbo|opus|ffmpeg|libvpx)/'))
symbols = g.Add('Other Third-Party', symbols.Filter(
lambda s: 'third_party' in s.source_path))
return g.Finalize(symbols)
def _CategorizeGenerated(symbols):
g = _Grouper()
# Don't count other symbols or prebuilts.
symbols = symbols.Filter(lambda s: s.section_name != models.SECTION_OTHER and
not s.source_path.endswith('.class'))
# JNI is generated into .h files then #included, so the symbols don't actaully
# appear as "SourceIsGenerated".
# Note: String literals within symbols like "kBaseRegisteredMethods" are not
# being accounted for here because they end up within "** merge strings".
# This could be fixed by assigning them all to proper variables rather
# than having them be inline.
symbols = g.Add('RegisterJNI', symbols.WhereFullNameMatches(
r'Register.*JNIEnv\*\)|RegisteredMethods$'))
symbols = g.Add('gl_bindings_autogen',
symbols.WherePathMatches('gl_bindings_autogen'))
symbols = symbols.WhereSourceIsGenerated()
symbols = g.Add(
'Java Protocol Buffers',
symbols.Filter(lambda s: '__protoc_java.srcjar' in s.source_path))
symbols = g.Add('C++ Protocol Buffers', symbols.Filter(lambda s: (
'/protobuf/' in s.object_path or
s.object_path.endswith('.pbzero.o') or
s.object_path.endswith('.pb.o'))))
mojo_pattern = re.compile(r'\bmojom?\b')
symbols = g.Add(
'Mojo',
symbols.Filter(lambda s: (s.full_name.startswith('mojo::') or mojo_pattern
.search(s.source_path))))
symbols = g.Add('DevTools', symbols.WhereSourcePathMatches(
r'\b(?:protocol|devtools)\b'))
symbols = g.Add('Blink (bindings)', symbols.WherePathMatches(
r'(?:blink|WebKit)/.*bindings'))
symbols = g.Add('Blink (other)', symbols.Filter(lambda s: (
'WebKit' in s.object_path or 'blink/' in s.object_path)))
symbols = g.Add('V8 Builtins', symbols.Filter(lambda s: (
s.source_path.endswith('embedded.S'))))
symbols = g.Add('prepopulated_engines.cc', symbols.Filter(lambda s: (
'prepopulated_engines' in s.object_path)))
symbols = g.Add('Metrics-related code', symbols.Filter(lambda s: (
'/metrics/' in s.object_path)))
symbols = g.Add('gpu_driver_bug_list_autogen.cc', symbols.Filter(lambda s: (
'gpu_driver_bug_list' in s.object_path)))
symbols = g.Add('components/policy', symbols.Filter(lambda s: (
'components/policy' in s.object_path)))
return g.Finalize(symbols)
class CannedQueries:
"""A set of pre-written queries."""
def __init__(self, size_infos):
self._size_infos = size_infos
def _SymbolsArg(self, arg, native_only=False, pak_only=False):
arg = arg if arg is not None else self._size_infos[-1]
if isinstance(arg, models.BaseSizeInfo):
if native_only:
arg = arg.native_symbols
elif pak_only:
arg = arg.pak_symbols
else:
arg = arg.symbols
return arg
def CategorizeGenerated(self, symbols=None):
"""Categorizes symbols that come from generated source files."""
return _CategorizeGenerated(self._SymbolsArg(symbols))
def CategorizeByChromeComponent(self, symbols=None):
"""Groups symbols by component using predefined queries."""
return _CategorizeByChromeComponent(self._SymbolsArg(symbols))
def TemplatesByName(self, symbols=None, depth=0):
"""Lists C++ templates grouped by name."""
symbols = self._SymbolsArg(symbols, native_only=True)
# Call Sorted() twice so that subgroups will be sorted.
# TODO(agrieve): Might be nice to recursively GroupedByName() on these.
return symbols.WhereIsTemplate().Sorted().GroupedByName(depth).Sorted()
def StaticInitializers(self, symbols=None):
"""Lists Static Initializers."""
symbols = self._SymbolsArg(symbols, native_only=True)
# GCC generates "_GLOBAL__" symbols. Clang generates "startup".
return symbols.WhereNameMatches('^startup$|^_GLOBAL__')
def LargeFiles(self, symbols=None, min_size=50 * 1024):
"""Lists source files that are larger than a certain size (default 50kb)."""
symbols = self._SymbolsArg(symbols)
return symbols.GroupedByPath(fallback=None).WherePssBiggerThan(
min_size).Sorted()
def PakByPath(self, symbols=None):
"""Groups .pak.* symbols by path."""
symbols = self._SymbolsArg(symbols, pak_only=True)
return symbols.WhereIsPak().Sorted().GroupedByPath().Sorted()
| 3,305 |
488 |
#ifndef BUILD_LOOP_TREE
#define BUILD_LOOP_TREE
#include <LoopTree.h>
#include <ProcessAstTree.h>
class LoopTreeBuild : public ProcessAstTree
{
LoopTreeCreate *lt;
LoopTreeNode *cur;
bool supportNonFortranLoop;
protected:
bool ProcessLoop( AstInterface &fa, const AstNodePtr& loop ,
const AstNodePtr& body,
AstInterface::TraversalVisitType t)
{
LoopTreeNode *root = lt->GetTreeRoot();
if (t == AstInterface::PreVisit) {
// Liao, we want to allow a loop with nested non-fortran loop in the loop tree.
if (fa.IsFortranLoop(loop)||supportNonFortranLoop) {
LoopTreeNode* result = lt->CreateLoopNode(loop);
result->Link(cur, LoopTreeNode::AsLastChild);
cur = result;
}
else {
std::cerr << "Warning: treating non-Fortran loop as a single statement\n";
ProcessStmt(fa, loop);
}
}
else {
if (cur != root)
cur = cur->Parent();
}
return ProcessAstTree::ProcessLoop(fa, loop, body, t);
}
bool ProcessIf( AstInterface &fa, const AstNodePtr& s, const AstNodePtr& cond,
const AstNodePtr& body1, const AstNodePtr& body2,
AstInterface::TraversalVisitType t)
{
if (t == AstInterface::PreVisit) {
LoopTreeIfCond* result = lt->CreateIfCond(cond);
result->Link(cur, LoopTreeNode::AsLastChild);
cur = result;
}
else {
if (cur != lt->GetTreeRoot())
cur = cur->Parent();
}
return ProcessAstTree::ProcessIf(fa, s, cond, body1, body2, t);
}
bool ProcessGoto( AstInterface &fa, const AstNodePtr& start,
const AstNodePtr& dest)
{ return ProcessStmt(fa, start); }
bool ProcessStmt( AstInterface &fa, const AstNodePtr& start)
{
LoopTreeNode *stmtNode = lt->CreateStmtNode( start);
stmtNode->Link(cur, LoopTreeNode::AsLastChild);
return ProcessAstTree::ProcessStmt(fa, start);
}
public:
LoopTreeBuild(bool nonfortran=0) : supportNonFortranLoop(nonfortran) {}
bool operator ()( AstInterface& fa, const AstNodePtr& top,
LoopTreeCreate *ltc, LoopTreeNode* root = 0)
{
lt = ltc;
cur = (root)? root: lt->GetTreeRoot();
return ReadAstTraverse(fa, top, *this, AstInterface::PreAndPostOrder);
}
LoopTreeNode* LastProcessedNode()
{
if (cur->ChildCount() > 0)
return cur->LastChild();
else
return cur;
}
};
#endif
| 1,236 |
32,544 | package com.baeldung.maths;
import org.junit.Assert;
import org.junit.Test;
import java.math.BigInteger;
public class BigIntegerImplUnitTest {
@Test
public void givenBigIntegerNumbers_whenAddedTogether_thenGetExpectedResult() {
BigInteger numStarsMilkyWay = new BigInteger("8731409320171337804361260816606476");
BigInteger numStarsAndromeda = new BigInteger("5379309320171337804361260816606476");
BigInteger totalStars = numStarsMilkyWay.add(numStarsAndromeda);
BigInteger result = new BigInteger("14110718640342675608722521633212952");
Assert.assertEquals(result, totalStars);
}
}
| 262 |
1,498 | /*
Copyright (c) 2012, Broadcom Europe Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <termios.h>
#include "nb_io.h"
void nb_set_nonblocking_input(int enable)
{
struct termios ttystate;
//get the terminal state
tcgetattr(STDIN_FILENO, &ttystate);
if (enable)
{
//turn off canonical mode
ttystate.c_lflag &= ~ICANON;
//minimum of number input read.
ttystate.c_cc[VMIN] = 1;
}
else
{
//turn on canonical mode
ttystate.c_lflag |= ICANON;
}
//set the terminal attributes.
tcsetattr(STDIN_FILENO, TCSANOW, &ttystate);
}
int nb_char_available(void)
{
struct timeval tv;
fd_set fds;
tv.tv_sec = 0;
tv.tv_usec = 0;
FD_ZERO(&fds);
FD_SET(STDIN_FILENO, &fds);
select(STDIN_FILENO+1, &fds, NULL, NULL, &tv);
return (FD_ISSET(0, &fds));
}
char nb_get_char(void)
{
return getchar();
}
void nb_put_char(char ch)
{
putchar(ch);
}
| 886 |
7,137 | package io.onedev.server.web.resource;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;
import javax.persistence.EntityNotFoundException;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.tika.mime.MimeTypes;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.request.resource.AbstractResource;
import com.google.common.base.Joiner;
import io.onedev.commons.utils.ExplicitException;
import io.onedev.server.OneDev;
import io.onedev.server.entitymanager.AgentManager;
import io.onedev.server.model.Agent;
import io.onedev.server.security.SecurityUtils;
public class AgentLogResource extends AbstractResource {
private static final long serialVersionUID = 1L;
private static final String PARAM_AGENT = "agent";
@Override
protected ResourceResponse newResourceResponse(Attributes attributes) {
if (!SecurityUtils.isAdministrator())
throw new UnauthorizedException();
String agentName = attributes.getParameters().get(PARAM_AGENT).toString();
Agent agent = OneDev.getInstance(AgentManager.class).findByName(agentName);
if (agent == null)
throw new EntityNotFoundException("Unable to find agent: " + agentName);
if (!agent.isOnline())
throw new ExplicitException("Unable to read log: agent is offline");
ResourceResponse response = new ResourceResponse();
response.setContentType(MimeTypes.OCTET_STREAM);
response.disableCaching();
try {
response.setFileName(URLEncoder.encode("agent-log.txt", StandardCharsets.UTF_8.name()));
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
Long agentId = agent.getId();
response.setWriteCallback(new WriteCallback() {
@Override
public void writeData(Attributes attributes) throws IOException {
Agent agent = OneDev.getInstance(AgentManager.class).load(agentId);
List<String> agentLog = OneDev.getInstance(AgentManager.class).getAgentLog(agent);
String content = Joiner.on("\n").join(agentLog);
attributes.getResponse().getOutputStream().write(content.getBytes(StandardCharsets.UTF_8));
}
});
return response;
}
public static PageParameters paramsOf(Agent agent) {
PageParameters params = new PageParameters();
params.add(PARAM_AGENT, agent.getName());
return params;
}
}
| 783 |
937 | <reponame>zmyer/cyclops-react
package com.oath.cyclops.data.collections.extensions.lazy.immutable;
import com.oath.cyclops.types.persistent.PersistentSet;
import com.oath.cyclops.types.foldable.Evaluation;
import cyclops.reactive.collections.immutable.PersistentSetX;
import cyclops.control.Option;
import cyclops.function.Reducer;
import cyclops.reactive.ReactiveSeq;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
/**
* An extended List type {@see java.util.List}
* Extended List operations execute lazily e.g.
* <pre>
* {@code
* StreamX<Integer> q = StreamX.of(1,2,3)
* .map(i->i*2);
* }
* </pre>
* The map operation above is not executed immediately. It will only be executed when (if) the data inside the
* queue is accessed. This allows lazy operations to be chained and executed more efficiently e.g.
*
* <pre>
* {@code
* DequeX<Integer> q = DequeX.of(1,2,3)
* .map(i->i*2);
* .filter(i->i<5);
* }
* </pre>
*
* The operation above is more efficient than the equivalent operation with a ListX.
*
* @author johnmcclean
*
* @param <T> the type of elements held in this toX
*/
public class LazyPSetX<T> extends AbstractLazyPersistentCollection<T,PersistentSet<T>> implements PersistentSetX<T> {
public static final <T> Function<ReactiveSeq<PersistentSet<T>>, PersistentSet<T>> asyncSet() {
return r -> {
CompletablePersistentSetX<T> res = new CompletablePersistentSetX<>();
r.forEachAsync(l -> res.complete(l));
return res.asPersistentSetX();
};
}
public LazyPSetX(PersistentSet<T> list, ReactiveSeq<T> seq, Reducer<PersistentSet<T>,T> reducer, Evaluation strict) {
super(list, seq, reducer,strict,asyncSet());
}
//@Override
public PersistentSetX<T> materialize() {
get();
return this;
}
@Override
public PersistentSetX<T> type(Reducer<? extends PersistentSet<T>,T> reducer) {
return new LazyPSetX<T>(list,seq.get(),Reducer.narrow(reducer), evaluation());
}
// @Override
public <X> LazyPSetX<X> fromStream(ReactiveSeq<X> stream) {
return new LazyPSetX<X>((PersistentSet)getList(),ReactiveSeq.fromStream(stream),(Reducer)this.getCollectorInternal(), evaluation());
}
@Override
public <T1> LazyPSetX<T1> from(Iterable<T1> c) {
if(c instanceof PersistentSet)
return new LazyPSetX<T1>((PersistentSet)c,null,(Reducer)this.getCollectorInternal(), evaluation());
return fromStream(ReactiveSeq.fromIterable(c));
}
public <T1> LazyPSetX<T1> from(PersistentSet<T1> c) {
return new LazyPSetX<T1>((PersistentSet)c,null,(Reducer)this.getCollectorInternal(), evaluation());
}
@Override
public PersistentSetX<T> lazy() {
return new LazyPSetX<T>(list,seq.get(),getCollectorInternal(), Evaluation.LAZY) ;
}
@Override
public PersistentSetX<T> eager() {
return new LazyPSetX<T>(list,seq.get(),getCollectorInternal(),Evaluation.EAGER) ;
}
@Override
public PersistentSetX<T> plus(T e) {
return from(get().plus(e));
}
@Override
public PersistentSetX<T> plusAll(Iterable<? extends T> list) {
return from(get().plusAll(list));
}
@Override
public PersistentSetX<T> removeAll(Iterable<? extends T> list) {
return from(get().removeAll(list));
}
@Override
public PersistentSetX<T> removeValue(T remove) {
return from(get().removeValue(remove));
}
@Override
public <U> LazyPSetX<U> unitIterable(Iterable<U> it) {
return fromStream(ReactiveSeq.fromIterable(it));
}
@Override
public <R> LazyPSetX<R> unit(Iterable<R> col) {
return from(col);
}
@Override
public PersistentSetX<T> plusLoop(int max, IntFunction<T> value) {
return (PersistentSetX<T>)super.plusLoop(max,value);
}
@Override
public PersistentSetX<T> plusLoop(Supplier<Option<T>> supplier) {
return (PersistentSetX<T>)super.plusLoop(supplier);
}
}
| 1,739 |
524 | <filename>karate-core/src/main/java/com/intuit/karate/driver/DriverMouse.java
/*
* The MIT License
*
* Copyright 2019 Intuit Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.intuit.karate.driver;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
* @author pthomas3
*/
public class DriverMouse implements Mouse {
private final Driver driver;
public DriverMouse(Driver driver) {
this.driver = driver;
}
private Integer duration;
private final List<Map<String, Object>> actions = new ArrayList();
private Number x, y;
private Map<String, Object> moveAction(int x, int y) {
// {"type":"pointer","id":"1","actions":[{"type":"pointerMove","x":250,"y":250}]}
Map<String, Object> map = new HashMap();
map.put("type", "pointerMove");
map.put("x", x);
map.put("y", y);
if (duration != null) {
map.put("duration", duration);
}
return map;
}
@Override
public DriverMouse duration(Integer duration) {
this.duration = duration;
return this;
}
@Override
public DriverMouse pause(Integer duration) {
Map<String, Object> map = new HashMap();
map.put("type", "pause");
map.put("duration", duration);
actions.add(map);
return this;
}
@Override
public DriverMouse move(String locator) {
Map<String, Object> map = driver.position(locator);
Number x = (Number) map.get("x");
Number y = (Number) map.get("y");
Number width = (Number) map.get("width");
Number height = (Number) map.get("height");
return move(x.intValue() + width.intValue() / 2, y.intValue() + height.intValue() / 2);
}
@Override
public DriverMouse move(Number x, Number y) {
this.x = x == null ? 0 : x;
this.y = y == null ? 0 : y;
Map<String, Object> action = moveAction(this.x.intValue(), this.y.intValue());
actions.add(action);
return this;
}
@Override
public DriverMouse offset(Number x, Number y) {
if (x == null) {
x = 0;
}
if (y == null) {
y = 0;
}
if (this.x == null) {
this.x = 0;
}
if (this.y == null) {
this.y = 0;
}
Map<String, Object> action = moveAction(this.x.intValue() + x.intValue(), this.y.intValue() + y.intValue());
actions.add(action);
return this;
}
@Override
public DriverMouse down() {
Map<String, Object> map = new HashMap();
map.put("type", "pointerDown");
map.put("button", 0);
actions.add(map);
return this;
}
@Override
public DriverMouse up() {
Map<String, Object> up = new HashMap();
up.put("type", "pointerUp");
up.put("button", 0);
actions.add(up);
return go();
}
@Override
public DriverMouse submit() {
driver.submit();
return this;
}
@Override
public DriverMouse click() {
return down().up();
}
@Override
public DriverMouse doubleClick() {
String js = "document.elementFromPoint(" + x + "," + y + ").dispatchEvent(new MouseEvent('dblclick'))";
driver.script(js);
return this;
}
@Override
public DriverMouse go() {
Map<String, Object> map = new HashMap();
map.put("type", "pointer");
map.put("id", "1");
map.put("actions", actions);
driver.actions(Collections.singletonList(map));
actions.clear();
return this;
}
}
| 1,891 |
488 | int main()
{
int i, n, a, b, c, d;
#pragma scop
for (i = 0; i < n; ++i)
{
if (i > 1)
a = 0;
b = 0;
if (i > 2)
{
if (i < n - 1)
c = 0;
d = 0;
}
}
#pragma endscop
}
| 136 |
1,306 | <reponame>lifansama/xposed_art_n
public class Main {
public static void main(String[] args) {
test_printNarrowing();
}
public static void test_printNarrowing() {
System.out.println();
System.out.println("Double.POSITIVE_INFINITY = "
+ Long.toHexString(Double.doubleToRawLongBits(Double.POSITIVE_INFINITY)));
System.out.println("Double.NEGATIVE_INFINITY = "
+ Long.toHexString(Double.doubleToRawLongBits(Double.NEGATIVE_INFINITY)));
System.out.println("Float.POSITIVE_INFINITY = "
+ Long.toHexString(Double.doubleToRawLongBits(Float.POSITIVE_INFINITY)));
System.out.println("Float.NEGATIVE_INFINITY = "
+ Long.toHexString(Double.doubleToRawLongBits(Float.NEGATIVE_INFINITY)));
System.out.println("Double.NaN = "
+ Long.toHexString(Double.doubleToRawLongBits(Double.NaN)));
System.out.println("Float.NaN = "
+ Long.toHexString(Double.doubleToRawLongBits(Float.NaN)));
double dbl2 = Double.NaN;
System.out.println();
System.out.println("(byte) Double.NaN = "
+ (Long.toHexString((byte)dbl2).equals("0") ? "00" : Long.toHexString((byte)dbl2)
.substring(6)) + " expected: 00");
System.out.println("(short) Double.NaN = "
+ (Integer.toHexString((short)dbl2).equals("0") ? "0000" : Integer.toHexString(
(short)dbl2).substring(4)) + " expected: 0000");
System.out.println("(int) Double.NaN = "
+ (Integer.toHexString((int)dbl2).equals("0") ? "00000000" : Integer
.toHexString((int)dbl2)) + " expected: 00000000");
System.out.println("(long) Double.NaN = "
+ (Long.toHexString((long)dbl2).equals("0") ? "0000000000000000" : Long
.toHexString((long)dbl2)) + " expected: 0000000000000000");
float fl2 = Float.NaN;
System.out.println();
System.out.println("(byte) Float.NaN = "
+ (Long.toHexString((byte)fl2).equals("0") ? "00" : Long.toHexString((byte)fl2)
.substring(6)) + " expected: 00");
System.out.println("(short) Float.NaN = "
+ (Integer.toHexString((short)fl2).equals("0") ? "0000" : Integer.toHexString(
(short)fl2).substring(4)) + " expected: 0000");
System.out.println("(int) Float.NaN = "
+ (Integer.toHexString((int)fl2).equals("0") ? "00000000" : Integer
.toHexString((int)fl2)) + " expected: 00000000");
System.out.println("(long) Float.NaN = "
+ (Long.toHexString((long)fl2).equals("0") ? "0000000000000000" : Long
.toHexString((long)fl2)) + " expected: 0000000000000000");
double dbl3 = Double.POSITIVE_INFINITY;
System.out.println();
System.out.println("(byte) Double.POSITIVE_INFINITY = "
+ (Integer.toHexString((byte)dbl3).equals("0") ? "00" : Integer.toHexString(
(byte)dbl3).substring(6)) + " expected: ff");
System.out.println("(short) Double.POSITIVE_INFINITY = "
+ (Integer.toHexString((short)dbl3).equals("0") ? "0000" : Integer.toHexString(
(short)dbl3).substring(4)) + " expected: ffff");
System.out.println("(int) Double.POSITIVE_INFINITY = "
+ Integer.toHexString((int)dbl3) + " expected: 7fffffff");
System.out.println("(long) Double.POSITIVE_INFINITY = " + Long.toHexString((long)dbl3)
+ " expected: 7fffffffffffffff");
double dbl4 = Double.NEGATIVE_INFINITY;
System.out.println();
System.out.println("(byte) Double.NEGATIVE_INFINITY = "
+ (Long.toHexString((byte)dbl4).equals("0") ? " 00" : Long
.toHexString((byte)dbl4)) + " expected: 00");
System.out.println("(short) Double.NEGATIVE_INFINITY = "
+ (Integer.toHexString((short)dbl4).equals("0") ? " 0000" : Long
.toHexString((short)dbl4)) + " expected: 0000");
System.out.println("(int) Double.NEGATIVE_INFINITY = "
+ Integer.toHexString((int)dbl4) + " expected: 80000000");
System.out.println("(long) Double.NEGATIVE_INFINITY = " + Long.toHexString((long)dbl4)
+ " expected: 8000000000000000");
float fl3 = Float.POSITIVE_INFINITY;
System.out.println();
System.out.println("(byte) Float.POSITIVE_INFINITY = "
+ (Integer.toHexString((byte)fl3).equals("0") ? "00" : Integer.toHexString(
(byte)fl3).substring(6)) + " expected: ff");
System.out.println("(short) Float.POSITIVE_INFINITY = "
+ (Integer.toHexString((short)fl3).equals("0") ? "0000" : Integer.toHexString(
(short)fl3).substring(4)) + " expected: ffff");
System.out.println("(int) Float.POSITIVE_INFINITY = "
+ Integer.toHexString((int)fl3) + " expected: 7fffffff");
System.out.println("(long) Float.POSITIVE_INFINITY = " + Long.toHexString((long)fl3)
+ " expected: 7fffffffffffffff");
float fl4 = Float.NEGATIVE_INFINITY;
System.out.println();
System.out.println("(byte) Float.NEGATIVE_INFINITY = "
+ (Long.toHexString((byte)fl4).equals("0") ? " 00" : Long
.toHexString((byte)fl4)) + " expected: 00");
System.out.println("(short) Float.NEGATIVE_INFINITY = "
+ (Integer.toHexString((short)fl4).equals("0") ? " 0000" : Long
.toHexString((short)fl4)) + " expected: 0000");
System.out.println("(int) Float.NEGATIVE_INFINITY = "
+ Integer.toHexString((int)fl4) + " expected: 80000000");
System.out.println("(long) Float.NEGATIVE_INFINITY = " + Long.toHexString((long)fl4)
+ " expected: 8000000000000000");
System.out.println();
}
}
| 3,489 |
921 | <reponame>0to1/rmf_traffic
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011-2014, <NAME>, Inc.
* Copyright (c) 2014-2016, Open Source Robotics Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Open Source Robotics Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/** @author <NAME> */
#ifndef FCL_BROADPHASE_BROADPHASECONTINUOUSCOLLISIONMANAGER_H
#define FCL_BROADPHASE_BROADPHASECONTINUOUSCOLLISIONMANAGER_H
#include "fcl/broadphase/broadphase_collision_manager.h"
#include "fcl/narrowphase/collision_object.h"
#include "fcl/narrowphase/continuous_collision_object.h"
namespace fcl
{
/// @brief Callback for continuous collision between two objects. Return value
/// is whether can stop now.
template <typename S>
using ContinuousCollisionCallBack = bool (*)(
ContinuousCollisionObject<S>* o1,
ContinuousCollisionObject<S>* o2, void* cdata);
/// @brief Callback for continuous distance between two objects, Return value is
/// whether can stop now, also return the minimum distance till now.
template <typename S>
using ContinuousDistanceCallBack = bool (*)(
ContinuousCollisionObject<S>* o1,
ContinuousCollisionObject<S>* o2, void* cdata, S& dist);
/// @brief Base class for broad phase continuous collision. It helps to
/// accelerate the continuous collision/distance between N objects. Also support
/// self collision, self distance and collision/distance with another M objects.
template <typename S>
class FCL_EXPORT BroadPhaseContinuousCollisionManager
{
public:
BroadPhaseContinuousCollisionManager();
virtual ~BroadPhaseContinuousCollisionManager();
/// @brief add objects to the manager
virtual void registerObjects(const std::vector<ContinuousCollisionObject<S>*>& other_objs);
/// @brief add one object to the manager
virtual void registerObject(ContinuousCollisionObject<S>* obj) = 0;
/// @brief remove one object from the manager
virtual void unregisterObject(ContinuousCollisionObject<S>* obj) = 0;
/// @brief initialize the manager, related with the specific type of manager
virtual void setup() = 0;
/// @brief update the condition of manager
virtual void update() = 0;
/// @brief update the manager by explicitly given the object updated
virtual void update(ContinuousCollisionObject<S>* updated_obj);
/// @brief update the manager by explicitly given the set of objects update
virtual void update(const std::vector<ContinuousCollisionObject<S>*>& updated_objs);
/// @brief clear the manager
virtual void clear() = 0;
/// @brief return the objects managed by the manager
virtual void getObjects(std::vector<ContinuousCollisionObject<S>*>& objs) const = 0;
/// @brief perform collision test between one object and all the objects belonging to the manager
virtual void collide(ContinuousCollisionObject<S>* obj, void* cdata, CollisionCallBack<S> callback) const = 0;
/// @brief perform distance computation between one object and all the objects belonging to the manager
virtual void distance(ContinuousCollisionObject<S>* obj, void* cdata, DistanceCallBack<S> callback) const = 0;
/// @brief perform collision test for the objects belonging to the manager (i.e., N^2 self collision)
virtual void collide(void* cdata, CollisionCallBack<S> callback) const = 0;
/// @brief perform distance test for the objects belonging to the manager (i.e., N^2 self distance)
virtual void distance(void* cdata, DistanceCallBack<S> callback) const = 0;
/// @brief perform collision test with objects belonging to another manager
virtual void collide(BroadPhaseContinuousCollisionManager<S>* other_manager, void* cdata, CollisionCallBack<S> callback) const = 0;
/// @brief perform distance test with objects belonging to another manager
virtual void distance(BroadPhaseContinuousCollisionManager<S>* other_manager, void* cdata, DistanceCallBack<S> callback) const = 0;
/// @brief whether the manager is empty
virtual bool empty() const = 0;
/// @brief the number of objects managed by the manager
virtual size_t size() const = 0;
};
using BroadPhaseContinuousCollisionManagerf = BroadPhaseContinuousCollisionManager<float>;
using BroadPhaseContinuousCollisionManagerd = BroadPhaseContinuousCollisionManager<double>;
} // namespace fcl
#include "fcl/broadphase/broadphase_continuous_collision_manager-inl.h"
#endif
| 1,663 |
2,500 | /*
* Copyright 2021 DiffPlug
*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.diffplug.spotless.pom;
import org.junit.jupiter.api.Test;
import com.diffplug.spotless.Provisioner;
import com.diffplug.spotless.StepHarness;
import com.diffplug.spotless.TestProvisioner;
public class SortPomTest {
@Test
public void testSortPomWithDefaultConfig() throws Exception {
SortPomCfg cfg = new SortPomCfg();
Provisioner provisioner = TestProvisioner.mavenCentral();
StepHarness harness = StepHarness.forStep(SortPomStep.create(cfg, provisioner));
harness.testResource("pom/pom_dirty.xml", "pom/pom_clean_default.xml");
}
}
| 352 |
678 | /**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/iTunesStoreUI.framework/iTunesStoreUI
*/
#import <iTunesStoreUI/SUInputSource.h>
@class NSData;
@interface SUDataInputSource : SUInputSource {
NSData *_data; // 4 = 0x4
int _offset; // 8 = 0x8
id _promiseBlock; // 12 = 0xc
}
@property(readonly, assign, nonatomic) NSData *data; // G=0xc9bc5;
- (int)read:(char *)read maxLength:(unsigned)length error:(id *)error; // 0xc9cb9
- (BOOL)open:(id *)open; // 0xc9c95
- (BOOL)hasBytesAvailable; // 0xc9c59
- (long long)expectedLength; // 0xc9c31
// declared property getter: - (id)data; // 0xc9bc5
- (id)copyAllData:(id *)data; // 0xc9b9d
- (void)dealloc; // 0xc9b3d
- (id)initWithDataPromise:(id)dataPromise; // 0xc9ae9
- (id)initWithData:(id)data; // 0xc9a95
@end
| 342 |
848 | //===- Configuration.h - Configuration object base classes ------*- C++ -*-===//
//
// Copyright 2019 The MLIR Authors.
//
// Licensed 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
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// =============================================================================
//
// The quantizer is relatively agnostic to source and target dialects, with
// the specific represented by configuration policy objects derived from
// classes in this file.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_QUANTIZER_SUPPORT_CONFIGURATION_H
#define MLIR_QUANTIZER_SUPPORT_CONFIGURATION_H
#include <functional>
#include "mlir/Dialect/QuantOps/QuantTypes.h"
#include "mlir/IR/Identifier.h"
#include "mlir/Quantizer/Support/ConstraintAnalysisGraph.h"
#include "mlir/Quantizer/Support/Metadata.h"
#include "mlir/Quantizer/Support/Rules.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/ADT/StringSet.h"
namespace mlir {
class Operation;
namespace quantizer {
class CAGSlice;
/// Defines quantization configuration for the target.
/// The settings here depend on a variety of details about the deployment
/// environment, although, where we have control over such things, we do
/// try to standardize as possible.
///
/// Non-const methods are used to setup the configuration. It is expected that
/// const instances/references are used post-build.
class TargetConfiguration {
public:
static constexpr size_t MaxSchemeIndex = 31;
using OpHandlerFn = std::function<void(Operation *op, CAGSlice &cag)>;
TargetConfiguration(SolverContext &context);
virtual ~TargetConfiguration() = default;
/// Adds a candidate type, returning its ordinal.
unsigned addCandidateType(quant::AnyQuantizedType quantizedType,
CandidateQuantizedType::Scheme scheme) {
unsigned ordinal = candidateTypes.size();
assert(allCandidateTypesMask.size() == ordinal);
CandidateQuantizedType ct{ordinal, quantizedType, scheme};
candidateTypes.push_back(ct);
allCandidateTypesMask.push_back(true);
return ordinal;
}
/// Gets a prototype scheme by index.
const CandidateQuantizedType &getCandidateType(unsigned index) const {
assert(index < candidateTypes.size());
return candidateTypes[index];
}
llvm::ArrayRef<CandidateQuantizedType> getCandidateTypes() const {
return candidateTypes;
}
/// Gets a mask of all enabled candidate types by ordinal.
llvm::SmallBitVector getAllCandidateTypesMask() const {
return allCandidateTypesMask;
}
/// Gets a mask with every candidate type except those in the given mask.
llvm::SmallBitVector getCandidateTypeDisabledExceptMask(
llvm::ArrayRef<unsigned> exceptOrdinals) const {
llvm::SmallBitVector disabled(allCandidateTypesMask);
for (unsigned ordinal : exceptOrdinals) {
disabled.reset(ordinal);
}
return disabled;
}
/// Adds an op handler.
template <typename OpTy>
void addOpHandler(OpHandlerFn fn) {
addOpHandlerByName(OpTy::getOperationName(), fn);
}
/// Adds an operation which requires statistics at its result nodes for
/// best quantization performance. Note that the opName StringRef is
/// expected to come from getOperationName() and be static.
template <typename OpTy>
void addRequireStatsOp() {
addRequireStatsOpByName(OpTy::getOperationName());
}
/// Returns whether opName is a RequireStatsOp.
bool isRequireStatsOp(Operation *op) const;
/// Adds an op which does not mutate its values but may mutate its shape
/// or combine its operands in an arbitrary way.
/// Such ops are expected to have the same types for operands and results
/// and must be capable of operating on storage types.
template <typename OpTy>
void addValueIdentityOp() {
addValueIdentityOpByName(OpTy::getOperationName());
}
/// Handles the operation if a handler is defined for it.
void handleOp(Operation *op, CAGSlice &cag) const;
/// Finalizes the CAG after all anchors have been added.
virtual void finalizeAnchors(CAGSlice &cag) const {}
/// Whether an operand or result type is subject to analysis by this config.
virtual bool isHandledType(Type t) const = 0;
protected:
virtual void addValueIdentityOpByName(StringRef opName) = 0;
void addOpHandlerByName(StringRef name, OpHandlerFn fn);
private:
void addRequireStatsOpByName(StringRef opName);
/// Vector of all candidate type constraints, indexed by ordinal.
std::vector<CandidateQuantizedType> candidateTypes;
// A SmallBoolVector with bits set for all known candidate types.
llvm::SmallBitVector allCandidateTypesMask;
/// Map of all op handlers.
llvm::StringMap<OpHandlerFn> opHandlers;
/// Names of operations which should have their results annotated with
/// statistics.
llvm::StringSet<> requireStatsOpNames;
};
} // namespace quantizer
} // namespace mlir
#endif // MLIR_QUANTIZER_SUPPORT_CONFIGURATION_H
| 1,592 |
30,023 | """Entity for the SleepIQ integration."""
from abc import abstractmethod
from asyncsleepiq import SleepIQBed, SleepIQSleeper
from homeassistant.core import callback
from homeassistant.helpers import device_registry
from homeassistant.helpers.entity import DeviceInfo, Entity
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
)
from .const import ENTITY_TYPES, ICON_OCCUPIED
def device_from_bed(bed: SleepIQBed) -> DeviceInfo:
"""Create a device given a bed."""
return DeviceInfo(
connections={(device_registry.CONNECTION_NETWORK_MAC, bed.mac_addr)},
manufacturer="SleepNumber",
name=bed.name,
model=bed.model,
)
class SleepIQEntity(Entity):
"""Implementation of a SleepIQ entity."""
def __init__(self, bed: SleepIQBed) -> None:
"""Initialize the SleepIQ entity."""
self.bed = bed
self._attr_device_info = device_from_bed(bed)
class SleepIQBedEntity(CoordinatorEntity):
"""Implementation of a SleepIQ sensor."""
_attr_icon = ICON_OCCUPIED
def __init__(
self,
coordinator: DataUpdateCoordinator,
bed: SleepIQBed,
) -> None:
"""Initialize the SleepIQ sensor entity."""
super().__init__(coordinator)
self.bed = bed
self._attr_device_info = device_from_bed(bed)
self._async_update_attrs()
@callback
def _handle_coordinator_update(self) -> None:
"""Handle updated data from the coordinator."""
self._async_update_attrs()
super()._handle_coordinator_update()
@callback
@abstractmethod
def _async_update_attrs(self) -> None:
"""Update sensor attributes."""
class SleepIQSleeperEntity(SleepIQBedEntity):
"""Implementation of a SleepIQ sensor."""
_attr_icon = ICON_OCCUPIED
def __init__(
self,
coordinator: DataUpdateCoordinator,
bed: SleepIQBed,
sleeper: SleepIQSleeper,
name: str,
) -> None:
"""Initialize the SleepIQ sensor entity."""
self.sleeper = sleeper
super().__init__(coordinator, bed)
self._attr_name = f"SleepNumber {bed.name} {sleeper.name} {ENTITY_TYPES[name]}"
self._attr_unique_id = f"{sleeper.sleeper_id}_{name}"
| 907 |
369 | /* - mftupdate.cpp -
* Author: <NAME>. / TDM, 2014-12-24
*
* Update the TDMInstall XML manifest with current version and archive info for
* a TDM-GCC package that has just been built.
*
* This program reads all input data on stdin rather than using command-line
* arguments.
*
* COPYING:
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along
* with this software. If not, see
* <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include <iostream>
#include <regex>
#include <string>
#include "tinyxml2.h"
using std::cin;
using std::getline;
using std::string;
using tinyxml2::XMLDocument;
using tinyxml2::XMLElement;
using tinyxml2::XMLHandle;
using tinyxml2::XMLNode;
using tinyxml2::XMLText;
XMLNode* deepCopy(XMLNode* src, XMLDocument& destDoc)
{
XMLNode *current = src->ShallowClone(&destDoc);
for (XMLNode* child = src->FirstChild(); child; child = child->NextSibling())
current->InsertEndChild(deepCopy(child, destDoc));
return current;
}
XMLElement* ChildElementMatchingRegex(
XMLElement* parent,
const string& regex_str,
const string& element_type,
const char* attribute_type
)
{
if (!parent || regex_str.length() <= 0)
return nullptr;
std::regex rgx(regex_str);
XMLElement* child;
for (
child = parent->FirstChildElement(element_type.c_str());
child;
child = child->NextSiblingElement(element_type.c_str())
)
{
const char* attribute_value = nullptr;
if (attribute_type)
attribute_value = child->Attribute(attribute_type);
else
{
XMLText* childtxt = XMLHandle(child->FirstChild()).ToText();
if (childtxt)
attribute_value = childtxt->Value();
}
if (std::regex_match(attribute_value, rgx))
break;
}
return child;
}
int main()
{
string mft_path;
XMLDocument doc;
{
getline(cin, mft_path);
FILE* fp = fopen(mft_path.c_str(), "rb");
if (!fp)
{
fprintf(stderr, "Unable to open '%s' for reading\n", mft_path.c_str());
exit(1);
}
if (doc.LoadFile(fp) != tinyxml2::XML_NO_ERROR)
{
fprintf(stderr, "Unable to load '%s' as XML\n", mft_path.c_str());
exit(1);
}
fclose(fp);
}
while (!cin.eof())
{
XMLElement* at_element = doc.RootElement();
while (!cin.eof())
{
string linestr;
getline(cin, linestr);
if (linestr == "]]>]]>")
break;
size_t elementtype_foundpos = linestr.find(":");
if (elementtype_foundpos == string::npos)
continue;
string elementtypestr = linestr.substr(0, elementtype_foundpos);
size_t attributetype_foundpos = linestr.find("|");
if (attributetype_foundpos == string::npos
|| attributetype_foundpos <= elementtype_foundpos)
continue;
string attributetypestr = linestr.substr(elementtype_foundpos + 1,
attributetype_foundpos - elementtype_foundpos - 1);
string attributevaluergx = linestr.substr(attributetype_foundpos + 1);
XMLElement* found_element = ChildElementMatchingRegex(at_element,
attributevaluergx, elementtypestr, attributetypestr.c_str());
if (!found_element)
{
fprintf(stderr, "Couldn't find %s element with %s matching '%s'\n",
elementtypestr.c_str(), attributetypestr.c_str(),
attributevaluergx.c_str());
exit(1);
}
at_element = found_element;
}
string replace_contents;
while (!cin.eof())
{
string addline;
getline(cin, addline);
if (addline == "]]>]]>")
break;
replace_contents += addline;
replace_contents += '\n';
}
XMLDocument replace_doc;
if (replace_doc.Parse(replace_contents.c_str()) != tinyxml2::XML_NO_ERROR)
{
fprintf(stderr, "Couldn't parse replacement contents as XML\n");
exit(1);
}
XMLNode* previous_sibling = at_element->PreviousSibling();
XMLElement* parent = XMLHandle(at_element->Parent()).ToElement();
if (!parent)
{
fprintf(stderr, "Can't replace root element\n");
exit(1);
}
parent->DeleteChild(at_element);
XMLNode* copied_contents = deepCopy(replace_doc.RootElement(), doc);
if (previous_sibling)
parent->InsertAfterChild(previous_sibling, copied_contents);
else
parent->InsertFirstChild(copied_contents);
}
doc.Print();
return 0;
}
| 1,680 |
442 | <reponame>AndreyNudko/ClickHouse-Native-JDBC
/*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.github.housepower.jdbc;
import com.github.housepower.exception.InvalidValueException;
import com.github.housepower.log.Logger;
import com.github.housepower.log.LoggerFactory;
import com.github.housepower.misc.StrUtil;
import com.github.housepower.misc.Validate;
import com.github.housepower.settings.ClickHouseConfig;
import com.github.housepower.settings.SettingKey;
import com.github.housepower.jdbc.wrapper.SQLWrapper;
import java.io.PrintWriter;
import java.io.Serializable;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.sql.DataSource;
/**
* <p> Database for clickhouse jdbc connections.
* <p> It has list of database urls.
* For every {@link #getConnection() getConnection} invocation, it returns connection to random host from the list.
* Furthermore, this class has method { #scheduleActualization(int, TimeUnit) scheduleActualization}
* which test hosts for availability. By default, this option is turned off.
*/
public final class BalancedClickhouseDataSource implements DataSource, SQLWrapper {
private static final Logger LOG = LoggerFactory.getLogger(BalancedClickhouseDataSource.class);
private static final Pattern URL_TEMPLATE = Pattern.compile(ClickhouseJdbcUrlParser.JDBC_CLICKHOUSE_PREFIX +
"//([a-zA-Z0-9_:,.-]+)" +
"((/[a-zA-Z0-9_]+)?" +
"([?][a-zA-Z0-9_]+[=][a-zA-Z0-9_]+([&][a-zA-Z0-9_]+[=][a-zA-Z0-9_]*)*)?" +
")?");
private PrintWriter printWriter;
private int loginTimeoutSeconds = 0;
private final ThreadLocal<Random> randomThreadLocal = new ThreadLocal<>();
private final List<String> allUrls;
private volatile List<String> enabledUrls;
private final ClickHouseConfig cfg;
private final ClickHouseDriver driver = new ClickHouseDriver();
/**
* create Datasource for clickhouse JDBC connections
*
* @param url address for connection to the database, must have the next format
* {@code jdbc:clickhouse://<first-host>:<port>,<second-host>:<port>/<database>?param1=value1¶m2=value2 }
* for example, {@code jdbc:clickhouse://localhost:9000,localhost:9000/database?compress=1&decompress=2 }
* @throws IllegalArgumentException if param have not correct format,
* or error happens when checking host availability
*/
public BalancedClickhouseDataSource(String url) {
this(splitUrl(url), new Properties());
}
/**
* create Datasource for clickhouse JDBC connections
*
* @param url address for connection to the database
* @param properties database properties
* @see #BalancedClickhouseDataSource(String)
*/
public BalancedClickhouseDataSource(String url, Properties properties) {
this(splitUrl(url), properties);
}
/**
* create Datasource for clickhouse JDBC connections
*
* @param url address for connection to the database
* @param settings clickhouse settings
* @see #BalancedClickhouseDataSource(String)
*/
public BalancedClickhouseDataSource(final String url, Map<SettingKey, Serializable> settings) {
this(splitUrl(url), settings);
}
private BalancedClickhouseDataSource(final List<String> urls, Properties properties) {
this(urls, ClickhouseJdbcUrlParser.parseProperties(properties));
}
private BalancedClickhouseDataSource(final List<String> urls, Map<SettingKey, Serializable> settings) {
Validate.ensure(!urls.isEmpty(), "Incorrect ClickHouse jdbc url list. It must be not empty");
this.cfg = ClickHouseConfig.Builder.builder()
.withJdbcUrl(urls.get(0))
.withSettings(settings)
.host("undefined")
.port(0)
.build();
List<String> allUrls = new ArrayList<>(urls.size());
for (final String url : urls) {
try {
if (driver.acceptsURL(url)) {
allUrls.add(url);
} else {
LOG.warn("that url is has not correct format: {}", url);
}
} catch (Exception e) {
throw new InvalidValueException("error while checking url: " + url, e);
}
}
Validate.ensure(!allUrls.isEmpty(), "there are no correct urls");
this.allUrls = Collections.unmodifiableList(allUrls);
this.enabledUrls = this.allUrls;
}
static List<String> splitUrl(final String url) {
Matcher m = URL_TEMPLATE.matcher(url);
Validate.ensure(m.matches(), "Incorrect url: " + url);
final String database = StrUtil.getOrDefault(m.group(2), "");
String[] hosts = m.group(1).split(",");
return Arrays.stream(hosts)
.map(host -> ClickhouseJdbcUrlParser.JDBC_CLICKHOUSE_PREFIX + "//" + host + database)
.collect(Collectors.toList());
}
private boolean ping(final String url) {
try (ClickHouseConnection connection = driver.connect(url, cfg)) {
return connection.ping(Duration.ofSeconds(1));
} catch (Exception e) {
return false;
}
}
/**
* Checks if clickhouse on url is alive, if it isn't, disable url, else enable.
*
* @return number of available clickhouse urls
*/
synchronized int actualize() {
List<String> enabledUrls = new ArrayList<>(allUrls.size());
for (String url : allUrls) {
LOG.debug("Pinging disabled url: {}", url);
if (ping(url)) {
LOG.debug("Url is alive now: {}", url);
enabledUrls.add(url);
} else {
LOG.warn("Url is dead now: {}", url);
}
}
this.enabledUrls = Collections.unmodifiableList(enabledUrls);
return enabledUrls.size();
}
private String getAnyUrl() throws SQLException {
List<String> localEnabledUrls = enabledUrls;
if (localEnabledUrls.isEmpty()) {
throw new SQLException("Unable to get connection: there are no enabled urls");
}
Random random = this.randomThreadLocal.get();
if (random == null) {
this.randomThreadLocal.set(new Random());
random = this.randomThreadLocal.get();
}
int index = random.nextInt(localEnabledUrls.size());
return localEnabledUrls.get(index);
}
/**
* {@inheritDoc}
*/
@Override
public ClickHouseConnection getConnection() throws SQLException {
return driver.connect(getAnyUrl(), cfg);
}
/**
* {@inheritDoc}
*/
@Override
public ClickHouseConnection getConnection(String user, String password) throws SQLException {
return driver.connect(getAnyUrl(), cfg.withCredentials(user, password));
}
/**
* {@inheritDoc}
*/
@Override
public PrintWriter getLogWriter() throws SQLException {
return printWriter;
}
/**
* {@inheritDoc}
*/
@Override
public void setLogWriter(PrintWriter printWriter) throws SQLException {
this.printWriter = printWriter;
}
/**
* {@inheritDoc}
*/
@Override
public void setLoginTimeout(int seconds) throws SQLException {
loginTimeoutSeconds = seconds;
}
/**
* {@inheritDoc}
*/
@Override
public int getLoginTimeout() throws SQLException {
return loginTimeoutSeconds;
}
/**
* {@inheritDoc}
*/
@Override
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
public List<String> getAllClickhouseUrls() {
return allUrls;
}
public List<String> getEnabledClickHouseUrls() {
return enabledUrls;
}
public List<String> getDisabledUrls() {
List<String> enabledUrls = this.enabledUrls;
if (!hasDisabledUrls()) {
return Collections.emptyList();
}
List<String> disabledUrls = new ArrayList<>(allUrls);
disabledUrls.removeAll(enabledUrls);
return disabledUrls;
}
public boolean hasDisabledUrls() {
return allUrls.size() != enabledUrls.size();
}
public ClickHouseConfig getCfg() {
return cfg;
}
}
| 3,682 |
14,668 | // Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/quic/web_transport_error.h"
#include "base/strings/strcat.h"
namespace net {
std::string WebTransportErrorToString(const WebTransportError& error) {
std::string message =
ExtendedErrorToString(error.net_error, error.quic_error);
if (error.details == message)
return message;
return base::StrCat({message, " (", error.details, ")"});
}
std::ostream& operator<<(std::ostream& os, const WebTransportError& error) {
os << WebTransportErrorToString(error);
return os;
}
} // namespace net
| 224 |
502 | <filename>modules/fixflow-core/src/main/java/org/eclipse/bpmn2/impl/CallActivityImpl.java
/**
* <copyright>
*
* Copyright (c) 2010 SAP AG.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* <NAME> (SAP AG) - initial API and implementation and/or initial documentation
*
* </copyright>
*/
package org.eclipse.bpmn2.impl;
import org.eclipse.bpmn2.Bpmn2Package;
import org.eclipse.bpmn2.CallActivity;
import org.eclipse.bpmn2.CallableElement;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
/**
* <!-- begin-user-doc -->
* An implementation of the model object '<em><b>Call Activity</b></em>'.
* <!-- end-user-doc -->
* <p>
* The following features are implemented:
* <ul>
* <li>{@link org.eclipse.bpmn2.impl.CallActivityImpl#getCalledElementRef <em>Called Element Ref</em>}</li>
* </ul>
* </p>
*
* @generated
*/
public class CallActivityImpl extends ActivityImpl implements CallActivity {
/**
* The cached value of the '{@link #getCalledElementRef() <em>Called Element Ref</em>}' reference.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getCalledElementRef()
* @generated
* @ordered
*/
protected CallableElement calledElementRef;
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
protected CallActivityImpl() {
super();
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
protected EClass eStaticClass() {
return Bpmn2Package.Literals.CALL_ACTIVITY;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public CallableElement getCalledElementRef() {
if (calledElementRef != null && calledElementRef.eIsProxy()) {
InternalEObject oldCalledElementRef = (InternalEObject) calledElementRef;
calledElementRef = (CallableElement) eResolveProxy(oldCalledElementRef);
if (calledElementRef != oldCalledElementRef) {
if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.RESOLVE,
Bpmn2Package.CALL_ACTIVITY__CALLED_ELEMENT_REF, oldCalledElementRef,
calledElementRef));
}
}
return calledElementRef;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public CallableElement basicGetCalledElementRef() {
return calledElementRef;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public void setCalledElementRef(CallableElement newCalledElementRef) {
CallableElement oldCalledElementRef = calledElementRef;
calledElementRef = newCalledElementRef;
if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.SET,
Bpmn2Package.CALL_ACTIVITY__CALLED_ELEMENT_REF, oldCalledElementRef,
calledElementRef));
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public Object eGet(int featureID, boolean resolve, boolean coreType) {
switch (featureID) {
case Bpmn2Package.CALL_ACTIVITY__CALLED_ELEMENT_REF:
if (resolve)
return getCalledElementRef();
return basicGetCalledElementRef();
}
return super.eGet(featureID, resolve, coreType);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public void eSet(int featureID, Object newValue) {
switch (featureID) {
case Bpmn2Package.CALL_ACTIVITY__CALLED_ELEMENT_REF:
setCalledElementRef((CallableElement) newValue);
return;
}
super.eSet(featureID, newValue);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public void eUnset(int featureID) {
switch (featureID) {
case Bpmn2Package.CALL_ACTIVITY__CALLED_ELEMENT_REF:
setCalledElementRef((CallableElement) null);
return;
}
super.eUnset(featureID);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public boolean eIsSet(int featureID) {
switch (featureID) {
case Bpmn2Package.CALL_ACTIVITY__CALLED_ELEMENT_REF:
return calledElementRef != null;
}
return super.eIsSet(featureID);
}
} //CallActivityImpl
| 2,131 |
791 | #include <stdint.h>
#include "syscall.h"
#include "soso.h"
int32_t manage_message(int32_t command, SosoMessage* message)
{
return __syscall(SYS_manage_message, command, (int)message);
}
int get_message_count()
{
return manage_message(0, 0);
}
void send_message(SosoMessage* message)
{
manage_message(1, message);
}
int get_next_message(SosoMessage* message)
{
return manage_message(2, message);
} | 163 |
384 | <reponame>fernandogar92/javaee8-samples
package org.javaee8.cdi.dynamic.bean;
import static org.jboss.shrinkwrap.api.ShrinkWrap.create;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.container.test.api.RunAsClient;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.arquillian.test.api.ArquillianResource;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
/**
*
* @author <NAME>
*
*/
@RunWith(Arquillian.class)
public class ExtensionlessMappingTest {
@ArquillianResource
private URL base;
private WebClient webClient;
@Before
public void setup() {
webClient = new WebClient();
}
@After
public void teardown() {
webClient.close();
}
@Deployment
public static WebArchive deploy() {
WebArchive war =
create(WebArchive.class)
.addClasses(MappingInit.class, ApplicationInit.class, MappingServletContextListener.class)
.addAsWebResource(new File("src/main/webapp/foo.xhtml"))
.addAsWebResource(new File("src/main/webapp/bar.xhtml"))
.addAsWebResource(new File("src/main/webapp/sub/bar.xhtml"), "/sub/bar.xhtml")
.addAsWebInfResource("beans.xml")
.addAsWebInfResource(new File("src/main/webapp/WEB-INF/faces-config.xml"));
System.out.println("War to be deployed contains: \n" + war.toString(true));
return war;
}
@Test
@RunAsClient
public void testExtensionlessMappingFoo() throws IOException {
HtmlPage page = webClient.getPage(base + "foo");
String content = page.asXml();
System.out.println("\nContent for `"+ base + "foo" + "` :\n" + content + "\n");
assertTrue(content.contains("This is page foo"));
}
@Test
@RunAsClient
public void testExtensionlessMappingBar() throws IOException {
HtmlPage page = webClient.getPage(base + "bar");
String content = page.asXml();
System.out.println("\nContent for `"+ base + "bar" + "` :\n" + content + "\n");
assertTrue(content.contains("This is page bar"));
}
@Test
@RunAsClient
public void testExtensionlessMappingSubBar() throws IOException {
HtmlPage page = webClient.getPage(base + "sub/bar");
String content = page.asXml();
System.out.println("\nContent for `"+ base + "sub/bar" + "` :\n" + content + "\n");
assertTrue(content.contains("This is page sub-bar"));
}
}
| 1,299 |
480 | #include <iostream>
#include <fstream>
#include <unordered_map>
#include <experimental/filesystem>
using namespace std;
using namespace experimental::filesystem;
using hash_map = unordered_map<size_t, path>;
static size_t hash_from_path(const path &p)
{
ifstream is {p.c_str(), ios::in | ios::binary};
if (!is) { throw errno; }
string s;
is.seekg(0, ios::end);
s.reserve(is.tellg());
is.seekg(0, ios::beg);
s.assign(istreambuf_iterator<char>{is}, {});
return hash<string>{}(s);
}
static size_t reduce_dupes(const path &dir)
{
hash_map m;
size_t count {0};
for (const auto &entry : recursive_directory_iterator{dir}) {
const path p {entry.path()};
if (is_directory(p)) { continue; }
const auto &[it, success] = m.try_emplace(hash_from_path(p), p);
if (!success) {
cout << "Removed " << p.c_str()
<< " because it is a duplicate of "
<< it->second.c_str() << '\n';
remove(p);
create_symlink(absolute(it->second), p);
++count;
}
}
return count;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
cout << "Usage: " << argv[0] << " <path>\n";
return 1;
}
path dir {argv[1]};
if (!exists(dir)) {
cout << "Path " << dir << " does not exist.\n";
return 1;
}
const size_t dupes {reduce_dupes(dir)};
cout << "Removed " << dupes << " duplicates.\n";
}
| 707 |
8,238 | <reponame>jjhoo/otp<filename>lib/wx/c_src/gen/wxe_wrapper_3.cpp
/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 2008-2021. All Rights Reserved.
*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* %CopyrightEnd%
*/
/***** This file is generated do not edit ****/
#include <wx/wx.h>
#include "../wxe_impl.h"
#include "../wxe_events.h"
#include "../wxe_return.h"
#include "../wxe_gl.h"
#include "wxe_macros.h"
#include "wxe_derived_dest.h"
// gdicmn::wxDisplaySize
void gdicmn_wxDisplaySize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int width;
int height;
::wxDisplaySize(&width,&height);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_int(width),
rt.make_int(height));
rt.send(msg);
}
// gdicmn::wxSetCursor
void gdicmn_wxSetCursor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxCursor *cursor;
cursor = (wxCursor *) memenv->getPtr(env, argv[0], "cursor");
::wxSetCursor(*cursor);
}
// wxEraseEvent::GetDC
void wxEraseEvent_GetDC(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEraseEvent *This;
This = (wxEraseEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxDC * Result = (wxDC*)This->GetDC();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxDC"));
}
// wxEvent::GetId
void wxEvent_GetId(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetId();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxEvent::GetSkipped
void wxEvent_GetSkipped(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->GetSkipped();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxEvent::GetTimestamp
void wxEvent_GetTimestamp(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
long Result = This->GetTimestamp();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_uint(Result));
}
// wxEvent::IsCommandEvent
void wxEvent_IsCommandEvent(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsCommandEvent();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxEvent::ResumePropagation
void wxEvent_ResumePropagation(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
int propagationLevel;
if(!enif_get_int(env, argv[1], &propagationLevel)) Badarg("propagationLevel"); // int
if(!This) throw wxe_badarg("This");
This->ResumePropagation(propagationLevel);
}
// wxEvent::ShouldPropagate
void wxEvent_ShouldPropagate(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->ShouldPropagate();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxEvent::Skip
void wxEvent_Skip(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool skip=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "skip"))) {
skip = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->Skip(skip);
}
// wxEvent::StopPropagation
void wxEvent_StopPropagation(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxEvent *This;
This = (wxEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->StopPropagation();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
void wxEvtHandler_Connect(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int winid;
int lastid;
int skip;
wxeErlTerm * userData;
int fun_cb;
wxEvtHandler *This = (wxEvtHandler *) memenv->getPtr(env, argv[0], "This");
if(!enif_get_int(env, argv[1], &winid)) Badarg("Winid");
if(!enif_get_int(env, argv[2], &lastid)) Badarg("LastId");
skip = enif_is_identical(argv[3], WXE_ATOM_true);
userData = new wxeErlTerm(argv[4]);
if(!enif_get_int(env, argv[5], &fun_cb)) Badarg("FunId");
if(!enif_is_atom(env, argv[6])) Badarg("EvType");
int eventType = wxeEventTypeFromAtom(argv[6]);
if(!enif_is_atom(env, argv[7])) Badarg("ClassName");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
if(eventType > 0 ) {
wxeEvtListener * Evt_cb = new wxeEvtListener(Ecmd.caller,app->getRef(This, memenv),
argv[7], fun_cb, skip, userData, memenv->me_ref);
This->Connect(winid, lastid, eventType,
(wxObjectEventFunction)(wxEventFunction) &wxeEvtListener::forward,
Evt_cb, Evt_cb);
rt.send(enif_make_tuple2(rt.env, WXE_ATOM_ok,
rt.make_ref(app->getRef((void *)Evt_cb,memenv),
"wxeEvtListener")));
} else {
rt.send(enif_make_tuple2(rt.env, WXE_ATOM_badarg, rt.make_atom("event_type")));
}
}
void wxEvtHandler_Disconnect_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int winid;
int lastid;
wxeEvtListener *Listener = (wxeEvtListener *) memenv->getPtr(env, argv[0], "Listener");
wxEvtHandler *This = (wxEvtHandler *) memenv->getPtr(env, argv[1],"This");
if(!enif_get_int(env, argv[2], &winid)) Badarg("Winid");
if(!enif_get_int(env, argv[3], &lastid)) Badarg("LastId");
if(!enif_is_atom(env, argv[4])) Badarg("EvType");
int eventType = wxeEventTypeFromAtom(argv[4]);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
if(eventType > 0) {
if(app->recurse_level > 1) {
Ecmd.op = 101;
app->delayed_delete->Append(&Ecmd);
} else {
bool Result = This->Disconnect(winid,lastid,eventType,
(wxObjectEventFunction)(wxEventFunction)
&wxeEvtListener::forward,
NULL, Listener);
rt.send(rt.make_bool(Result));
}
} else {
rt.send(enif_make_tuple2(rt.env, WXE_ATOM_badarg, rt.make_atom("event_type")));
}
}
// wxFileDataObject::wxFileDataObject
void wxFileDataObject_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFileDataObject * Result = new wxFileDataObject();
app->newPtr((void *) Result, 216, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFileDataObject"));
}
// wxFileDataObject::AddFile
void wxFileDataObject_AddFile(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDataObject *This;
This = (wxFileDataObject *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary file_bin;
wxString file;
if(!enif_inspect_binary(env, argv[1], &file_bin)) Badarg("file");
file = wxString(file_bin.data, wxConvUTF8, file_bin.size);
if(!This) throw wxe_badarg("This");
This->AddFile(file);
}
// wxFileDataObject::GetFilenames
void wxFileDataObject_GetFilenames(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDataObject *This;
This = (wxFileDataObject *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxArrayString Result = This->GetFilenames();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFileDataObject::destroy
void wxFileDataObject_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDataObject *This;
This = (wxFileDataObject *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxFileDialog::wxFileDialog
void wxFileDialog_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxString message= wxFileSelectorPromptStr;
wxString defaultDir= wxEmptyString;
wxString defaultFile= wxEmptyString;
wxString wildCard= wxFileSelectorDefaultWildcardStr;
long style=wxFD_DEFAULT_STYLE;
wxPoint pos= wxDefaultPosition;
wxSize sz= wxDefaultSize;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "message"))) {
ErlNifBinary message_bin;
if(!enif_inspect_binary(env, tpl[1], &message_bin)) Badarg("message");
message = wxString(message_bin.data, wxConvUTF8, message_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "defaultDir"))) {
ErlNifBinary defaultDir_bin;
if(!enif_inspect_binary(env, tpl[1], &defaultDir_bin)) Badarg("defaultDir");
defaultDir = wxString(defaultDir_bin.data, wxConvUTF8, defaultDir_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "defaultFile"))) {
ErlNifBinary defaultFile_bin;
if(!enif_inspect_binary(env, tpl[1], &defaultFile_bin)) Badarg("defaultFile");
defaultFile = wxString(defaultFile_bin.data, wxConvUTF8, defaultFile_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "wildCard"))) {
ErlNifBinary wildCard_bin;
if(!enif_inspect_binary(env, tpl[1], &wildCard_bin)) Badarg("wildCard");
wildCard = wxString(wildCard_bin.data, wxConvUTF8, wildCard_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "sz"))) {
const ERL_NIF_TERM *sz_t;
int sz_sz;
if(!enif_get_tuple(env, tpl[1], &sz_sz, &sz_t)) Badarg("sz");
int szW;
if(!enif_get_int(env, sz_t[0], &szW)) Badarg("sz");
int szH;
if(!enif_get_int(env, sz_t[1], &szH)) Badarg("sz");
sz = wxSize(szW,szH);
} else Badarg("Options");
};
wxFileDialog * Result = new EwxFileDialog(parent,message,defaultDir,defaultFile,wildCard,style,pos,sz);
app->newPtr((void *) Result, 2, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFileDialog"));
}
// wxFileDialog::GetDirectory
void wxFileDialog_GetDirectory(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetDirectory();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFileDialog::GetFilename
void wxFileDialog_GetFilename(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetFilename();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFileDialog::GetFilenames
void wxFileDialog_GetFilenames(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxArrayString filenames;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->GetFilenames(filenames);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(filenames));
}
// wxFileDialog::GetFilterIndex
void wxFileDialog_GetFilterIndex(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetFilterIndex();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFileDialog::GetMessage
void wxFileDialog_GetMessage(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetMessage();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFileDialog::GetPath
void wxFileDialog_GetPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetPath();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFileDialog::GetPaths
void wxFileDialog_GetPaths(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxArrayString paths;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->GetPaths(paths);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(paths));
}
// wxFileDialog::GetWildcard
void wxFileDialog_GetWildcard(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetWildcard();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFileDialog::SetDirectory
void wxFileDialog_SetDirectory(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary directory_bin;
wxString directory;
if(!enif_inspect_binary(env, argv[1], &directory_bin)) Badarg("directory");
directory = wxString(directory_bin.data, wxConvUTF8, directory_bin.size);
if(!This) throw wxe_badarg("This");
This->SetDirectory(directory);
}
// wxFileDialog::SetFilename
void wxFileDialog_SetFilename(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary setfilename_bin;
wxString setfilename;
if(!enif_inspect_binary(env, argv[1], &setfilename_bin)) Badarg("setfilename");
setfilename = wxString(setfilename_bin.data, wxConvUTF8, setfilename_bin.size);
if(!This) throw wxe_badarg("This");
This->SetFilename(setfilename);
}
// wxFileDialog::SetFilterIndex
void wxFileDialog_SetFilterIndex(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
int filterIndex;
if(!enif_get_int(env, argv[1], &filterIndex)) Badarg("filterIndex"); // int
if(!This) throw wxe_badarg("This");
This->SetFilterIndex(filterIndex);
}
// wxFileDialog::SetMessage
void wxFileDialog_SetMessage(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary message_bin;
wxString message;
if(!enif_inspect_binary(env, argv[1], &message_bin)) Badarg("message");
message = wxString(message_bin.data, wxConvUTF8, message_bin.size);
if(!This) throw wxe_badarg("This");
This->SetMessage(message);
}
// wxFileDialog::SetPath
void wxFileDialog_SetPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary path_bin;
wxString path;
if(!enif_inspect_binary(env, argv[1], &path_bin)) Badarg("path");
path = wxString(path_bin.data, wxConvUTF8, path_bin.size);
if(!This) throw wxe_badarg("This");
This->SetPath(path);
}
// wxFileDialog::SetWildcard
void wxFileDialog_SetWildcard(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDialog *This;
This = (wxFileDialog *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary wildCard_bin;
wxString wildCard;
if(!enif_inspect_binary(env, argv[1], &wildCard_bin)) Badarg("wildCard");
wildCard = wxString(wildCard_bin.data, wxConvUTF8, wildCard_bin.size);
if(!This) throw wxe_badarg("This");
This->SetWildcard(wildCard);
}
// wxFileDirPickerEvent::GetPath
void wxFileDirPickerEvent_GetPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFileDirPickerEvent *This;
This = (wxFileDirPickerEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetPath();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFilePickerCtrl::wxFilePickerCtrl
void wxFilePickerCtrl_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFilePickerCtrl * Result = new EwxFilePickerCtrl();
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFilePickerCtrl"));
}
// wxFilePickerCtrl::wxFilePickerCtrl
void wxFilePickerCtrl_new_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxString path= wxEmptyString;
wxString message= wxFileSelectorPromptStr;
wxString wildcard= wxFileSelectorDefaultWildcardStr;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxFLP_DEFAULT_STYLE;
const wxValidator * validator= &wxDefaultValidator;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
int id;
if(!enif_get_int(env, argv[1], &id)) Badarg("id"); // wxWindowID
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "path"))) {
ErlNifBinary path_bin;
if(!enif_inspect_binary(env, tpl[1], &path_bin)) Badarg("path");
path = wxString(path_bin.data, wxConvUTF8, path_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "message"))) {
ErlNifBinary message_bin;
if(!enif_inspect_binary(env, tpl[1], &message_bin)) Badarg("message");
message = wxString(message_bin.data, wxConvUTF8, message_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "wildcard"))) {
ErlNifBinary wildcard_bin;
if(!enif_inspect_binary(env, tpl[1], &wildcard_bin)) Badarg("wildcard");
wildcard = wxString(wildcard_bin.data, wxConvUTF8, wildcard_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "validator"))) {
validator = (wxValidator *) memenv->getPtr(env, tpl[1], "validator");
} else Badarg("Options");
};
wxFilePickerCtrl * Result = new EwxFilePickerCtrl(parent,id,path,message,wildcard,pos,size,style,*validator);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFilePickerCtrl"));
}
// wxFilePickerCtrl::Create
void wxFilePickerCtrl_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxString path= wxEmptyString;
wxString message= wxFileSelectorPromptStr;
wxString wildcard= wxFileSelectorDefaultWildcardStr;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxFLP_DEFAULT_STYLE;
const wxValidator * validator= &wxDefaultValidator;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFilePickerCtrl *This;
This = (wxFilePickerCtrl *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
int id;
if(!enif_get_int(env, argv[2], &id)) Badarg("id"); // wxWindowID
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "path"))) {
ErlNifBinary path_bin;
if(!enif_inspect_binary(env, tpl[1], &path_bin)) Badarg("path");
path = wxString(path_bin.data, wxConvUTF8, path_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "message"))) {
ErlNifBinary message_bin;
if(!enif_inspect_binary(env, tpl[1], &message_bin)) Badarg("message");
message = wxString(message_bin.data, wxConvUTF8, message_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "wildcard"))) {
ErlNifBinary wildcard_bin;
if(!enif_inspect_binary(env, tpl[1], &wildcard_bin)) Badarg("wildcard");
wildcard = wxString(wildcard_bin.data, wxConvUTF8, wildcard_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "validator"))) {
validator = (wxValidator *) memenv->getPtr(env, tpl[1], "validator");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,id,path,message,wildcard,pos,size,style,*validator);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFilePickerCtrl::GetPath
void wxFilePickerCtrl_GetPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFilePickerCtrl *This;
This = (wxFilePickerCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetPath();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFilePickerCtrl::SetPath
void wxFilePickerCtrl_SetPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFilePickerCtrl *This;
This = (wxFilePickerCtrl *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary filename_bin;
wxString filename;
if(!enif_inspect_binary(env, argv[1], &filename_bin)) Badarg("filename");
filename = wxString(filename_bin.data, wxConvUTF8, filename_bin.size);
if(!This) throw wxe_badarg("This");
This->SetPath(filename);
}
// wxFindReplaceData::wxFindReplaceData
void wxFindReplaceData_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
unsigned int flags=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "flags"))) {
if(!enif_get_uint(env, tpl[1], &flags)) Badarg("flags");
} else Badarg("Options");
};
wxFindReplaceData * Result = new EwxFindReplaceData(flags);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFindReplaceData"));
}
// wxFindReplaceData::GetFindString
void wxFindReplaceData_GetFindString(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceData *This;
This = (wxFindReplaceData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxString Result = This->GetFindString();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFindReplaceData::GetReplaceString
void wxFindReplaceData_GetReplaceString(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceData *This;
This = (wxFindReplaceData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxString Result = This->GetReplaceString();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFindReplaceData::GetFlags
void wxFindReplaceData_GetFlags(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceData *This;
This = (wxFindReplaceData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetFlags();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFindReplaceData::SetFlags
void wxFindReplaceData_SetFlags(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceData *This;
This = (wxFindReplaceData *) memenv->getPtr(env, argv[0], "This");
unsigned int flags;
if(!enif_get_uint(env, argv[1], &flags)) Badarg("flags");
if(!This) throw wxe_badarg("This");
This->SetFlags(flags);
}
// wxFindReplaceData::SetFindString
void wxFindReplaceData_SetFindString(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceData *This;
This = (wxFindReplaceData *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary str_bin;
wxString str;
if(!enif_inspect_binary(env, argv[1], &str_bin)) Badarg("str");
str = wxString(str_bin.data, wxConvUTF8, str_bin.size);
if(!This) throw wxe_badarg("This");
This->SetFindString(str);
}
// wxFindReplaceData::SetReplaceString
void wxFindReplaceData_SetReplaceString(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceData *This;
This = (wxFindReplaceData *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary str_bin;
wxString str;
if(!enif_inspect_binary(env, argv[1], &str_bin)) Badarg("str");
str = wxString(str_bin.data, wxConvUTF8, str_bin.size);
if(!This) throw wxe_badarg("This");
This->SetReplaceString(str);
}
// wxFindReplaceDialog::wxFindReplaceDialog
void wxFindReplaceDialog_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFindReplaceDialog * Result = new EwxFindReplaceDialog();
app->newPtr((void *) Result, 2, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFindReplaceDialog"));
}
// wxFindReplaceDialog::wxFindReplaceDialog
void wxFindReplaceDialog_new_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int style=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
wxFindReplaceData *data;
data = (wxFindReplaceData *) memenv->getPtr(env, argv[1], "data");
ErlNifBinary title_bin;
wxString title;
if(!enif_inspect_binary(env, argv[2], &title_bin)) Badarg("title");
title = wxString(title_bin.data, wxConvUTF8, title_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_int(env, tpl[1], &style)) Badarg("style"); // int
} else Badarg("Options");
};
wxFindReplaceDialog * Result = new EwxFindReplaceDialog(parent,data,title,style);
app->newPtr((void *) Result, 2, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFindReplaceDialog"));
}
// wxFindReplaceDialog::Create
void wxFindReplaceDialog_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int style=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceDialog *This;
This = (wxFindReplaceDialog *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
wxFindReplaceData *data;
data = (wxFindReplaceData *) memenv->getPtr(env, argv[2], "data");
ErlNifBinary title_bin;
wxString title;
if(!enif_inspect_binary(env, argv[3], &title_bin)) Badarg("title");
title = wxString(title_bin.data, wxConvUTF8, title_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[4];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_int(env, tpl[1], &style)) Badarg("style"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,data,title,style);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFindReplaceDialog::GetData
void wxFindReplaceDialog_GetData(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFindReplaceDialog *This;
This = (wxFindReplaceDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxFindReplaceData * Result = (wxFindReplaceData*)This->GetData();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFindReplaceData"));
}
// wxFlexGridSizer::wxFlexGridSizer
void wxFlexGridSizer_new_3_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int cols;
if(!enif_get_int(env, argv[0], &cols)) Badarg("cols"); // int
int vgap;
if(!enif_get_int(env, argv[1], &vgap)) Badarg("vgap"); // int
int hgap;
if(!enif_get_int(env, argv[2], &hgap)) Badarg("hgap"); // int
wxFlexGridSizer * Result = new EwxFlexGridSizer(cols,vgap,hgap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFlexGridSizer"));
}
// wxFlexGridSizer::wxFlexGridSizer
void wxFlexGridSizer_new_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxSize gap= wxSize(0, 0);
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int cols;
if(!enif_get_int(env, argv[0], &cols)) Badarg("cols"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "gap"))) {
const ERL_NIF_TERM *gap_t;
int gap_sz;
if(!enif_get_tuple(env, tpl[1], &gap_sz, &gap_t)) Badarg("gap");
int gapW;
if(!enif_get_int(env, gap_t[0], &gapW)) Badarg("gap");
int gapH;
if(!enif_get_int(env, gap_t[1], &gapH)) Badarg("gap");
gap = wxSize(gapW,gapH);
} else Badarg("Options");
};
wxFlexGridSizer * Result = new EwxFlexGridSizer(cols,gap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFlexGridSizer"));
}
// wxFlexGridSizer::wxFlexGridSizer
void wxFlexGridSizer_new_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int rows;
if(!enif_get_int(env, argv[0], &rows)) Badarg("rows"); // int
int cols;
if(!enif_get_int(env, argv[1], &cols)) Badarg("cols"); // int
int vgap;
if(!enif_get_int(env, argv[2], &vgap)) Badarg("vgap"); // int
int hgap;
if(!enif_get_int(env, argv[3], &hgap)) Badarg("hgap"); // int
wxFlexGridSizer * Result = new EwxFlexGridSizer(rows,cols,vgap,hgap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFlexGridSizer"));
}
// wxFlexGridSizer::wxFlexGridSizer
void wxFlexGridSizer_new_3_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int rows;
if(!enif_get_int(env, argv[0], &rows)) Badarg("rows"); // int
int cols;
if(!enif_get_int(env, argv[1], &cols)) Badarg("cols"); // int
const ERL_NIF_TERM *gap_t;
int gap_sz;
if(!enif_get_tuple(env, argv[2], &gap_sz, &gap_t)) Badarg("gap");
int gapW;
if(!enif_get_int(env, gap_t[0], &gapW)) Badarg("gap");
int gapH;
if(!enif_get_int(env, gap_t[1], &gapH)) Badarg("gap");
wxSize gap = wxSize(gapW,gapH);
wxFlexGridSizer * Result = new EwxFlexGridSizer(rows,cols,gap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFlexGridSizer"));
}
// wxFlexGridSizer::AddGrowableCol
void wxFlexGridSizer_AddGrowableCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int proportion=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
size_t idx;
if(!wxe_get_size_t(env, argv[1], &idx)) Badarg("idx");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "proportion"))) {
if(!enif_get_int(env, tpl[1], &proportion)) Badarg("proportion"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->AddGrowableCol(idx,proportion);
}
// wxFlexGridSizer::AddGrowableRow
void wxFlexGridSizer_AddGrowableRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int proportion=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
size_t idx;
if(!wxe_get_size_t(env, argv[1], &idx)) Badarg("idx");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "proportion"))) {
if(!enif_get_int(env, tpl[1], &proportion)) Badarg("proportion"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->AddGrowableRow(idx,proportion);
}
// wxFlexGridSizer::GetFlexibleDirection
void wxFlexGridSizer_GetFlexibleDirection(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetFlexibleDirection();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFlexGridSizer::GetNonFlexibleGrowMode
void wxFlexGridSizer_GetNonFlexibleGrowMode(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetNonFlexibleGrowMode();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFlexGridSizer::RemoveGrowableCol
void wxFlexGridSizer_RemoveGrowableCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
size_t idx;
if(!wxe_get_size_t(env, argv[1], &idx)) Badarg("idx");
if(!This) throw wxe_badarg("This");
This->RemoveGrowableCol(idx);
}
// wxFlexGridSizer::RemoveGrowableRow
void wxFlexGridSizer_RemoveGrowableRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
size_t idx;
if(!wxe_get_size_t(env, argv[1], &idx)) Badarg("idx");
if(!This) throw wxe_badarg("This");
This->RemoveGrowableRow(idx);
}
// wxFlexGridSizer::SetFlexibleDirection
void wxFlexGridSizer_SetFlexibleDirection(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
int direction;
if(!enif_get_int(env, argv[1], &direction)) Badarg("direction"); // int
if(!This) throw wxe_badarg("This");
This->SetFlexibleDirection(direction);
}
// wxFlexGridSizer::SetNonFlexibleGrowMode
void wxFlexGridSizer_SetNonFlexibleGrowMode(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFlexGridSizer *This;
This = (wxFlexGridSizer *) memenv->getPtr(env, argv[0], "This");
wxFlexSizerGrowMode mode;
if(!enif_get_int(env, argv[1], (int *) &mode)) Badarg("mode"); // enum
if(!This) throw wxe_badarg("This");
This->SetNonFlexibleGrowMode(mode);
}
// wxFocusEvent::GetWindow
void wxFocusEvent_GetWindow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFocusEvent *This;
This = (wxFocusEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxWindow * Result = (wxWindow*)This->GetWindow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxWindow"));
}
// wxFont::wxFont
void wxFont_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFont * Result = new EwxFont();
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFont::wxFont
void wxFont_new_1_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[0], "font");
wxFont * Result = new EwxFont(*font);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFont::wxFont
void wxFont_new_5_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool underlined=false;
wxString face= wxEmptyString;
wxFontEncoding encoding=wxFONTENCODING_DEFAULT;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int pointSize;
if(!enif_get_int(env, argv[0], &pointSize)) Badarg("pointSize"); // int
wxFontFamily family;
if(!enif_get_int(env, argv[1], (int *) &family)) Badarg("family"); // enum
wxFontStyle style;
if(!enif_get_int(env, argv[2], (int *) &style)) Badarg("style"); // enum
wxFontWeight weight;
if(!enif_get_int(env, argv[3], (int *) &weight)) Badarg("weight"); // enum
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[4];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "underlined"))) {
underlined = enif_is_identical(tpl[1], WXE_ATOM_true);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "face"))) {
ErlNifBinary face_bin;
if(!enif_inspect_binary(env, tpl[1], &face_bin)) Badarg("face");
face = wxString(face_bin.data, wxConvUTF8, face_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "encoding"))) {
if(!enif_get_int(env, tpl[1], (int *) &encoding)) Badarg("encoding"); // enum
} else Badarg("Options");
};
wxFont * Result = new EwxFont(pointSize,family,style,weight,underlined,face,encoding);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFont::wxFont
void wxFont_new_5_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool underline=false;
wxString faceName= wxEmptyString;
wxFontEncoding encoding=wxFONTENCODING_DEFAULT;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
const ERL_NIF_TERM *pixelSize_t;
int pixelSize_sz;
if(!enif_get_tuple(env, argv[0], &pixelSize_sz, &pixelSize_t)) Badarg("pixelSize");
int pixelSizeW;
if(!enif_get_int(env, pixelSize_t[0], &pixelSizeW)) Badarg("pixelSize");
int pixelSizeH;
if(!enif_get_int(env, pixelSize_t[1], &pixelSizeH)) Badarg("pixelSize");
wxSize pixelSize = wxSize(pixelSizeW,pixelSizeH);
wxFontFamily family;
if(!enif_get_int(env, argv[1], (int *) &family)) Badarg("family"); // enum
wxFontStyle style;
if(!enif_get_int(env, argv[2], (int *) &style)) Badarg("style"); // enum
wxFontWeight weight;
if(!enif_get_int(env, argv[3], (int *) &weight)) Badarg("weight"); // enum
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[4];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "underline"))) {
underline = enif_is_identical(tpl[1], WXE_ATOM_true);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "faceName"))) {
ErlNifBinary faceName_bin;
if(!enif_inspect_binary(env, tpl[1], &faceName_bin)) Badarg("faceName");
faceName = wxString(faceName_bin.data, wxConvUTF8, faceName_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "encoding"))) {
if(!enif_get_int(env, tpl[1], (int *) &encoding)) Badarg("encoding"); // enum
} else Badarg("Options");
};
wxFont * Result = new EwxFont(pixelSize,family,style,weight,underline,faceName,encoding);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFont::wxFont
void wxFont_new_1_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ErlNifBinary nativeInfoString_bin;
wxString nativeInfoString;
if(!enif_inspect_binary(env, argv[0], &nativeInfoString_bin)) Badarg("nativeInfoString");
nativeInfoString = wxString(nativeInfoString_bin.data, wxConvUTF8, nativeInfoString_bin.size);
wxFont * Result = new EwxFont(nativeInfoString);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFont::IsFixedWidth
void wxFont_IsFixedWidth(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsFixedWidth();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFont::GetDefaultEncoding
void wxFont_GetDefaultEncoding(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int Result = wxFont::GetDefaultEncoding();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFont::GetFaceName
void wxFont_GetFaceName(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetFaceName();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFont::GetFamily
void wxFont_GetFamily(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetFamily();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFont::GetNativeFontInfoDesc
void wxFont_GetNativeFontInfoDesc(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetNativeFontInfoDesc();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFont::GetNativeFontInfoUserDesc
void wxFont_GetNativeFontInfoUserDesc(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetNativeFontInfoUserDesc();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFont::GetPointSize
void wxFont_GetPointSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetPointSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFont::GetStyle
void wxFont_GetStyle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetStyle();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFont::GetUnderlined
void wxFont_GetUnderlined(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->GetUnderlined();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFont::GetWeight
void wxFont_GetWeight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetWeight();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFont::IsOk
void wxFont_IsOk(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsOk();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFont::SetDefaultEncoding
void wxFont_SetDefaultEncoding(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontEncoding encoding;
if(!enif_get_int(env, argv[0], (int *) &encoding)) Badarg("encoding"); // enum
wxFont::SetDefaultEncoding(encoding);
}
// wxFont::SetFaceName
void wxFont_SetFaceName(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary faceName_bin;
wxString faceName;
if(!enif_inspect_binary(env, argv[1], &faceName_bin)) Badarg("faceName");
faceName = wxString(faceName_bin.data, wxConvUTF8, faceName_bin.size);
if(!This) throw wxe_badarg("This");
bool Result = This->SetFaceName(faceName);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFont::SetFamily
void wxFont_SetFamily(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
wxFontFamily family;
if(!enif_get_int(env, argv[1], (int *) &family)) Badarg("family"); // enum
if(!This) throw wxe_badarg("This");
This->SetFamily(family);
}
// wxFont::SetPointSize
void wxFont_SetPointSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
int pointSize;
if(!enif_get_int(env, argv[1], &pointSize)) Badarg("pointSize"); // int
if(!This) throw wxe_badarg("This");
This->SetPointSize(pointSize);
}
// wxFont::SetStyle
void wxFont_SetStyle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
wxFontStyle style;
if(!enif_get_int(env, argv[1], (int *) &style)) Badarg("style"); // enum
if(!This) throw wxe_badarg("This");
This->SetStyle(style);
}
// wxFont::SetUnderlined
void wxFont_SetUnderlined(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
bool underlined;
underlined = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->SetUnderlined(underlined);
}
// wxFont::SetWeight
void wxFont_SetWeight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFont *This;
This = (wxFont *) memenv->getPtr(env, argv[0], "This");
wxFontWeight weight;
if(!enif_get_int(env, argv[1], (int *) &weight)) Badarg("weight"); // enum
if(!This) throw wxe_badarg("This");
This->SetWeight(weight);
}
// wxFontData::wxFontData
void wxFontData_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFontData * Result = new EwxFontData();
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontData"));
}
// wxFontData::wxFontData
void wxFontData_new_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *data;
data = (wxFontData *) memenv->getPtr(env, argv[0], "data");
wxFontData * Result = new EwxFontData(*data);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontData"));
}
// wxFontData::EnableEffects
void wxFontData_EnableEffects(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
bool enable;
enable = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->EnableEffects(enable);
}
// wxFontData::GetAllowSymbols
void wxFontData_GetAllowSymbols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->GetAllowSymbols();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFontData::GetColour
void wxFontData_GetColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxColour * Result = &This->GetColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make((*Result)));
}
// wxFontData::GetChosenFont
void wxFontData_GetChosenFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetChosenFont()); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFontData::GetEnableEffects
void wxFontData_GetEnableEffects(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->GetEnableEffects();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFontData::GetInitialFont
void wxFontData_GetInitialFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetInitialFont()); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFontData::GetShowHelp
void wxFontData_GetShowHelp(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->GetShowHelp();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFontData::SetAllowSymbols
void wxFontData_SetAllowSymbols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
bool allowSymbols;
allowSymbols = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->SetAllowSymbols(allowSymbols);
}
// wxFontData::SetChosenFont
void wxFontData_SetChosenFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetChosenFont(*font);
}
// wxFontData::SetColour
void wxFontData_SetColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[1], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetColour(colour);
}
// wxFontData::SetInitialFont
void wxFontData_SetInitialFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetInitialFont(*font);
}
// wxFontData::SetRange
void wxFontData_SetRange(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
int min;
if(!enif_get_int(env, argv[1], &min)) Badarg("min"); // int
int max;
if(!enif_get_int(env, argv[2], &max)) Badarg("max"); // int
if(!This) throw wxe_badarg("This");
This->SetRange(min,max);
}
// wxFontData::SetShowHelp
void wxFontData_SetShowHelp(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontData *This;
This = (wxFontData *) memenv->getPtr(env, argv[0], "This");
bool showHelp;
showHelp = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->SetShowHelp(showHelp);
}
// wxFontDialog::wxFontDialog
void wxFontDialog_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFontDialog * Result = new EwxFontDialog();
app->newPtr((void *) Result, 2, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontDialog"));
}
// wxFontDialog::wxFontDialog
void wxFontDialog_new_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
wxFontData *data;
data = (wxFontData *) memenv->getPtr(env, argv[1], "data");
wxFontDialog * Result = new EwxFontDialog(parent,*data);
app->newPtr((void *) Result, 2, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontDialog"));
}
// wxFontDialog::Create
void wxFontDialog_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontDialog *This;
This = (wxFontDialog *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
wxFontData *data;
data = (wxFontData *) memenv->getPtr(env, argv[2], "data");
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,*data);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFontDialog::GetFontData
void wxFontDialog_GetFontData(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontDialog *This;
This = (wxFontDialog *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxFontData * Result = &This->GetFontData();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontData"));
}
// wxFontPickerCtrl::wxFontPickerCtrl
void wxFontPickerCtrl_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFontPickerCtrl * Result = new EwxFontPickerCtrl();
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontPickerCtrl"));
}
// wxFontPickerCtrl::wxFontPickerCtrl
void wxFontPickerCtrl_new_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
const wxFont * initial= &wxNullFont;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxFNTP_DEFAULT_STYLE;
const wxValidator * validator= &wxDefaultValidator;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
int id;
if(!enif_get_int(env, argv[1], &id)) Badarg("id"); // wxWindowID
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "initial"))) {
initial = (wxFont *) memenv->getPtr(env, tpl[1], "initial");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "validator"))) {
validator = (wxValidator *) memenv->getPtr(env, tpl[1], "validator");
} else Badarg("Options");
};
wxFontPickerCtrl * Result = new EwxFontPickerCtrl(parent,id,*initial,pos,size,style,*validator);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFontPickerCtrl"));
}
// wxFontPickerCtrl::Create
void wxFontPickerCtrl_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
const wxFont * initial= &wxNullFont;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxFNTP_DEFAULT_STYLE;
const wxValidator * validator= &wxDefaultValidator;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontPickerCtrl *This;
This = (wxFontPickerCtrl *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
int id;
if(!enif_get_int(env, argv[2], &id)) Badarg("id"); // wxWindowID
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "initial"))) {
initial = (wxFont *) memenv->getPtr(env, tpl[1], "initial");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "validator"))) {
validator = (wxValidator *) memenv->getPtr(env, tpl[1], "validator");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,id,*initial,pos,size,style,*validator);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFontPickerCtrl::GetSelectedFont
void wxFontPickerCtrl_GetSelectedFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontPickerCtrl *This;
This = (wxFontPickerCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetSelectedFont()); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFontPickerCtrl::SetSelectedFont
void wxFontPickerCtrl_SetSelectedFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontPickerCtrl *This;
This = (wxFontPickerCtrl *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetSelectedFont(*font);
}
// wxFontPickerCtrl::GetMaxPointSize
void wxFontPickerCtrl_GetMaxPointSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontPickerCtrl *This;
This = (wxFontPickerCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetMaxPointSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_uint(Result));
}
// wxFontPickerCtrl::SetMaxPointSize
void wxFontPickerCtrl_SetMaxPointSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontPickerCtrl *This;
This = (wxFontPickerCtrl *) memenv->getPtr(env, argv[0], "This");
unsigned int max;
if(!enif_get_uint(env, argv[1], &max)) Badarg("max");
if(!This) throw wxe_badarg("This");
This->SetMaxPointSize(max);
}
// wxFontPickerEvent::GetFont
void wxFontPickerEvent_GetFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFontPickerEvent *This;
This = (wxFontPickerEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetFont()); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxFrame::wxFrame
void wxFrame_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxFrame * Result = new EwxFrame();
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFrame"));
}
// wxFrame::wxFrame
void wxFrame_new_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxDEFAULT_FRAME_STYLE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
int id;
if(!enif_get_int(env, argv[1], &id)) Badarg("id"); // wxWindowID
ErlNifBinary title_bin;
wxString title;
if(!enif_inspect_binary(env, argv[2], &title_bin)) Badarg("title");
title = wxString(title_bin.data, wxConvUTF8, title_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else Badarg("Options");
};
wxFrame * Result = new EwxFrame(parent,id,title,pos,size,style);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFrame"));
}
// wxFrame::Create
void wxFrame_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxDEFAULT_FRAME_STYLE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
int id;
if(!enif_get_int(env, argv[2], &id)) Badarg("id"); // wxWindowID
ErlNifBinary title_bin;
wxString title;
if(!enif_inspect_binary(env, argv[3], &title_bin)) Badarg("title");
title = wxString(title_bin.data, wxConvUTF8, title_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[4];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,id,title,pos,size,style);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFrame::CreateStatusBar
void wxFrame_CreateStatusBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int number=1;
long style=wxSTB_DEFAULT_STYLE;
wxWindowID id=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "number"))) {
if(!enif_get_int(env, tpl[1], &number)) Badarg("number"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "id"))) {
if(!enif_get_int(env, tpl[1], &id)) Badarg("id"); // wxWindowID
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxStatusBar * Result = (wxStatusBar*)This->CreateStatusBar(number,style,id);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxStatusBar"));
}
// wxFrame::CreateToolBar
void wxFrame_CreateToolBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
long style=wxTB_DEFAULT_STYLE;
wxWindowID id=wxID_ANY;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "id"))) {
if(!enif_get_int(env, tpl[1], &id)) Badarg("id"); // wxWindowID
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxToolBar * Result = (wxToolBar*)This->CreateToolBar(style,id);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxToolBar"));
}
// wxFrame::GetClientAreaOrigin
void wxFrame_GetClientAreaOrigin(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxPoint Result = This->GetClientAreaOrigin();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxFrame::GetMenuBar
void wxFrame_GetMenuBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxMenuBar * Result = (wxMenuBar*)This->GetMenuBar();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxMenuBar"));
}
// wxFrame::GetStatusBar
void wxFrame_GetStatusBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxStatusBar * Result = (wxStatusBar*)This->GetStatusBar();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxStatusBar"));
}
// wxFrame::GetStatusBarPane
void wxFrame_GetStatusBarPane(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetStatusBarPane();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxFrame::GetToolBar
void wxFrame_GetToolBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxToolBar * Result = (wxToolBar*)This->GetToolBar();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxToolBar"));
}
// wxFrame::ProcessCommand
void wxFrame_ProcessCommand(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
int id;
if(!enif_get_int(env, argv[1], &id)) Badarg("id"); // int
if(!This) throw wxe_badarg("This");
bool Result = This->ProcessCommand(id);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxFrame::SendSizeEvent
void wxFrame_SendSizeEvent(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int flags=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "flags"))) {
if(!enif_get_int(env, tpl[1], &flags)) Badarg("flags"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SendSizeEvent(flags);
}
// wxFrame::SetMenuBar
void wxFrame_SetMenuBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
wxMenuBar *menuBar;
menuBar = (wxMenuBar *) memenv->getPtr(env, argv[1], "menuBar");
if(!This) throw wxe_badarg("This");
This->SetMenuBar(menuBar);
}
// wxFrame::SetStatusBar
void wxFrame_SetStatusBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
wxStatusBar *statusBar;
statusBar = (wxStatusBar *) memenv->getPtr(env, argv[1], "statusBar");
if(!This) throw wxe_badarg("This");
This->SetStatusBar(statusBar);
}
// wxFrame::SetStatusBarPane
void wxFrame_SetStatusBarPane(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
int n;
if(!enif_get_int(env, argv[1], &n)) Badarg("n"); // int
if(!This) throw wxe_badarg("This");
This->SetStatusBarPane(n);
}
// wxFrame::SetStatusText
void wxFrame_SetStatusText(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int number=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary text_bin;
wxString text;
if(!enif_inspect_binary(env, argv[1], &text_bin)) Badarg("text");
text = wxString(text_bin.data, wxConvUTF8, text_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "number"))) {
if(!enif_get_int(env, tpl[1], &number)) Badarg("number"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SetStatusText(text,number);
}
// wxFrame::SetStatusWidths
void wxFrame_SetStatusWidths(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
int widths_field_tmp;
unsigned int widths_fieldLen;
ERL_NIF_TERM widths_fieldHead, widths_fieldTail;
if(!enif_get_list_length(env, argv[1], &widths_fieldLen)) Badarg("widths_field");
std::vector <int> widths_field;
widths_fieldTail = argv[1];
while(!enif_is_empty_list(env, widths_fieldTail)) {
if(!enif_get_list_cell(env, widths_fieldTail, &widths_fieldHead, &widths_fieldTail)) Badarg("widths_field");
if(!enif_get_int(env, widths_fieldHead, &widths_field_tmp)) Badarg("widths_field");
widths_field.push_back( (int) widths_field_tmp);
};
if(!This) throw wxe_badarg("This");
This->SetStatusWidths(widths_fieldLen,widths_field.data());
}
// wxFrame::SetToolBar
void wxFrame_SetToolBar(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxFrame *This;
This = (wxFrame *) memenv->getPtr(env, argv[0], "This");
wxToolBar *toolBar;
toolBar = (wxToolBar *) memenv->getPtr(env, argv[1], "toolBar");
if(!This) throw wxe_badarg("This");
This->SetToolBar(toolBar);
}
#if wxUSE_GRAPHICS_CONTEXT
// wxGCDC::wxGCDC
void wxGCDC_new_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM windowDC_type;
void * windowDC = memenv->getPtr(env, argv[0], "windowDC", &windowDC_type);
wxGCDC * Result;
if(enif_is_identical(windowDC_type, WXE_ATOM_wxWindowDC))
Result = new EwxGCDC(* static_cast<wxWindowDC*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxMemoryDC))
Result = new EwxGCDC(* static_cast<wxMemoryDC*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxGraphicsContext))
Result = new EwxGCDC(static_cast<wxGraphicsContext*> (windowDC));
else throw wxe_badarg("windowDC");
app->newPtr((void *) Result, 8, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGCDC"));
}
// wxGCDC::wxGCDC
void wxGCDC_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGCDC * Result = new EwxGCDC();
app->newPtr((void *) Result, 8, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGCDC"));
}
// wxGCDC::GetGraphicsContext
void wxGCDC_GetGraphicsContext(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGCDC *This;
This = (wxGCDC *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGraphicsContext * Result = (wxGraphicsContext*)This->GetGraphicsContext();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv,8), "wxGraphicsContext")
);
}
// wxGCDC::SetGraphicsContext
void wxGCDC_SetGraphicsContext(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGCDC *This;
This = (wxGCDC *) memenv->getPtr(env, argv[0], "This");
wxGraphicsContext *context;
context = (wxGraphicsContext *) memenv->getPtr(env, argv[1], "context");
if(!This) throw wxe_badarg("This");
This->SetGraphicsContext(context);
}
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GLCANVAS
// wxGLCanvas::wxGLCanvas
void wxGLCanvas_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxWindowID id=wxID_ANY;
unsigned int attribListLen;
std::vector <int> attribList;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=0;
wxString name= "GLCanvas";
const wxPalette * palette= &wxNullPalette;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "id"))) {
if(!enif_get_int(env, tpl[1], &id)) Badarg("id"); // wxWindowID
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "attribList"))) {
int attribList_tmp;
ERL_NIF_TERM attribListHead, attribListTail;
if(!enif_get_list_length(env, tpl[1], &attribListLen)) Badarg("attribList");
attribListTail = tpl[1];
while(!enif_is_empty_list(env, attribListTail)) {
if(!enif_get_list_cell(env, attribListTail, &attribListHead, &attribListTail)) Badarg("attribList");
if(!enif_get_int(env, attribListHead, &attribList_tmp)) Badarg("attribList");
attribList.push_back( (int) attribList_tmp);
};
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "name"))) {
ErlNifBinary name_bin;
if(!enif_inspect_binary(env, tpl[1], &name_bin)) Badarg("name");
name = wxString(name_bin.data, wxConvUTF8, name_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "palette"))) {
palette = (wxPalette *) memenv->getPtr(env, tpl[1], "palette");
} else Badarg("Options");
};
wxGLCanvas * Result = new EwxGLCanvas(parent,id, attribList.empty() ? NULL : attribList.data(),pos,size,style,name,*palette);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGLCanvas"));
}
// wxGLCanvas::SetCurrent
void wxGLCanvas_SetCurrent(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGLCanvas *This;
This = (wxGLCanvas *) memenv->getPtr(env, argv[0], "This");
wxGLContext *context;
context = (wxGLContext *) memenv->getPtr(env, argv[1], "context");
if(!This) throw wxe_badarg("This");
bool Result = This->SetCurrent(*context);
setActiveGL(memenv, Ecmd.caller, This, context);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGLCanvas::SwapBuffers
void wxGLCanvas_SwapBuffers(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGLCanvas *This;
This = (wxGLCanvas *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->SwapBuffers();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
#endif // wxUSE_GLCANVAS
#if wxUSE_GLCANVAS
// wxGLContext::wxGLContext
void wxGLContext_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGLContext * other=NULL;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGLCanvas *win;
win = (wxGLCanvas *) memenv->getPtr(env, argv[0], "win");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "other"))) {
other = (wxGLContext *) memenv->getPtr(env, tpl[1], "other");
} else Badarg("Options");
};
wxGLContext * Result = new EwxGLContext(win,other);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGLContext"));
}
// wxGLContext::SetCurrent
void wxGLContext_SetCurrent(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGLContext *This;
This = (wxGLContext *) memenv->getPtr(env, argv[0], "This");
wxGLCanvas *win;
win = (wxGLCanvas *) memenv->getPtr(env, argv[1], "win");
if(!This) throw wxe_badarg("This");
bool Result = This->SetCurrent(*win);
setActiveGL(memenv, Ecmd.caller, win, This);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
#endif // wxUSE_GLCANVAS
// wxGauge::wxGauge
void wxGauge_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGauge * Result = new EwxGauge();
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGauge"));
}
// wxGauge::wxGauge
void wxGauge_new_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxGA_HORIZONTAL;
const wxValidator * validator= &wxDefaultValidator;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
int id;
if(!enif_get_int(env, argv[1], &id)) Badarg("id"); // wxWindowID
int range;
if(!enif_get_int(env, argv[2], &range)) Badarg("range"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "validator"))) {
validator = (wxValidator *) memenv->getPtr(env, tpl[1], "validator");
} else Badarg("Options");
};
wxGauge * Result = new EwxGauge(parent,id,range,pos,size,style,*validator);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGauge"));
}
// wxGauge::Create
void wxGauge_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxGA_HORIZONTAL;
const wxValidator * validator= &wxDefaultValidator;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
int id;
if(!enif_get_int(env, argv[2], &id)) Badarg("id"); // wxWindowID
int range;
if(!enif_get_int(env, argv[3], &range)) Badarg("range"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[4];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "validator"))) {
validator = (wxValidator *) memenv->getPtr(env, tpl[1], "validator");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,id,range,pos,size,style,*validator);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGauge::GetRange
void wxGauge_GetRange(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetRange();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGauge::GetValue
void wxGauge_GetValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetValue();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGauge::IsVertical
void wxGauge_IsVertical(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsVertical();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGauge::SetRange
void wxGauge_SetRange(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
int range;
if(!enif_get_int(env, argv[1], &range)) Badarg("range"); // int
if(!This) throw wxe_badarg("This");
This->SetRange(range);
}
// wxGauge::SetValue
void wxGauge_SetValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
int pos;
if(!enif_get_int(env, argv[1], &pos)) Badarg("pos"); // int
if(!This) throw wxe_badarg("This");
This->SetValue(pos);
}
// wxGauge::Pulse
void wxGauge_Pulse(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGauge *This;
This = (wxGauge *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->Pulse();
}
// wxGenericDirCtrl::wxGenericDirCtrl
void wxGenericDirCtrl_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGenericDirCtrl * Result = new EwxGenericDirCtrl();
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGenericDirCtrl"));
}
// wxGenericDirCtrl::wxGenericDirCtrl
void wxGenericDirCtrl_new_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxWindowID id=wxID_ANY;
wxString dir= wxDirDialogDefaultFolderStr;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxDIRCTRL_3D_INTERNAL;
wxString filter= wxEmptyString;
int defaultFilter=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "id"))) {
if(!enif_get_int(env, tpl[1], &id)) Badarg("id"); // wxWindowID
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "dir"))) {
ErlNifBinary dir_bin;
if(!enif_inspect_binary(env, tpl[1], &dir_bin)) Badarg("dir");
dir = wxString(dir_bin.data, wxConvUTF8, dir_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "filter"))) {
ErlNifBinary filter_bin;
if(!enif_inspect_binary(env, tpl[1], &filter_bin)) Badarg("filter");
filter = wxString(filter_bin.data, wxConvUTF8, filter_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "defaultFilter"))) {
if(!enif_get_int(env, tpl[1], &defaultFilter)) Badarg("defaultFilter"); // int
} else Badarg("Options");
};
wxGenericDirCtrl * Result = new EwxGenericDirCtrl(parent,id,dir,pos,size,style,filter,defaultFilter);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGenericDirCtrl"));
}
// wxGenericDirCtrl::Create
void wxGenericDirCtrl_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxWindowID id=wxID_ANY;
wxString dir= wxDirDialogDefaultFolderStr;
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxDIRCTRL_3D_INTERNAL;
wxString filter= wxEmptyString;
int defaultFilter=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "id"))) {
if(!enif_get_int(env, tpl[1], &id)) Badarg("id"); // wxWindowID
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "dir"))) {
ErlNifBinary dir_bin;
if(!enif_inspect_binary(env, tpl[1], &dir_bin)) Badarg("dir");
dir = wxString(dir_bin.data, wxConvUTF8, dir_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "filter"))) {
ErlNifBinary filter_bin;
if(!enif_inspect_binary(env, tpl[1], &filter_bin)) Badarg("filter");
filter = wxString(filter_bin.data, wxConvUTF8, filter_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "defaultFilter"))) {
if(!enif_get_int(env, tpl[1], &defaultFilter)) Badarg("defaultFilter"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Create(parent,id,dir,pos,size,style,filter,defaultFilter);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGenericDirCtrl::Init
void wxGenericDirCtrl_Init(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->Init();
}
// wxGenericDirCtrl::CollapseTree
void wxGenericDirCtrl_CollapseTree(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->CollapseTree();
}
// wxGenericDirCtrl::ExpandPath
void wxGenericDirCtrl_ExpandPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary path_bin;
wxString path;
if(!enif_inspect_binary(env, argv[1], &path_bin)) Badarg("path");
path = wxString(path_bin.data, wxConvUTF8, path_bin.size);
if(!This) throw wxe_badarg("This");
bool Result = This->ExpandPath(path);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGenericDirCtrl::GetDefaultPath
void wxGenericDirCtrl_GetDefaultPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetDefaultPath();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGenericDirCtrl::GetPath
void wxGenericDirCtrl_GetPath_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetPath();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGenericDirCtrl::GetPath
void wxGenericDirCtrl_GetPath_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
ErlNifUInt64 itemId_tmp;
if(!enif_get_uint64(env, argv[1], &itemId_tmp)) Badarg("itemId");
wxTreeItemId itemId = wxTreeItemId((void *) (wxUint64) itemId_tmp);
if(!This) throw wxe_badarg("This");
wxString Result = This->GetPath(itemId);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGenericDirCtrl::GetFilePath
void wxGenericDirCtrl_GetFilePath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetFilePath();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGenericDirCtrl::GetFilter
void wxGenericDirCtrl_GetFilter(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetFilter();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGenericDirCtrl::GetFilterIndex
void wxGenericDirCtrl_GetFilterIndex(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetFilterIndex();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGenericDirCtrl::GetRootId
void wxGenericDirCtrl_GetRootId(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxTreeItemId Result = This->GetRootId();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make((wxUIntPtr *) Result.m_pItem));
}
// wxGenericDirCtrl::GetTreeCtrl
void wxGenericDirCtrl_GetTreeCtrl(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxTreeCtrl * Result = (wxTreeCtrl*)This->GetTreeCtrl();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxTreeCtrl"));
}
// wxGenericDirCtrl::ReCreateTree
void wxGenericDirCtrl_ReCreateTree(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->ReCreateTree();
}
// wxGenericDirCtrl::SetDefaultPath
void wxGenericDirCtrl_SetDefaultPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary path_bin;
wxString path;
if(!enif_inspect_binary(env, argv[1], &path_bin)) Badarg("path");
path = wxString(path_bin.data, wxConvUTF8, path_bin.size);
if(!This) throw wxe_badarg("This");
This->SetDefaultPath(path);
}
// wxGenericDirCtrl::SetFilter
void wxGenericDirCtrl_SetFilter(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary filter_bin;
wxString filter;
if(!enif_inspect_binary(env, argv[1], &filter_bin)) Badarg("filter");
filter = wxString(filter_bin.data, wxConvUTF8, filter_bin.size);
if(!This) throw wxe_badarg("This");
This->SetFilter(filter);
}
// wxGenericDirCtrl::SetFilterIndex
void wxGenericDirCtrl_SetFilterIndex(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
int n;
if(!enif_get_int(env, argv[1], &n)) Badarg("n"); // int
if(!This) throw wxe_badarg("This");
This->SetFilterIndex(n);
}
// wxGenericDirCtrl::SetPath
void wxGenericDirCtrl_SetPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGenericDirCtrl *This;
This = (wxGenericDirCtrl *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary path_bin;
wxString path;
if(!enif_inspect_binary(env, argv[1], &path_bin)) Badarg("path");
path = wxString(path_bin.data, wxConvUTF8, path_bin.size);
if(!This) throw wxe_badarg("This");
This->SetPath(path);
}
#if wxUSE_GRAPHICS_CONTEXT
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
// wxGraphicsContext::Create
void wxGraphicsContext_Create_STAT_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM windowDC_type;
void * windowDC = memenv->getPtr(env, argv[0], "windowDC", &windowDC_type);
wxGraphicsContext * Result;
if(enif_is_identical(windowDC_type, WXE_ATOM_wxWindowDC))
Result = (wxGraphicsContext*)wxGraphicsContext::Create(* static_cast<wxWindowDC*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxWindow))
Result = (wxGraphicsContext*)wxGraphicsContext::Create(static_cast<wxWindow*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxMemoryDC))
Result = (wxGraphicsContext*)wxGraphicsContext::Create(* static_cast<wxMemoryDC*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxImage))
Result = (wxGraphicsContext*)wxGraphicsContext::Create(* static_cast<wxImage*> (windowDC));
else throw wxe_badarg("windowDC");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv,8), "wxGraphicsContext")
);
}
// wxGraphicsContext::Create
void wxGraphicsContext_Create_STAT_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGraphicsContext * Result = (wxGraphicsContext*)wxGraphicsContext::Create();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv,8), "wxGraphicsContext")
);
}
// wxGraphicsContext::CreatePen
void wxGraphicsContext_CreatePen(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxPen *pen;
pen = (wxPen *) memenv->getPtr(env, argv[1], "pen");
if(!This) throw wxe_badarg("This");
wxGraphicsPen * Result = new wxGraphicsPen(This->CreatePen(*pen)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsPen"));
}
// wxGraphicsContext::CreateBrush
void wxGraphicsContext_CreateBrush(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxBrush *brush;
brush = (wxBrush *) memenv->getPtr(env, argv[1], "brush");
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateBrush(*brush)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsContext::CreateRadialGradientBrush
void wxGraphicsContext_CreateRadialGradientBrush_7(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double startX;
if(!wxe_get_double(env, argv[1], &startX)) Badarg("startX");
double startY;
if(!wxe_get_double(env, argv[2], &startY)) Badarg("startY");
double endX;
if(!wxe_get_double(env, argv[3], &endX)) Badarg("endX");
double endY;
if(!wxe_get_double(env, argv[4], &endY)) Badarg("endY");
double radius;
if(!wxe_get_double(env, argv[5], &radius)) Badarg("radius");
const ERL_NIF_TERM *oColor_t;
int oColor_sz;
if(!enif_get_tuple(env, argv[6], &oColor_sz, &oColor_t)) Badarg("oColor");
int oColorR;
if(!enif_get_int(env, oColor_t[0], &oColorR)) Badarg("oColor");
int oColorG;
if(!enif_get_int(env, oColor_t[1], &oColorG)) Badarg("oColor");
int oColorB;
if(!enif_get_int(env, oColor_t[2], &oColorB)) Badarg("oColor");
int oColorA;
if(!enif_get_int(env, oColor_t[3], &oColorA)) Badarg("oColor");
wxColour oColor = wxColour(oColorR,oColorG,oColorB,oColorA);
const ERL_NIF_TERM *cColor_t;
int cColor_sz;
if(!enif_get_tuple(env, argv[7], &cColor_sz, &cColor_t)) Badarg("cColor");
int cColorR;
if(!enif_get_int(env, cColor_t[0], &cColorR)) Badarg("cColor");
int cColorG;
if(!enif_get_int(env, cColor_t[1], &cColorG)) Badarg("cColor");
int cColorB;
if(!enif_get_int(env, cColor_t[2], &cColorB)) Badarg("cColor");
int cColorA;
if(!enif_get_int(env, cColor_t[3], &cColorA)) Badarg("cColor");
wxColour cColor = wxColour(cColorR,cColorG,cColorB,cColorA);
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateRadialGradientBrush(startX,startY,endX,endY,radius,oColor,cColor)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsContext::CreateRadialGradientBrush
void wxGraphicsContext_CreateRadialGradientBrush_6(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double startX;
if(!wxe_get_double(env, argv[1], &startX)) Badarg("startX");
double startY;
if(!wxe_get_double(env, argv[2], &startY)) Badarg("startY");
double endX;
if(!wxe_get_double(env, argv[3], &endX)) Badarg("endX");
double endY;
if(!wxe_get_double(env, argv[4], &endY)) Badarg("endY");
double radius;
if(!wxe_get_double(env, argv[5], &radius)) Badarg("radius");
wxGraphicsGradientStops *stops;
stops = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[6], "stops");
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateRadialGradientBrush(startX,startY,endX,endY,radius,*stops)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsContext::CreateLinearGradientBrush
void wxGraphicsContext_CreateLinearGradientBrush_6(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x1;
if(!wxe_get_double(env, argv[1], &x1)) Badarg("x1");
double y1;
if(!wxe_get_double(env, argv[2], &y1)) Badarg("y1");
double x2;
if(!wxe_get_double(env, argv[3], &x2)) Badarg("x2");
double y2;
if(!wxe_get_double(env, argv[4], &y2)) Badarg("y2");
const ERL_NIF_TERM *c1_t;
int c1_sz;
if(!enif_get_tuple(env, argv[5], &c1_sz, &c1_t)) Badarg("c1");
int c1R;
if(!enif_get_int(env, c1_t[0], &c1R)) Badarg("c1");
int c1G;
if(!enif_get_int(env, c1_t[1], &c1G)) Badarg("c1");
int c1B;
if(!enif_get_int(env, c1_t[2], &c1B)) Badarg("c1");
int c1A;
if(!enif_get_int(env, c1_t[3], &c1A)) Badarg("c1");
wxColour c1 = wxColour(c1R,c1G,c1B,c1A);
const ERL_NIF_TERM *c2_t;
int c2_sz;
if(!enif_get_tuple(env, argv[6], &c2_sz, &c2_t)) Badarg("c2");
int c2R;
if(!enif_get_int(env, c2_t[0], &c2R)) Badarg("c2");
int c2G;
if(!enif_get_int(env, c2_t[1], &c2G)) Badarg("c2");
int c2B;
if(!enif_get_int(env, c2_t[2], &c2B)) Badarg("c2");
int c2A;
if(!enif_get_int(env, c2_t[3], &c2A)) Badarg("c2");
wxColour c2 = wxColour(c2R,c2G,c2B,c2A);
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateLinearGradientBrush(x1,y1,x2,y2,c1,c2)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsContext::CreateLinearGradientBrush
void wxGraphicsContext_CreateLinearGradientBrush_5(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x1;
if(!wxe_get_double(env, argv[1], &x1)) Badarg("x1");
double y1;
if(!wxe_get_double(env, argv[2], &y1)) Badarg("y1");
double x2;
if(!wxe_get_double(env, argv[3], &x2)) Badarg("x2");
double y2;
if(!wxe_get_double(env, argv[4], &y2)) Badarg("y2");
wxGraphicsGradientStops *stops;
stops = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[5], "stops");
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateLinearGradientBrush(x1,y1,x2,y2,*stops)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsContext::CreateFont
void wxGraphicsContext_CreateFont_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxColour col= *wxBLACK;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "col"))) {
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, tpl[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
col = wxColour(colR,colG,colB,colA);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxGraphicsFont * Result = new wxGraphicsFont(This->CreateFont(*font,col)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsFont"));
}
// wxGraphicsContext::CreateFont
void wxGraphicsContext_CreateFont_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int flags=wxFONTFLAG_DEFAULT;
wxColour col= *wxBLACK;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double sizeInPixels;
if(!wxe_get_double(env, argv[1], &sizeInPixels)) Badarg("sizeInPixels");
ErlNifBinary facename_bin;
wxString facename;
if(!enif_inspect_binary(env, argv[2], &facename_bin)) Badarg("facename");
facename = wxString(facename_bin.data, wxConvUTF8, facename_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "flags"))) {
if(!enif_get_int(env, tpl[1], &flags)) Badarg("flags"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "col"))) {
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, tpl[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
col = wxColour(colR,colG,colB,colA);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxGraphicsFont * Result = new wxGraphicsFont(This->CreateFont(sizeInPixels,facename,flags,col)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsFont"));
}
// wxGraphicsContext::CreateMatrix
void wxGraphicsContext_CreateMatrix(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble a=1.0;
wxDouble b=0.0;
wxDouble c=0.0;
wxDouble d=1.0;
wxDouble tx=0.0;
wxDouble ty=0.0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "a"))) {
if(!wxe_get_double(env, tpl[1], &a)) Badarg("a");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "b"))) {
if(!wxe_get_double(env, tpl[1], &b)) Badarg("b");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "c"))) {
if(!wxe_get_double(env, tpl[1], &c)) Badarg("c");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "d"))) {
if(!wxe_get_double(env, tpl[1], &d)) Badarg("d");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "tx"))) {
if(!wxe_get_double(env, tpl[1], &tx)) Badarg("tx");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "ty"))) {
if(!wxe_get_double(env, tpl[1], &ty)) Badarg("ty");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxGraphicsMatrix * Result = new wxGraphicsMatrix(This->CreateMatrix(a,b,c,d,tx,ty)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsMatrix"));
}
// wxGraphicsContext::CreatePath
void wxGraphicsContext_CreatePath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGraphicsPath * Result = new wxGraphicsPath(This->CreatePath()); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsPath"));
}
// wxGraphicsContext::Clip
void wxGraphicsContext_Clip_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxRegion *region;
region = (wxRegion *) memenv->getPtr(env, argv[1], "region");
if(!This) throw wxe_badarg("This");
This->Clip(*region);
}
// wxGraphicsContext::Clip
void wxGraphicsContext_Clip_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->Clip(x,y,w,h);
}
// wxGraphicsContext::ResetClip
void wxGraphicsContext_ResetClip(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->ResetClip();
}
// wxGraphicsContext::DrawBitmap
void wxGraphicsContext_DrawBitmap(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxBitmap *bmp;
bmp = (wxBitmap *) memenv->getPtr(env, argv[1], "bmp");
double x;
if(!wxe_get_double(env, argv[2], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[3], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[4], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[5], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->DrawBitmap(*bmp,x,y,w,h);
}
// wxGraphicsContext::DrawEllipse
void wxGraphicsContext_DrawEllipse(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->DrawEllipse(x,y,w,h);
}
// wxGraphicsContext::DrawIcon
void wxGraphicsContext_DrawIcon(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxIcon *icon;
icon = (wxIcon *) memenv->getPtr(env, argv[1], "icon");
double x;
if(!wxe_get_double(env, argv[2], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[3], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[4], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[5], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->DrawIcon(*icon,x,y,w,h);
}
// wxGraphicsContext::DrawLines
void wxGraphicsContext_DrawLines(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPolygonFillMode fillStyle=wxODDEVEN_RULE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
unsigned pointsLen;
ERL_NIF_TERM pointsHead, pointsTail;
const ERL_NIF_TERM *points_tpl;
int points_tsz;
if(!enif_get_list_length(env, argv[1], &pointsLen)) Badarg("points");
std::vector <wxPoint2DDouble> points;
double x, y;
pointsTail = argv[1];
while(!enif_is_empty_list(env, pointsTail)) {
if(!enif_get_list_cell(env, pointsTail, &pointsHead, &pointsTail)) Badarg("points");
if(!enif_get_tuple(env, pointsHead, &points_tsz, &points_tpl) || points_tsz != 2) Badarg("points");
if(!wxe_get_double(env, points_tpl[0], &x)) Badarg("points");
if(!wxe_get_double(env, points_tpl[1], &y)) Badarg("points");
points.push_back(wxPoint2DDouble(x,y));
};
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "fillStyle"))) {
if(!enif_get_int(env, tpl[1], (int *) &fillStyle)) Badarg("fillStyle"); // enum
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->DrawLines(pointsLen,points.data(),fillStyle);
}
// wxGraphicsContext::DrawPath
void wxGraphicsContext_DrawPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPolygonFillMode fillStyle=wxODDEVEN_RULE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxGraphicsPath *path;
path = (wxGraphicsPath *) memenv->getPtr(env, argv[1], "path");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "fillStyle"))) {
if(!enif_get_int(env, tpl[1], (int *) &fillStyle)) Badarg("fillStyle"); // enum
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->DrawPath(*path,fillStyle);
}
// wxGraphicsContext::DrawRectangle
void wxGraphicsContext_DrawRectangle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->DrawRectangle(x,y,w,h);
}
// wxGraphicsContext::DrawRoundedRectangle
void wxGraphicsContext_DrawRoundedRectangle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
double radius;
if(!wxe_get_double(env, argv[5], &radius)) Badarg("radius");
if(!This) throw wxe_badarg("This");
This->DrawRoundedRectangle(x,y,w,h,radius);
}
// wxGraphicsContext::DrawText
void wxGraphicsContext_DrawText_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary str_bin;
wxString str;
if(!enif_inspect_binary(env, argv[1], &str_bin)) Badarg("str");
str = wxString(str_bin.data, wxConvUTF8, str_bin.size);
double x;
if(!wxe_get_double(env, argv[2], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[3], &y)) Badarg("y");
if(!This) throw wxe_badarg("This");
This->DrawText(str,x,y);
}
// wxGraphicsContext::DrawText
void wxGraphicsContext_DrawText_4_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary str_bin;
wxString str;
if(!enif_inspect_binary(env, argv[1], &str_bin)) Badarg("str");
str = wxString(str_bin.data, wxConvUTF8, str_bin.size);
double x;
if(!wxe_get_double(env, argv[2], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[3], &y)) Badarg("y");
double angle;
if(!wxe_get_double(env, argv[4], &angle)) Badarg("angle");
if(!This) throw wxe_badarg("This");
This->DrawText(str,x,y,angle);
}
// wxGraphicsContext::DrawText
void wxGraphicsContext_DrawText_4_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary str_bin;
wxString str;
if(!enif_inspect_binary(env, argv[1], &str_bin)) Badarg("str");
str = wxString(str_bin.data, wxConvUTF8, str_bin.size);
double x;
if(!wxe_get_double(env, argv[2], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[3], &y)) Badarg("y");
wxGraphicsBrush *backgroundBrush;
backgroundBrush = (wxGraphicsBrush *) memenv->getPtr(env, argv[4], "backgroundBrush");
if(!This) throw wxe_badarg("This");
This->DrawText(str,x,y,*backgroundBrush);
}
// wxGraphicsContext::DrawText
void wxGraphicsContext_DrawText_5(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary str_bin;
wxString str;
if(!enif_inspect_binary(env, argv[1], &str_bin)) Badarg("str");
str = wxString(str_bin.data, wxConvUTF8, str_bin.size);
double x;
if(!wxe_get_double(env, argv[2], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[3], &y)) Badarg("y");
double angle;
if(!wxe_get_double(env, argv[4], &angle)) Badarg("angle");
wxGraphicsBrush *backgroundBrush;
backgroundBrush = (wxGraphicsBrush *) memenv->getPtr(env, argv[5], "backgroundBrush");
if(!This) throw wxe_badarg("This");
This->DrawText(str,x,y,angle,*backgroundBrush);
}
// wxGraphicsContext::FillPath
void wxGraphicsContext_FillPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPolygonFillMode fillStyle=wxODDEVEN_RULE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxGraphicsPath *path;
path = (wxGraphicsPath *) memenv->getPtr(env, argv[1], "path");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "fillStyle"))) {
if(!enif_get_int(env, tpl[1], (int *) &fillStyle)) Badarg("fillStyle"); // enum
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->FillPath(*path,fillStyle);
}
// wxGraphicsContext::StrokePath
void wxGraphicsContext_StrokePath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxGraphicsPath *path;
path = (wxGraphicsPath *) memenv->getPtr(env, argv[1], "path");
if(!This) throw wxe_badarg("This");
This->StrokePath(*path);
}
// wxGraphicsContext::GetPartialTextExtents
void wxGraphicsContext_GetPartialTextExtents(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxArrayDouble widths;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary text_bin;
wxString text;
if(!enif_inspect_binary(env, argv[1], &text_bin)) Badarg("text");
text = wxString(text_bin.data, wxConvUTF8, text_bin.size);
if(!This) throw wxe_badarg("This");
This->GetPartialTextExtents(text,widths);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(widths));
}
// wxGraphicsContext::GetTextExtent
void wxGraphicsContext_GetTextExtent(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble width;
wxDouble height;
wxDouble descent;
wxDouble externalLeading;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary text_bin;
wxString text;
if(!enif_inspect_binary(env, argv[1], &text_bin)) Badarg("text");
text = wxString(text_bin.data, wxConvUTF8, text_bin.size);
if(!This) throw wxe_badarg("This");
This->GetTextExtent(text,&width,&height,&descent,&externalLeading);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple4(rt.env,
rt.make_double(width),
rt.make_double(height),
rt.make_double(descent),
rt.make_double(externalLeading));
rt.send(msg);
}
// wxGraphicsContext::Rotate
void wxGraphicsContext_Rotate(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double angle;
if(!wxe_get_double(env, argv[1], &angle)) Badarg("angle");
if(!This) throw wxe_badarg("This");
This->Rotate(angle);
}
// wxGraphicsContext::Scale
void wxGraphicsContext_Scale(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double xScale;
if(!wxe_get_double(env, argv[1], &xScale)) Badarg("xScale");
double yScale;
if(!wxe_get_double(env, argv[2], &yScale)) Badarg("yScale");
if(!This) throw wxe_badarg("This");
This->Scale(xScale,yScale);
}
// wxGraphicsContext::Translate
void wxGraphicsContext_Translate(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double dx;
if(!wxe_get_double(env, argv[1], &dx)) Badarg("dx");
double dy;
if(!wxe_get_double(env, argv[2], &dy)) Badarg("dy");
if(!This) throw wxe_badarg("This");
This->Translate(dx,dy);
}
// wxGraphicsContext::GetTransform
void wxGraphicsContext_GetTransform(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGraphicsMatrix * Result = new wxGraphicsMatrix(This->GetTransform()); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsMatrix"));
}
// wxGraphicsContext::SetTransform
void wxGraphicsContext_SetTransform(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxGraphicsMatrix *matrix;
matrix = (wxGraphicsMatrix *) memenv->getPtr(env, argv[1], "matrix");
if(!This) throw wxe_badarg("This");
This->SetTransform(*matrix);
}
// wxGraphicsContext::ConcatTransform
void wxGraphicsContext_ConcatTransform(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxGraphicsMatrix *matrix;
matrix = (wxGraphicsMatrix *) memenv->getPtr(env, argv[1], "matrix");
if(!This) throw wxe_badarg("This");
This->ConcatTransform(*matrix);
}
// wxGraphicsContext::SetBrush
void wxGraphicsContext_SetBrush(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM brush_type;
void * brush = memenv->getPtr(env, argv[1], "brush", &brush_type);
if(!This) throw wxe_badarg("This");
if(enif_is_identical(brush_type, WXE_ATOM_wxGraphicsBrush))
This->SetBrush(* static_cast<wxGraphicsBrush*> (brush));
else if(enif_is_identical(brush_type, WXE_ATOM_wxBrush))
This->SetBrush(* static_cast<wxBrush*> (brush));
else throw wxe_badarg("brush");
}
// wxGraphicsContext::SetFont
void wxGraphicsContext_SetFont_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[2], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetFont(*font,colour);
}
// wxGraphicsContext::SetFont
void wxGraphicsContext_SetFont_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
wxGraphicsFont *font;
font = (wxGraphicsFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetFont(*font);
}
// wxGraphicsContext::SetPen
void wxGraphicsContext_SetPen(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM pen_type;
void * pen = memenv->getPtr(env, argv[1], "pen", &pen_type);
if(!This) throw wxe_badarg("This");
if(enif_is_identical(pen_type, WXE_ATOM_wxPen))
This->SetPen(* static_cast<wxPen*> (pen));
else if(enif_is_identical(pen_type, WXE_ATOM_wxGraphicsPen))
This->SetPen(* static_cast<wxGraphicsPen*> (pen));
else throw wxe_badarg("pen");
}
// wxGraphicsContext::StrokeLine
void wxGraphicsContext_StrokeLine(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
double x1;
if(!wxe_get_double(env, argv[1], &x1)) Badarg("x1");
double y1;
if(!wxe_get_double(env, argv[2], &y1)) Badarg("y1");
double x2;
if(!wxe_get_double(env, argv[3], &x2)) Badarg("x2");
double y2;
if(!wxe_get_double(env, argv[4], &y2)) Badarg("y2");
if(!This) throw wxe_badarg("This");
This->StrokeLine(x1,y1,x2,y2);
}
// wxGraphicsContext::StrokeLines
void wxGraphicsContext_StrokeLines(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsContext *This;
This = (wxGraphicsContext *) memenv->getPtr(env, argv[0], "This");
unsigned pointsLen;
ERL_NIF_TERM pointsHead, pointsTail;
const ERL_NIF_TERM *points_tpl;
int points_tsz;
if(!enif_get_list_length(env, argv[1], &pointsLen)) Badarg("points");
std::vector <wxPoint2DDouble> points;
double x, y;
pointsTail = argv[1];
while(!enif_is_empty_list(env, pointsTail)) {
if(!enif_get_list_cell(env, pointsTail, &pointsHead, &pointsTail)) Badarg("points");
if(!enif_get_tuple(env, pointsHead, &points_tsz, &points_tpl) || points_tsz != 2) Badarg("points");
if(!wxe_get_double(env, points_tpl[0], &x)) Badarg("points");
if(!wxe_get_double(env, points_tpl[1], &y)) Badarg("points");
points.push_back(wxPoint2DDouble(x,y));
};
if(!This) throw wxe_badarg("This");
This->StrokeLines(pointsLen,points.data());
}
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
// wxGraphicsGradientStops::wxGraphicsGradientStops
void wxGraphicsGradientStops_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxColour startCol = wxTransparentColour;
wxColour endCol = wxTransparentColour;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "startCol"))) {
const ERL_NIF_TERM *startCol_t;
int startCol_sz;
if(!enif_get_tuple(env, tpl[1], &startCol_sz, &startCol_t)) Badarg("startCol");
int startColR;
if(!enif_get_int(env, startCol_t[0], &startColR)) Badarg("startCol");
int startColG;
if(!enif_get_int(env, startCol_t[1], &startColG)) Badarg("startCol");
int startColB;
if(!enif_get_int(env, startCol_t[2], &startColB)) Badarg("startCol");
int startColA;
if(!enif_get_int(env, startCol_t[3], &startColA)) Badarg("startCol");
startCol = wxColour(startColR,startColG,startColB,startColA);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "endCol"))) {
const ERL_NIF_TERM *endCol_t;
int endCol_sz;
if(!enif_get_tuple(env, tpl[1], &endCol_sz, &endCol_t)) Badarg("endCol");
int endColR;
if(!enif_get_int(env, endCol_t[0], &endColR)) Badarg("endCol");
int endColG;
if(!enif_get_int(env, endCol_t[1], &endColG)) Badarg("endCol");
int endColB;
if(!enif_get_int(env, endCol_t[2], &endColB)) Badarg("endCol");
int endColA;
if(!enif_get_int(env, endCol_t[3], &endColA)) Badarg("endCol");
endCol = wxColour(endColR,endColG,endColB,endColA);
} else Badarg("Options");
};
wxGraphicsGradientStops * Result = new EwxGraphicsGradientStops(startCol,endCol);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsGradientStops"));
}
// wxGraphicsGradientStops::Item
void wxGraphicsGradientStops_Item(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
unsigned int n;
if(!enif_get_uint(env, argv[1], &n)) Badarg("n");
if(!This) throw wxe_badarg("This");
wxGraphicsGradientStop Result = This->Item(n);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGraphicsGradientStops::GetCount
void wxGraphicsGradientStops_GetCount(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
size_t Result = This->GetCount();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGraphicsGradientStops::SetStartColour
void wxGraphicsGradientStops_SetStartColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, argv[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
wxColour col = wxColour(colR,colG,colB,colA);
if(!This) throw wxe_badarg("This");
This->SetStartColour(col);
}
// wxGraphicsGradientStops::GetStartColour
void wxGraphicsGradientStops_GetStartColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetStartColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGraphicsGradientStops::SetEndColour
void wxGraphicsGradientStops_SetEndColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, argv[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
wxColour col = wxColour(colR,colG,colB,colA);
if(!This) throw wxe_badarg("This");
This->SetEndColour(col);
}
// wxGraphicsGradientStops::GetEndColour
void wxGraphicsGradientStops_GetEndColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetEndColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGraphicsGradientStops::Add
void wxGraphicsGradientStops_Add(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsGradientStops *This;
This = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, argv[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
wxColour col = wxColour(colR,colG,colB,colA);
float pos;
if(!wxe_get_float(env, argv[2], &pos)) Badarg("pos");
if(!This) throw wxe_badarg("This");
This->Add(col,pos);
}
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
// wxGraphicsMatrix::Concat
void wxGraphicsMatrix_Concat(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
wxGraphicsMatrix *t;
t = (wxGraphicsMatrix *) memenv->getPtr(env, argv[1], "t");
if(!This) throw wxe_badarg("This");
This->Concat(t);
}
// wxGraphicsMatrix::Get
void wxGraphicsMatrix_Get(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble a;
wxDouble b;
wxDouble c;
wxDouble d;
wxDouble tx;
wxDouble ty;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->Get(&a,&b,&c,&d,&tx,&ty);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple6(rt.env,
rt.make_double(a),
rt.make_double(b),
rt.make_double(c),
rt.make_double(d),
rt.make_double(tx),
rt.make_double(ty));
rt.send(msg);
}
// wxGraphicsMatrix::Invert
void wxGraphicsMatrix_Invert(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->Invert();
}
// wxGraphicsMatrix::IsEqual
void wxGraphicsMatrix_IsEqual(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
wxGraphicsMatrix *t;
t = (wxGraphicsMatrix *) memenv->getPtr(env, argv[1], "t");
if(!This) throw wxe_badarg("This");
bool Result = This->IsEqual(t);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGraphicsMatrix::IsIdentity
void wxGraphicsMatrix_IsIdentity(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsIdentity();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGraphicsMatrix::Rotate
void wxGraphicsMatrix_Rotate(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
double angle;
if(!wxe_get_double(env, argv[1], &angle)) Badarg("angle");
if(!This) throw wxe_badarg("This");
This->Rotate(angle);
}
// wxGraphicsMatrix::Scale
void wxGraphicsMatrix_Scale(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
double xScale;
if(!wxe_get_double(env, argv[1], &xScale)) Badarg("xScale");
double yScale;
if(!wxe_get_double(env, argv[2], &yScale)) Badarg("yScale");
if(!This) throw wxe_badarg("This");
This->Scale(xScale,yScale);
}
// wxGraphicsMatrix::Translate
void wxGraphicsMatrix_Translate(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
double dx;
if(!wxe_get_double(env, argv[1], &dx)) Badarg("dx");
double dy;
if(!wxe_get_double(env, argv[2], &dy)) Badarg("dy");
if(!This) throw wxe_badarg("This");
This->Translate(dx,dy);
}
// wxGraphicsMatrix::Set
void wxGraphicsMatrix_Set(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble a=1.0;
wxDouble b=0.0;
wxDouble c=0.0;
wxDouble d=1.0;
wxDouble tx=0.0;
wxDouble ty=0.0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "a"))) {
if(!wxe_get_double(env, tpl[1], &a)) Badarg("a");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "b"))) {
if(!wxe_get_double(env, tpl[1], &b)) Badarg("b");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "c"))) {
if(!wxe_get_double(env, tpl[1], &c)) Badarg("c");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "d"))) {
if(!wxe_get_double(env, tpl[1], &d)) Badarg("d");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "tx"))) {
if(!wxe_get_double(env, tpl[1], &tx)) Badarg("tx");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "ty"))) {
if(!wxe_get_double(env, tpl[1], &ty)) Badarg("ty");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->Set(a,b,c,d,tx,ty);
}
// wxGraphicsMatrix::TransformPoint
void wxGraphicsMatrix_TransformPoint(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble x;
wxDouble y;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->TransformPoint(&x,&y);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_double(x),
rt.make_double(y));
rt.send(msg);
}
// wxGraphicsMatrix::TransformDistance
void wxGraphicsMatrix_TransformDistance(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble dx;
wxDouble dy;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsMatrix *This;
This = (wxGraphicsMatrix *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->TransformDistance(&dx,&dy);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_double(dx),
rt.make_double(dy));
rt.send(msg);
}
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
// wxGraphicsObject::GetRenderer
void wxGraphicsObject_GetRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsObject *This;
This = (wxGraphicsObject *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGraphicsRenderer * Result = (wxGraphicsRenderer*)This->GetRenderer();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsRenderer"));
}
// wxGraphicsObject::IsNull
void wxGraphicsObject_IsNull(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsObject *This;
This = (wxGraphicsObject *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsNull();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
// wxGraphicsPath::MoveToPoint
void wxGraphicsPath_MoveToPoint_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
if(!This) throw wxe_badarg("This");
This->MoveToPoint(x,y);
}
// wxGraphicsPath::MoveToPoint
void wxGraphicsPath_MoveToPoint_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *p_t;
int p_sz;
if(!enif_get_tuple(env, argv[1], &p_sz, &p_t)) Badarg("p");
double pX;
if(!wxe_get_double(env, p_t[0], &pX)) Badarg("p");
double pY;
if(!wxe_get_double(env, p_t[1], &pY)) Badarg("p");
wxPoint2DDouble p = wxPoint2DDouble(pX,pY);
if(!This) throw wxe_badarg("This");
This->MoveToPoint(p);
}
// wxGraphicsPath::AddArc
void wxGraphicsPath_AddArc_6(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double r;
if(!wxe_get_double(env, argv[3], &r)) Badarg("r");
double startAngle;
if(!wxe_get_double(env, argv[4], &startAngle)) Badarg("startAngle");
double endAngle;
if(!wxe_get_double(env, argv[5], &endAngle)) Badarg("endAngle");
bool clockwise;
clockwise = enif_is_identical(argv[6], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->AddArc(x,y,r,startAngle,endAngle,clockwise);
}
// wxGraphicsPath::AddArc
void wxGraphicsPath_AddArc_5(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *c_t;
int c_sz;
if(!enif_get_tuple(env, argv[1], &c_sz, &c_t)) Badarg("c");
double cX;
if(!wxe_get_double(env, c_t[0], &cX)) Badarg("c");
double cY;
if(!wxe_get_double(env, c_t[1], &cY)) Badarg("c");
wxPoint2DDouble c = wxPoint2DDouble(cX,cY);
double r;
if(!wxe_get_double(env, argv[2], &r)) Badarg("r");
double startAngle;
if(!wxe_get_double(env, argv[3], &startAngle)) Badarg("startAngle");
double endAngle;
if(!wxe_get_double(env, argv[4], &endAngle)) Badarg("endAngle");
bool clockwise;
clockwise = enif_is_identical(argv[5], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->AddArc(c,r,startAngle,endAngle,clockwise);
}
// wxGraphicsPath::AddArcToPoint
void wxGraphicsPath_AddArcToPoint(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x1;
if(!wxe_get_double(env, argv[1], &x1)) Badarg("x1");
double y1;
if(!wxe_get_double(env, argv[2], &y1)) Badarg("y1");
double x2;
if(!wxe_get_double(env, argv[3], &x2)) Badarg("x2");
double y2;
if(!wxe_get_double(env, argv[4], &y2)) Badarg("y2");
double r;
if(!wxe_get_double(env, argv[5], &r)) Badarg("r");
if(!This) throw wxe_badarg("This");
This->AddArcToPoint(x1,y1,x2,y2,r);
}
// wxGraphicsPath::AddCircle
void wxGraphicsPath_AddCircle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double r;
if(!wxe_get_double(env, argv[3], &r)) Badarg("r");
if(!This) throw wxe_badarg("This");
This->AddCircle(x,y,r);
}
// wxGraphicsPath::AddCurveToPoint
void wxGraphicsPath_AddCurveToPoint_6(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double cx1;
if(!wxe_get_double(env, argv[1], &cx1)) Badarg("cx1");
double cy1;
if(!wxe_get_double(env, argv[2], &cy1)) Badarg("cy1");
double cx2;
if(!wxe_get_double(env, argv[3], &cx2)) Badarg("cx2");
double cy2;
if(!wxe_get_double(env, argv[4], &cy2)) Badarg("cy2");
double x;
if(!wxe_get_double(env, argv[5], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[6], &y)) Badarg("y");
if(!This) throw wxe_badarg("This");
This->AddCurveToPoint(cx1,cy1,cx2,cy2,x,y);
}
// wxGraphicsPath::AddCurveToPoint
void wxGraphicsPath_AddCurveToPoint_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *c1_t;
int c1_sz;
if(!enif_get_tuple(env, argv[1], &c1_sz, &c1_t)) Badarg("c1");
double c1X;
if(!wxe_get_double(env, c1_t[0], &c1X)) Badarg("c1");
double c1Y;
if(!wxe_get_double(env, c1_t[1], &c1Y)) Badarg("c1");
wxPoint2DDouble c1 = wxPoint2DDouble(c1X,c1Y);
const ERL_NIF_TERM *c2_t;
int c2_sz;
if(!enif_get_tuple(env, argv[2], &c2_sz, &c2_t)) Badarg("c2");
double c2X;
if(!wxe_get_double(env, c2_t[0], &c2X)) Badarg("c2");
double c2Y;
if(!wxe_get_double(env, c2_t[1], &c2Y)) Badarg("c2");
wxPoint2DDouble c2 = wxPoint2DDouble(c2X,c2Y);
const ERL_NIF_TERM *e_t;
int e_sz;
if(!enif_get_tuple(env, argv[3], &e_sz, &e_t)) Badarg("e");
double eX;
if(!wxe_get_double(env, e_t[0], &eX)) Badarg("e");
double eY;
if(!wxe_get_double(env, e_t[1], &eY)) Badarg("e");
wxPoint2DDouble e = wxPoint2DDouble(eX,eY);
if(!This) throw wxe_badarg("This");
This->AddCurveToPoint(c1,c2,e);
}
// wxGraphicsPath::AddEllipse
void wxGraphicsPath_AddEllipse(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->AddEllipse(x,y,w,h);
}
// wxGraphicsPath::AddLineToPoint
void wxGraphicsPath_AddLineToPoint_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
if(!This) throw wxe_badarg("This");
This->AddLineToPoint(x,y);
}
// wxGraphicsPath::AddLineToPoint
void wxGraphicsPath_AddLineToPoint_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *p_t;
int p_sz;
if(!enif_get_tuple(env, argv[1], &p_sz, &p_t)) Badarg("p");
double pX;
if(!wxe_get_double(env, p_t[0], &pX)) Badarg("p");
double pY;
if(!wxe_get_double(env, p_t[1], &pY)) Badarg("p");
wxPoint2DDouble p = wxPoint2DDouble(pX,pY);
if(!This) throw wxe_badarg("This");
This->AddLineToPoint(p);
}
// wxGraphicsPath::AddPath
void wxGraphicsPath_AddPath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
wxGraphicsPath *path;
path = (wxGraphicsPath *) memenv->getPtr(env, argv[1], "path");
if(!This) throw wxe_badarg("This");
This->AddPath(*path);
}
// wxGraphicsPath::AddQuadCurveToPoint
void wxGraphicsPath_AddQuadCurveToPoint(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double cx;
if(!wxe_get_double(env, argv[1], &cx)) Badarg("cx");
double cy;
if(!wxe_get_double(env, argv[2], &cy)) Badarg("cy");
double x;
if(!wxe_get_double(env, argv[3], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[4], &y)) Badarg("y");
if(!This) throw wxe_badarg("This");
This->AddQuadCurveToPoint(cx,cy,x,y);
}
// wxGraphicsPath::AddRectangle
void wxGraphicsPath_AddRectangle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
if(!This) throw wxe_badarg("This");
This->AddRectangle(x,y,w,h);
}
// wxGraphicsPath::AddRoundedRectangle
void wxGraphicsPath_AddRoundedRectangle(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
double w;
if(!wxe_get_double(env, argv[3], &w)) Badarg("w");
double h;
if(!wxe_get_double(env, argv[4], &h)) Badarg("h");
double radius;
if(!wxe_get_double(env, argv[5], &radius)) Badarg("radius");
if(!This) throw wxe_badarg("This");
This->AddRoundedRectangle(x,y,w,h,radius);
}
// wxGraphicsPath::CloseSubpath
void wxGraphicsPath_CloseSubpath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->CloseSubpath();
}
// wxGraphicsPath::Contains
void wxGraphicsPath_Contains_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPolygonFillMode fillStyle=wxODDEVEN_RULE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *c_t;
int c_sz;
if(!enif_get_tuple(env, argv[1], &c_sz, &c_t)) Badarg("c");
double cX;
if(!wxe_get_double(env, c_t[0], &cX)) Badarg("c");
double cY;
if(!wxe_get_double(env, c_t[1], &cY)) Badarg("c");
wxPoint2DDouble c = wxPoint2DDouble(cX,cY);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "fillStyle"))) {
if(!enif_get_int(env, tpl[1], (int *) &fillStyle)) Badarg("fillStyle"); // enum
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Contains(c,fillStyle);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGraphicsPath::Contains
void wxGraphicsPath_Contains_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPolygonFillMode fillStyle=wxODDEVEN_RULE;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
double x;
if(!wxe_get_double(env, argv[1], &x)) Badarg("x");
double y;
if(!wxe_get_double(env, argv[2], &y)) Badarg("y");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "fillStyle"))) {
if(!enif_get_int(env, tpl[1], (int *) &fillStyle)) Badarg("fillStyle"); // enum
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->Contains(x,y,fillStyle);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGraphicsPath::GetBox
void wxGraphicsPath_GetBox(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxRect2DDouble Result = This->GetBox();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGraphicsPath::GetCurrentPoint
void wxGraphicsPath_GetCurrentPoint(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxPoint2DDouble Result = This->GetCurrentPoint();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGraphicsPath::Transform
void wxGraphicsPath_Transform(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsPath *This;
This = (wxGraphicsPath *) memenv->getPtr(env, argv[0], "This");
wxGraphicsMatrix *matrix;
matrix = (wxGraphicsMatrix *) memenv->getPtr(env, argv[1], "matrix");
if(!This) throw wxe_badarg("This");
This->Transform(*matrix);
}
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
#endif // wxUSE_GRAPHICS_CONTEXT
#if wxUSE_GRAPHICS_CONTEXT
// wxGraphicsRenderer::GetDefaultRenderer
void wxGraphicsRenderer_GetDefaultRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGraphicsRenderer * Result = (wxGraphicsRenderer*)wxGraphicsRenderer::GetDefaultRenderer();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsRenderer"));
}
// wxGraphicsRenderer::CreateContext
void wxGraphicsRenderer_CreateContext(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM windowDC_type;
void * windowDC = memenv->getPtr(env, argv[1], "windowDC", &windowDC_type);
if(!This) throw wxe_badarg("This");
wxGraphicsContext * Result;
if(enif_is_identical(windowDC_type, WXE_ATOM_wxWindowDC))
Result = (wxGraphicsContext*)This->CreateContext(* static_cast<wxWindowDC*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxWindow))
Result = (wxGraphicsContext*)This->CreateContext(static_cast<wxWindow*> (windowDC));
else if(enif_is_identical(windowDC_type, WXE_ATOM_wxMemoryDC))
Result = (wxGraphicsContext*)This->CreateContext(* static_cast<wxMemoryDC*> (windowDC));
else throw wxe_badarg("windowDC");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv,8), "wxGraphicsContext")
);
}
// wxGraphicsRenderer::CreateBrush
void wxGraphicsRenderer_CreateBrush(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
wxBrush *brush;
brush = (wxBrush *) memenv->getPtr(env, argv[1], "brush");
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateBrush(*brush)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsRenderer::CreateLinearGradientBrush
void wxGraphicsRenderer_CreateLinearGradientBrush(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
double x1;
if(!wxe_get_double(env, argv[1], &x1)) Badarg("x1");
double y1;
if(!wxe_get_double(env, argv[2], &y1)) Badarg("y1");
double x2;
if(!wxe_get_double(env, argv[3], &x2)) Badarg("x2");
double y2;
if(!wxe_get_double(env, argv[4], &y2)) Badarg("y2");
wxGraphicsGradientStops *stops;
stops = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[5], "stops");
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateLinearGradientBrush(x1,y1,x2,y2,*stops)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsRenderer::CreateRadialGradientBrush
void wxGraphicsRenderer_CreateRadialGradientBrush(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
double startX;
if(!wxe_get_double(env, argv[1], &startX)) Badarg("startX");
double startY;
if(!wxe_get_double(env, argv[2], &startY)) Badarg("startY");
double endX;
if(!wxe_get_double(env, argv[3], &endX)) Badarg("endX");
double endY;
if(!wxe_get_double(env, argv[4], &endY)) Badarg("endY");
double radius;
if(!wxe_get_double(env, argv[5], &radius)) Badarg("radius");
wxGraphicsGradientStops *stops;
stops = (wxGraphicsGradientStops *) memenv->getPtr(env, argv[6], "stops");
if(!This) throw wxe_badarg("This");
wxGraphicsBrush * Result = new wxGraphicsBrush(This->CreateRadialGradientBrush(startX,startY,endX,endY,radius,*stops)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsBrush"));
}
// wxGraphicsRenderer::CreateFont
void wxGraphicsRenderer_CreateFont_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxColour col= *wxBLACK;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "col"))) {
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, tpl[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
col = wxColour(colR,colG,colB,colA);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxGraphicsFont * Result = new wxGraphicsFont(This->CreateFont(*font,col)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsFont"));
}
// wxGraphicsRenderer::CreateFont
void wxGraphicsRenderer_CreateFont_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int flags=wxFONTFLAG_DEFAULT;
wxColour col= *wxBLACK;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
double sizeInPixels;
if(!wxe_get_double(env, argv[1], &sizeInPixels)) Badarg("sizeInPixels");
ErlNifBinary facename_bin;
wxString facename;
if(!enif_inspect_binary(env, argv[2], &facename_bin)) Badarg("facename");
facename = wxString(facename_bin.data, wxConvUTF8, facename_bin.size);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "flags"))) {
if(!enif_get_int(env, tpl[1], &flags)) Badarg("flags"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "col"))) {
const ERL_NIF_TERM *col_t;
int col_sz;
if(!enif_get_tuple(env, tpl[1], &col_sz, &col_t)) Badarg("col");
int colR;
if(!enif_get_int(env, col_t[0], &colR)) Badarg("col");
int colG;
if(!enif_get_int(env, col_t[1], &colG)) Badarg("col");
int colB;
if(!enif_get_int(env, col_t[2], &colB)) Badarg("col");
int colA;
if(!enif_get_int(env, col_t[3], &colA)) Badarg("col");
col = wxColour(colR,colG,colB,colA);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxGraphicsFont * Result = new wxGraphicsFont(This->CreateFont(sizeInPixels,facename,flags,col)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsFont"));
}
// wxGraphicsRenderer::CreateMatrix
void wxGraphicsRenderer_CreateMatrix(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxDouble a=1.0;
wxDouble b=0.0;
wxDouble c=0.0;
wxDouble d=1.0;
wxDouble tx=0.0;
wxDouble ty=0.0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "a"))) {
if(!wxe_get_double(env, tpl[1], &a)) Badarg("a");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "b"))) {
if(!wxe_get_double(env, tpl[1], &b)) Badarg("b");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "c"))) {
if(!wxe_get_double(env, tpl[1], &c)) Badarg("c");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "d"))) {
if(!wxe_get_double(env, tpl[1], &d)) Badarg("d");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "tx"))) {
if(!wxe_get_double(env, tpl[1], &tx)) Badarg("tx");
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "ty"))) {
if(!wxe_get_double(env, tpl[1], &ty)) Badarg("ty");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxGraphicsMatrix * Result = new wxGraphicsMatrix(This->CreateMatrix(a,b,c,d,tx,ty)); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsMatrix"));
}
// wxGraphicsRenderer::CreatePath
void wxGraphicsRenderer_CreatePath(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGraphicsRenderer *This;
This = (wxGraphicsRenderer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGraphicsPath * Result = new wxGraphicsPath(This->CreatePath()); app->newPtr((void *) Result,4, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGraphicsPath"));
}
#endif // wxUSE_GRAPHICS_CONTEXT
// wxGrid::wxGrid
void wxGrid_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGrid * Result = new EwxGrid();
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGrid"));
}
// wxGrid::wxGrid
void wxGrid_new_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxPoint pos= wxDefaultPosition;
wxSize size= wxDefaultSize;
long style=wxWANTS_CHARS;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[0], "parent");
int id;
if(!enif_get_int(env, argv[1], &id)) Badarg("id"); // wxWindowID
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, tpl[1], &pos_sz, &pos_t)) Badarg("pos");
int posX;
if(!enif_get_int(env, pos_t[0], &posX)) Badarg("pos");
int posY;
if(!enif_get_int(env, pos_t[1], &posY)) Badarg("pos");
pos = wxPoint(posX,posY);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "size"))) {
const ERL_NIF_TERM *size_t;
int size_sz;
if(!enif_get_tuple(env, tpl[1], &size_sz, &size_t)) Badarg("size");
int sizeW;
if(!enif_get_int(env, size_t[0], &sizeW)) Badarg("size");
int sizeH;
if(!enif_get_int(env, size_t[1], &sizeH)) Badarg("size");
size = wxSize(sizeW,sizeH);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "style"))) {
if(!enif_get_long(env, tpl[1], &style)) Badarg("style");
} else Badarg("Options");
};
wxGrid * Result = new EwxGrid(parent,id,pos,size,style);
app->newPtr((void *) Result, 0, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGrid"));
}
// wxGrid::AppendCols
void wxGrid_AppendCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int numCols=1;
bool updateLabels=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "numCols"))) {
if(!enif_get_int(env, tpl[1], &numCols)) Badarg("numCols"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "updateLabels"))) {
updateLabels = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->AppendCols(numCols,updateLabels);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::AppendRows
void wxGrid_AppendRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int numRows=1;
bool updateLabels=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "numRows"))) {
if(!enif_get_int(env, tpl[1], &numRows)) Badarg("numRows"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "updateLabels"))) {
updateLabels = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->AppendRows(numRows,updateLabels);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::AutoSize
void wxGrid_AutoSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->AutoSize();
}
// wxGrid::AutoSizeColumn
void wxGrid_AutoSizeColumn(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool setAsMin=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "setAsMin"))) {
setAsMin = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->AutoSizeColumn(col,setAsMin);
}
// wxGrid::AutoSizeColumns
void wxGrid_AutoSizeColumns(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool setAsMin=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "setAsMin"))) {
setAsMin = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->AutoSizeColumns(setAsMin);
}
// wxGrid::AutoSizeRow
void wxGrid_AutoSizeRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool setAsMin=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "setAsMin"))) {
setAsMin = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->AutoSizeRow(row,setAsMin);
}
// wxGrid::AutoSizeRows
void wxGrid_AutoSizeRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool setAsMin=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "setAsMin"))) {
setAsMin = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->AutoSizeRows(setAsMin);
}
// wxGrid::BeginBatch
void wxGrid_BeginBatch(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->BeginBatch();
}
// wxGrid::BlockToDeviceRect
void wxGrid_BlockToDeviceRect(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *topLeft_t;
int topLeft_sz;
if(!enif_get_tuple(env, argv[1], &topLeft_sz, &topLeft_t)) Badarg("topLeft");
int topLeftR;
if(!enif_get_int(env, topLeft_t[0], &topLeftR)) Badarg("topLeft");
int topLeftC;
if(!enif_get_int(env, topLeft_t[1], &topLeftC)) Badarg("topLeft");
wxGridCellCoords topLeft = wxGridCellCoords(topLeftR,topLeftC);
const ERL_NIF_TERM *bottomRight_t;
int bottomRight_sz;
if(!enif_get_tuple(env, argv[2], &bottomRight_sz, &bottomRight_t)) Badarg("bottomRight");
int bottomRightR;
if(!enif_get_int(env, bottomRight_t[0], &bottomRightR)) Badarg("bottomRight");
int bottomRightC;
if(!enif_get_int(env, bottomRight_t[1], &bottomRightC)) Badarg("bottomRight");
wxGridCellCoords bottomRight = wxGridCellCoords(bottomRightR,bottomRightC);
if(!This) throw wxe_badarg("This");
wxRect Result = This->BlockToDeviceRect(topLeft,bottomRight);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::CanDragCell
void wxGrid_CanDragCell(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->CanDragCell();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::CanDragColMove
void wxGrid_CanDragColMove(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->CanDragColMove();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
#if wxCHECK_VERSION(3,1,4)
// wxGrid::CanDragGridRowEdges
void wxGrid_CanDragGridRowEdges(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->CanDragGridRowEdges();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
#endif
// wxGrid::CanDragColSize
void wxGrid_CanDragColSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
bool Result = This->CanDragColSize(col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::CanDragRowSize
void wxGrid_CanDragRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
if(!This) throw wxe_badarg("This");
bool Result = This->CanDragRowSize(row);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::CanDragGridSize
void wxGrid_CanDragGridSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->CanDragGridSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::CanEnableCellControl
void wxGrid_CanEnableCellControl(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->CanEnableCellControl();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::CellToRect
void wxGrid_CellToRect_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxRect Result = This->CellToRect(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::CellToRect
void wxGrid_CellToRect_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
if(!This) throw wxe_badarg("This");
wxRect Result = This->CellToRect(coords);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::ClearGrid
void wxGrid_ClearGrid(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->ClearGrid();
}
// wxGrid::ClearSelection
void wxGrid_ClearSelection(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->ClearSelection();
}
// wxGrid::CreateGrid
void wxGrid_CreateGrid(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGrid::wxGridSelectionModes selmode=wxGrid::wxGridSelectCells;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int numRows;
if(!enif_get_int(env, argv[1], &numRows)) Badarg("numRows"); // int
int numCols;
if(!enif_get_int(env, argv[2], &numCols)) Badarg("numCols"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "selmode"))) {
if(!enif_get_int(env, tpl[1], (int *) &selmode)) Badarg("selmode"); // enum
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->CreateGrid(numRows,numCols,selmode);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::DeleteCols
void wxGrid_DeleteCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int pos=0;
int numCols=1;
bool updateLabels=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
if(!enif_get_int(env, tpl[1], &pos)) Badarg("pos"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "numCols"))) {
if(!enif_get_int(env, tpl[1], &numCols)) Badarg("numCols"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "updateLabels"))) {
updateLabels = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->DeleteCols(pos,numCols,updateLabels);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::DeleteRows
void wxGrid_DeleteRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int pos=0;
int numRows=1;
bool updateLabels=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
if(!enif_get_int(env, tpl[1], &pos)) Badarg("pos"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "numRows"))) {
if(!enif_get_int(env, tpl[1], &numRows)) Badarg("numRows"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "updateLabels"))) {
updateLabels = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->DeleteRows(pos,numRows,updateLabels);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::DisableCellEditControl
void wxGrid_DisableCellEditControl(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->DisableCellEditControl();
}
// wxGrid::DisableDragColSize
void wxGrid_DisableDragColSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->DisableDragColSize();
}
// wxGrid::DisableDragGridSize
void wxGrid_DisableDragGridSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->DisableDragGridSize();
}
// wxGrid::DisableDragRowSize
void wxGrid_DisableDragRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->DisableDragRowSize();
}
// wxGrid::EnableCellEditControl
void wxGrid_EnableCellEditControl(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool enable=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "enable"))) {
enable = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->EnableCellEditControl(enable);
}
// wxGrid::EnableDragColSize
void wxGrid_EnableDragColSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool enable=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "enable"))) {
enable = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->EnableDragColSize(enable);
}
// wxGrid::EnableDragGridSize
void wxGrid_EnableDragGridSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool enable=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "enable"))) {
enable = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->EnableDragGridSize(enable);
}
// wxGrid::EnableDragRowSize
void wxGrid_EnableDragRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool enable=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "enable"))) {
enable = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->EnableDragRowSize(enable);
}
// wxGrid::EnableEditing
void wxGrid_EnableEditing(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool edit;
edit = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->EnableEditing(edit);
}
// wxGrid::EnableGridLines
void wxGrid_EnableGridLines(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool enable=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "enable"))) {
enable = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->EnableGridLines(enable);
}
// wxGrid::EndBatch
void wxGrid_EndBatch(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->EndBatch();
}
// wxGrid::Fit
void wxGrid_Fit(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->Fit();
}
// wxGrid::ForceRefresh
void wxGrid_ForceRefresh(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->ForceRefresh();
}
// wxGrid::GetBatchCount
void wxGrid_GetBatchCount(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetBatchCount();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetCellAlignment
void wxGrid_GetCellAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int horiz;
int vert;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
This->GetCellAlignment(row,col,&horiz,&vert);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_int(horiz),
rt.make_int(vert));
rt.send(msg);
}
// wxGrid::GetCellBackgroundColour
void wxGrid_GetCellBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetCellBackgroundColour(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetCellEditor
void wxGrid_GetCellEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellEditor * Result = (wxGridCellEditor*)This->GetCellEditor(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellEditor"));
}
// wxGrid::GetCellFont
void wxGrid_GetCellFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetCellFont(row,col)); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxGrid::GetCellRenderer
void wxGrid_GetCellRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellRenderer * Result = (wxGridCellRenderer*)This->GetCellRenderer(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellRenderer"));
}
// wxGrid::GetCellTextColour
void wxGrid_GetCellTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetCellTextColour(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetCellValue
void wxGrid_GetCellValue_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxString Result = This->GetCellValue(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetCellValue
void wxGrid_GetCellValue_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
if(!This) throw wxe_badarg("This");
wxString Result = This->GetCellValue(coords);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetColLabelAlignment
void wxGrid_GetColLabelAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int horiz;
int vert;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->GetColLabelAlignment(&horiz,&vert);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_int(horiz),
rt.make_int(vert));
rt.send(msg);
}
// wxGrid::GetColLabelSize
void wxGrid_GetColLabelSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetColLabelSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetColLabelValue
void wxGrid_GetColLabelValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxString Result = This->GetColLabelValue(col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetColMinimalAcceptableWidth
void wxGrid_GetColMinimalAcceptableWidth(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetColMinimalAcceptableWidth();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetDefaultCellAlignment
void wxGrid_GetDefaultCellAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int horiz;
int vert;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->GetDefaultCellAlignment(&horiz,&vert);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_int(horiz),
rt.make_int(vert));
rt.send(msg);
}
// wxGrid::GetDefaultCellBackgroundColour
void wxGrid_GetDefaultCellBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetDefaultCellBackgroundColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetDefaultCellFont
void wxGrid_GetDefaultCellFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetDefaultCellFont()); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxGrid::GetDefaultCellTextColour
void wxGrid_GetDefaultCellTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetDefaultCellTextColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetDefaultColLabelSize
void wxGrid_GetDefaultColLabelSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetDefaultColLabelSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetDefaultColSize
void wxGrid_GetDefaultColSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetDefaultColSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetDefaultEditor
void wxGrid_GetDefaultEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGridCellEditor * Result = (wxGridCellEditor*)This->GetDefaultEditor();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellEditor"));
}
// wxGrid::GetDefaultEditorForCell
void wxGrid_GetDefaultEditorForCell_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellEditor * Result = (wxGridCellEditor*)This->GetDefaultEditorForCell(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellEditor"));
}
// wxGrid::GetDefaultEditorForCell
void wxGrid_GetDefaultEditorForCell_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *c_t;
int c_sz;
if(!enif_get_tuple(env, argv[1], &c_sz, &c_t)) Badarg("c");
int cR;
if(!enif_get_int(env, c_t[0], &cR)) Badarg("c");
int cC;
if(!enif_get_int(env, c_t[1], &cC)) Badarg("c");
wxGridCellCoords c = wxGridCellCoords(cR,cC);
if(!This) throw wxe_badarg("This");
wxGridCellEditor * Result = (wxGridCellEditor*)This->GetDefaultEditorForCell(c);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellEditor"));
}
// wxGrid::GetDefaultEditorForType
void wxGrid_GetDefaultEditorForType(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary typeName_bin;
wxString typeName;
if(!enif_inspect_binary(env, argv[1], &typeName_bin)) Badarg("typeName");
typeName = wxString(typeName_bin.data, wxConvUTF8, typeName_bin.size);
if(!This) throw wxe_badarg("This");
wxGridCellEditor * Result = (wxGridCellEditor*)This->GetDefaultEditorForType(typeName);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellEditor"));
}
// wxGrid::GetDefaultRenderer
void wxGrid_GetDefaultRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGridCellRenderer * Result = (wxGridCellRenderer*)This->GetDefaultRenderer();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellRenderer"));
}
// wxGrid::GetDefaultRendererForCell
void wxGrid_GetDefaultRendererForCell(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellRenderer * Result = (wxGridCellRenderer*)This->GetDefaultRendererForCell(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellRenderer"));
}
// wxGrid::GetDefaultRendererForType
void wxGrid_GetDefaultRendererForType(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary typeName_bin;
wxString typeName;
if(!enif_inspect_binary(env, argv[1], &typeName_bin)) Badarg("typeName");
typeName = wxString(typeName_bin.data, wxConvUTF8, typeName_bin.size);
if(!This) throw wxe_badarg("This");
wxGridCellRenderer * Result = (wxGridCellRenderer*)This->GetDefaultRendererForType(typeName);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellRenderer"));
}
// wxGrid::GetDefaultRowLabelSize
void wxGrid_GetDefaultRowLabelSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetDefaultRowLabelSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetDefaultRowSize
void wxGrid_GetDefaultRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetDefaultRowSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetGridCursorCol
void wxGrid_GetGridCursorCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetGridCursorCol();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetGridCursorRow
void wxGrid_GetGridCursorRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetGridCursorRow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetGridLineColour
void wxGrid_GetGridLineColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetGridLineColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GridLinesEnabled
void wxGrid_GridLinesEnabled(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->GridLinesEnabled();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::GetLabelBackgroundColour
void wxGrid_GetLabelBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetLabelBackgroundColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetLabelFont
void wxGrid_GetLabelFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxFont * Result = new wxFont(This->GetLabelFont()); app->newPtr((void *) Result,3, memenv);;
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxGrid::GetLabelTextColour
void wxGrid_GetLabelTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetLabelTextColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetNumberCols
void wxGrid_GetNumberCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetNumberCols();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetNumberRows
void wxGrid_GetNumberRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetNumberRows();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetOrCreateCellAttr
void wxGrid_GetOrCreateCellAttr(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellAttr * Result = (wxGridCellAttr*)This->GetOrCreateCellAttr(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellAttr"));
}
// wxGrid::GetRowMinimalAcceptableHeight
void wxGrid_GetRowMinimalAcceptableHeight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetRowMinimalAcceptableHeight();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetRowLabelAlignment
void wxGrid_GetRowLabelAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int horiz;
int vert;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->GetRowLabelAlignment(&horiz,&vert);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_int(horiz),
rt.make_int(vert));
rt.send(msg);
}
// wxGrid::GetRowLabelSize
void wxGrid_GetRowLabelSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetRowLabelSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetRowLabelValue
void wxGrid_GetRowLabelValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
if(!This) throw wxe_badarg("This");
wxString Result = This->GetRowLabelValue(row);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetRowSize
void wxGrid_GetRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
if(!This) throw wxe_badarg("This");
int Result = This->GetRowSize(row);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetScrollLineX
void wxGrid_GetScrollLineX(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetScrollLineX();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetScrollLineY
void wxGrid_GetScrollLineY(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetScrollLineY();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::GetSelectedCells
void wxGrid_GetSelectedCells(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGridCellCoordsArray Result = This->GetSelectedCells();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_array_objs(Result));
}
// wxGrid::GetSelectedCols
void wxGrid_GetSelectedCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxArrayInt Result = This->GetSelectedCols();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetSelectedRows
void wxGrid_GetSelectedRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxArrayInt Result = This->GetSelectedRows();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetSelectionBackground
void wxGrid_GetSelectionBackground(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetSelectionBackground();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetSelectionBlockTopLeft
void wxGrid_GetSelectionBlockTopLeft(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGridCellCoordsArray Result = This->GetSelectionBlockTopLeft();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_array_objs(Result));
}
// wxGrid::GetSelectionBlockBottomRight
void wxGrid_GetSelectionBlockBottomRight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxGridCellCoordsArray Result = This->GetSelectionBlockBottomRight();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_array_objs(Result));
}
// wxGrid::GetSelectionForeground
void wxGrid_GetSelectionForeground(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxColour Result = This->GetSelectionForeground();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGrid::GetGridWindow
void wxGrid_GetGridWindow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxWindow * Result = (wxWindow*)This->GetGridWindow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxWindow"));
}
// wxGrid::GetGridRowLabelWindow
void wxGrid_GetGridRowLabelWindow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxWindow * Result = (wxWindow*)This->GetGridRowLabelWindow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxWindow"));
}
// wxGrid::GetGridColLabelWindow
void wxGrid_GetGridColLabelWindow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxWindow * Result = (wxWindow*)This->GetGridColLabelWindow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxWindow"));
}
// wxGrid::GetGridCornerLabelWindow
void wxGrid_GetGridCornerLabelWindow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxWindow * Result = (wxWindow*)This->GetGridCornerLabelWindow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxWindow"));
}
// wxGrid::HideCellEditControl
void wxGrid_HideCellEditControl(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->HideCellEditControl();
}
// wxGrid::InsertCols
void wxGrid_InsertCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int pos=0;
int numCols=1;
bool updateLabels=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
if(!enif_get_int(env, tpl[1], &pos)) Badarg("pos"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "numCols"))) {
if(!enif_get_int(env, tpl[1], &numCols)) Badarg("numCols"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "updateLabels"))) {
updateLabels = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->InsertCols(pos,numCols,updateLabels);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::InsertRows
void wxGrid_InsertRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int pos=0;
int numRows=1;
bool updateLabels=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "pos"))) {
if(!enif_get_int(env, tpl[1], &pos)) Badarg("pos"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "numRows"))) {
if(!enif_get_int(env, tpl[1], &numRows)) Badarg("numRows"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "updateLabels"))) {
updateLabels = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->InsertRows(pos,numRows,updateLabels);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsCellEditControlEnabled
void wxGrid_IsCellEditControlEnabled(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsCellEditControlEnabled();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsCurrentCellReadOnly
void wxGrid_IsCurrentCellReadOnly(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsCurrentCellReadOnly();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsEditable
void wxGrid_IsEditable(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsEditable();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsInSelection
void wxGrid_IsInSelection_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
bool Result = This->IsInSelection(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsInSelection
void wxGrid_IsInSelection_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
if(!This) throw wxe_badarg("This");
bool Result = This->IsInSelection(coords);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsReadOnly
void wxGrid_IsReadOnly(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
bool Result = This->IsReadOnly(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsSelection
void wxGrid_IsSelection(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsSelection();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsVisible
void wxGrid_IsVisible_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool wholeCellVisible=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "wholeCellVisible"))) {
wholeCellVisible = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->IsVisible(row,col,wholeCellVisible);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::IsVisible
void wxGrid_IsVisible_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool wholeCellVisible=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "wholeCellVisible"))) {
wholeCellVisible = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->IsVisible(coords,wholeCellVisible);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MakeCellVisible
void wxGrid_MakeCellVisible_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
This->MakeCellVisible(row,col);
}
// wxGrid::MakeCellVisible
void wxGrid_MakeCellVisible_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
if(!This) throw wxe_badarg("This");
This->MakeCellVisible(coords);
}
// wxGrid::MoveCursorDown
void wxGrid_MoveCursorDown(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorDown(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorLeft
void wxGrid_MoveCursorLeft(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorLeft(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorRight
void wxGrid_MoveCursorRight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorRight(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorUp
void wxGrid_MoveCursorUp(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorUp(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorDownBlock
void wxGrid_MoveCursorDownBlock(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorDownBlock(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorLeftBlock
void wxGrid_MoveCursorLeftBlock(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorLeftBlock(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorRightBlock
void wxGrid_MoveCursorRightBlock(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorRightBlock(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MoveCursorUpBlock
void wxGrid_MoveCursorUpBlock(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
bool expandSelection;
expandSelection = enif_is_identical(argv[1], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
bool Result = This->MoveCursorUpBlock(expandSelection);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MovePageDown
void wxGrid_MovePageDown(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->MovePageDown();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::MovePageUp
void wxGrid_MovePageUp(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->MovePageUp();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGrid::RegisterDataType
void wxGrid_RegisterDataType(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary typeName_bin;
wxString typeName;
if(!enif_inspect_binary(env, argv[1], &typeName_bin)) Badarg("typeName");
typeName = wxString(typeName_bin.data, wxConvUTF8, typeName_bin.size);
wxGridCellRenderer *renderer;
renderer = (wxGridCellRenderer *) memenv->getPtr(env, argv[2], "renderer");
wxGridCellEditor *editor;
editor = (wxGridCellEditor *) memenv->getPtr(env, argv[3], "editor");
if(!This) throw wxe_badarg("This");
This->RegisterDataType(typeName,renderer,editor);
}
// wxGrid::SaveEditControlValue
void wxGrid_SaveEditControlValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->SaveEditControlValue();
}
// wxGrid::SelectAll
void wxGrid_SelectAll(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->SelectAll();
}
// wxGrid::SelectBlock
void wxGrid_SelectBlock_5(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool addToSelected=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int topRow;
if(!enif_get_int(env, argv[1], &topRow)) Badarg("topRow"); // int
int leftCol;
if(!enif_get_int(env, argv[2], &leftCol)) Badarg("leftCol"); // int
int bottomRow;
if(!enif_get_int(env, argv[3], &bottomRow)) Badarg("bottomRow"); // int
int rightCol;
if(!enif_get_int(env, argv[4], &rightCol)) Badarg("rightCol"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[5];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "addToSelected"))) {
addToSelected = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SelectBlock(topRow,leftCol,bottomRow,rightCol,addToSelected);
}
// wxGrid::SelectBlock
void wxGrid_SelectBlock_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool addToSelected=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *topLeft_t;
int topLeft_sz;
if(!enif_get_tuple(env, argv[1], &topLeft_sz, &topLeft_t)) Badarg("topLeft");
int topLeftR;
if(!enif_get_int(env, topLeft_t[0], &topLeftR)) Badarg("topLeft");
int topLeftC;
if(!enif_get_int(env, topLeft_t[1], &topLeftC)) Badarg("topLeft");
wxGridCellCoords topLeft = wxGridCellCoords(topLeftR,topLeftC);
const ERL_NIF_TERM *bottomRight_t;
int bottomRight_sz;
if(!enif_get_tuple(env, argv[2], &bottomRight_sz, &bottomRight_t)) Badarg("bottomRight");
int bottomRightR;
if(!enif_get_int(env, bottomRight_t[0], &bottomRightR)) Badarg("bottomRight");
int bottomRightC;
if(!enif_get_int(env, bottomRight_t[1], &bottomRightC)) Badarg("bottomRight");
wxGridCellCoords bottomRight = wxGridCellCoords(bottomRightR,bottomRightC);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "addToSelected"))) {
addToSelected = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SelectBlock(topLeft,bottomRight,addToSelected);
}
// wxGrid::SelectCol
void wxGrid_SelectCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool addToSelected=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "addToSelected"))) {
addToSelected = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SelectCol(col,addToSelected);
}
// wxGrid::SelectRow
void wxGrid_SelectRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool addToSelected=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "addToSelected"))) {
addToSelected = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SelectRow(row,addToSelected);
}
// wxGrid::SetCellAlignment
void wxGrid_SetCellAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
int horiz;
if(!enif_get_int(env, argv[3], &horiz)) Badarg("horiz"); // int
int vert;
if(!enif_get_int(env, argv[4], &vert)) Badarg("vert"); // int
if(!This) throw wxe_badarg("This");
This->SetCellAlignment(row,col,horiz,vert);
}
// wxGrid::SetCellBackgroundColour
void wxGrid_SetCellBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[3], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetCellBackgroundColour(row,col,colour);
}
// wxGrid::SetCellEditor
void wxGrid_SetCellEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
wxGridCellEditor *editor;
editor = (wxGridCellEditor *) memenv->getPtr(env, argv[3], "editor");
if(!This) throw wxe_badarg("This");
This->SetCellEditor(row,col,editor);
}
// wxGrid::SetCellFont
void wxGrid_SetCellFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[3], "font");
if(!This) throw wxe_badarg("This");
This->SetCellFont(row,col,*font);
}
// wxGrid::SetCellRenderer
void wxGrid_SetCellRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
wxGridCellRenderer *renderer;
renderer = (wxGridCellRenderer *) memenv->getPtr(env, argv[3], "renderer");
if(!This) throw wxe_badarg("This");
This->SetCellRenderer(row,col,renderer);
}
// wxGrid::SetCellTextColour
void wxGrid_SetCellTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[3], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetCellTextColour(row,col,colour);
}
// wxGrid::SetCellValue
void wxGrid_SetCellValue_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
ErlNifBinary s_bin;
wxString s;
if(!enif_inspect_binary(env, argv[3], &s_bin)) Badarg("s");
s = wxString(s_bin.data, wxConvUTF8, s_bin.size);
if(!This) throw wxe_badarg("This");
This->SetCellValue(row,col,s);
}
// wxGrid::SetCellValue
void wxGrid_SetCellValue_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
ErlNifBinary s_bin;
wxString s;
if(!enif_inspect_binary(env, argv[2], &s_bin)) Badarg("s");
s = wxString(s_bin.data, wxConvUTF8, s_bin.size);
if(!This) throw wxe_badarg("This");
This->SetCellValue(coords,s);
}
// wxGrid::SetColAttr
void wxGrid_SetColAttr(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
wxGridCellAttr *attr;
attr = (wxGridCellAttr *) memenv->getPtr(env, argv[2], "attr");
if(!This) throw wxe_badarg("This");
This->SetColAttr(col,attr);
}
// wxGrid::SetColFormatBool
void wxGrid_SetColFormatBool(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
This->SetColFormatBool(col);
}
// wxGrid::SetColFormatNumber
void wxGrid_SetColFormatNumber(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
This->SetColFormatNumber(col);
}
// wxGrid::SetColFormatFloat
void wxGrid_SetColFormatFloat(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int width=-1;
int precision=-1;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "width"))) {
if(!enif_get_int(env, tpl[1], &width)) Badarg("width"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "precision"))) {
if(!enif_get_int(env, tpl[1], &precision)) Badarg("precision"); // int
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SetColFormatFloat(col,width,precision);
}
// wxGrid::SetColFormatCustom
void wxGrid_SetColFormatCustom(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
ErlNifBinary typeName_bin;
wxString typeName;
if(!enif_inspect_binary(env, argv[2], &typeName_bin)) Badarg("typeName");
typeName = wxString(typeName_bin.data, wxConvUTF8, typeName_bin.size);
if(!This) throw wxe_badarg("This");
This->SetColFormatCustom(col,typeName);
}
// wxGrid::SetColLabelAlignment
void wxGrid_SetColLabelAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int horiz;
if(!enif_get_int(env, argv[1], &horiz)) Badarg("horiz"); // int
int vert;
if(!enif_get_int(env, argv[2], &vert)) Badarg("vert"); // int
if(!This) throw wxe_badarg("This");
This->SetColLabelAlignment(horiz,vert);
}
// wxGrid::SetColLabelSize
void wxGrid_SetColLabelSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int height;
if(!enif_get_int(env, argv[1], &height)) Badarg("height"); // int
if(!This) throw wxe_badarg("This");
This->SetColLabelSize(height);
}
// wxGrid::SetColLabelValue
void wxGrid_SetColLabelValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
ErlNifBinary value_bin;
wxString value;
if(!enif_inspect_binary(env, argv[2], &value_bin)) Badarg("value");
value = wxString(value_bin.data, wxConvUTF8, value_bin.size);
if(!This) throw wxe_badarg("This");
This->SetColLabelValue(col,value);
}
// wxGrid::SetColMinimalWidth
void wxGrid_SetColMinimalWidth(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
int width;
if(!enif_get_int(env, argv[2], &width)) Badarg("width"); // int
if(!This) throw wxe_badarg("This");
This->SetColMinimalWidth(col,width);
}
// wxGrid::SetColMinimalAcceptableWidth
void wxGrid_SetColMinimalAcceptableWidth(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int width;
if(!enif_get_int(env, argv[1], &width)) Badarg("width"); // int
if(!This) throw wxe_badarg("This");
This->SetColMinimalAcceptableWidth(width);
}
// wxGrid::SetColSize
void wxGrid_SetColSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int col;
if(!enif_get_int(env, argv[1], &col)) Badarg("col"); // int
int width;
if(!enif_get_int(env, argv[2], &width)) Badarg("width"); // int
if(!This) throw wxe_badarg("This");
This->SetColSize(col,width);
}
// wxGrid::SetDefaultCellAlignment
void wxGrid_SetDefaultCellAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int horiz;
if(!enif_get_int(env, argv[1], &horiz)) Badarg("horiz"); // int
int vert;
if(!enif_get_int(env, argv[2], &vert)) Badarg("vert"); // int
if(!This) throw wxe_badarg("This");
This->SetDefaultCellAlignment(horiz,vert);
}
// wxGrid::SetDefaultCellBackgroundColour
void wxGrid_SetDefaultCellBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[1], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetDefaultCellBackgroundColour(colour);
}
// wxGrid::SetDefaultCellFont
void wxGrid_SetDefaultCellFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetDefaultCellFont(*font);
}
// wxGrid::SetDefaultCellTextColour
void wxGrid_SetDefaultCellTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[1], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetDefaultCellTextColour(colour);
}
// wxGrid::SetDefaultEditor
void wxGrid_SetDefaultEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
wxGridCellEditor *editor;
editor = (wxGridCellEditor *) memenv->getPtr(env, argv[1], "editor");
if(!This) throw wxe_badarg("This");
This->SetDefaultEditor(editor);
}
// wxGrid::SetDefaultRenderer
void wxGrid_SetDefaultRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
wxGridCellRenderer *renderer;
renderer = (wxGridCellRenderer *) memenv->getPtr(env, argv[1], "renderer");
if(!This) throw wxe_badarg("This");
This->SetDefaultRenderer(renderer);
}
// wxGrid::SetDefaultColSize
void wxGrid_SetDefaultColSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool resizeExistingCols=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int width;
if(!enif_get_int(env, argv[1], &width)) Badarg("width"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "resizeExistingCols"))) {
resizeExistingCols = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SetDefaultColSize(width,resizeExistingCols);
}
// wxGrid::SetDefaultRowSize
void wxGrid_SetDefaultRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool resizeExistingRows=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int height;
if(!enif_get_int(env, argv[1], &height)) Badarg("height"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "resizeExistingRows"))) {
resizeExistingRows = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SetDefaultRowSize(height,resizeExistingRows);
}
// wxGrid::SetGridCursor
void wxGrid_SetGridCursor_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
This->SetGridCursor(row,col);
}
// wxGrid::SetGridCursor
void wxGrid_SetGridCursor_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *coords_t;
int coords_sz;
if(!enif_get_tuple(env, argv[1], &coords_sz, &coords_t)) Badarg("coords");
int coordsR;
if(!enif_get_int(env, coords_t[0], &coordsR)) Badarg("coords");
int coordsC;
if(!enif_get_int(env, coords_t[1], &coordsC)) Badarg("coords");
wxGridCellCoords coords = wxGridCellCoords(coordsR,coordsC);
if(!This) throw wxe_badarg("This");
This->SetGridCursor(coords);
}
// wxGrid::SetGridLineColour
void wxGrid_SetGridLineColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[1], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetGridLineColour(colour);
}
// wxGrid::SetLabelBackgroundColour
void wxGrid_SetLabelBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[1], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetLabelBackgroundColour(colour);
}
// wxGrid::SetLabelFont
void wxGrid_SetLabelFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetLabelFont(*font);
}
// wxGrid::SetLabelTextColour
void wxGrid_SetLabelTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colour_t;
int colour_sz;
if(!enif_get_tuple(env, argv[1], &colour_sz, &colour_t)) Badarg("colour");
int colourR;
if(!enif_get_int(env, colour_t[0], &colourR)) Badarg("colour");
int colourG;
if(!enif_get_int(env, colour_t[1], &colourG)) Badarg("colour");
int colourB;
if(!enif_get_int(env, colour_t[2], &colourB)) Badarg("colour");
int colourA;
if(!enif_get_int(env, colour_t[3], &colourA)) Badarg("colour");
wxColour colour = wxColour(colourR,colourG,colourB,colourA);
if(!This) throw wxe_badarg("This");
This->SetLabelTextColour(colour);
}
// wxGrid::SetMargins
void wxGrid_SetMargins(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int extraWidth;
if(!enif_get_int(env, argv[1], &extraWidth)) Badarg("extraWidth"); // int
int extraHeight;
if(!enif_get_int(env, argv[2], &extraHeight)) Badarg("extraHeight"); // int
if(!This) throw wxe_badarg("This");
This->SetMargins(extraWidth,extraHeight);
}
// wxGrid::SetReadOnly
void wxGrid_SetReadOnly(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool isReadOnly=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "isReadOnly"))) {
isReadOnly = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SetReadOnly(row,col,isReadOnly);
}
// wxGrid::SetRowAttr
void wxGrid_SetRowAttr(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
wxGridCellAttr *attr;
attr = (wxGridCellAttr *) memenv->getPtr(env, argv[2], "attr");
if(!This) throw wxe_badarg("This");
This->SetRowAttr(row,attr);
}
// wxGrid::SetRowLabelAlignment
void wxGrid_SetRowLabelAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int horiz;
if(!enif_get_int(env, argv[1], &horiz)) Badarg("horiz"); // int
int vert;
if(!enif_get_int(env, argv[2], &vert)) Badarg("vert"); // int
if(!This) throw wxe_badarg("This");
This->SetRowLabelAlignment(horiz,vert);
}
// wxGrid::SetRowLabelSize
void wxGrid_SetRowLabelSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int width;
if(!enif_get_int(env, argv[1], &width)) Badarg("width"); // int
if(!This) throw wxe_badarg("This");
This->SetRowLabelSize(width);
}
// wxGrid::SetRowLabelValue
void wxGrid_SetRowLabelValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
ErlNifBinary value_bin;
wxString value;
if(!enif_inspect_binary(env, argv[2], &value_bin)) Badarg("value");
value = wxString(value_bin.data, wxConvUTF8, value_bin.size);
if(!This) throw wxe_badarg("This");
This->SetRowLabelValue(row,value);
}
// wxGrid::SetRowMinimalHeight
void wxGrid_SetRowMinimalHeight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int height;
if(!enif_get_int(env, argv[2], &height)) Badarg("height"); // int
if(!This) throw wxe_badarg("This");
This->SetRowMinimalHeight(row,height);
}
// wxGrid::SetRowMinimalAcceptableHeight
void wxGrid_SetRowMinimalAcceptableHeight(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int height;
if(!enif_get_int(env, argv[1], &height)) Badarg("height"); // int
if(!This) throw wxe_badarg("This");
This->SetRowMinimalAcceptableHeight(height);
}
// wxGrid::SetRowSize
void wxGrid_SetRowSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int height;
if(!enif_get_int(env, argv[2], &height)) Badarg("height"); // int
if(!This) throw wxe_badarg("This");
This->SetRowSize(row,height);
}
// wxGrid::SetScrollLineX
void wxGrid_SetScrollLineX(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int x;
if(!enif_get_int(env, argv[1], &x)) Badarg("x"); // int
if(!This) throw wxe_badarg("This");
This->SetScrollLineX(x);
}
// wxGrid::SetScrollLineY
void wxGrid_SetScrollLineY(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int y;
if(!enif_get_int(env, argv[1], &y)) Badarg("y"); // int
if(!This) throw wxe_badarg("This");
This->SetScrollLineY(y);
}
// wxGrid::SetSelectionBackground
void wxGrid_SetSelectionBackground(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *c_t;
int c_sz;
if(!enif_get_tuple(env, argv[1], &c_sz, &c_t)) Badarg("c");
int cR;
if(!enif_get_int(env, c_t[0], &cR)) Badarg("c");
int cG;
if(!enif_get_int(env, c_t[1], &cG)) Badarg("c");
int cB;
if(!enif_get_int(env, c_t[2], &cB)) Badarg("c");
int cA;
if(!enif_get_int(env, c_t[3], &cA)) Badarg("c");
wxColour c = wxColour(cR,cG,cB,cA);
if(!This) throw wxe_badarg("This");
This->SetSelectionBackground(c);
}
// wxGrid::SetSelectionForeground
void wxGrid_SetSelectionForeground(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *c_t;
int c_sz;
if(!enif_get_tuple(env, argv[1], &c_sz, &c_t)) Badarg("c");
int cR;
if(!enif_get_int(env, c_t[0], &cR)) Badarg("c");
int cG;
if(!enif_get_int(env, c_t[1], &cG)) Badarg("c");
int cB;
if(!enif_get_int(env, c_t[2], &cB)) Badarg("c");
int cA;
if(!enif_get_int(env, c_t[3], &cA)) Badarg("c");
wxColour c = wxColour(cR,cG,cB,cA);
if(!This) throw wxe_badarg("This");
This->SetSelectionForeground(c);
}
// wxGrid::SetSelectionMode
void wxGrid_SetSelectionMode(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
wxGrid::wxGridSelectionModes selmode;
if(!enif_get_int(env, argv[1], (int *) &selmode)) Badarg("selmode"); // enum
if(!This) throw wxe_badarg("This");
This->SetSelectionMode(selmode);
}
// wxGrid::ShowCellEditControl
void wxGrid_ShowCellEditControl(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->ShowCellEditControl();
}
// wxGrid::XToCol
void wxGrid_XToCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool clipToMinMax=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int x;
if(!enif_get_int(env, argv[1], &x)) Badarg("x"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "clipToMinMax"))) {
clipToMinMax = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
int Result = This->XToCol(x,clipToMinMax);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::XToEdgeOfCol
void wxGrid_XToEdgeOfCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int x;
if(!enif_get_int(env, argv[1], &x)) Badarg("x"); // int
if(!This) throw wxe_badarg("This");
int Result = This->XToEdgeOfCol(x);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::YToEdgeOfRow
void wxGrid_YToEdgeOfRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int y;
if(!enif_get_int(env, argv[1], &y)) Badarg("y"); // int
if(!This) throw wxe_badarg("This");
int Result = This->YToEdgeOfRow(y);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGrid::YToRow
void wxGrid_YToRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool clipToMinMax=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGrid *This;
This = (wxGrid *) memenv->getPtr(env, argv[0], "This");
int y;
if(!enif_get_int(env, argv[1], &y)) Badarg("y"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "clipToMinMax"))) {
clipToMinMax = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
int Result = This->YToRow(y,clipToMinMax);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridBagSizer::wxGridBagSizer
void wxGridBagSizer_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int vgap=0;
int hgap=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "vgap"))) {
if(!enif_get_int(env, tpl[1], &vgap)) Badarg("vgap"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "hgap"))) {
if(!enif_get_int(env, tpl[1], &hgap)) Badarg("hgap"); // int
} else Badarg("Options");
};
wxGridBagSizer * Result = new EwxGridBagSizer(vgap,hgap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridBagSizer"));
}
// wxGridBagSizer::Add
void wxGridBagSizer_Add_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGBSpan span= wxDefaultSpan;
int flag=0;
int border=0;
wxObject * userData=NULL;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM window_type;
void * window = memenv->getPtr(env, argv[1], "window", &window_type);
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, argv[2], &pos_sz, &pos_t)) Badarg("pos");
int posR;
if(!enif_get_int(env, pos_t[0], &posR)) Badarg("pos");
int posC;
if(!enif_get_int(env, pos_t[1], &posC)) Badarg("pos");
wxGBPosition pos = wxGBPosition(posR,posC);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "span"))) {
const ERL_NIF_TERM *span_t;
int span_sz;
if(!enif_get_tuple(env, tpl[1], &span_sz, &span_t)) Badarg("span");
int spanRS;
if(!enif_get_int(env, span_t[0], &spanRS)) Badarg("span");
int spanCS;
if(!enif_get_int(env, span_t[1], &spanCS)) Badarg("span");
span = wxGBSpan(spanRS,spanCS);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "flag"))) {
if(!enif_get_int(env, tpl[1], &flag)) Badarg("flag"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "border"))) {
if(!enif_get_int(env, tpl[1], &border)) Badarg("border"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "userData"))) {
userData = (wxObject *) memenv->getPtr(env, tpl[1], "userData");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxSizerItem * Result;
if(enif_is_identical(window_type, WXE_ATOM_wxWindow))
Result = (wxSizerItem*)This->Add(static_cast<wxWindow*> (window),pos,span,flag,border,userData);
else if(enif_is_identical(window_type, WXE_ATOM_wxSizer))
Result = (wxSizerItem*)This->Add(static_cast<wxSizer*> (window),pos,span,flag,border,userData);
else throw wxe_badarg("window");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxSizerItem"));
}
// wxGridBagSizer::Add
void wxGridBagSizer_Add_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
wxGBSizerItem *item;
item = (wxGBSizerItem *) memenv->getPtr(env, argv[1], "item");
if(!This) throw wxe_badarg("This");
wxSizerItem * Result = (wxSizerItem*)This->Add(item);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxSizerItem"));
}
// wxGridBagSizer::Add
void wxGridBagSizer_Add_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGBSpan span= wxDefaultSpan;
int flag=0;
int border=0;
wxObject * userData=NULL;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
int width;
if(!enif_get_int(env, argv[1], &width)) Badarg("width"); // int
int height;
if(!enif_get_int(env, argv[2], &height)) Badarg("height"); // int
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, argv[3], &pos_sz, &pos_t)) Badarg("pos");
int posR;
if(!enif_get_int(env, pos_t[0], &posR)) Badarg("pos");
int posC;
if(!enif_get_int(env, pos_t[1], &posC)) Badarg("pos");
wxGBPosition pos = wxGBPosition(posR,posC);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[4];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "span"))) {
const ERL_NIF_TERM *span_t;
int span_sz;
if(!enif_get_tuple(env, tpl[1], &span_sz, &span_t)) Badarg("span");
int spanRS;
if(!enif_get_int(env, span_t[0], &spanRS)) Badarg("span");
int spanCS;
if(!enif_get_int(env, span_t[1], &spanCS)) Badarg("span");
span = wxGBSpan(spanRS,spanCS);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "flag"))) {
if(!enif_get_int(env, tpl[1], &flag)) Badarg("flag"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "border"))) {
if(!enif_get_int(env, tpl[1], &border)) Badarg("border"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "userData"))) {
userData = (wxObject *) memenv->getPtr(env, tpl[1], "userData");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
wxSizerItem * Result = (wxSizerItem*)This->Add(width,height,pos,span,flag,border,userData);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxSizerItem"));
}
// wxGridBagSizer::CalcMin
void wxGridBagSizer_CalcMin(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxSize Result = This->CalcMin();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::CheckForIntersection
void wxGridBagSizer_CheckForIntersection_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGBSizerItem * excludeItem=NULL;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
wxGBSizerItem *item;
item = (wxGBSizerItem *) memenv->getPtr(env, argv[1], "item");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "excludeItem"))) {
excludeItem = (wxGBSizerItem *) memenv->getPtr(env, tpl[1], "excludeItem");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->CheckForIntersection(item,excludeItem);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridBagSizer::CheckForIntersection
void wxGridBagSizer_CheckForIntersection_3(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGBSizerItem * excludeItem=NULL;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, argv[1], &pos_sz, &pos_t)) Badarg("pos");
int posR;
if(!enif_get_int(env, pos_t[0], &posR)) Badarg("pos");
int posC;
if(!enif_get_int(env, pos_t[1], &posC)) Badarg("pos");
wxGBPosition pos = wxGBPosition(posR,posC);
const ERL_NIF_TERM *span_t;
int span_sz;
if(!enif_get_tuple(env, argv[2], &span_sz, &span_t)) Badarg("span");
int spanRS;
if(!enif_get_int(env, span_t[0], &spanRS)) Badarg("span");
int spanCS;
if(!enif_get_int(env, span_t[1], &spanCS)) Badarg("span");
wxGBSpan span = wxGBSpan(spanRS,spanCS);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[3];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "excludeItem"))) {
excludeItem = (wxGBSizerItem *) memenv->getPtr(env, tpl[1], "excludeItem");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
bool Result = This->CheckForIntersection(pos,span,excludeItem);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridBagSizer::FindItem
void wxGridBagSizer_FindItem(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM window_type;
void * window = memenv->getPtr(env, argv[1], "window", &window_type);
if(!This) throw wxe_badarg("This");
wxGBSizerItem * Result;
if(enif_is_identical(window_type, WXE_ATOM_wxWindow))
Result = (wxGBSizerItem*)This->FindItem(static_cast<wxWindow*> (window));
else if(enif_is_identical(window_type, WXE_ATOM_wxSizer))
Result = (wxGBSizerItem*)This->FindItem(static_cast<wxSizer*> (window));
else throw wxe_badarg("window");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGBSizerItem"));
}
// wxGridBagSizer::FindItemAtPoint
void wxGridBagSizer_FindItemAtPoint(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *pt_t;
int pt_sz;
if(!enif_get_tuple(env, argv[1], &pt_sz, &pt_t)) Badarg("pt");
int ptX;
if(!enif_get_int(env, pt_t[0], &ptX)) Badarg("pt");
int ptY;
if(!enif_get_int(env, pt_t[1], &ptY)) Badarg("pt");
wxPoint pt = wxPoint(ptX,ptY);
if(!This) throw wxe_badarg("This");
wxGBSizerItem * Result = (wxGBSizerItem*)This->FindItemAtPoint(pt);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGBSizerItem"));
}
// wxGridBagSizer::FindItemAtPosition
void wxGridBagSizer_FindItemAtPosition(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, argv[1], &pos_sz, &pos_t)) Badarg("pos");
int posR;
if(!enif_get_int(env, pos_t[0], &posR)) Badarg("pos");
int posC;
if(!enif_get_int(env, pos_t[1], &posC)) Badarg("pos");
wxGBPosition pos = wxGBPosition(posR,posC);
if(!This) throw wxe_badarg("This");
wxGBSizerItem * Result = (wxGBSizerItem*)This->FindItemAtPosition(pos);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGBSizerItem"));
}
// wxGridBagSizer::FindItemWithData
void wxGridBagSizer_FindItemWithData(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
wxObject *userData;
userData = (wxObject *) memenv->getPtr(env, argv[1], "userData");
if(!This) throw wxe_badarg("This");
wxGBSizerItem * Result = (wxGBSizerItem*)This->FindItemWithData(userData);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGBSizerItem"));
}
// wxGridBagSizer::GetCellSize
void wxGridBagSizer_GetCellSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
int row;
if(!enif_get_int(env, argv[1], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[2], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxSize Result = This->GetCellSize(row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::GetEmptyCellSize
void wxGridBagSizer_GetEmptyCellSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxSize Result = This->GetEmptyCellSize();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::GetItemPosition
void wxGridBagSizer_GetItemPosition_1_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM window_type;
void * window = memenv->getPtr(env, argv[1], "window", &window_type);
if(!This) throw wxe_badarg("This");
wxGBPosition Result;
if(enif_is_identical(window_type, WXE_ATOM_wxWindow))
Result = This->GetItemPosition(static_cast<wxWindow*> (window));
else if(enif_is_identical(window_type, WXE_ATOM_wxSizer))
Result = This->GetItemPosition(static_cast<wxSizer*> (window));
else throw wxe_badarg("window");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::GetItemPosition
void wxGridBagSizer_GetItemPosition_1_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
size_t index;
if(!wxe_get_size_t(env, argv[1], &index)) Badarg("index");
if(!This) throw wxe_badarg("This");
wxGBPosition Result = This->GetItemPosition(index);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::GetItemSpan
void wxGridBagSizer_GetItemSpan_1_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM window_type;
void * window = memenv->getPtr(env, argv[1], "window", &window_type);
if(!This) throw wxe_badarg("This");
wxGBSpan Result;
if(enif_is_identical(window_type, WXE_ATOM_wxWindow))
Result = This->GetItemSpan(static_cast<wxWindow*> (window));
else if(enif_is_identical(window_type, WXE_ATOM_wxSizer))
Result = This->GetItemSpan(static_cast<wxSizer*> (window));
else throw wxe_badarg("window");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::GetItemSpan
void wxGridBagSizer_GetItemSpan_1_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
size_t index;
if(!wxe_get_size_t(env, argv[1], &index)) Badarg("index");
if(!This) throw wxe_badarg("This");
wxGBSpan Result = This->GetItemSpan(index);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridBagSizer::SetEmptyCellSize
void wxGridBagSizer_SetEmptyCellSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *sz_t;
int sz_sz;
if(!enif_get_tuple(env, argv[1], &sz_sz, &sz_t)) Badarg("sz");
int szW;
if(!enif_get_int(env, sz_t[0], &szW)) Badarg("sz");
int szH;
if(!enif_get_int(env, sz_t[1], &szH)) Badarg("sz");
wxSize sz = wxSize(szW,szH);
if(!This) throw wxe_badarg("This");
This->SetEmptyCellSize(sz);
}
// wxGridBagSizer::SetItemPosition
void wxGridBagSizer_SetItemPosition_2_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM window_type;
void * window = memenv->getPtr(env, argv[1], "window", &window_type);
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, argv[2], &pos_sz, &pos_t)) Badarg("pos");
int posR;
if(!enif_get_int(env, pos_t[0], &posR)) Badarg("pos");
int posC;
if(!enif_get_int(env, pos_t[1], &posC)) Badarg("pos");
wxGBPosition pos = wxGBPosition(posR,posC);
if(!This) throw wxe_badarg("This");
bool Result;
if(enif_is_identical(window_type, WXE_ATOM_wxWindow))
Result = This->SetItemPosition(static_cast<wxWindow*> (window),pos);
else if(enif_is_identical(window_type, WXE_ATOM_wxSizer))
Result = This->SetItemPosition(static_cast<wxSizer*> (window),pos);
else throw wxe_badarg("window");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridBagSizer::SetItemPosition
void wxGridBagSizer_SetItemPosition_2_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
size_t index;
if(!wxe_get_size_t(env, argv[1], &index)) Badarg("index");
const ERL_NIF_TERM *pos_t;
int pos_sz;
if(!enif_get_tuple(env, argv[2], &pos_sz, &pos_t)) Badarg("pos");
int posR;
if(!enif_get_int(env, pos_t[0], &posR)) Badarg("pos");
int posC;
if(!enif_get_int(env, pos_t[1], &posC)) Badarg("pos");
wxGBPosition pos = wxGBPosition(posR,posC);
if(!This) throw wxe_badarg("This");
bool Result = This->SetItemPosition(index,pos);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridBagSizer::SetItemSpan
void wxGridBagSizer_SetItemSpan_2_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM window_type;
void * window = memenv->getPtr(env, argv[1], "window", &window_type);
const ERL_NIF_TERM *span_t;
int span_sz;
if(!enif_get_tuple(env, argv[2], &span_sz, &span_t)) Badarg("span");
int spanRS;
if(!enif_get_int(env, span_t[0], &spanRS)) Badarg("span");
int spanCS;
if(!enif_get_int(env, span_t[1], &spanCS)) Badarg("span");
wxGBSpan span = wxGBSpan(spanRS,spanCS);
if(!This) throw wxe_badarg("This");
bool Result;
if(enif_is_identical(window_type, WXE_ATOM_wxWindow))
Result = This->SetItemSpan(static_cast<wxWindow*> (window),span);
else if(enif_is_identical(window_type, WXE_ATOM_wxSizer))
Result = This->SetItemSpan(static_cast<wxSizer*> (window),span);
else throw wxe_badarg("window");
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridBagSizer::SetItemSpan
void wxGridBagSizer_SetItemSpan_2_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridBagSizer *This;
This = (wxGridBagSizer *) memenv->getPtr(env, argv[0], "This");
size_t index;
if(!wxe_get_size_t(env, argv[1], &index)) Badarg("index");
const ERL_NIF_TERM *span_t;
int span_sz;
if(!enif_get_tuple(env, argv[2], &span_sz, &span_t)) Badarg("span");
int spanRS;
if(!enif_get_int(env, span_t[0], &spanRS)) Badarg("span");
int spanCS;
if(!enif_get_int(env, span_t[1], &spanCS)) Badarg("span");
wxGBSpan span = wxGBSpan(spanRS,spanCS);
if(!This) throw wxe_badarg("This");
bool Result = This->SetItemSpan(index,span);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::SetTextColour
void wxGridCellAttr_SetTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colText_t;
int colText_sz;
if(!enif_get_tuple(env, argv[1], &colText_sz, &colText_t)) Badarg("colText");
int colTextR;
if(!enif_get_int(env, colText_t[0], &colTextR)) Badarg("colText");
int colTextG;
if(!enif_get_int(env, colText_t[1], &colTextG)) Badarg("colText");
int colTextB;
if(!enif_get_int(env, colText_t[2], &colTextB)) Badarg("colText");
int colTextA;
if(!enif_get_int(env, colText_t[3], &colTextA)) Badarg("colText");
wxColour colText = wxColour(colTextR,colTextG,colTextB,colTextA);
if(!This) throw wxe_badarg("This");
This->SetTextColour(colText);
}
// wxGridCellAttr::SetBackgroundColour
void wxGridCellAttr_SetBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *colBack_t;
int colBack_sz;
if(!enif_get_tuple(env, argv[1], &colBack_sz, &colBack_t)) Badarg("colBack");
int colBackR;
if(!enif_get_int(env, colBack_t[0], &colBackR)) Badarg("colBack");
int colBackG;
if(!enif_get_int(env, colBack_t[1], &colBackG)) Badarg("colBack");
int colBackB;
if(!enif_get_int(env, colBack_t[2], &colBackB)) Badarg("colBack");
int colBackA;
if(!enif_get_int(env, colBack_t[3], &colBackA)) Badarg("colBack");
wxColour colBack = wxColour(colBackR,colBackG,colBackB,colBackA);
if(!This) throw wxe_badarg("This");
This->SetBackgroundColour(colBack);
}
// wxGridCellAttr::SetFont
void wxGridCellAttr_SetFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
wxFont *font;
font = (wxFont *) memenv->getPtr(env, argv[1], "font");
if(!This) throw wxe_badarg("This");
This->SetFont(*font);
}
// wxGridCellAttr::SetAlignment
void wxGridCellAttr_SetAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
int hAlign;
if(!enif_get_int(env, argv[1], &hAlign)) Badarg("hAlign"); // int
int vAlign;
if(!enif_get_int(env, argv[2], &vAlign)) Badarg("vAlign"); // int
if(!This) throw wxe_badarg("This");
This->SetAlignment(hAlign,vAlign);
}
// wxGridCellAttr::SetReadOnly
void wxGridCellAttr_SetReadOnly(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool isReadOnly=true;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "isReadOnly"))) {
isReadOnly = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->SetReadOnly(isReadOnly);
}
// wxGridCellAttr::SetRenderer
void wxGridCellAttr_SetRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
wxGridCellRenderer *renderer;
renderer = (wxGridCellRenderer *) memenv->getPtr(env, argv[1], "renderer");
if(!This) throw wxe_badarg("This");
This->SetRenderer(renderer);
}
// wxGridCellAttr::SetEditor
void wxGridCellAttr_SetEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
wxGridCellEditor *editor;
editor = (wxGridCellEditor *) memenv->getPtr(env, argv[1], "editor");
if(!This) throw wxe_badarg("This");
This->SetEditor(editor);
}
// wxGridCellAttr::HasTextColour
void wxGridCellAttr_HasTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->HasTextColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::HasBackgroundColour
void wxGridCellAttr_HasBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->HasBackgroundColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::HasFont
void wxGridCellAttr_HasFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->HasFont();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::HasAlignment
void wxGridCellAttr_HasAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->HasAlignment();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::HasRenderer
void wxGridCellAttr_HasRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->HasRenderer();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::HasEditor
void wxGridCellAttr_HasEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->HasEditor();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::GetTextColour
void wxGridCellAttr_GetTextColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxColour * Result = &This->GetTextColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make((*Result)));
}
// wxGridCellAttr::GetBackgroundColour
void wxGridCellAttr_GetBackgroundColour(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxColour * Result = &This->GetBackgroundColour();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make((*Result)));
}
// wxGridCellAttr::GetFont
void wxGridCellAttr_GetFont(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
const wxFont * Result = &This->GetFont();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxFont"));
}
// wxGridCellAttr::GetAlignment
void wxGridCellAttr_GetAlignment(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int hAlign;
int vAlign;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->GetAlignment(&hAlign,&vAlign);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
ERL_NIF_TERM msg = enif_make_tuple2(rt.env,
rt.make_int(hAlign),
rt.make_int(vAlign));
rt.send(msg);
}
// wxGridCellAttr::GetRenderer
void wxGridCellAttr_GetRenderer(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
wxGrid *grid;
grid = (wxGrid *) memenv->getPtr(env, argv[1], "grid");
int row;
if(!enif_get_int(env, argv[2], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[3], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellRenderer * Result = (wxGridCellRenderer*)This->GetRenderer(grid,row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellRenderer"));
}
// wxGridCellAttr::GetEditor
void wxGridCellAttr_GetEditor(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
wxGrid *grid;
grid = (wxGrid *) memenv->getPtr(env, argv[1], "grid");
int row;
if(!enif_get_int(env, argv[2], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[3], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxGridCellEditor * Result = (wxGridCellEditor*)This->GetEditor(grid,row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellEditor"));
}
// wxGridCellAttr::IsReadOnly
void wxGridCellAttr_IsReadOnly(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsReadOnly();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellAttr::SetDefAttr
void wxGridCellAttr_SetDefAttr(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellAttr *This;
This = (wxGridCellAttr *) memenv->getPtr(env, argv[0], "This");
wxGridCellAttr *defAttr;
defAttr = (wxGridCellAttr *) memenv->getPtr(env, argv[1], "defAttr");
if(!This) throw wxe_badarg("This");
This->SetDefAttr(defAttr);
}
// wxGridCellBoolEditor::wxGridCellBoolEditor
void wxGridCellBoolEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGridCellBoolEditor * Result = new wxGridCellBoolEditor();
app->newPtr((void *) Result, 25, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellBoolEditor"));
}
// wxGridCellBoolEditor::IsTrueValue
void wxGridCellBoolEditor_IsTrueValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ErlNifBinary value_bin;
wxString value;
if(!enif_inspect_binary(env, argv[0], &value_bin)) Badarg("value");
value = wxString(value_bin.data, wxConvUTF8, value_bin.size);
bool Result = wxGridCellBoolEditor::IsTrueValue(value);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellBoolEditor::UseStringValues
void wxGridCellBoolEditor_UseStringValues(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxString valueTrue= "1";
wxString valueFalse= wxEmptyString;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "valueTrue"))) {
ErlNifBinary valueTrue_bin;
if(!enif_inspect_binary(env, tpl[1], &valueTrue_bin)) Badarg("valueTrue");
valueTrue = wxString(valueTrue_bin.data, wxConvUTF8, valueTrue_bin.size);
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "valueFalse"))) {
ErlNifBinary valueFalse_bin;
if(!enif_inspect_binary(env, tpl[1], &valueFalse_bin)) Badarg("valueFalse");
valueFalse = wxString(valueFalse_bin.data, wxConvUTF8, valueFalse_bin.size);
} else Badarg("Options");
};
wxGridCellBoolEditor::UseStringValues(valueTrue,valueFalse);
}
// wxGridCellBoolEditor::destroy
void wxGridCellBoolEditor_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellBoolEditor *This;
This = (wxGridCellBoolEditor *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellBoolRenderer::wxGridCellBoolRenderer
void wxGridCellBoolRenderer_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGridCellBoolRenderer * Result = new wxGridCellBoolRenderer();
app->newPtr((void *) Result, 24, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellBoolRenderer"));
}
// wxGridCellBoolRenderer::destroy
void wxGridCellBoolRenderer_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellBoolRenderer *This;
This = (wxGridCellBoolRenderer *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellChoiceEditor::wxGridCellChoiceEditor
void wxGridCellChoiceEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
bool allowOthers=false;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM choicesHead, choicesTail;
ErlNifBinary choices_bin;
wxArrayString choices;
choicesTail = argv[0];
while(!enif_is_empty_list(env, choicesTail)) {
if(!enif_get_list_cell(env, choicesTail, &choicesHead, &choicesTail)) Badarg("choices");
if(!enif_inspect_binary(env, choicesHead, &choices_bin)) Badarg("choices");
choices.Add(wxString(choices_bin.data, wxConvUTF8, choices_bin.size));
};
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "allowOthers"))) {
allowOthers = enif_is_identical(tpl[1], WXE_ATOM_true);
} else Badarg("Options");
};
wxGridCellChoiceEditor * Result = new wxGridCellChoiceEditor(choices,allowOthers);
app->newPtr((void *) Result, 30, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellChoiceEditor"));
}
// wxGridCellChoiceEditor::SetParameters
void wxGridCellChoiceEditor_SetParameters(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellChoiceEditor *This;
This = (wxGridCellChoiceEditor *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary params_bin;
wxString params;
if(!enif_inspect_binary(env, argv[1], ¶ms_bin)) Badarg("params");
params = wxString(params_bin.data, wxConvUTF8, params_bin.size);
if(!This) throw wxe_badarg("This");
This->SetParameters(params);
}
// wxGridCellChoiceEditor::destroy
void wxGridCellChoiceEditor_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellChoiceEditor *This;
This = (wxGridCellChoiceEditor *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellEditor::Create
void wxGridCellEditor_Create(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
wxWindow *parent;
parent = (wxWindow *) memenv->getPtr(env, argv[1], "parent");
int id;
if(!enif_get_int(env, argv[2], &id)) Badarg("id"); // wxWindowID
wxEvtHandler *evtHandler;
evtHandler = (wxEvtHandler *) memenv->getPtr(env, argv[3], "evtHandler");
if(!This) throw wxe_badarg("This");
This->Create(parent,id,evtHandler);
}
// wxGridCellEditor::IsCreated
void wxGridCellEditor_IsCreated(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->IsCreated();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridCellEditor::SetSize
void wxGridCellEditor_SetSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
const ERL_NIF_TERM *rect_t;
int rect_sz;
if(!enif_get_tuple(env, argv[1], &rect_sz, &rect_t)) Badarg("rect");
int rectX;
if(!enif_get_int(env, rect_t[0], &rectX)) Badarg("rect");
int rectY;
if(!enif_get_int(env, rect_t[1], &rectY)) Badarg("rect");
int rectW;
if(!enif_get_int(env, rect_t[2], &rectW)) Badarg("rect");
int rectH;
if(!enif_get_int(env, rect_t[3], &rectH)) Badarg("rect");
wxRect rect = wxRect(rectX,rectY,rectW,rectH);
if(!This) throw wxe_badarg("This");
This->SetSize(rect);
}
// wxGridCellEditor::Show
void wxGridCellEditor_Show(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGridCellAttr * attr=NULL;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
bool show;
show = enif_is_identical(argv[1], WXE_ATOM_true);
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[2];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "attr"))) {
attr = (wxGridCellAttr *) memenv->getPtr(env, tpl[1], "attr");
} else Badarg("Options");
};
if(!This) throw wxe_badarg("This");
This->Show(show,attr);
}
// wxGridCellEditor::Reset
void wxGridCellEditor_Reset(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->Reset();
}
// wxGridCellEditor::StartingKey
void wxGridCellEditor_StartingKey(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
wxKeyEvent *event;
event = (wxKeyEvent *) memenv->getPtr(env, argv[1], "event");
if(!This) throw wxe_badarg("This");
This->StartingKey(*event);
}
// wxGridCellEditor::StartingClick
void wxGridCellEditor_StartingClick(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
This->StartingClick();
}
// wxGridCellEditor::HandleReturn
void wxGridCellEditor_HandleReturn(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellEditor *This;
This = (wxGridCellEditor *) memenv->getPtr(env, argv[0], "This");
wxKeyEvent *event;
event = (wxKeyEvent *) memenv->getPtr(env, argv[1], "event");
if(!This) throw wxe_badarg("This");
This->HandleReturn(*event);
}
// wxGridCellFloatEditor::wxGridCellFloatEditor
void wxGridCellFloatEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int width=-1;
int precision=-1;
int format=wxGRID_FLOAT_FORMAT_DEFAULT;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "width"))) {
if(!enif_get_int(env, tpl[1], &width)) Badarg("width"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "precision"))) {
if(!enif_get_int(env, tpl[1], &precision)) Badarg("precision"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "format"))) {
if(!enif_get_int(env, tpl[1], &format)) Badarg("format"); // int
} else Badarg("Options");
};
wxGridCellFloatEditor * Result = new wxGridCellFloatEditor(width,precision,format);
app->newPtr((void *) Result, 27, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellFloatEditor"));
}
// wxGridCellFloatEditor::SetParameters
void wxGridCellFloatEditor_SetParameters(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatEditor *This;
This = (wxGridCellFloatEditor *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary params_bin;
wxString params;
if(!enif_inspect_binary(env, argv[1], ¶ms_bin)) Badarg("params");
params = wxString(params_bin.data, wxConvUTF8, params_bin.size);
if(!This) throw wxe_badarg("This");
This->SetParameters(params);
}
// wxGridCellFloatEditor::destroy
void wxGridCellFloatEditor_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatEditor *This;
This = (wxGridCellFloatEditor *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellFloatRenderer::wxGridCellFloatRenderer
void wxGridCellFloatRenderer_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int width=-1;
int precision=-1;
int format=wxGRID_FLOAT_FORMAT_DEFAULT;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "width"))) {
if(!enif_get_int(env, tpl[1], &width)) Badarg("width"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "precision"))) {
if(!enif_get_int(env, tpl[1], &precision)) Badarg("precision"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "format"))) {
if(!enif_get_int(env, tpl[1], &format)) Badarg("format"); // int
} else Badarg("Options");
};
wxGridCellFloatRenderer * Result = new wxGridCellFloatRenderer(width,precision,format);
app->newPtr((void *) Result, 26, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellFloatRenderer"));
}
// wxGridCellFloatRenderer::GetPrecision
void wxGridCellFloatRenderer_GetPrecision(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatRenderer *This;
This = (wxGridCellFloatRenderer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetPrecision();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridCellFloatRenderer::GetWidth
void wxGridCellFloatRenderer_GetWidth(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatRenderer *This;
This = (wxGridCellFloatRenderer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetWidth();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridCellFloatRenderer::SetParameters
void wxGridCellFloatRenderer_SetParameters(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatRenderer *This;
This = (wxGridCellFloatRenderer *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary params_bin;
wxString params;
if(!enif_inspect_binary(env, argv[1], ¶ms_bin)) Badarg("params");
params = wxString(params_bin.data, wxConvUTF8, params_bin.size);
if(!This) throw wxe_badarg("This");
This->SetParameters(params);
}
// wxGridCellFloatRenderer::SetPrecision
void wxGridCellFloatRenderer_SetPrecision(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatRenderer *This;
This = (wxGridCellFloatRenderer *) memenv->getPtr(env, argv[0], "This");
int precision;
if(!enif_get_int(env, argv[1], &precision)) Badarg("precision"); // int
if(!This) throw wxe_badarg("This");
This->SetPrecision(precision);
}
// wxGridCellFloatRenderer::SetWidth
void wxGridCellFloatRenderer_SetWidth(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatRenderer *This;
This = (wxGridCellFloatRenderer *) memenv->getPtr(env, argv[0], "This");
int width;
if(!enif_get_int(env, argv[1], &width)) Badarg("width"); // int
if(!This) throw wxe_badarg("This");
This->SetWidth(width);
}
// wxGridCellFloatRenderer::destroy
void wxGridCellFloatRenderer_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellFloatRenderer *This;
This = (wxGridCellFloatRenderer *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellNumberEditor::wxGridCellNumberEditor
void wxGridCellNumberEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
int min=-1;
int max=-1;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "min"))) {
if(!enif_get_int(env, tpl[1], &min)) Badarg("min"); // int
} else if(enif_is_identical(tpl[0], enif_make_atom(env, "max"))) {
if(!enif_get_int(env, tpl[1], &max)) Badarg("max"); // int
} else Badarg("Options");
};
wxGridCellNumberEditor * Result = new wxGridCellNumberEditor(min,max);
app->newPtr((void *) Result, 32, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellNumberEditor"));
}
// wxGridCellNumberEditor::GetValue
void wxGridCellNumberEditor_GetValue(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellNumberEditor *This;
This = (wxGridCellNumberEditor *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxString Result = This->GetValue();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridCellNumberEditor::SetParameters
void wxGridCellNumberEditor_SetParameters(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellNumberEditor *This;
This = (wxGridCellNumberEditor *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary params_bin;
wxString params;
if(!enif_inspect_binary(env, argv[1], ¶ms_bin)) Badarg("params");
params = wxString(params_bin.data, wxConvUTF8, params_bin.size);
if(!This) throw wxe_badarg("This");
This->SetParameters(params);
}
// wxGridCellNumberEditor::destroy
void wxGridCellNumberEditor_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellNumberEditor *This;
This = (wxGridCellNumberEditor *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellNumberRenderer::wxGridCellNumberRenderer
void wxGridCellNumberRenderer_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGridCellNumberRenderer * Result = new wxGridCellNumberRenderer();
app->newPtr((void *) Result, 31, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellNumberRenderer"));
}
// wxGridCellNumberRenderer::destroy
void wxGridCellNumberRenderer_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellNumberRenderer *This;
This = (wxGridCellNumberRenderer *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellRenderer::Draw
void wxGridCellRenderer_Draw(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellRenderer *This;
This = (wxGridCellRenderer *) memenv->getPtr(env, argv[0], "This");
wxGrid *grid;
grid = (wxGrid *) memenv->getPtr(env, argv[1], "grid");
wxGridCellAttr *attr;
attr = (wxGridCellAttr *) memenv->getPtr(env, argv[2], "attr");
wxDC *dc;
dc = (wxDC *) memenv->getPtr(env, argv[3], "dc");
const ERL_NIF_TERM *rect_t;
int rect_sz;
if(!enif_get_tuple(env, argv[4], &rect_sz, &rect_t)) Badarg("rect");
int rectX;
if(!enif_get_int(env, rect_t[0], &rectX)) Badarg("rect");
int rectY;
if(!enif_get_int(env, rect_t[1], &rectY)) Badarg("rect");
int rectW;
if(!enif_get_int(env, rect_t[2], &rectW)) Badarg("rect");
int rectH;
if(!enif_get_int(env, rect_t[3], &rectH)) Badarg("rect");
wxRect rect = wxRect(rectX,rectY,rectW,rectH);
int row;
if(!enif_get_int(env, argv[5], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[6], &col)) Badarg("col"); // int
bool isSelected;
isSelected = enif_is_identical(argv[7], WXE_ATOM_true);
if(!This) throw wxe_badarg("This");
This->Draw(*grid,*attr,*dc,rect,row,col,isSelected);
}
// wxGridCellRenderer::GetBestSize
void wxGridCellRenderer_GetBestSize(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellRenderer *This;
This = (wxGridCellRenderer *) memenv->getPtr(env, argv[0], "This");
wxGrid *grid;
grid = (wxGrid *) memenv->getPtr(env, argv[1], "grid");
wxGridCellAttr *attr;
attr = (wxGridCellAttr *) memenv->getPtr(env, argv[2], "attr");
wxDC *dc;
dc = (wxDC *) memenv->getPtr(env, argv[3], "dc");
int row;
if(!enif_get_int(env, argv[4], &row)) Badarg("row"); // int
int col;
if(!enif_get_int(env, argv[5], &col)) Badarg("col"); // int
if(!This) throw wxe_badarg("This");
wxSize Result = This->GetBestSize(*grid,*attr,*dc,row,col);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridCellStringRenderer::wxGridCellStringRenderer
void wxGridCellStringRenderer_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGridCellStringRenderer * Result = new wxGridCellStringRenderer();
app->newPtr((void *) Result, 28, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellStringRenderer"));
}
// wxGridCellStringRenderer::destroy
void wxGridCellStringRenderer_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellStringRenderer *This;
This = (wxGridCellStringRenderer *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridCellTextEditor::wxGridCellTextEditor
void wxGridCellTextEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
size_t maxChars=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "maxChars"))) {
if(!wxe_get_size_t(env, tpl[1], &maxChars)) Badarg("maxChars");
} else Badarg("Options");
};
wxGridCellTextEditor * Result = new wxGridCellTextEditor(maxChars);
app->newPtr((void *) Result, 29, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellTextEditor"));
}
// wxGridCellTextEditor::SetParameters
void wxGridCellTextEditor_SetParameters(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellTextEditor *This;
This = (wxGridCellTextEditor *) memenv->getPtr(env, argv[0], "This");
ErlNifBinary params_bin;
wxString params;
if(!enif_inspect_binary(env, argv[1], ¶ms_bin)) Badarg("params");
params = wxString(params_bin.data, wxConvUTF8, params_bin.size);
if(!This) throw wxe_badarg("This");
This->SetParameters(params);
}
// wxGridCellTextEditor::destroy
void wxGridCellTextEditor_destroy(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellTextEditor *This;
This = (wxGridCellTextEditor *) memenv->getPtr(env, argv[0], "This");
if(This) { ((WxeApp *) wxTheApp)->clearPtr((void *) This);
delete This;}
}
// wxGridEvent::AltDown
void wxGridEvent_AltDown(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->AltDown();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridEvent::ControlDown
void wxGridEvent_ControlDown(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->ControlDown();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridEvent::GetCol
void wxGridEvent_GetCol(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetCol();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridEvent::GetPosition
void wxGridEvent_GetPosition(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
wxPoint Result = This->GetPosition();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make(Result));
}
// wxGridEvent::GetRow
void wxGridEvent_GetRow(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetRow();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridEvent::MetaDown
void wxGridEvent_MetaDown(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->MetaDown();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridEvent::Selecting
void wxGridEvent_Selecting(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->Selecting();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridEvent::ShiftDown
void wxGridEvent_ShiftDown(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridEvent *This;
This = (wxGridEvent *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
bool Result = This->ShiftDown();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_bool(Result));
}
// wxGridSizer::wxGridSizer
void wxGridSizer_new_3_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int cols;
if(!enif_get_int(env, argv[0], &cols)) Badarg("cols"); // int
int vgap;
if(!enif_get_int(env, argv[1], &vgap)) Badarg("vgap"); // int
int hgap;
if(!enif_get_int(env, argv[2], &hgap)) Badarg("hgap"); // int
wxGridSizer * Result = new EwxGridSizer(cols,vgap,hgap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridSizer"));
}
// wxGridSizer::wxGridSizer
void wxGridSizer_new_2(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxSize gap= wxSize(0, 0);
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int cols;
if(!enif_get_int(env, argv[0], &cols)) Badarg("cols"); // int
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[1];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "gap"))) {
const ERL_NIF_TERM *gap_t;
int gap_sz;
if(!enif_get_tuple(env, tpl[1], &gap_sz, &gap_t)) Badarg("gap");
int gapW;
if(!enif_get_int(env, gap_t[0], &gapW)) Badarg("gap");
int gapH;
if(!enif_get_int(env, gap_t[1], &gapH)) Badarg("gap");
gap = wxSize(gapW,gapH);
} else Badarg("Options");
};
wxGridSizer * Result = new EwxGridSizer(cols,gap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridSizer"));
}
// wxGridSizer::wxGridSizer
void wxGridSizer_new_4(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int rows;
if(!enif_get_int(env, argv[0], &rows)) Badarg("rows"); // int
int cols;
if(!enif_get_int(env, argv[1], &cols)) Badarg("cols"); // int
int vgap;
if(!enif_get_int(env, argv[2], &vgap)) Badarg("vgap"); // int
int hgap;
if(!enif_get_int(env, argv[3], &hgap)) Badarg("hgap"); // int
wxGridSizer * Result = new EwxGridSizer(rows,cols,vgap,hgap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridSizer"));
}
// wxGridSizer::wxGridSizer
void wxGridSizer_new_3_1(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
int rows;
if(!enif_get_int(env, argv[0], &rows)) Badarg("rows"); // int
int cols;
if(!enif_get_int(env, argv[1], &cols)) Badarg("cols"); // int
const ERL_NIF_TERM *gap_t;
int gap_sz;
if(!enif_get_tuple(env, argv[2], &gap_sz, &gap_t)) Badarg("gap");
int gapW;
if(!enif_get_int(env, gap_t[0], &gapW)) Badarg("gap");
int gapH;
if(!enif_get_int(env, gap_t[1], &gapH)) Badarg("gap");
wxSize gap = wxSize(gapW,gapH);
wxGridSizer * Result = new EwxGridSizer(rows,cols,gap);
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridSizer"));
}
// wxGridSizer::GetCols
void wxGridSizer_GetCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetCols();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridSizer::GetHGap
void wxGridSizer_GetHGap(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetHGap();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridSizer::GetRows
void wxGridSizer_GetRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetRows();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridSizer::GetVGap
void wxGridSizer_GetVGap(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
if(!This) throw wxe_badarg("This");
int Result = This->GetVGap();
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_int(Result));
}
// wxGridSizer::SetCols
void wxGridSizer_SetCols(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
int cols;
if(!enif_get_int(env, argv[1], &cols)) Badarg("cols"); // int
if(!This) throw wxe_badarg("This");
This->SetCols(cols);
}
// wxGridSizer::SetHGap
void wxGridSizer_SetHGap(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
int gap;
if(!enif_get_int(env, argv[1], &gap)) Badarg("gap"); // int
if(!This) throw wxe_badarg("This");
This->SetHGap(gap);
}
// wxGridSizer::SetRows
void wxGridSizer_SetRows(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
int rows;
if(!enif_get_int(env, argv[1], &rows)) Badarg("rows"); // int
if(!This) throw wxe_badarg("This");
This->SetRows(rows);
}
// wxGridSizer::SetVGap
void wxGridSizer_SetVGap(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridSizer *This;
This = (wxGridSizer *) memenv->getPtr(env, argv[0], "This");
int gap;
if(!enif_get_int(env, argv[1], &gap)) Badarg("gap"); // int
if(!This) throw wxe_badarg("This");
This->SetVGap(gap);
}
| 165,321 |
648 | {"resourceType":"DataElement","id":"ElementDefinition.constraint.xpath","meta":{"lastUpdated":"2017-04-19T07:44:43.294+10:00"},"url":"http://hl7.org/fhir/DataElement/ElementDefinition.constraint.xpath","status":"draft","experimental":true,"stringency":"fully-specified","element":[{"id":"ElementDefinition.constraint.xpath","path":"ElementDefinition.constraint.xpath","short":"XPath expression of constraint","definition":"An XPath expression of constraint that can be executed to see if this constraint is met.","comment":"Elements SHALL use \"f\" as the namespace prefix for the FHIR namespace, and \"x\" for the xhtml namespace, and SHALL NOT use any other prefixes. \n\nNote: we are considering deprecating the xpath element. Implementer feedback is welcome.","requirements":"Used in Schematron tests of the validity of the resource.","min":0,"max":"1","type":[{"code":"string"}],"isSummary":true,"mapping":[{"identity":"rim","map":"N/A (MIF territory)"}]}]} | 256 |
1,837 | /*
* Copyright (c) 2011-2018, <NAME>. All Rights Reserved.
*
* 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.dianping.zebra.single.jdbc;
import com.dianping.zebra.Constants;
import com.dianping.zebra.config.ServiceConfigBuilder;
import com.dianping.zebra.exception.ZebraException;
import com.dianping.zebra.filter.JdbcFilter;
import com.dianping.zebra.util.StringUtils;
import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
public abstract class AbstractDataSource implements DataSource {
public static final String LOCAL = Constants.CONFIG_MANAGER_TYPE_LOCAL;
protected String configManagerType = LOCAL;
protected Map<String, Object> serviceConfigs = ServiceConfigBuilder.newInstance().build();
protected volatile List<JdbcFilter> filters;
private int loginTimeout = 0;
private PrintWriter out = null;
protected void close() throws SQLException {
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return out;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
this.out = out;
}
@Override
public int getLoginTimeout() throws SQLException {
return this.loginTimeout;
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
this.loginTimeout = seconds;
}
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new UnsupportedOperationException("getParentLogger");
}
protected void init() {
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
if(iface == null) {
return false;
}
return iface.isAssignableFrom(this.getClass());
}
public void setConfigManagerType(String configManagerType) {
if (StringUtils.isNotBlank(configManagerType)) {
this.configManagerType = configManagerType;
}
}
@Override
@SuppressWarnings("unchecked")
public <T> T unwrap(Class<T> iface) throws SQLException {
if(iface == null) {
return null;
}
try {
if(iface.isAssignableFrom(this.getClass())) {
return (T) this;
} else {
throw new SQLException(getClass().getName() + " Can not unwrap to" + iface.getName());
}
} catch (Exception e) {
throw new SQLException(e);
}
}
}
| 968 |
6,207 | <reponame>amarallab/ResearchKit<filename>Testing/ORKTest/ORKTestTests/samples.bundle/ORKPSATStep.json
{"footnote":"","stimulusDuration":0,"recorderConfigurations":[],"shouldContinueOnFinish":true,"shouldSpeakCountDown":false,"interStimulusInterval":0,"shouldTintImages":true,"iconImage":{"imageName":"A0A7FA5A-91F9-4FC1-8D58-287F482B2074"},"auxiliaryImage":{"imageName":"A2ED4D38-98B4-46E2-A926-C226ED3415B0"},"shouldPlaySoundOnFinish":false,"seriesLength":0,"shouldPlaySoundOnStart":false,"title":"","image":{"imageName":"F7381130-E0E1-4B0E-A726-C0D0C6D0C8F0"},"detailText":"", "headerTextAlignment": 0, "stepDuration":0,"shouldShowDefaultTimer":false,"shouldVibrateOnFinish":false,"spokenInstruction":"","optional":false,"useSurveyMode":false,"identifier":"","shouldUseNextAsSkipButton":false,"presentationMode":0,"shouldVibrateOnStart":false,"bodyItems":[],"shouldSpeakRemainingTimeAtHalfway":false,"text":"","finishedSpokenInstruction":"","_class":"ORKPSATStep","shouldStartTimerAutomatically":true,"imageContentMode": 0,"bodyItemTextAlignment":0,"buildInBodyItems": 0,"useExtendedPadding":0}
| 358 |
326 | // Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2007-2015 <NAME>, Amsterdam, the Netherlands.
// This file was modified by Oracle on 2013-2020.
// Modifications copyright (c) 2013-2020 Oracle and/or its affiliates.
// Contributed and/or modified by <NAME>, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_DE9IM_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_DE9IM_HPP
#include <tuple>
#include <boost/geometry/algorithms/detail/relate/result.hpp>
#include <boost/geometry/core/topological_dimension.hpp>
#include <boost/geometry/core/tag.hpp>
#include <boost/geometry/util/sequence.hpp>
#include <boost/geometry/util/tuples.hpp>
namespace boost { namespace geometry
{
namespace de9im
{
/*!
\brief DE-9IM model intersection matrix.
\ingroup de9im
\details This matrix can be used to express spatial relations as defined in
Dimensionally Extended 9-Intersection Model.
\qbk{[heading See also]}
\qbk{* [link geometry.reference.algorithms.relation relation]}
*/
class matrix
: public detail::relate::matrix<3, 3>
{
#ifdef DOXYGEN_INVOKED
public:
/*!
\brief Initializes all of the matrix elements to F
*/
matrix();
/*!
\brief Subscript operator
\param index The index of the element
\return The element
*/
char operator[](std::size_t index) const;
/*!
\brief Returns the iterator to the first element
\return const RandomAccessIterator
*/
const_iterator begin() const;
/*!
\brief Returns the iterator past the last element
\return const RandomAccessIterator
*/
const_iterator end() const;
/*!
\brief Returns the number of elements
\return 9
*/
static std::size_t size();
/*!
\brief Returns raw pointer to elements
\return const pointer to array of elements
*/
inline const char * data() const;
/*!
\brief Returns std::string containing elements
\return string containing elements
*/
inline std::string str() const;
#endif
};
/*!
\brief DE-9IM model intersection mask.
\ingroup de9im
\details This mask can be used to check spatial relations as defined in
Dimensionally Extended 9-Intersection Model.
\qbk{[heading See also]}
\qbk{* [link geometry.reference.algorithms.relate relate]}
*/
class mask
: public detail::relate::mask<3, 3>
{
typedef detail::relate::mask<3, 3> base_type;
public:
/*!
\brief The constructor.
\param code The mask pattern.
*/
inline explicit mask(const char* code)
: base_type(code)
{}
/*!
\brief The constructor.
\param code The mask pattern.
*/
inline explicit mask(std::string const& code)
: base_type(code.c_str(), code.size())
{}
};
// static_mask
/*!
\brief DE-9IM model intersection mask (static version).
\ingroup de9im
\details This mask can be used to check spatial relations as defined in
Dimensionally Extended 9-Intersection Model.
\tparam II Interior/Interior intersection mask element
\tparam IB Interior/Boundary intersection mask element
\tparam IE Interior/Exterior intersection mask element
\tparam BI Boundary/Interior intersection mask element
\tparam BB Boundary/Boundary intersection mask element
\tparam BE Boundary/Exterior intersection mask element
\tparam EI Exterior/Interior intersection mask element
\tparam EB Exterior/Boundary intersection mask element
\tparam EE Exterior/Exterior intersection mask element
\qbk{[heading See also]}
\qbk{* [link geometry.reference.algorithms.relate relate]}
*/
template
<
char II = '*', char IB = '*', char IE = '*',
char BI = '*', char BB = '*', char BE = '*',
char EI = '*', char EB = '*', char EE = '*'
>
class static_mask
: public detail::relate::static_mask
<
std::integer_sequence
<
char, II, IB, IE, BI, BB, BE, EI, EB, EE
>,
3, 3
>
{};
inline
std::tuple<mask, mask>
operator||(mask const& m1, mask const& m2)
{
return std::tuple<mask, mask>(m1, m2);
}
template <typename ...Masks>
inline
std::tuple<Masks..., mask>
operator||(std::tuple<Masks...> const& t, mask const& m)
{
return geometry::tuples::push_back
<
std::tuple<Masks...>,
mask
>::apply(t, m);
}
template
<
char II1, char IB1, char IE1,
char BI1, char BB1, char BE1,
char EI1, char EB1, char EE1,
char II2, char IB2, char IE2,
char BI2, char BB2, char BE2,
char EI2, char EB2, char EE2
>
inline
util::type_sequence
<
static_mask<II1, IB1, IE1, BI1, BB1, BE1, EI1, EB1, EE1>,
static_mask<II2, IB2, IE2, BI2, BB2, BE2, EI2, EB2, EE2>
>
operator||(static_mask<II1, IB1, IE1, BI1, BB1, BE1, EI1, EB1, EE1> const& ,
static_mask<II2, IB2, IE2, BI2, BB2, BE2, EI2, EB2, EE2> const& )
{
return util::type_sequence
<
static_mask<II1, IB1, IE1, BI1, BB1, BE1, EI1, EB1, EE1>,
static_mask<II2, IB2, IE2, BI2, BB2, BE2, EI2, EB2, EE2>
>();
}
template
<
typename ...StaticMasks,
char II, char IB, char IE,
char BI, char BB, char BE,
char EI, char EB, char EE
>
inline
util::type_sequence
<
StaticMasks...,
static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE>
>
operator||(util::type_sequence<StaticMasks...> const& ,
static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE> const& )
{
return util::type_sequence
<
StaticMasks...,
static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE>
>();
}
} // namespace de9im
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace de9im
{
// PREDEFINED MASKS
// TODO:
// 1. specialize for simplified masks if available
// e.g. for TOUCHES use 1 mask for A/A
// 2. Think about dimensions > 2 e.g. should TOUCHES be true
// if the interior of the Areal overlaps the boundary of the Volumetric
// like it's true for Linear/Areal
// EQUALS
template <typename Geometry1, typename Geometry2>
struct static_mask_equals_type
{
typedef geometry::de9im::static_mask<'T', '*', 'F', '*', '*', 'F', 'F', 'F', '*'> type; // wikipedia
//typedef geometry::de9im::static_mask<'T', 'F', 'F', 'F', 'T', 'F', 'F', 'F', 'T'> type; // OGC
};
// DISJOINT
template <typename Geometry1, typename Geometry2>
struct static_mask_disjoint_type
{
typedef geometry::de9im::static_mask<'F', 'F', '*', 'F', 'F', '*', '*', '*', '*'> type;
};
// TOUCHES - NOT P/P
template
<
typename Geometry1,
typename Geometry2,
std::size_t Dim1 = geometry::topological_dimension<Geometry1>::value,
std::size_t Dim2 = geometry::topological_dimension<Geometry2>::value
>
struct static_mask_touches_impl
{
typedef util::type_sequence
<
geometry::de9im::static_mask<'F', 'T', '*', '*', '*', '*', '*', '*', '*'>,
geometry::de9im::static_mask<'F', '*', '*', 'T', '*', '*', '*', '*', '*'>,
geometry::de9im::static_mask<'F', '*', '*', '*', 'T', '*', '*', '*', '*'>
> type;
};
// According to OGC, doesn't apply to P/P
// Using the above mask the result would be always false
template <typename Geometry1, typename Geometry2>
struct static_mask_touches_impl<Geometry1, Geometry2, 0, 0>
{
typedef geometry::detail::relate::false_mask type;
};
template <typename Geometry1, typename Geometry2>
struct static_mask_touches_type
: static_mask_touches_impl<Geometry1, Geometry2>
{};
// WITHIN
template <typename Geometry1, typename Geometry2>
struct static_mask_within_type
{
typedef geometry::de9im::static_mask<'T', '*', 'F', '*', '*', 'F', '*', '*', '*'> type;
};
// COVERED_BY (non OGC)
template <typename Geometry1, typename Geometry2>
struct static_mask_covered_by_type
{
typedef util::type_sequence
<
geometry::de9im::static_mask<'T', '*', 'F', '*', '*', 'F', '*', '*', '*'>,
geometry::de9im::static_mask<'*', 'T', 'F', '*', '*', 'F', '*', '*', '*'>,
geometry::de9im::static_mask<'*', '*', 'F', 'T', '*', 'F', '*', '*', '*'>,
geometry::de9im::static_mask<'*', '*', 'F', '*', 'T', 'F', '*', '*', '*'>
> type;
};
// CROSSES
// dim(G1) < dim(G2) - P/L P/A L/A
template
<
typename Geometry1,
typename Geometry2,
std::size_t Dim1 = geometry::topological_dimension<Geometry1>::value,
std::size_t Dim2 = geometry::topological_dimension<Geometry2>::value,
bool D1LessD2 = (Dim1 < Dim2)
>
struct static_mask_crosses_impl
{
typedef geometry::de9im::static_mask<'T', '*', 'T', '*', '*', '*', '*', '*', '*'> type;
};
// TODO: I'm not sure if this one below should be available!
// dim(G1) > dim(G2) - L/P A/P A/L
template
<
typename Geometry1, typename Geometry2, std::size_t Dim1, std::size_t Dim2
>
struct static_mask_crosses_impl<Geometry1, Geometry2, Dim1, Dim2, false>
{
typedef geometry::de9im::static_mask<'T', '*', '*', '*', '*', '*', 'T', '*', '*'> type;
};
// dim(G1) == dim(G2) - P/P A/A
template
<
typename Geometry1, typename Geometry2, std::size_t Dim
>
struct static_mask_crosses_impl<Geometry1, Geometry2, Dim, Dim, false>
{
typedef geometry::detail::relate::false_mask type;
};
// dim(G1) == 1 && dim(G2) == 1 - L/L
template <typename Geometry1, typename Geometry2>
struct static_mask_crosses_impl<Geometry1, Geometry2, 1, 1, false>
{
typedef geometry::de9im::static_mask<'0', '*', '*', '*', '*', '*', '*', '*', '*'> type;
};
template <typename Geometry1, typename Geometry2>
struct static_mask_crosses_type
: static_mask_crosses_impl<Geometry1, Geometry2>
{};
// OVERLAPS
// dim(G1) != dim(G2) - NOT P/P, L/L, A/A
template
<
typename Geometry1,
typename Geometry2,
std::size_t Dim1 = geometry::topological_dimension<Geometry1>::value,
std::size_t Dim2 = geometry::topological_dimension<Geometry2>::value
>
struct static_mask_overlaps_impl
{
typedef geometry::detail::relate::false_mask type;
};
// dim(G1) == D && dim(G2) == D - P/P A/A
template <typename Geometry1, typename Geometry2, std::size_t Dim>
struct static_mask_overlaps_impl<Geometry1, Geometry2, Dim, Dim>
{
typedef geometry::de9im::static_mask<'T', '*', 'T', '*', '*', '*', 'T', '*', '*'> type;
};
// dim(G1) == 1 && dim(G2) == 1 - L/L
template <typename Geometry1, typename Geometry2>
struct static_mask_overlaps_impl<Geometry1, Geometry2, 1, 1>
{
typedef geometry::de9im::static_mask<'1', '*', 'T', '*', '*', '*', 'T', '*', '*'> type;
};
template <typename Geometry1, typename Geometry2>
struct static_mask_overlaps_type
: static_mask_overlaps_impl<Geometry1, Geometry2>
{};
}} // namespace detail::de9im
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_DE9IM_HPP
| 4,591 |
1,125 | <reponame>food-beaverages/elassandra
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.elassandra.ingest.common;
import org.apache.cassandra.utils.Hex;
import org.elasticsearch.ingest.IngestDocument;
import org.elasticsearch.ingest.Processor;
import org.elasticsearch.ingest.RandomDocumentPicks;
import org.elasticsearch.test.ESTestCase;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.notNullValue;
public class Base64ProcessorTests extends ESTestCase {
public void testBinary() throws Exception {
Map<String, Object> document = new HashMap<>();
String hexa = "ed953b2e446ec412fc45f68356cfb0f9b3a065c19a1fdb748bcc58ba95c289fe";
document.put("docker_id", hexa);
IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), document);
Processor processor = new Base64Processor(randomAlphaOfLength(10), "docker_id", null);
processor.execute(ingestDocument);
assertThat(ingestDocument.getFieldValue("docker_id", String.class), notNullValue());
String base64 = ingestDocument.getFieldValue("docker_id", String.class);
String hexa2 = Hex.bytesToHex(Base64.getDecoder().decode(base64));
assertThat(hexa, equalTo(hexa2));
}
}
| 665 |
679 | <reponame>Grosskopf/openoffice<filename>main/toolkit/source/awt/vclxgraphics.cxx<gh_stars>100-1000
/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_toolkit.hxx"
#include <toolkit/awt/vclxgraphics.hxx>
#include <toolkit/awt/vclxdevice.hxx>
#include <toolkit/awt/vclxfont.hxx>
#include <toolkit/helper/macros.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <cppuhelper/typeprovider.hxx>
#include <rtl/memory.h>
#include <rtl/uuid.h>
#include <vcl/svapp.hxx>
#include <vcl/outdev.hxx>
#include <vcl/image.hxx>
#include <vcl/gradient.hxx>
#include <tools/debug.hxx>
using namespace com::sun::star;
// ----------------------------------------------------
// class VCLXGraphics
// ----------------------------------------------------
// uno::XInterface
uno::Any VCLXGraphics::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException)
{
uno::Any aRet = ::cppu::queryInterface( rType,
SAL_STATIC_CAST( awt::XGraphics*, this ),
SAL_STATIC_CAST( lang::XTypeProvider*, this ),
SAL_STATIC_CAST( lang::XUnoTunnel*, this ) );
return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ));
}
// lang::XUnoTunnel
IMPL_XUNOTUNNEL( VCLXGraphics )
// lang::XTypeProvider
IMPL_XTYPEPROVIDER_START( VCLXGraphics )
getCppuType( ( uno::Reference< awt::XGraphics>* ) NULL )
IMPL_XTYPEPROVIDER_END
VCLXGraphics::VCLXGraphics() : mrMutex( Application::GetSolarMutex() )
{
mpOutputDevice = NULL;
mpClipRegion = NULL;
}
VCLXGraphics::~VCLXGraphics()
{
List* pLst = mpOutputDevice ? mpOutputDevice->GetUnoGraphicsList() : NULL;
if ( pLst )
pLst->Remove( this );
delete mpClipRegion;
}
void VCLXGraphics::SetOutputDevice( OutputDevice* pOutDev )
{
mpOutputDevice = pOutDev;
mxDevice = NULL;
initAttrs();
}
void VCLXGraphics::Init( OutputDevice* pOutDev )
{
DBG_ASSERT( !mpOutputDevice, "VCLXGraphics::Init already has pOutDev !" );
mpOutputDevice = pOutDev;
initAttrs();
mpClipRegion = NULL;
// Register at OutputDevice
List* pLst = mpOutputDevice->GetUnoGraphicsList();
if ( !pLst )
pLst = mpOutputDevice->CreateUnoGraphicsList();
pLst->Insert( this, LIST_APPEND );
}
void VCLXGraphics::initAttrs()
{
if ( !mpOutputDevice )
return;
maFont = mpOutputDevice->GetFont();
maTextColor = mpOutputDevice->GetTextColor(); /* COL_BLACK */
maTextFillColor = mpOutputDevice->GetTextFillColor(); /* COL_TRANSPARENT */
maLineColor = mpOutputDevice->GetLineColor(); /* COL_BLACK */
maFillColor = mpOutputDevice->GetFillColor(); /* COL_WHITE */
meRasterOp = mpOutputDevice->GetRasterOp(); /* ROP_OVERPAINT */
}
void VCLXGraphics::InitOutputDevice( sal_uInt16 nFlags )
{
if(mpOutputDevice)
{
vos::OGuard aVclGuard( Application::GetSolarMutex() );
if ( nFlags & INITOUTDEV_FONT )
{
mpOutputDevice->SetFont( maFont );
mpOutputDevice->SetTextColor( maTextColor );
mpOutputDevice->SetTextFillColor( maTextFillColor );
}
if ( nFlags & INITOUTDEV_COLORS )
{
mpOutputDevice->SetLineColor( maLineColor );
mpOutputDevice->SetFillColor( maFillColor );
}
if ( nFlags & INITOUTDEV_RASTEROP )
{
mpOutputDevice->SetRasterOp( meRasterOp );
}
if ( nFlags & INITOUTDEV_CLIPREGION )
{
if( mpClipRegion )
mpOutputDevice->SetClipRegion( *mpClipRegion );
else
mpOutputDevice->SetClipRegion();
}
}
}
uno::Reference< awt::XDevice > VCLXGraphics::getDevice() throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( !mxDevice.is() && mpOutputDevice )
{
VCLXDevice* pDev = new VCLXDevice;
pDev->SetOutputDevice( mpOutputDevice );
mxDevice = pDev;
}
return mxDevice;
}
awt::SimpleFontMetric VCLXGraphics::getFontMetric() throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
awt::SimpleFontMetric aM;
if( mpOutputDevice )
{
mpOutputDevice->SetFont( maFont );
aM = VCLUnoHelper::CreateFontMetric( mpOutputDevice->GetFontMetric() );
}
return aM;
}
void VCLXGraphics::setFont( const uno::Reference< awt::XFont >& rxFont ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
maFont = VCLUnoHelper::CreateFont( rxFont );
}
uno::Reference< awt::XFont > VCLXGraphics::getFont() throw(uno::RuntimeException)
{
uno::Reference< awt::XFont > xFont;
uno::Reference< awt::XDevice > xDevice( getDevice() );
::vos::OGuard aGuard( GetMutex() );
if ( xDevice.is() )
{
VCLXFont *pFont = new VCLXFont;
pFont->Init( *xDevice.get(), maFont );
xFont.set( static_cast< ::cppu::OWeakObject* >( pFont ), uno::UNO_QUERY );
}
return xFont;
}
void VCLXGraphics::selectFont( const awt::FontDescriptor& rDescription ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
maFont = VCLUnoHelper::CreateFont( rDescription, Font() );
}
void VCLXGraphics::setTextColor( sal_Int32 nColor ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
maTextColor = Color( (sal_uInt32)nColor );
}
::sal_Int32 VCLXGraphics::getTextColor() throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
return maTextColor.GetColor();
}
void VCLXGraphics::setTextFillColor( sal_Int32 nColor ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
maTextFillColor = Color( (sal_uInt32)nColor );
}
::sal_Int32 VCLXGraphics::getTextFillColor() throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
return maTextFillColor.GetColor();
}
void VCLXGraphics::setLineColor( sal_Int32 nColor ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
maLineColor = Color( (sal_uInt32)nColor );
}
::sal_Int32 VCLXGraphics::getLineColor() throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
return maLineColor.GetColor();
}
void VCLXGraphics::setFillColor( sal_Int32 nColor ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
maFillColor = Color( (sal_uInt32)nColor );
}
::sal_Int32 VCLXGraphics::getFillColor() throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
return maFillColor.GetColor();
}
void VCLXGraphics::setRasterOp( awt::RasterOperation eROP ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
meRasterOp = (RasterOp)eROP;
}
awt::RasterOperation VCLXGraphics::getRasterOp()
throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
return (awt::RasterOperation) meRasterOp;
}
void VCLXGraphics::setClipRegion( const uno::Reference< awt::XRegion >& rxRegion ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
delete mpClipRegion;
if ( rxRegion.is() )
mpClipRegion = new Region( VCLUnoHelper::GetRegion( rxRegion ) );
else
mpClipRegion = NULL;
}
void VCLXGraphics::intersectClipRegion( const uno::Reference< awt::XRegion >& rxRegion ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if ( rxRegion.is() )
{
Region aRegion( VCLUnoHelper::GetRegion( rxRegion ) );
if ( !mpClipRegion )
mpClipRegion = new Region( aRegion );
else
mpClipRegion->Intersect( aRegion );
}
}
void VCLXGraphics::push( ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
mpOutputDevice->Push();
}
void VCLXGraphics::pop( ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
mpOutputDevice->Pop();
}
void VCLXGraphics::clear(
const awt::Rectangle& aRect )
throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
const ::Rectangle aVCLRect = VCLUnoHelper::ConvertToVCLRect( aRect );
mpOutputDevice->Erase( aVCLRect );
}
}
void VCLXGraphics::copy( const uno::Reference< awt::XDevice >& rxSource, sal_Int32 nSourceX, sal_Int32 nSourceY, sal_Int32 nSourceWidth, sal_Int32 nSourceHeight, sal_Int32 nDestX, sal_Int32 nDestY, sal_Int32 nDestWidth, sal_Int32 nDestHeight ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if ( mpOutputDevice )
{
VCLXDevice* pFromDev = VCLXDevice::GetImplementation( rxSource );
DBG_ASSERT( pFromDev, "VCLXGraphics::copy - invalid device" );
if ( pFromDev )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP );
mpOutputDevice->DrawOutDev( Point( nDestX, nDestY ), Size( nDestWidth, nDestHeight ),
Point( nSourceX, nSourceY ), Size( nSourceWidth, nSourceHeight ), *pFromDev->GetOutputDevice() );
}
}
}
void VCLXGraphics::draw( const uno::Reference< awt::XDisplayBitmap >& rxBitmapHandle, sal_Int32 nSourceX, sal_Int32 nSourceY, sal_Int32 nSourceWidth, sal_Int32 nSourceHeight, sal_Int32 nDestX, sal_Int32 nDestY, sal_Int32 nDestWidth, sal_Int32 nDestHeight ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP);
uno::Reference< awt::XBitmap > xBitmap( rxBitmapHandle, uno::UNO_QUERY );
BitmapEx aBmpEx = VCLUnoHelper::GetBitmap( xBitmap );
Point aPos(nDestX - nSourceX, nDestY - nSourceY);
Size aSz = aBmpEx.GetSizePixel();
if(nDestWidth != nSourceWidth)
{
float zoomX = (float)nDestWidth / (float)nSourceWidth;
aSz.Width() = (long) ((float)aSz.Width() * zoomX);
}
if(nDestHeight != nSourceHeight)
{
float zoomY = (float)nDestHeight / (float)nSourceHeight;
aSz.Height() = (long) ((float)aSz.Height() * zoomY);
}
if(nSourceX || nSourceY || aSz.Width() != nSourceWidth || aSz.Height() != nSourceHeight)
mpOutputDevice->IntersectClipRegion(Region(Rectangle(nDestX, nDestY, nDestX + nDestWidth - 1, nDestY + nDestHeight - 1)));
mpOutputDevice->DrawBitmapEx( aPos, aSz, aBmpEx );
}
}
void VCLXGraphics::drawPixel( sal_Int32 x, sal_Int32 y ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawPixel( Point( x, y ) );
}
}
void VCLXGraphics::drawLine( sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawLine( Point( x1, y1 ), Point( x2, y2 ) );
}
}
void VCLXGraphics::drawRect( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawRect( Rectangle( Point( x, y ), Size( width, height ) ) );
}
}
void VCLXGraphics::drawRoundedRect( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 nHorzRound, sal_Int32 nVertRound ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawRect( Rectangle( Point( x, y ), Size( width, height ) ), nHorzRound, nVertRound );
}
}
void VCLXGraphics::drawPolyLine( const uno::Sequence< sal_Int32 >& DataX, const uno::Sequence< sal_Int32 >& DataY ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawPolyLine( VCLUnoHelper::CreatePolygon( DataX, DataY ) );
}
}
void VCLXGraphics::drawPolygon( const uno::Sequence< sal_Int32 >& DataX, const uno::Sequence< sal_Int32 >& DataY ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawPolygon( VCLUnoHelper::CreatePolygon( DataX, DataY ) );
}
}
void VCLXGraphics::drawPolyPolygon( const uno::Sequence< uno::Sequence< sal_Int32 > >& DataX, const uno::Sequence< uno::Sequence< sal_Int32 > >& DataY ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
sal_uInt16 nPolys = (sal_uInt16) DataX.getLength();
PolyPolygon aPolyPoly( nPolys );
for ( sal_uInt16 n = 0; n < nPolys; n++ )
aPolyPoly[n] = VCLUnoHelper::CreatePolygon( DataX.getConstArray()[n], DataY.getConstArray()[n] );
mpOutputDevice->DrawPolyPolygon( aPolyPoly );
}
}
void VCLXGraphics::drawEllipse( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawEllipse( Rectangle( Point( x, y ), Size( width, height ) ) );
}
}
void VCLXGraphics::drawArc( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawArc( Rectangle( Point( x, y ), Size( width, height ) ), Point( x1, y1 ), Point( x2, y2 ) );
}
}
void VCLXGraphics::drawPie( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawPie( Rectangle( Point( x, y ), Size( width, height ) ), Point( x1, y1 ), Point( x2, y2 ) );
}
}
void VCLXGraphics::drawChord( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int32 x1, sal_Int32 y1, sal_Int32 x2, sal_Int32 y2 ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawChord( Rectangle( Point( x, y ), Size( width, height ) ), Point( x1, y1 ), Point( x2, y2 ) );
}
}
void VCLXGraphics::drawGradient( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, const awt::Gradient& rGradient ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
Gradient aGradient((GradientStyle)rGradient.Style, rGradient.StartColor, rGradient.EndColor);
aGradient.SetAngle(rGradient.Angle);
aGradient.SetBorder(rGradient.Border);
aGradient.SetOfsX(rGradient.XOffset);
aGradient.SetOfsY(rGradient.YOffset);
aGradient.SetStartIntensity(rGradient.StartIntensity);
aGradient.SetEndIntensity(rGradient.EndIntensity);
aGradient.SetSteps(rGradient.StepCount);
mpOutputDevice->DrawGradient( Rectangle( Point( x, y ), Size( width, height ) ), aGradient );
}
}
void VCLXGraphics::drawText( sal_Int32 x, sal_Int32 y, const ::rtl::OUString& rText ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS |INITOUTDEV_FONT);
mpOutputDevice->DrawText( Point( x, y ), rText );
}
}
void VCLXGraphics::drawTextArray( sal_Int32 x, sal_Int32 y, const ::rtl::OUString& rText, const uno::Sequence< sal_Int32 >& rLongs ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS|INITOUTDEV_FONT );
mpOutputDevice->DrawTextArray( Point( x, y ), rText, rLongs.getConstArray() );
}
}
void VCLXGraphics::drawImage( sal_Int32 x, sal_Int32 y, sal_Int32 width, sal_Int32 height, sal_Int16 nStyle, const uno::Reference< graphic::XGraphic >& xGraphic ) throw(uno::RuntimeException)
{
::vos::OGuard aGuard( GetMutex() );
if( mpOutputDevice && xGraphic.is() )
{
Image aImage( xGraphic );
if ( !!aImage )
{
InitOutputDevice( INITOUTDEV_CLIPREGION|INITOUTDEV_RASTEROP|INITOUTDEV_COLORS );
mpOutputDevice->DrawImage( Point( x, y ), Size( width, height ), aImage, nStyle );
}
}
}
| 6,793 |
1,056 | <filename>ide/parsing.indexing/src/org/netbeans/modules/parsing/impl/indexing/IndexingUtils.java
/*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.modules.parsing.impl.indexing;
import java.util.Set;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Parameters;
/**
*
* @author sdedic
*/
public final class IndexingUtils {
public static void runAsScanWork(@NonNull Runnable work) {
Parameters.notNull("work", work); //NOI18N
RepositoryUpdater.getDefault().runAsWork(work);
}
/**
* Sets the {@link IndexingStatus}
* @param st an {@link IndexingStatus}
*/
public static void setIndexingStatus (final IndexingStatus st) {
assert st != null;
assert status == null;
status = st;
}
public static Set<? extends RepositoryUpdater.IndexingState> getIndexingState() {
if (status == null) {
return RepositoryUpdater.getDefault().getIndexingState();
} else {
return status.getIndexingState();
}
}
/**
* Asks the {@link IndexingStatus} about state of indexing
* @return true when indexing is active
*/
public static boolean isScanInProgress () {
return !getIndexingState().isEmpty();
}
//where
private static volatile IndexingStatus status;
/**
* Provides state of indexing
*/
public static interface IndexingStatus {
Set<? extends RepositoryUpdater.IndexingState> getIndexingState ();
}
private IndexingUtils() {}
}
| 796 |
459 | <gh_stars>100-1000
package com.knight.arch.api;
/**
* @author andyiac
* @date 15/11/10
* @web http://blog.andyiac.com
* @github https://github.com/andyiac
*/
public class GitHubApiConstants {
// todo id和 secret 是否放在其它地方
public static String GITHUB_APP_CLIENT_ID = "d23f22372a297175a100";
public static String GITHUB_APP_CLIENT_SECRET = "d0d616882a5ee2d9456a16a3c4e9f72e93ca1e4b";
}
| 186 |
701 | <reponame>spocino/brutal
#include <virtio/config.h> | 23 |
979 | <gh_stars>100-1000
#!/usr/bin/python
############################################################
# Copyright (c) 2013 VMware, Inc. All rights reserved.
# This script is provided as-is, with no warranties.
############################################################
#
# VMware-Java7-patch.py --
#
# This script applies a binary patch to liblwawt.dylib in the Java 7
# Runtime Environment for Mac OS. The patch addresses a compatiblity
# issue preventing the Java runtime from launching on platforms lacking
# hardware-accelerated OpenGL support. Installation instructions are
# located below.
#
# Environment: OS X 10.8 guest on VMware Fusion or ESXi, with Java 7
# installed in the guest.
#
# Symptom: Java applications (and Java Control Panel) fail to launch,
# with the guest OS presenting a dialog box such as:
#
# Java Control Panel quit unexpectedly while
# using the libjvm.dylib plug-in.
#
# Click Reopen to open the application again. Click Report
# to see more detailed information and send a report to
# Apple.
#
# The following text is present in the error report:
#
# Crashed Thread: <nn> Java: Java2D Queue Flusher
#
# Exception Type: EXC_BAD_ACCESS (SIGABRT)
# Exception Codes: KERN_INVALID_ADDRESS at 0x00000000000003b0
#
# The crash occurs in function glGetString; That function name should
# be visible in the stack trace of the crashed thread.
#
# Cause: The JRE assumes that hardware-accelerated graphics are available.
# Without hardware acceleration, no suitable pixel formats are found while
# initializing OpenGL. This triggers a failure in the initialization of
# the CGLGraphicsContext, and a later attempt to query the graphics context
# by an indirect function call to glGetString fails due to the lack of a
# functional graphics context.
#
# Remedy: Removing the kCGLPFAAccelerated, kCGLPFAFullScreen and
# kCGLPFAPBuffer attributes from the pixel format request allows the
# software renderer to be used. This patch modifies the method
# +[GraphicsConfigUtil _getCGLConfigInfo:] to alter the attributes it
# passes to -[NSOpenGLPixelFormat initWithAttributes:] accordingly.
#
#
################################################################################
#
# Installation: In Terminal, run "sudo python ./VMware-Java7-patch.py".
# Enter your password if prompted. You'll get either an error message or
# an indication that the patch was successful.
#
# The script creates a backup of the file that it modifies.
#
# Disclaimer: This has only been lightly tested. Feedback welcome!
# It is possible that older or newer JRE versions might not be patchable
# with this script.
#
# Successfully tested with Mac OS X 10.8.3 (12D78) and Java 7 Update 17
# (build 1.7.0_17-b02). DOES NOT WORK for Mac OS X 10.7.x guests: The
# patch prevents the crash, but Java windows/frames do not display any
# content.
#
# Feedback? Visit: http://communities.vmware.com/thread/422493
#
def patchLibLwAwt(fileName):
import shutil
import os
oldBytes = bytearray([
0xc7, 0x85, 0x6c, 0xff, 0xff, 0xff, 0x4a, 0x00, 0x00, 0x00, # kCGLPFAClosestPolicy
0xc7, 0x85, 0x70, 0xff, 0xff, 0xff, 0x48, 0x00, 0x00, 0x00, # kCGLPFANoRecovery
0xc7, 0x85, 0x74, 0xff, 0xff, 0xff, 0x49, 0x00, 0x00, 0x00, # kCGLPFAAccelerated <REMOVE>
0xc7, 0x85, 0x78, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, # kCGLPFAFullScreen <REMOVE>
0xc7, 0x85, 0x7c, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, # kCGLPFAWindow
0xc7, 0x45, 0x80, 0x5a, 0x00, 0x00, 0x00, # kCGLPFAPBuffer <REMOVE>
0xc7, 0x45, 0x84, 0x05, 0x00, 0x00, 0x00, # kCGLPFADoubleBuffer
0xc7, 0x45, 0x88, 0x08, 0x00, 0x00, 0x00, # kCGLPFAColorSize
0xc7, 0x45, 0x8c, 0x20, 0x00, 0x00, 0x00, # => 32-bit color
0xc7, 0x45, 0x90, 0x0b, 0x00, 0x00, 0x00, # kCGLPFAAlphaSize
0xc7, 0x45, 0x94, 0x08, 0x00, 0x00, 0x00, # => 8-bit alpha
0xc7, 0x45, 0x98, 0x0c, 0x00, 0x00, 0x00, # kCGLPFADepthSize
0xc7, 0x45, 0x9c, 0x10, 0x00, 0x00, 0x00, # => 16-bit depth
0xc7, 0x45, 0xa0, 0x54, 0x00, 0x00, 0x00, # kCGLPFADisplayMask
0x44, 0x89, 0x7d, 0xa4, # => display ID
0xc7, 0x45, 0xa8, 0x00, 0x00, 0x00, 0x00 # (end)
])
newBytes = bytearray([
0xc7, 0x85, 0x6c, 0xff, 0xff, 0xff, 0x4a, 0x00, 0x00, 0x00, # kCGLPFAClosestPolicy
0xc7, 0x85, 0x70, 0xff, 0xff, 0xff, 0x48, 0x00, 0x00, 0x00, # kCGLPFANoRecovery
0xc7, 0x85, 0x74, 0xff, 0xff, 0xff, 0x50, 0x00, 0x00, 0x00, # kCGLPFAWindow
0xc7, 0x85, 0x78, 0xff, 0xff, 0xff, 0x05, 0x00, 0x00, 0x00, # kCGLPFADoubleBuffer
0xc7, 0x85, 0x7c, 0xff, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, # kCGLPFAColorSize
0xc7, 0x45, 0x80, 0x20, 0x00, 0x00, 0x00, # => 32-bit color
0xc7, 0x45, 0x84, 0x0b, 0x00, 0x00, 0x00, # kCGLPFAAlphaSize
0xc7, 0x45, 0x88, 0x08, 0x00, 0x00, 0x00, # => 8-bit alpha
0xc7, 0x45, 0x8c, 0x0c, 0x00, 0x00, 0x00, # kCGLPFADepthSize
0xc7, 0x45, 0x90, 0x10, 0x00, 0x00, 0x00, # => 16-bit depth
0xc7, 0x45, 0x94, 0x54, 0x00, 0x00, 0x00, # kCGLPFADisplayMask
0x44, 0x89, 0x7d, 0x98, # => display ID
0xc7, 0x45, 0x9c, 0x00, 0x00, 0x00, 0x00, # (end)
0xc7, 0x45, 0xa0, 0x56, 0x00, 0x00, 0x00, #
0xc7, 0x45, 0xa4, 0x4d, 0x00, 0x00, 0x00, #
0xc7, 0x45, 0xa8, 0x57, 0x00, 0x00, 0x00, #
])
oldFile = bytearray(open(fileName, "rb").read())
if not oldBytes in oldFile:
if newBytes in oldFile:
raise RuntimeError("File seems to already be patched.")
raise RuntimeError("No patchable sequences found.")
newFile = oldFile.replace(oldBytes, newBytes, 1)
if oldBytes in newFile:
raise RuntimeError("Multiple patchable sequences found.")
if oldFile == newFile:
raise RuntimeError("Patching failed.")
if len(oldFile) != len(newFile):
raise RuntimeError("Patching changed the file size.")
shutil.copy2(fileName, "%s.backup.%d" % (fileName, os.getpid()))
open(fileName, "wb").write(newFile)
patchLibLwAwt("/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/lib/lwawt/liblwawt.dylib")
print "Java 7 patch successfully installed."
| 3,200 |
2,161 | from eth_utils import to_tuple
from typing import Iterable
from eth2spec.gen_helpers.gen_base import gen_runner, gen_typing
from eth2spec.test.helpers.typing import PresetBaseName
from eth2spec.phase0 import mainnet as spec_mainnet, minimal as spec_minimal
from eth2spec.test.helpers.constants import PHASE0, MINIMAL, MAINNET
def shuffling_case_fn(spec, seed, count):
yield 'mapping', 'data', {
'seed': '0x' + seed.hex(),
'count': count,
'mapping': [int(spec.compute_shuffled_index(i, count, seed)) for i in range(count)]
}
def shuffling_case(spec, seed, count):
return f'shuffle_0x{seed.hex()}_{count}', lambda: shuffling_case_fn(spec, seed, count)
@to_tuple
def shuffling_test_cases(spec):
for seed in [spec.hash(seed_init_value.to_bytes(length=4, byteorder='little')) for seed_init_value in range(30)]:
for count in [0, 1, 2, 3, 5, 10, 33, 100, 1000, 9999]:
yield shuffling_case(spec, seed, count)
def create_provider(preset_name: PresetBaseName) -> gen_typing.TestProvider:
def prepare_fn() -> None:
return
def cases_fn() -> Iterable[gen_typing.TestCase]:
if preset_name == MAINNET:
spec = spec_mainnet
elif preset_name == MINIMAL:
spec = spec_minimal
else:
raise Exception(f"unrecognized preset: {preset_name}")
for (case_name, case_fn) in shuffling_test_cases(spec):
yield gen_typing.TestCase(
fork_name=PHASE0,
preset_name=preset_name,
runner_name='shuffling',
handler_name='core',
suite_name='shuffle',
case_name=case_name,
case_fn=case_fn
)
return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn)
if __name__ == "__main__":
gen_runner.run_generator("shuffling", [create_provider(MINIMAL), create_provider(MAINNET)])
| 867 |
897 | <reponame>Khushboo85277/NeoAlgo
'''
here : https://www.hackerrank.com/challenges/climbing-the-leaderboard/problem
An arcade game player wants to climb to the top of the leaderboard and track their ranking.
The game uses Dense Ranking, so its leaderboard works like this:
The player with the highest score is ranked number 1 on the leaderboard.
Players who have equal scores receive the same ranking number, and the next player(s) receive the immediately following ranking number.
'''
def calc_alice_rank(
score_board, alice_score, alice_games
):
score_board_hash = {}
for score in score_board:
if score in score_board_hash:
continue
else:
score_board_hash[score] = 1
score_board = list(score_board_hash.keys())
alice_score_hash = {}
for score in alice_score:
if score in alice_score_hash:
alice_score_hash[score] += 1
else:
alice_score_hash[score] = 1
alice_rank_counter = 0
for index in reversed(range(len(score_board))):
if alice_rank_counter >= alice_games:
break
while alice_score[alice_rank_counter] <= score_board[index]:
current_score = alice_score[alice_rank_counter]
if score_board[index] == current_score:
for _ in range(alice_score_hash[current_score]):
print(index + 1)
alice_rank_counter += alice_score_hash[current_score]
elif score_board[index] > current_score:
for _ in range(alice_score_hash[current_score]):
print(index + 2)
alice_rank_counter += alice_score_hash[current_score]
elif index == 0 and current_score > score_board[index]:
print(1)
alice_rank_counter += 1
if alice_rank_counter >= alice_games:
break
if index == 0:
for _ in range(alice_games - alice_rank_counter):
print(1)
if __name__ == "__main__":
#taking the input
score_board_size = int(input("Enter the size of score board: "))
score_board = list(map(int, input("Enter the score board: ").split()))
alice_games = int(input("Enter the no. of player: "))
alice_score = list(map(int, input("Enter players:").split()))
calc_alice_rank(score_board, alice_score, alice_games)
'''
Time complexcity : O(n log n)
Space Complexcity : O(n log n)
Input:
Enter the size of score board: 7
Enter the score board: 100 100 50 40 40 20 10
Enter the no. of player: 4
Enter players: 5 25 50 120
Output:
6
4
2
1
'''
| 1,114 |
575 | // Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/bindings/no_alloc_direct_call_exception_state.h"
namespace blink {
void NoAllocDirectCallExceptionState::ThrowDOMException(DOMExceptionCode code,
const String& message) {
deferred_exception_ = WTF::Bind(
[](v8::Isolate* isolate, ExceptionContext&& exception_context,
DOMExceptionCode code, const String& message) {
ExceptionState exception_state(isolate, std::move(exception_context));
exception_state.ThrowDOMException(code, message);
},
WTF::Unretained(GetIsolate()), GetContext(), code, message);
SetExceptionCode(ToExceptionCode(code));
}
void NoAllocDirectCallExceptionState::ThrowTypeError(const String& message) {
deferred_exception_ = WTF::Bind(
[](v8::Isolate* isolate, ExceptionContext&& exception_context,
const String& message) {
ExceptionState exception_state(isolate, std::move(exception_context));
exception_state.ThrowTypeError(message);
},
WTF::Unretained(GetIsolate()), GetContext(), message);
SetExceptionCode(ToExceptionCode(ESErrorType::kTypeError));
}
void NoAllocDirectCallExceptionState::ThrowSecurityError(
const String& sanitized_message,
const String& unsanitized_message) {
deferred_exception_ = WTF::Bind(
[](v8::Isolate* isolate, ExceptionContext&& exception_context,
const String& sanitized_message, const String& unsanitized_message) {
ExceptionState exception_state(isolate, std::move(exception_context));
exception_state.ThrowSecurityError(sanitized_message,
unsanitized_message);
},
WTF::Unretained(GetIsolate()), GetContext(), sanitized_message,
unsanitized_message);
SetExceptionCode(ToExceptionCode(DOMExceptionCode::kSecurityError));
}
void NoAllocDirectCallExceptionState::ThrowRangeError(const String& message) {
deferred_exception_ = WTF::Bind(
[](v8::Isolate* isolate, ExceptionContext&& exception_context,
const String& message) {
ExceptionState exception_state(isolate, std::move(exception_context));
exception_state.ThrowRangeError(message);
},
WTF::Unretained(GetIsolate()), GetContext(), message);
SetExceptionCode(ToExceptionCode(ESErrorType::kRangeError));
}
void NoAllocDirectCallExceptionState::ClearException() {
ExceptionState::ClearException();
deferred_exception_.Reset();
}
NoAllocDirectCallExceptionState::~NoAllocDirectCallExceptionState() {
if (deferred_exception_) {
host_->PostDeferrableAction(std::move(deferred_exception_));
}
}
} // namespace blink
| 1,012 |
16,870 | /*
* Copyright 2019 Google Inc. All rights reserved.
*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.flatbuffers;
import static com.google.flatbuffers.Constants.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
/**
* Helper type for accessing vector of signed or unsigned 32-bit values.
*/
public final class IntVector extends BaseVector {
/**
* Assigns vector access object to vector data.
*
* @param _vector Start data of a vector.
* @param _bb Table's ByteBuffer.
* @return Returns current vector access object assigned to vector data whose offset is stored at
* `vector`.
*/
public IntVector __assign(int _vector, ByteBuffer _bb) {
__reset(_vector, Constants.SIZEOF_INT, _bb); return this;
}
/**
* Reads the integer at the given index.
*
* @param j The index from which the integer will be read.
* @return the 32-bit value at the given index.
*/
public int get(int j) {
return bb.getInt(__element(j));
}
/**
* Reads the integer at the given index, zero-extends it to type long, and returns the result,
* which is therefore in the range 0 through 4294967295.
*
* @param j The index from which the integer will be read.
* @return the unsigned 32-bit at the given index.
*/
public long getAsUnsigned(int j) {
return (long) get(j) & 0xFFFFFFFFL;
}
}
| 597 |
1,093 | /*
* Copyright 2002-2019 the original author or authors.
*
* Licensed 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.gateway;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.Mockito.mock;
import java.time.Duration;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.integration.annotation.Gateway;
import org.springframework.integration.annotation.GatewayHeader;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.PollableChannel;
import org.springframework.messaging.support.ChannelInterceptor;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import reactor.core.publisher.Mono;
/**
* @author <NAME>
* @author <NAME>
* @author <NAME>
* @author <NAME>
*
* @since 2.0
*/
public class AsyncGatewayTests {
@Test
public void futureWithMessageReturned() throws Exception {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Future<Message<?>> f = service.returnMessage("foo");
Object result = f.get(10000, TimeUnit.MILLISECONDS);
assertThat(result).isNotNull();
assertThat(((Message<?>) result).getPayload()).isEqualTo("foobar");
}
@Test
public void futureWithError() throws Exception {
final Error error = new Error("error");
DirectChannel channel = new DirectChannel() {
@Override
protected boolean doSend(Message<?> message, long timeout) {
throw error;
}
};
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(channel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Future<Message<?>> f = service.returnMessage("foo");
assertThatExceptionOfType(ExecutionException.class)
.isThrownBy(() -> f.get(10000, TimeUnit.MILLISECONDS))
.withCause(error);
}
@Test
public void listenableFutureWithMessageReturned() throws Exception {
QueueChannel requestChannel = new QueueChannel();
addThreadEnricher(requestChannel);
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
ListenableFuture<Message<?>> f = service.returnMessageListenable("foo");
long start = System.currentTimeMillis();
final AtomicReference<Message<?>> result = new AtomicReference<>();
final CountDownLatch latch = new CountDownLatch(1);
f.addCallback(new ListenableFutureCallback<Message<?>>() {
@Override
public void onSuccess(Message<?> msg) {
result.set(msg);
latch.countDown();
}
@Override
public void onFailure(Throwable t) {
}
});
assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
long elapsed = System.currentTimeMillis() - start;
assertThat(elapsed >= 200).isTrue();
assertThat(result.get().getPayload()).isEqualTo("foobar");
Object thread = result.get().getHeaders().get("thread");
assertThat(thread).isNotEqualTo(Thread.currentThread());
}
@Test
public void customFutureReturned() {
QueueChannel requestChannel = new QueueChannel();
addThreadEnricher(requestChannel);
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
CustomFuture f = service.returnCustomFuture("foo");
String result = f.get(10000, TimeUnit.MILLISECONDS);
assertThat(result).isEqualTo("foobar");
assertThat(f.thread).isEqualTo(Thread.currentThread());
}
@Test
public void nonAsyncFutureReturned() throws Exception {
QueueChannel requestChannel = new QueueChannel();
addThreadEnricher(requestChannel);
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.setAsyncExecutor(null); // Not async - user flow returns Future<?>
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
CustomFuture f = (CustomFuture) service.returnCustomFutureWithTypeFuture("foo");
String result = f.get(10000, TimeUnit.MILLISECONDS);
assertThat(result).isEqualTo("foobar");
assertThat(f.thread).isEqualTo(Thread.currentThread());
}
protected void addThreadEnricher(QueueChannel requestChannel) {
requestChannel.addInterceptor(new ChannelInterceptor() {
@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
return MessageBuilder.fromMessage(message)
.setHeader("thread", Thread.currentThread())
.build();
}
});
}
@Test
public void futureWithPayloadReturned() throws Exception {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Future<String> f = service.returnString("foo");
Object result = f.get(10000, TimeUnit.MILLISECONDS);
assertThat(result).isNotNull();
assertThat(result).isEqualTo("foobar");
}
@Test
public void futureWithWildcardReturned() throws Exception {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanName("testGateway");
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Future<?> f = service.returnSomething("foo");
Object result = f.get(10000, TimeUnit.MILLISECONDS);
assertThat(result instanceof String).isTrue();
assertThat(result).isEqualTo("foobar");
}
@Test
public void monoWithMessageReturned() {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.setBeanName("testGateway");
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Mono<Message<?>> mono = service.returnMessagePromise("foo");
Object result = mono.block(Duration.ofSeconds(10));
assertThat(((Message<?>) result).getPayload()).isEqualTo("foobar");
}
@Test
public void monoWithPayloadReturned() {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.setBeanName("testGateway");
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Mono<String> mono = service.returnStringPromise("foo");
Object result = mono.block(Duration.ofSeconds(10));
assertThat(result).isEqualTo("foobar");
}
@Test
public void monoWithWildcardReturned() {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.setBeanName("testGateway");
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Mono<?> mono = service.returnSomethingPromise("foo");
Object result = mono.block(Duration.ofSeconds(10));
assertThat(result).isNotNull();
assertThat(result).isEqualTo("foobar");
}
@Test
public void monoWithConsumer() throws Exception {
QueueChannel requestChannel = new QueueChannel();
startResponder(requestChannel);
GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
proxyFactory.setDefaultRequestChannel(requestChannel);
proxyFactory.setBeanFactory(mock(BeanFactory.class));
proxyFactory.setBeanName("testGateway");
proxyFactory.afterPropertiesSet();
TestEchoService service = (TestEchoService) proxyFactory.getObject();
Mono<String> mono = service.returnStringPromise("foo");
final AtomicReference<String> result = new AtomicReference<>();
final CountDownLatch latch = new CountDownLatch(1);
mono.subscribe(s -> {
result.set(s);
latch.countDown();
});
latch.await(10, TimeUnit.SECONDS);
assertThat(result.get()).isEqualTo("foobar");
}
private static void startResponder(final PollableChannel requestChannel) {
new Thread(() -> {
Message<?> input = requestChannel.receive();
String payload = input.getPayload() + "bar";
Message<?> reply = MessageBuilder.withPayload(payload)
.copyHeaders(input.getHeaders())
.build();
try {
Thread.sleep(200);
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
String header = (String) input.getHeaders().get("method");
if (header != null && header.startsWith("returnCustomFuture")) {
reply = MessageBuilder.withPayload(new CustomFuture(payload,
(Thread) input.getHeaders().get("thread")))
.copyHeaders(input.getHeaders())
.build();
}
((MessageChannel) input.getHeaders().getReplyChannel()).send(reply);
}).start();
}
private interface TestEchoService {
Future<String> returnString(String s);
Future<Message<?>> returnMessage(String s);
Future<?> returnSomething(String s);
ListenableFuture<Message<?>> returnMessageListenable(String s);
@Gateway(headers = @GatewayHeader(name = "method", expression = "#gatewayMethod.name"))
CustomFuture returnCustomFuture(String s);
@Gateway(headers = @GatewayHeader(name = "method", expression = "#gatewayMethod.name"))
Future<?> returnCustomFutureWithTypeFuture(String s);
Mono<String> returnStringPromise(String s);
Mono<Message<?>> returnMessagePromise(String s);
Mono<?> returnSomethingPromise(String s);
}
private static class CustomFuture implements Future<String> {
private final String result;
private final Thread thread;
private CustomFuture(String result, Thread thread) {
this.result = result;
this.thread = thread;
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {
return false;
}
@Override
public boolean isCancelled() {
return false;
}
@Override
public boolean isDone() {
return true;
}
@Override
public String get() {
return this.result;
}
@Override
public String get(long timeout, TimeUnit unit) {
return this.result;
}
}
}
| 4,178 |
1,234 | package org.benf.cfr.reader.util.output;
import org.benf.cfr.reader.bytecode.analysis.parse.expression.misc.Precedence;
import org.benf.cfr.reader.util.Troolean;
public interface DumpableWithPrecedence extends Dumpable {
Precedence getPrecedence();
Dumper dumpWithOuterPrecedence(Dumper d, Precedence outerPrecedence, Troolean isLhs);
}
| 124 |
452 | <filename>spring-cloud-dubbo-demo/spring-cloud-dubbo-demo-provider/spring-cloud-dubbo-demo-provider-service/src/main/java/cn/springcloud/dubbo/demo/provider/service/ProviderServiceImpl.java<gh_stars>100-1000
package cn.springcloud.dubbo.demo.provider.service;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ProviderServiceImpl implements ProviderService {
@Override
public String hello() {
return "Hello " + System.currentTimeMillis();
}
}
| 176 |
3,810 | package com.birbit.android.jobqueue.messaging;
import com.birbit.android.jobqueue.messaging.message.CommandMessage;
import org.hamcrest.CoreMatchers;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@RunWith(Parameterized.class)
public class DelayedMessageBagAddTest {
MessageFactory factory = new MessageFactory();
DelayedMessageBag bag = new DelayedMessageBag(factory);
List<Long> ordered;
Map<Long, Message> added = new HashMap<>();
public DelayedMessageBagAddTest(List<Long> ordered) {
this.ordered = ordered;
}
@Parameterized.Parameters(name = "{0}")
static public List<List<Long>> params() {
List<List<Long>> result = new ArrayList<>();
for (int a = 0; a < 3; a++) {
for (int b = 0; b < 3; b ++) {
if (b == a) {
continue;
}
for (int c = 0; c < 3; c ++) {
if (c == a || c == b) {
continue;
}
Long[] items = new Long[3];
items[a] = 1000L;
items[b] = 2000L;
items[c] = 3000L;
result.add(Arrays.asList(items));
}
}
}
return result;
}
@Test
public void testAddOrdered() {
for (Long readyNs : ordered) {
add(readyNs);
}
Message m1 = added.get(1000L);
Message m2 = added.get(2000L);
Message m3 = added.get(3000L);
assertThat(m1, CoreMatchers.notNullValue());
assertThat(m2, CoreMatchers.notNullValue());
assertThat(m3, CoreMatchers.notNullValue());
MessageQueue mq = mock(MessageQueue.class);
long t1 = bag.flushReadyMessages(500, mq);
assertThat(t1, CoreMatchers.is(1000L));
verify(mq, times(0)).post(any(Message.class));
long t2 = bag.flushReadyMessages(1000, mq);
assertThat(t2, CoreMatchers.is(2000L));
verify(mq).post(m1);
Long t3 = bag.flushReadyMessages(3001, mq);
assertThat(t3, CoreMatchers.nullValue());
verify(mq).post(m2);
verify(mq).post(m3);
}
private Message add(long readyNs) {
CommandMessage msg = factory.obtain(CommandMessage.class);
bag.add(msg, readyNs);
added.put(readyNs, msg);
return msg;
}
}
| 1,318 |
5,169 | <filename>Specs/0/4/2/face-SDK/1.0.0/face-SDK.podspec.json
{
"name": "face-SDK",
"version": "1.0.0",
"summary": "A short description of face-SDK.",
"description": "TODO: Add long description of the pod here.",
"homepage": "https://github.com/huangmengfei/face-SDK",
"license": {
"type": "MIT",
"file": "LICENSE"
},
"authors": {
"huangmengfei": "<EMAIL>"
},
"source": {
"git": "https://github.com/huangmengfei/face-SDK.git",
"tag": "1.0.0"
},
"platforms": {
"ios": "9.0"
},
"resources": [
"face-SDK/Assets/MGFaceIDDetectResource.bundle",
"face-SDK/Assets/MGFaceIDZZIDCardResouce.bundle"
],
"vendored_frameworks": [
"MGFaceIDBaseKit.framework",
"MGFaceIDDetect.framework",
"MGFaceIDZZIDCardKit.framework"
],
"dependencies": {
"Masonry": [
]
}
}
| 382 |
365 | /*
* Copyright (c) 2014, Ericsson AB. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*/
package com.ericsson.research.owr.examples.natiev;
import android.app.Activity;
import android.content.pm.ActivityInfo;
import android.graphics.SurfaceTexture;
import android.os.Bundle;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.view.Window;
import com.ericsson.research.owr.CaptureSourcesCallback;
import com.ericsson.research.owr.MediaSource;
import com.ericsson.research.owr.MediaType;
import com.ericsson.research.owr.Owr;
import com.ericsson.research.owr.VideoRenderer;
import com.ericsson.research.owr.WindowRegistry;
import java.util.EnumSet;
import java.util.List;
public class NativeExampleActivity extends Activity {
private static final String TAG = "NativeExampleActivity";
private static final String SELF_VIEW_TAG = "self-view";
/**
* Initialize OpenWebRTC at startup
*/
static {
Owr.init();
Owr.runInBackground();
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_openwebrtc);
Owr.getCaptureSources(EnumSet.of(MediaType.VIDEO), new CaptureSourcesCallback() {
@Override
public void onCaptureSourcesCallback(final List<MediaSource> mediaSources) {
/* Use default video source */
MediaSource mediaSource = mediaSources.get(0);
VideoRenderer videoRenderer = new VideoRenderer(SELF_VIEW_TAG);
videoRenderer.setWidth(720);
videoRenderer.setHeight(720);
videoRenderer.setSource(mediaSource);
}
});
final TextureView textureView = (TextureView) findViewById(R.id.texture_view);
textureView.setSurfaceTextureListener(new TextureView.SurfaceTextureListener() {
@Override
public void onSurfaceTextureAvailable(final SurfaceTexture surfaceTexture, final int width, final int height) {
Log.v(TAG, "onSurfaceTextureAvailable: " + width + "x" + height);
Surface surface = new Surface(surfaceTexture);
WindowRegistry.get().register(SELF_VIEW_TAG, surface);
}
@Override
public void onSurfaceTextureSizeChanged(final SurfaceTexture surface, final int width, final int height) {
Log.v(TAG, "onSurfaceTextureSizeChanged: " + width + "x" + height);
}
@Override
public boolean onSurfaceTextureDestroyed(final SurfaceTexture surface) {
Log.v(TAG, "onSurfaceTextureDestroyed");
WindowRegistry.get().unregister(SELF_VIEW_TAG);
return true;
}
@Override
public void onSurfaceTextureUpdated(final SurfaceTexture surface) {
}
});
}
/**
* Shutdown the process as a workaround until cleanup has been fully implemented.
*/
@Override
protected void onStop() {
finish();
System.exit(0);
}
}
| 1,671 |
1,590 | <reponame>libc16/azure-rest-api-specs
{
"parameters": {
"resourceGroupName": "markusavstestrg",
"api-version": "2019-10-01",
"subscriptionId": "31be0ff4-c932-4cb3-8efc-efa411d79280",
"projectName": "rajoshCCY9671project",
"importCollectorName": "importCollector2952",
"CollectorBody": {
"id": "/subscriptions/31be0ff4-c932-4cb3-8efc-efa411d79280/resourceGroups/markusavstestrg/providers/Microsoft.Migrate/assessmentprojects/rajoshCCY9671project/importcollectors/importCollector2951",
"name": "importCollector2951",
"eTag": "\"000064a2-0000-3300-0000-605994800000\"",
"type": "Microsoft.Migrate/assessmentprojects/importcollectors",
"properties": {
"discoverySiteId": "/subscriptions/31be0ff4-c932-4cb3-8efc-efa411d79280/resourcegroups/MarkusAVStestRG/providers/microsoft.offazure/importsites/rajoshCCY54cbimportSite"
}
}
},
"responses": {
"200": {
"body": {
"id": "/subscriptions/31be0ff4-c932-4cb3-8efc-efa411d79280/resourceGroups/markusavstestrg/providers/Microsoft.Migrate/assessmentprojects/rajoshCCY9671project/importcollectors/importCollector2952",
"name": "importCollector2952",
"eTag": "\"0000a7a2-0000-3300-0000-6059964d0000\"",
"type": "Microsoft.Migrate/assessmentprojects/importcollectors",
"properties": {
"discoverySiteId": "/subscriptions/31be0ff4-c932-4cb3-8efc-efa411d79280/resourcegroups/MarkusAVStestRG/providers/microsoft.offazure/importsites/rajoshCCY54cbimportSite",
"createdTimestamp": "2021-03-23T07:18:37.2247735Z",
"updatedTimestamp": "2021-03-23T07:18:37.2247735Z"
}
}
},
"201": {
"body": {
"id": "/subscriptions/31be0ff4-c932-4cb3-8efc-efa411d79280/resourceGroups/markusavstestrg/providers/Microsoft.Migrate/assessmentprojects/rajoshCCY9671project/importcollectors/importCollector2952",
"name": "importCollector2952",
"eTag": "\"0000a7a2-0000-3300-0000-6059964d0000\"",
"type": "Microsoft.Migrate/assessmentprojects/importcollectors",
"properties": {
"discoverySiteId": "/subscriptions/31be0ff4-c932-4cb3-8efc-efa411d79280/resourcegroups/MarkusAVStestRG/providers/microsoft.offazure/importsites/rajoshCCY54cbimportSite",
"createdTimestamp": "2021-03-23T07:18:37.2247735Z",
"updatedTimestamp": "2021-03-23T07:18:37.2247735Z"
}
}
}
}
}
| 1,121 |
1,056 | /*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.test.web;
import junit.framework.Test;
/**
*/
public class WebProjectValidationEE5 extends WebProjectValidation {
public static final String[] TESTS = new String[]{
"testNewWebProject", "testRedeployProject",
"testNewJSP", "testNewJSP2", "testNewServlet", "testNewServlet2",
"testCompileAllJSP", "testCompileJSP",
"testCleanAndBuildProject", "testRunProject", "testRunJSP", "testViewServlet",
"testRunServlet", "testCreateTLD", "testCreateTagHandler", "testRunTag",
"testNewHTML", "testRunHTML", "testNewSegment", "testNewDocument",
"testFinish"
};
public WebProjectValidationEE5(String name) {
super(name);
PROJECT_NAME = "WebJ2EE5Project"; // NOI18N
}
public static Test suite() {
return createAllModulesServerSuite(Server.GLASSFISH, WebProjectValidationEE5.class, TESTS);
}
@Override
protected String getEEVersion() {
return JAVA_EE_5;
}
}
| 593 |
4,140 | /*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.hive.hcatalog.templeton;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Future;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobRequestExecutor<T> {
private static final Logger LOG = LoggerFactory.getLogger(JobRequestExecutor.class);
private static AppConfig appConf = Main.getAppConfigInstance();
/*
* Thread pool to execute job requests.
*/
private ThreadPoolExecutor jobExecutePool = null;
/*
* Type of job request.
*/
private JobRequestType requestType;
/*
* Config name used to find the number of concurrent requests.
*/
private String concurrentRequestsConfigName;
/*
* Config name used to find the maximum time job request can be executed.
*/
private String jobTimeoutConfigName;
/*
* Job request execution time out in seconds. If it is 0 then request
* will not be timed out.
*/
private int requestExecutionTimeoutInSec = 0;
/*
* Amount of time a thread can be alive in thread pool before cleaning this up. Core threads
* will not be cleanup from thread pool.
*/
private int threadKeepAliveTimeInHours = 1;
/*
* Maximum number of times a cancel request is sent to job request execution
* thread. Future.cancel may not be able to interrupt the thread if it is
* blocked on network calls.
*/
private int maxTaskCancelRetryCount = 10;
/*
* Wait time in milliseconds before another cancel request is made.
*/
private int maxTaskCancelRetryWaitTimeInMs = 1000;
/*
* A flag to indicate whether to cancel the task when exception TimeoutException or
* InterruptedException or CancellationException raised. The default is cancel thread.
*/
private boolean enableCancelTask = true;
/*
* Job Request type.
*/
public enum JobRequestType {
Submit,
Status,
List
}
/*
* Creates a job request object and sets up execution environment. Creates a thread pool
* to execute job requests.
*
* @param requestType
* Job request type
*
* @param concurrentRequestsConfigName
* Config name to be used to extract number of concurrent requests to be serviced.
*
* @param jobTimeoutConfigName
* Config name to be used to extract maximum time a task can execute a request.
*
* @param enableCancelTask
* A flag to indicate whether to cancel the task when exception TimeoutException
* or InterruptedException or CancellationException raised.
*
*/
public JobRequestExecutor(JobRequestType requestType, String concurrentRequestsConfigName,
String jobTimeoutConfigName, boolean enableCancelTask) {
this.concurrentRequestsConfigName = concurrentRequestsConfigName;
this.jobTimeoutConfigName = jobTimeoutConfigName;
this.requestType = requestType;
this.enableCancelTask = enableCancelTask;
/*
* The default number of threads will be 0. That means thread pool is not used and
* operation is executed with the current thread.
*/
int threads = !StringUtils.isEmpty(concurrentRequestsConfigName) ?
appConf.getInt(concurrentRequestsConfigName, 0) : 0;
if (threads > 0) {
/*
* Create a thread pool with no queue wait time to execute the operation. This will ensure
* that job requests are rejected if there are already maximum number of threads busy.
*/
this.jobExecutePool = new ThreadPoolExecutor(threads, threads,
threadKeepAliveTimeInHours, TimeUnit.HOURS,
new SynchronousQueue<Runnable>());
this.jobExecutePool.allowCoreThreadTimeOut(true);
/*
* Get the job request time out value. If this configuration value is set to 0
* then job request will wait until it finishes.
*/
if (!StringUtils.isEmpty(jobTimeoutConfigName)) {
this.requestExecutionTimeoutInSec = appConf.getInt(jobTimeoutConfigName, 0);
}
LOG.info("Configured " + threads + " threads for job request type " + this.requestType
+ " with time out " + this.requestExecutionTimeoutInSec + " s.");
} else {
/*
* If threads are not configured then they will be executed in current thread itself.
*/
LOG.info("No thread pool configured for job request type " + this.requestType);
}
}
/*
* Creates a job request object and sets up execution environment. Creates a thread pool
* to execute job requests.
*
* @param requestType
* Job request type
*
* @param concurrentRequestsConfigName
* Config name to be used to extract number of concurrent requests to be serviced.
*
* @param jobTimeoutConfigName
* Config name to be used to extract maximum time a task can execute a request.
*
*/
public JobRequestExecutor(JobRequestType requestType, String concurrentRequestsConfigName,
String jobTimeoutConfigName) {
this(requestType, concurrentRequestsConfigName, jobTimeoutConfigName, true);
}
/*
* Returns true of thread pool is created and can be used for executing a job request.
* Otherwise, returns false.
*/
public boolean isThreadPoolEnabled() {
return this.jobExecutePool != null;
}
/*
* Executes job request operation. If thread pool is not created then job request is
* executed in current thread itself.
*
* @param jobExecuteCallable
* Callable object to run the job request task.
*
*/
public T execute(JobCallable<T> jobExecuteCallable) throws InterruptedException,
TimeoutException, TooManyRequestsException, ExecutionException {
/*
* The callable shouldn't be null to execute. The thread pool also should be configured
* to execute requests.
*/
assert (jobExecuteCallable != null);
assert (this.jobExecutePool != null);
String type = this.requestType.toString().toLowerCase();
String retryMessageForConcurrentRequests = "Please wait for some time before retrying "
+ "the operation. Please refer to the config " + concurrentRequestsConfigName
+ " to configure concurrent requests.";
LOG.debug("Starting new " + type + " job request with time out " + this.requestExecutionTimeoutInSec
+ "seconds.");
Future<T> future = null;
try {
future = this.jobExecutePool.submit(jobExecuteCallable);
} catch (RejectedExecutionException rejectedException) {
/*
* Not able to find thread to execute the job request. Raise Busy exception and client
* can retry the operation.
*/
String tooManyRequestsExceptionMessage = "Unable to service the " + type + " job request as "
+ "templeton service is busy with too many " + type + " job requests. "
+ retryMessageForConcurrentRequests;
LOG.warn(tooManyRequestsExceptionMessage);
throw new TooManyRequestsException(tooManyRequestsExceptionMessage);
}
T result = null;
try {
result = this.requestExecutionTimeoutInSec > 0
? future.get(this.requestExecutionTimeoutInSec, TimeUnit.SECONDS) : future.get();
} catch (TimeoutException e) {
/*
* See if the execution thread has just completed operation and result is available.
* If result is available then return the result. Otherwise, raise exception.
*/
if ((result = tryGetJobResultOrSetJobStateFailed(jobExecuteCallable)) == null) {
String message = this.requestType + " job request got timed out. Please wait for some time "
+ "before retrying the operation. Please refer to the config "
+ jobTimeoutConfigName + " to configure job request time out.";
LOG.warn(message);
/*
* Throw TimeoutException to caller.
*/
throw new TimeoutException(message);
}
} catch (InterruptedException e) {
/*
* See if the execution thread has just completed operation and result is available.
* If result is available then return the result. Otherwise, raise exception.
*/
if ((result = tryGetJobResultOrSetJobStateFailed(jobExecuteCallable)) == null) {
String message = this.requestType + " job request got interrupted. Please wait for some time "
+ "before retrying the operation.";
LOG.warn(message);
/*
* Throw TimeoutException to caller.
*/
throw new InterruptedException(message);
}
} catch (CancellationException e) {
/*
* See if the execution thread has just completed operation and result is available.
* If result is available then return the result. Otherwise, raise exception.
*/
if ((result = tryGetJobResultOrSetJobStateFailed(jobExecuteCallable)) == null) {
String message = this.requestType + " job request got cancelled and thread got interrupted. "
+ "Please wait for some time before retrying the operation.";
LOG.warn(message);
throw new InterruptedException(message);
}
} finally {
/*
* If the thread is still active and needs to be cancelled then cancel it. This may
* happen in case task got interrupted, or timed out.
*/
if (enableCancelTask) {
cancelExecutePoolThread(future);
}
}
LOG.debug("Completed " + type + " job request.");
return result;
}
/*
* Initiate cancel request to cancel the thread execution and interrupt the thread.
* If thread interruption is not handled by jobExecuteCallable then thread may continue
* running to completion. The cancel call may fail for some scenarios. In that case,
* retry the cancel call until it returns true or max retry count is reached.
*
* @param future
* Future object which has handle to cancel the thread.
*
*/
private void cancelExecutePoolThread(Future<T> future) {
int retryCount = 0;
while(retryCount < this.maxTaskCancelRetryCount && !future.isDone()) {
LOG.info("Task is still executing the job request. Cancelling it with retry count: "
+ retryCount);
if (future.cancel(true)) {
/*
* Cancelled the job request and return to client.
*/
LOG.info("Cancel job request issued successfully.");
return;
}
retryCount++;
try {
Thread.sleep(this.maxTaskCancelRetryWaitTimeInMs);
} catch (InterruptedException e) {
/*
* Nothing to do. Just retry.
*/
}
}
LOG.warn("Failed to cancel the job. isCancelled: " + future.isCancelled()
+ " Retry count: " + retryCount);
}
/*
* Tries to get the job result if job request is completed. Otherwise it sets job status
* to FAILED such that execute thread can do necessary clean up based on FAILED state.
*/
private T tryGetJobResultOrSetJobStateFailed(JobCallable<T> jobExecuteCallable) {
if (!jobExecuteCallable.setJobStateFailed()) {
LOG.info("Job is already COMPLETED. Returning the result.");
return jobExecuteCallable.returnResult;
} else {
LOG.info("Job status set to FAILED. Job clean up to be done by execute thread "
+ "after job request is executed.");
return null;
}
}
}
| 4,332 |
1,041 | <gh_stars>1000+
package org.tests.query.cache;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
public class Contract {
@Id
@GeneratedValue
protected Long id;
private String name;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "contract")
private List<Position> positions;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "container", fetch = FetchType.LAZY)
private List<AclContainerRelation> aclEntries = new ArrayList<>();
public Long getId() {
return id;
}
public void setId(final Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Position> getPositions() {
return positions;
}
public void setPositions(final List<Position> positions) {
this.positions = positions;
}
public List<AclContainerRelation> getAclEntries() {
return aclEntries;
}
public void setAclEntries(final List<AclContainerRelation> aclEntries) {
this.aclEntries = aclEntries;
}
}
| 367 |
1,587 | <reponame>jeap-rs/code-examples
package io.reflectoring.exception.repository;
import io.reflectoring.exception.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface ProductRepository extends JpaRepository<Product, String> {
}
| 103 |
17,703 | // NOLINT(namespace-envoy)
constexpr char TEST_SELFSIGNED2_ECDSA_P256_CERT_256_HASH[] =
"4a3a4a14179d8af55cd89b0613e987e49335e826da53672933ab115247416baf";
constexpr char TEST_SELFSIGNED2_ECDSA_P256_CERT_1_HASH[] =
"024359839fb45be9e70c3a01594c64d9955ce6e8";
constexpr char TEST_SELFSIGNED2_ECDSA_P256_CERT_SPKI[] =
"/dozXU2pNDFTzYxiPFcysW+ZaZP063Nn3gfc3LHjQEI=";
constexpr char TEST_SELFSIGNED2_ECDSA_P256_CERT_SERIAL[] =
"19c1d80d217a3fd9a71632378f9dc5160b438c8e";
constexpr char TEST_SELFSIGNED2_ECDSA_P256_CERT_NOT_BEFORE[] = "Aug 20 16:57:52 2020 GMT";
constexpr char TEST_SELFSIGNED2_ECDSA_P256_CERT_NOT_AFTER[] = "Aug 20 16:57:52 2022 GMT";
| 345 |
538 | #pragma once
#include "Format.h"
#include "Matcher.h"
#include "Root.h"
#include "TamSoftPS1Scanner.h"
// ****************
// TamSoftPS1Format
// ****************
#define TAMSOFTPS1_KEY_OFFSET 0
BEGIN_FORMAT(TamSoftPS1)
USING_SCANNER(TamSoftPS1Scanner)
USING_MATCHER(FilegroupMatcher)
END_FORMAT()
| 125 |
Subsets and Splits