defmodule ElixirLibxl do @moduledoc """ # [LibXL](https://www.libxl.com/) elixir port このモジュールを使用するにはLibXLのC言語ライブラリがインストールされていることが必須です。 * 必須ヘッダ /usr/local/include または /usr/include /usr/local/include/AutoFilterA.h または /usr/include/AutoFilterA.h /usr/local/include/AutoFilterW.h または /usr/include/AutoFilterW.h /usr/local/include/BookA.h または /usr/include/BookA.h /usr/local/include/BookW.h または /usr/include/BookW.h /usr/local/include/FilterColumnA.h または /usr/include/FilterColumnA.h /usr/local/include/FilterColumnW.h または /usr/include/FilterColumnW.h /usr/local/include/FontA.h または /usr/include/FontA.h /usr/local/include/FontW.h または /usr/include/FontW.h /usr/local/include/FormControlA.h または /usr/include/FormControlA.h /usr/local/include/FormControlW.h または /usr/include/FormControlW.h /usr/local/include/FormatA.h または /usr/include/FormatA.h /usr/local/include/FormatW.h または /usr/include/FormatW.h /usr/local/include/RichStringA.h または /usr/include/RichStringA.h /usr/local/include/RichStringW.h または /usr/include/RichStringW.h /usr/local/include/SheetA.h または /usr/include/SheetA.h /usr/local/include/SheetW.h または /usr/include/SheetW.h /usr/local/include/enum.h または /usr/include/enum.h /usr/local/include/handle.h または /usr/include/handle.h /usr/local/include/libxl.h または /usr/include/libxl.h /usr/local/include/setup.h または /usr/include/setup.h * 必須ライブラリ /usr/local/lib/libxl.a または /usr/lib/libxl.a /usr/local/lib/libxl.dylib または /usr/lib/libxl.dylib /usr/local/lib/libxl.so または /usr/lib/libxl.so # install ```elixir def deps do [ {:elixir_libxl, "~> 0.2.0"} ] end ``` # 基本的な使用方法 ```elixir book_handle = ElixirLibxl.xlCreateXMLBook() ElixirLibxl.xlBookLoad(book_handle, "path/to/xlsx") ElixirLibxl.xlBookRelease(book_handle) ``` # 注意点 * 定数はConstant.exに定義してありますが実際にコンパイルされた値ではないので注意してください。 * 出力用のポインタ引数の存在する関数は引数には含まずListとして、関数の戻り値と共にreturnされます。 - 例 `xlSheetMerge()`のC言語プロトタイプは`int xlSheetMerge(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast);` となっていますが本モジュールでは`@spec xlSheetMerge(reference(), integer()) :: [integer()]`となります。 # revision version: "0.2.0" libxl 4.1.0 """ @on_load {:load_nif, 0} @compile {:autoload, false} def load_nif do Application.app_dir(:elixir_libxl, "priv/libxl") |> to_charlist() |> :erlang.load_nif(0) end # ======================================================================================================================================================== # int xlAutoFilterGetRef(AutoFilterHandle handle, int* rowFirst, int* rowLast, int* colFirst, int* colLast); @spec xlAutoFilterGetRef(reference()) :: [integer()] def xlAutoFilterGetRef(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlAutoFilterSetRef(AutoFilterHandle handle, int rowFirst, int rowLast, int colFirst, int colLast); @spec xlAutoFilterSetRef(reference(), integer(), integer(), integer(), integer()) :: nil def xlAutoFilterSetRef(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # FilterColumnHandle xlAutoFilterColumn(AutoFilterHandle handle, int colId); @spec xlAutoFilterColumn(reference(), integer()) :: reference() | nil def xlAutoFilterColumn(_handle, _colId), do: :erlang.nif_error(:nif_not_loaded) # int xlAutoFilterColumnSize(AutoFilterHandle handle); @spec xlAutoFilterColumnSize(reference()) :: integer() def xlAutoFilterColumnSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # FilterColumnHandle xlAutoFilterColumnByIndex(AutoFilterHandle handle, int index); @spec xlAutoFilterColumnByIndex(reference(), integer()) :: reference() | nil def xlAutoFilterColumnByIndex(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlAutoFilterGetSortRange(AutoFilterHandle handle, int* rowFirst, int* rowLast, int* colFirst, int* colLast); @spec xlAutoFilterGetSortRange(reference()) :: [integer()] def xlAutoFilterGetSortRange(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlAutoFilterGetSort(AutoFilterHandle handle, int* columnIndex, int* descending); @spec xlAutoFilterGetSort(reference()) :: [integer()] def xlAutoFilterGetSort(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlAutoFilterSetSort(AutoFilterHandle handle, int columnIndex, int descending); @spec xlAutoFilterSetSort(reference(), integer(), integer()) :: integer() def xlAutoFilterSetSort(_handle, _columnIndex, _descending), do: :erlang.nif_error(:nif_not_loaded) # int xlAutoFilterAddSort(AutoFilterHandle handle, int columnIndex, int descending); @spec xlAutoFilterAddSort(reference(), integer(), integer()) :: integer() def xlAutoFilterAddSort(_handle, _columnIndex, _descending), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # int xlFilterColumnIndex(FilterColumnHandle handle); @spec xlFilterColumnIndex(reference()) :: integer() def xlFilterColumnIndex(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFilterColumnFilterType(FilterColumnHandle handle); @spec xlFilterColumnFilterType(reference()) :: integer() def xlFilterColumnFilterType(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFilterColumnFilterSize(FilterColumnHandle handle); @spec xlFilterColumnFilterSize(reference()) :: integer() def xlFilterColumnFilterSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFilterColumnFilter(FilterColumnHandle handle, int index); @spec xlFilterColumnFilter(reference(), integer()) :: String.t() def xlFilterColumnFilter(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # void xlFilterColumnAddFilter(FilterColumnHandle handle, const wchar_t* value); @spec xlFilterColumnAddFilter(reference(), String.t()) :: nil def xlFilterColumnAddFilter(_handle, _value), do: :erlang.nif_error(:nif_not_loaded) # int xlFilterColumnGetTop10(FilterColumnHandle handle, double* value, int* top, int* percent); @spec xlFilterColumnGetTop10(reference()) :: [any()] def xlFilterColumnGetTop10(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFilterColumnSetTop10(FilterColumnHandle handle, double value, int top, int percent); @spec xlFilterColumnSetTop10(reference(), float(), integer(), integer()) :: nil def xlFilterColumnSetTop10(_handle, _value, _top, _percent), do: :erlang.nif_error(:nif_not_loaded) # int xlFilterColumnGetCustomFilter(FilterColumnHandle handle, int* op1, const wchar_t** v1, int* op2, const wchar_t** v2, int* andOp); @spec xlFilterColumnGetCustomFilter(reference()) :: [any()] def xlFilterColumnGetCustomFilter(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFilterColumnSetCustomFilter(FilterColumnHandle handle, int op, const wchar_t* val); @spec xlFilterColumnSetCustomFilter(reference(), integer(), String.t()) :: nil def xlFilterColumnSetCustomFilter(_handle, _op, _val), do: :erlang.nif_error(:nif_not_loaded) # void xlFilterColumnSetCustomFilterEx(FilterColumnHandle handle, int op1, const wchar_t* v1, int op2, const wchar_t* v2, int andOp); @spec xlFilterColumnSetCustomFilterEx(reference(), integer(), String.t(), integer(), String.t(), integer()) :: nil def xlFilterColumnSetCustomFilterEx(_handle, _op1, _v1, _op2, _v2, _andOp), do: :erlang.nif_error(:nif_not_loaded) # void xlFilterColumnClear(FilterColumnHandle handle); @spec xlFilterColumnClear(reference()) :: nil def xlFilterColumnClear(_handle), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # int xlFontSize(FontHandle handle); @spec xlFontSize(reference()) :: integer() def xlFontSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetSize(FontHandle handle, int size); @spec xlFontSetSize(reference(), integer()) :: nil def xlFontSetSize(_handle, _size), do: :erlang.nif_error(:nif_not_loaded) # int xlFontItalic(FontHandle handle); @spec xlFontItalic(reference()) :: integer() def xlFontItalic(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetItalic(FontHandle handle, int italic); @spec xlFontSetItalic(reference(), integer()) :: nil def xlFontSetItalic(_handle, _italic), do: :erlang.nif_error(:nif_not_loaded) # int xlFontStrikeOut(FontHandle handle); @spec xlFontStrikeOut(reference()) :: integer() def xlFontStrikeOut(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetStrikeOut(FontHandle handle, int strikeOut); @spec xlFontSetStrikeOut(reference(), integer()) :: nil def xlFontSetStrikeOut(_handle, _strikeOut), do: :erlang.nif_error(:nif_not_loaded) # int xlFontColor(FontHandle handle); @spec xlFontColor(reference()) :: integer() def xlFontColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetColor(FontHandle handle, int color); @spec xlFontSetColor(reference(), integer()) :: nil def xlFontSetColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFontBold(FontHandle handle); @spec xlFontBold(reference()) :: integer() def xlFontBold(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetBold(FontHandle handle, int bold); @spec xlFontSetBold(reference(), integer()) :: nil def xlFontSetBold(_handle, _bold), do: :erlang.nif_error(:nif_not_loaded) # int xlFontScript(FontHandle handle); @spec xlFontScript(reference()) :: integer() def xlFontScript(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetScript(FontHandle handle, int script); @spec xlFontSetScript(reference(), integer()) :: nil def xlFontSetScript(_handle, _script), do: :erlang.nif_error(:nif_not_loaded) # int xlFontUnderline(FontHandle handle); @spec xlFontUnderline(reference()) :: integer() def xlFontUnderline(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetUnderline(FontHandle handle, int underline); @spec xlFontSetUnderline(reference(), integer()) :: nil def xlFontSetUnderline(_handle, _underline), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFontName(FontHandle handle); @spec xlFontName(reference()) :: integer() def xlFontName(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFontSetName(FontHandle handle, const wchar_t* name); @spec xlFontSetName(reference(), String.t()) :: nil def xlFontSetName(_handle, _name), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # int xlFormControlObjectType(FormControlHandle handle); @spec xlFormControlObjectType(reference()) :: integer() def xlFormControlObjectType(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlChecked(FormControlHandle handle); @spec xlFormControlChecked(reference()) :: integer() def xlFormControlChecked(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetChecked(FormControlHandle handle, int checked); @spec xlFormControlSetChecked(reference(), integer()) :: nil def xlFormControlSetChecked(_handle, _checked), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlFmlaGroup(FormControlHandle handle); @spec xlFormControlFmlaGroup(reference()) :: String.t() def xlFormControlFmlaGroup(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetFmlaGroup(FormControlHandle handle, const wchar_t* group); @spec xlFormControlSetFmlaGroup(reference(), String.t()) :: nil def xlFormControlSetFmlaGroup(_handle, _group), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlFmlaLink(FormControlHandle handle); @spec xlFormControlFmlaLink(reference()) :: String.t() def xlFormControlFmlaLink(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetFmlaLink(FormControlHandle handle, const wchar_t* link); @spec xlFormControlSetFmlaLink(reference(), String.t()) :: nil def xlFormControlSetFmlaLink(_handle, _link), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlFmlaRange(FormControlHandle handle); @spec xlFormControlFmlaRange(reference()) :: String.t() def xlFormControlFmlaRange(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetFmlaRange(FormControlHandle handle, const wchar_t* range); @spec xlFormControlSetFmlaRange(reference(), String.t()) :: nil def xlFormControlSetFmlaRange(_handle, _range), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlFmlaTxbx(FormControlHandle handle); @spec xlFormControlFmlaTxbx(reference()) :: String.t() def xlFormControlFmlaTxbx(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetFmlaTxbx(FormControlHandle handle, const wchar_t* txbx); @spec xlFormControlSetFmlaTxbx(reference(), String.t()) :: nil def xlFormControlSetFmlaTxbx(_handle, _txbx), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlName(FormControlHandle handle); @spec xlFormControlName(reference()) :: String.t() def xlFormControlName(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlLinkedCell(FormControlHandle handle); @spec xlFormControlLinkedCell(reference()) :: String.t() def xlFormControlLinkedCell(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlListFillRange(FormControlHandle handle); @spec xlFormControlListFillRange(reference()) :: String.t() def xlFormControlListFillRange(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlMacro(FormControlHandle handle); @spec xlFormControlMacro(reference()) :: String.t() def xlFormControlMacro(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlAltText(FormControlHandle handle); @spec xlFormControlAltText(reference()) :: String.t() def xlFormControlAltText(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlLocked(FormControlHandle handle); @spec xlFormControlLocked(reference()) :: integer() def xlFormControlLocked(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlDefaultSize(FormControlHandle handle); @spec xlFormControlDefaultSize(reference()) :: integer() def xlFormControlDefaultSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlPrint(FormControlHandle handle); @spec xlFormControlPrint(reference()) :: integer() def xlFormControlPrint(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlDisabled(FormControlHandle handle); @spec xlFormControlDisabled(reference()) :: integer() def xlFormControlDisabled(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlItem(FormControlHandle handle, int index); @spec xlFormControlItem(reference(), integer()) :: String.t() def xlFormControlItem(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlItemSize(FormControlHandle handle); @spec xlFormControlItemSize(reference()) :: integer() def xlFormControlItemSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlAddItem(FormControlHandle handle, const wchar_t* value); @spec xlFormControlAddItem(reference(), String.t()) :: nil def xlFormControlAddItem(_handle, _value), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlInsertItem(FormControlHandle handle, int index, const wchar_t* value); @spec xlFormControlInsertItem(reference(), integer(), String.t()) :: nil def xlFormControlInsertItem(_handle, _index, _value), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlClearItems(FormControlHandle handle); @spec xlFormControlClearItems(reference()) :: nil def xlFormControlClearItems(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlDropLines(FormControlHandle handle); @spec xlFormControlDropLines(reference()) :: integer() def xlFormControlDropLines(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetDropLines(FormControlHandle handle, int lines); @spec xlFormControlSetDropLines(reference(), integer()) :: nil def xlFormControlSetDropLines(_handle, _lines), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlDx(FormControlHandle handle); @spec xlFormControlDx(reference()) :: integer() def xlFormControlDx(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetDx(FormControlHandle handle, int dx); @spec xlFormControlSetDx(reference(), integer()) :: nil def xlFormControlSetDx(_handle, _dx), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlFirstButton(FormControlHandle handle); @spec xlFormControlFirstButton(reference()) :: integer() def xlFormControlFirstButton(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetFirstButton(FormControlHandle handle, int firstButton); @spec xlFormControlSetFirstButton(reference(), integer()) :: nil def xlFormControlSetFirstButton(_handle, _firstButton), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlHoriz(FormControlHandle handle); @spec xlFormControlHoriz(reference()) :: integer() def xlFormControlHoriz(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetHoriz(FormControlHandle handle, int horiz); @spec xlFormControlSetHoriz(reference(), integer()) :: nil def xlFormControlSetHoriz(_handle, _horiz), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlInc(FormControlHandle handle); @spec xlFormControlInc(reference()) :: integer() def xlFormControlInc(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetInc(FormControlHandle handle, int inc); @spec xlFormControlSetInc(reference(), integer()) :: nil def xlFormControlSetInc(_handle, _inc), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlGetMax(FormControlHandle handle); @spec xlFormControlGetMax(reference()) :: integer() def xlFormControlGetMax(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetMax(FormControlHandle handle, int max); @spec xlFormControlSetMax(reference(), integer()) :: nil def xlFormControlSetMax(_handle, _max), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlGetMin(FormControlHandle handle); @spec xlFormControlGetMin(reference()) :: integer() def xlFormControlGetMin(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetMin(FormControlHandle handle, int min); @spec xlFormControlSetMin(reference(), integer()) :: nil def xlFormControlSetMin(_handle, _min), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlFormControlMultiSel(FormControlHandle handle); @spec xlFormControlMultiSel(reference()) :: String.t() def xlFormControlMultiSel(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetMultiSel(FormControlHandle handle, const wchar_t* value); @spec xlFormControlSetMultiSel(reference(), String.t()) :: nil def xlFormControlSetMultiSel(_handle, _value), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlSel(FormControlHandle handle); @spec xlFormControlSel(reference()) :: integer() def xlFormControlSel(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormControlSetSel(FormControlHandle handle, int sel); @spec xlFormControlSetSel(reference(), integer()) :: nil def xlFormControlSetSel(_handle, _sel), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlFromAnchor(FormControlHandle handle, int* col, int* colOff, int* row, int* rowOff); @spec xlFormControlFromAnchor(reference()) :: [any()] def xlFormControlFromAnchor(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormControlToAnchor(FormControlHandle handle, int* col, int* colOff, int* row, int* rowOff); @spec xlFormControlToAnchor(reference()) :: [any()] def xlFormControlToAnchor(_handle), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # FontHandle xlFormatFont(FormatHandle handle); @spec xlFormatFont(reference()) :: reference() | nil def xlFormatFont(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatSetFont(FormatHandle handle, FontHandle fontHandle); @spec xlFormatSetFont(reference(), reference()) :: integer() def xlFormatSetFont(_handle, _fontHandle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatNumFormat(FormatHandle handle); @spec xlFormatNumFormat(reference()) :: integer() def xlFormatNumFormat(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetNumFormat(FormatHandle handle, int numFormat); @spec xlFormatSetNumFormat(reference(), integer()) :: nil def xlFormatSetNumFormat(_handle, _numFormat), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatAlignH(FormatHandle handle); @spec xlFormatAlignH(reference()) :: integer() def xlFormatAlignH(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetAlignH(FormatHandle handle, int align); @spec xlFormatSetAlignH(reference(), integer()) :: nil def xlFormatSetAlignH(_handle, _align), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatAlignV(FormatHandle handle); @spec xlFormatAlignV(reference()) :: integer() def xlFormatAlignV(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetAlignV(FormatHandle handle, int align); @spec xlFormatSetAlignV(reference(), integer()) :: nil def xlFormatSetAlignV(_handle, _align), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatWrap(FormatHandle handle); @spec xlFormatWrap(reference()) :: integer() def xlFormatWrap(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetWrap(FormatHandle handle, int wrap); @spec xlFormatSetWrap(reference(), integer()) :: nil def xlFormatSetWrap(_handle, _wrap), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatRotation(FormatHandle handle); @spec xlFormatRotation(reference()) :: integer() def xlFormatRotation(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatSetRotation(FormatHandle handle, int rotation); @spec xlFormatSetRotation(reference(), integer()) :: integer() def xlFormatSetRotation(_handle, _rotation), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatIndent(FormatHandle handle); @spec xlFormatIndent(reference()) :: integer() def xlFormatIndent(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetIndent(FormatHandle handle, int indent); @spec xlFormatSetIndent(reference(), integer()) :: nil def xlFormatSetIndent(_handle, _indent), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatShrinkToFit(FormatHandle handle); @spec xlFormatShrinkToFit(reference()) :: integer() def xlFormatShrinkToFit(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetShrinkToFit(FormatHandle handle, int shrinkToFit); @spec xlFormatSetShrinkToFit(reference(), integer()) :: nil def xlFormatSetShrinkToFit(_handle, _shrinkToFit), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorder(FormatHandle handle, int style); @spec xlFormatSetBorder(reference(), integer()) :: nil def xlFormatSetBorder(_handle, _style), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderColor(FormatHandle handle, int color); @spec xlFormatSetBorderColor(reference(), integer()) :: nil def xlFormatSetBorderColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderLeft(FormatHandle handle); @spec xlFormatBorderLeft(reference()) :: integer() def xlFormatBorderLeft(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderLeft(FormatHandle handle, int style); @spec xlFormatSetBorderLeft(reference(), integer()) :: nil def xlFormatSetBorderLeft(_handle, _style), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderRight(FormatHandle handle); @spec xlFormatBorderRight(reference()) :: integer() def xlFormatBorderRight(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderRight(FormatHandle handle, int style); @spec xlFormatSetBorderRight(reference(), integer()) :: nil def xlFormatSetBorderRight(_handle, _style), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderTop(FormatHandle handle); @spec xlFormatBorderTop(reference()) :: integer() def xlFormatBorderTop(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderTop(FormatHandle handle, int style); @spec xlFormatSetBorderTop(reference(), integer()) :: nil def xlFormatSetBorderTop(_handle, _style), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderBottom(FormatHandle handle); @spec xlFormatBorderBottom(reference()) :: integer() def xlFormatBorderBottom(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderBottom(FormatHandle handle, int style); @spec xlFormatSetBorderBottom(reference(), integer()) :: nil def xlFormatSetBorderBottom(_handle, _style), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderLeftColor(FormatHandle handle); @spec xlFormatBorderLeftColor(reference()) :: integer() def xlFormatBorderLeftColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderLeftColor(FormatHandle handle, int color); @spec xlFormatSetBorderLeftColor(reference(), integer()) :: nil def xlFormatSetBorderLeftColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderRightColor(FormatHandle handle); @spec xlFormatBorderRightColor(reference()) :: integer() def xlFormatBorderRightColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderRightColor(FormatHandle handle, int color); @spec xlFormatSetBorderRightColor(reference(), integer()) :: nil def xlFormatSetBorderRightColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderTopColor(FormatHandle handle); @spec xlFormatBorderTopColor(reference()) :: integer() def xlFormatBorderTopColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderTopColor(FormatHandle handle, int color); @spec xlFormatSetBorderTopColor(reference(), integer()) :: nil def xlFormatSetBorderTopColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderBottomColor(FormatHandle handle); @spec xlFormatBorderBottomColor(reference()) :: integer() def xlFormatBorderBottomColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderBottomColor(FormatHandle handle, int color); @spec xlFormatSetBorderBottomColor(reference(), integer()) :: nil def xlFormatSetBorderBottomColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderDiagonal(FormatHandle handle); @spec xlFormatBorderDiagonal(reference()) :: integer() def xlFormatBorderDiagonal(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderDiagonal(FormatHandle handle, int border); @spec xlFormatSetBorderDiagonal(reference(), integer()) :: nil def xlFormatSetBorderDiagonal(_handle, _border), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderDiagonalStyle(FormatHandle handle); @spec xlFormatBorderDiagonalStyle(reference()) :: integer() def xlFormatBorderDiagonalStyle(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderDiagonalStyle(FormatHandle handle, int style); @spec xlFormatSetBorderDiagonalStyle(reference(), integer()) :: nil def xlFormatSetBorderDiagonalStyle(_handle, _style), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatBorderDiagonalColor(FormatHandle handle); @spec xlFormatBorderDiagonalColor(reference()) :: integer() def xlFormatBorderDiagonalColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetBorderDiagonalColor(FormatHandle handle, int color); @spec xlFormatSetBorderDiagonalColor(reference(), integer()) :: nil def xlFormatSetBorderDiagonalColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatFillPattern(FormatHandle handle); @spec xlFormatFillPattern(reference()) :: integer() def xlFormatFillPattern(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetFillPattern(FormatHandle handle, int pattern); @spec xlFormatSetFillPattern(reference(), integer()) :: nil def xlFormatSetFillPattern(_handle, _pattern), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatPatternForegroundColor(FormatHandle handle); @spec xlFormatPatternForegroundColor(reference()) :: integer() def xlFormatPatternForegroundColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetPatternForegroundColor(FormatHandle handle, int color); @spec xlFormatSetPatternForegroundColor(reference(), integer()) :: nil def xlFormatSetPatternForegroundColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatPatternBackgroundColor(FormatHandle handle); @spec xlFormatPatternBackgroundColor(reference()) :: integer() def xlFormatPatternBackgroundColor(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetPatternBackgroundColor(FormatHandle handle, int color); @spec xlFormatSetPatternBackgroundColor(reference(), integer()) :: nil def xlFormatSetPatternBackgroundColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatLocked(FormatHandle handle); @spec xlFormatLocked(reference()) :: integer() def xlFormatLocked(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetLocked(FormatHandle handle, int locked); @spec xlFormatSetLocked(reference(), integer()) :: nil def xlFormatSetLocked(_handle, _locked), do: :erlang.nif_error(:nif_not_loaded) # int xlFormatHidden(FormatHandle handle); @spec xlFormatHidden(reference()) :: integer() def xlFormatHidden(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlFormatSetHidden(FormatHandle handle, int hidden); @spec xlFormatSetHidden(reference(), integer()) :: nil def xlFormatSetHidden(_handle, _hidden), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # FontHandle xlRichStringAddFont(RichStringHandle handle, FontHandle initFont); @spec xlRichStringAddFont(reference(), reference() | nil) :: reference() | nil def xlRichStringAddFont(_handle, _initFont), do: :erlang.nif_error(:nif_not_loaded) # void xlRichStringAddText(RichStringHandle handle, const wchar_t* text, FontHandle font); @spec xlRichStringAddText(reference(), String.t(), reference()) :: nil def xlRichStringAddText(_handle, _text, _font), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlRichStringGetText(RichStringHandle handle, int index, FontHandle* font); @spec xlRichStringGetText(reference(), integer(), reference()) :: String.t() def xlRichStringGetText(_handle, _index, _font), do: :erlang.nif_error(:nif_not_loaded) # int xlRichStringTextSize(RichStringHandle handle); @spec xlRichStringTextSize(reference()) :: integer() def xlRichStringTextSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # int xlSheetCellType(SheetHandle handle, int row, int col); @spec xlSheetCellType(reference(), integer(), integer()) :: integer() def xlSheetCellType(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetIsFormula(SheetHandle handle, int row, int col); @spec xlSheetIsFormula(reference(), integer(), integer()) :: integer() def xlSheetIsFormula(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # FormatHandle xlSheetCellFormat(SheetHandle handle, int row, int col); @spec xlSheetCellFormat(reference(), integer(), integer()) :: reference() | nil def xlSheetCellFormat(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetCellFormat(SheetHandle handle, int row, int col, FormatHandle format); @spec xlSheetSetCellFormat(reference(), integer(), integer(), reference() | nil) :: nil def xlSheetSetCellFormat(_handle, _row, _col, _format), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetReadStr(SheetHandle handle, int row, int col, FormatHandle* format); @spec xlSheetReadStr(reference(), reference(), reference()) :: [any()] def xlSheetReadStr(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteStr(SheetHandle handle, int row, int col, const wchar_t* value, FormatHandle format); @spec xlSheetWriteStr(reference(), integer(), integer(), String.t(), reference() | nil) :: integer() def xlSheetWriteStr(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteStrAsNum(SheetHandle handle, int row, int col, const wchar_t* value, FormatHandle format); @spec xlSheetWriteStrAsNum(reference(), integer(), integer(), String.t(), reference() | nil) :: integer() def xlSheetWriteStrAsNum(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # RichStringHandle xlSheetReadRichStr(SheetHandle handle, int row, int col, FormatHandle* format); @spec xlSheetReadRichStr(reference(), integer(), integer()) :: [any()] def xlSheetReadRichStr(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteRichStr(SheetHandle handle, int row, int col, RichStringHandle richString, FormatHandle format); @spec xlSheetWriteRichStr(reference(), integer(), integer(), reference(), reference() | nil) :: integer() def xlSheetWriteRichStr(_handle, _row, _col, _richString, _format), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetReadNum(SheetHandle handle, int row, int col, FormatHandle* format); @spec xlSheetReadNum(reference(), integer(), integer()) :: [any()] def xlSheetReadNum(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteNum(SheetHandle handle, int row, int col, double value, FormatHandle format); @spec xlSheetWriteNum(reference(), integer(), integer(), float(), reference() | nil) :: integer() def xlSheetWriteNum(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetReadBool(SheetHandle handle, int row, int col, FormatHandle* format); @spec xlSheetReadBool(reference(), integer(), integer()) :: [any()] def xlSheetReadBool(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteBool(SheetHandle handle, int row, int col, int value, FormatHandle format); @spec xlSheetWriteBool(reference(), integer(), integer(), integer(), reference() | nil) :: integer() def xlSheetWriteBool(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetReadBlank(SheetHandle handle, int row, int col, FormatHandle* format); @spec xlSheetReadBlank(reference(), integer(), integer()) :: [any()] def xlSheetReadBlank(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteBlank(SheetHandle handle, int row, int col, FormatHandle format); @spec xlSheetWriteBlank(reference(), integer(), integer(), reference() | nil) :: integer() def xlSheetWriteBlank(_handle, _row, _col, _format), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetReadFormula(SheetHandle handle, int row, int col, FormatHandle* format); @spec xlSheetReadFormula(reference(), integer(), integer()) :: [any()] def xlSheetReadFormula(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteFormula(SheetHandle handle, int row, int col, const wchar_t* value, FormatHandle format); @spec xlSheetWriteFormula(reference(), integer(), integer(), String.t(), reference() | nil) :: integer() def xlSheetWriteFormula(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteFormulaNum(SheetHandle handle, int row, int col, const wchar_t* expr, double value, FormatHandle format); @spec xlSheetWriteFormulaNum(reference(), integer(), integer(), String.t(), float(), reference() | nil) :: integer() def xlSheetWriteFormulaNum(_handle, _row, _col, _expr, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteFormulaStr(SheetHandle handle, int row, int col, const wchar_t* expr, const wchar_t* value, FormatHandle format); @spec xlSheetWriteFormulaStr(reference(), integer(), integer(), String.t(), String.t(), reference() | nil) :: integer() def xlSheetWriteFormulaStr(_handle, _row, _col, _expr, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetWriteFormulaBool(SheetHandle handle, int row, int col, const wchar_t* expr, int value, FormatHandle format); @spec xlSheetWriteFormulaBool(reference(), integer(), integer(), String.t(), integer(), reference() | nil) :: integer() def xlSheetWriteFormulaBool(_handle, _row, _col, _expr, _value, _format), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetReadComment(SheetHandle handle, int row, int col); @spec xlSheetReadComment(reference(), integer(), integer()) :: integer() def xlSheetReadComment(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetWriteComment(SheetHandle handle, int row, int col, const wchar_t* value, const wchar_t* author, int width, int height); @spec xlSheetWriteComment(reference(), integer(), integer(), String.t(), String.t(), integer(), integer()) :: nil def xlSheetWriteComment(_handle, _row, _col, _value, _author, _width, _height), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetRemoveComment(SheetHandle handle, int row, int col); @spec xlSheetRemoveComment(reference(), integer(), integer()) :: nil def xlSheetRemoveComment(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetIsDate(SheetHandle handle, int row, int col); @spec xlSheetIsDate(reference(),integer(), integer() ) :: integer() def xlSheetIsDate(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetIsRichStr(SheetHandle handle, int row, int col); @spec xlSheetIsRichStr(reference(),integer(), integer() ) :: integer() def xlSheetIsRichStr(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetReadError(SheetHandle handle, int row, int col); @spec xlSheetReadError(reference(),integer(), integer() ) :: integer() def xlSheetReadError(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetWriteError(SheetHandle handle, int row, int col, int error, FormatHandle format); @spec xlSheetWriteError(reference(), integer(), integer(), integer(), reference() | nil) :: nil def xlSheetWriteError(_handle, _row, _col, _error, _format), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetColWidth(SheetHandle handle, int col); @spec xlSheetColWidth(reference(), integer()) :: integer() def xlSheetColWidth(_handle, _col), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetRowHeight(SheetHandle handle, int row); @spec xlSheetRowHeight(reference(), integer()) :: integer() def xlSheetRowHeight(_handle, _row), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetColWidthPx(SheetHandle handle, int col); @spec xlSheetColWidthPx(reference(), integer()) :: integer() def xlSheetColWidthPx(_handle, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRowHeightPx(SheetHandle handle, int row); @spec xlSheetRowHeightPx(reference(), integer()) :: integer() def xlSheetRowHeightPx(_handle, _row), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetCol(SheetHandle handle, int colFirst, int colLast, double width, FormatHandle format, int hidden); @spec xlSheetSetCol(reference(), integer(), integer(), float(), reference(), integer()) :: integer() def xlSheetSetCol(_handle, _colFirst, _colLast, _width, _format, _hidden), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetRow(SheetHandle handle, int row, double height, FormatHandle format, int hidden); @spec xlSheetSetRow(reference(), integer(), float(), reference() | nil, integer()) :: integer() def xlSheetSetRow(_handle, _row, _height, _format, _hidden), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRowHidden(SheetHandle handle, int row); @spec xlSheetRowHidden(reference(), integer()) :: integer() def xlSheetRowHidden(_handle, _row), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetRowHidden(SheetHandle handle, int row, int hidden); @spec xlSheetSetRowHidden(reference(), integer(), integer()) :: integer() def xlSheetSetRowHidden(_handle, _row, _hidden), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetColHidden(SheetHandle handle, int col); @spec xlSheetColHidden(reference(), integer()) :: integer() def xlSheetColHidden(_handle, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetColHidden(SheetHandle handle, int col, int hidden); @spec xlSheetSetColHidden(reference(), integer(), integer()) :: integer() def xlSheetSetColHidden(_handle, _col, _hidden), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetMerge(SheetHandle handle, int row, int col, int* rowFirst, int* rowLast, int* colFirst, int* colLast); @spec xlSheetGetMerge(reference(), integer(), integer()) :: [any()] def xlSheetGetMerge(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetMerge(SheetHandle handle, int rowFirst, int rowLast, int colFirst, int colLast); @spec xlSheetSetMerge(reference(),integer(), integer(), integer(), integer() ) :: integer() def xlSheetSetMerge(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetDelMerge(SheetHandle handle, int row, int col); @spec xlSheetDelMerge(reference(),integer(), integer() ) :: integer() def xlSheetDelMerge(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetMergeSize(SheetHandle handle); @spec xlSheetMergeSize(reference()) :: integer() def xlSheetMergeSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetMerge(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast); @spec xlSheetMerge(reference(), integer()) :: [any()] def xlSheetMerge(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetDelMergeByIndex(SheetHandle handle, int index); @spec xlSheetDelMergeByIndex(reference(), integer()) :: integer() def xlSheetDelMergeByIndex(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPictureSize(SheetHandle handle); @spec xlSheetPictureSize(reference()) :: integer() def xlSheetPictureSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetPicture(SheetHandle handle, int index, int* rowTop, int* colLeft, int* rowBottom, int* colRight, int* width, int* height, int* offset_x, int* offset_y); @spec xlSheetGetPicture(reference(), integer()) :: [any()] def xlSheetGetPicture(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRemovePictureByIndex(SheetHandle handle, int index); @spec xlSheetRemovePictureByIndex(reference(), integer()) :: integer() def xlSheetRemovePictureByIndex(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPicture(SheetHandle handle, int row, int col, int pictureId, double scale, int offset_x, int offset_y, int pos); @spec xlSheetSetPicture(reference(), integer(), integer(), integer(), float(), integer(), integer(), integer()) :: nil def xlSheetSetPicture(_handle, _row, _col, _pictureId, _scale, _offset_x, _offset_y, _pos), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPicture2(SheetHandle handle, int row, int col, int pictureId, int width, int height, int offset_x, int offset_y, int pos); @spec xlSheetSetPicture2(reference(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer()) :: nil def xlSheetSetPicture2(_handle, _row, _col, _pictureId, _width, _height, _offset_x, _offset_y, _pos), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRemovePicture(SheetHandle handle, int row, int col); @spec xlSheetRemovePicture(reference(),integer(), integer() ) :: integer() def xlSheetRemovePicture(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetHorPageBreak(SheetHandle handle, int index); @spec xlSheetGetHorPageBreak(reference(), integer()) :: integer() def xlSheetGetHorPageBreak(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetHorPageBreakSize(SheetHandle handle); @spec xlSheetGetHorPageBreakSize(reference()) :: integer() def xlSheetGetHorPageBreakSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetVerPageBreak(SheetHandle handle, int index); @spec xlSheetGetVerPageBreak(reference(), integer()) :: integer() def xlSheetGetVerPageBreak(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetVerPageBreakSize(SheetHandle handle); @spec xlSheetGetVerPageBreakSize(reference()) :: integer() def xlSheetGetVerPageBreakSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetHorPageBreak(SheetHandle handle, int row, int pageBreak); @spec xlSheetSetHorPageBreak(reference(), integer(), integer()) :: integer() def xlSheetSetHorPageBreak(_handle, _row, _pageBreak), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetVerPageBreak(SheetHandle handle, int col, int pageBreak); @spec xlSheetSetVerPageBreak(reference(), integer(), integer()) :: integer() def xlSheetSetVerPageBreak(_handle, _col, _pageBreak), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSplit(SheetHandle handle, int row, int col); @spec xlSheetSplit(reference(), integer(), integer()) :: nil def xlSheetSplit(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSplitInfo(SheetHandle handle, int* row, int* col); @spec xlSheetSplitInfo(reference()) :: [any()] def xlSheetSplitInfo(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGroupRows(SheetHandle handle, int rowFirst, int rowLast, int collapsed); @spec xlSheetGroupRows(reference(), integer(), integer(), integer()) :: integer() def xlSheetGroupRows(_handle, _rowFirst, _rowLast, _collapsed), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGroupCols(SheetHandle handle, int colFirst, int colLast, int collapsed); @spec xlSheetGroupCols(reference(), integer(), integer(), integer()) :: integer() def xlSheetGroupCols(_handle, _colFirst, _colLast, _collapsed), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGroupSummaryBelow(SheetHandle handle); @spec xlSheetGroupSummaryBelow(reference()) :: integer() def xlSheetGroupSummaryBelow(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetGroupSummaryBelow(SheetHandle handle, int below); @spec xlSheetSetGroupSummaryBelow(reference(), integer()) :: nil def xlSheetSetGroupSummaryBelow(_handle, _below), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGroupSummaryRight(SheetHandle handle); @spec xlSheetGroupSummaryRight(reference()) :: integer() def xlSheetGroupSummaryRight(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetGroupSummaryRight(SheetHandle handle, int right); @spec xlSheetSetGroupSummaryRight(reference(), integer()) :: nil def xlSheetSetGroupSummaryRight(_handle, _right), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetClear(SheetHandle handle, int rowFirst, int rowLast, int colFirst, int colLast); @spec xlSheetClear(reference(),integer(), integer(), integer(), integer() ) :: integer() def xlSheetClear(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetInsertCol(SheetHandle handle, int colFirst, int colLast); @spec xlSheetInsertCol(reference(), integer(), integer()) :: integer() def xlSheetInsertCol(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetInsertRow(SheetHandle handle, int rowFirst, int rowLast); @spec xlSheetInsertRow(reference(), integer(), integer()) :: integer() def xlSheetInsertRow(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRemoveCol(SheetHandle handle, int colFirst, int colLast); @spec xlSheetRemoveCol(reference(), integer(), integer()) :: integer() def xlSheetRemoveCol(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRemoveRow(SheetHandle handle, int rowFirst, int rowLast); @spec xlSheetRemoveRow(reference(), integer(), integer()) :: integer() def xlSheetRemoveRow(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetInsertColAndKeepRanges(SheetHandle handle, int colFirst, int colLast); @spec xlSheetInsertColAndKeepRanges(reference(), integer(), integer()) :: integer() def xlSheetInsertColAndKeepRanges(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetInsertRowAndKeepRanges(SheetHandle handle, int rowFirst, int rowLast); @spec xlSheetInsertRowAndKeepRanges(reference(), integer(), integer()) :: integer() def xlSheetInsertRowAndKeepRanges(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRemoveColAndKeepRanges(SheetHandle handle, int colFirst, int colLast); @spec xlSheetRemoveColAndKeepRanges(reference(), integer(), integer()) :: integer() def xlSheetRemoveColAndKeepRanges(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRemoveRowAndKeepRanges(SheetHandle handle, int rowFirst, int rowLast); @spec xlSheetRemoveRowAndKeepRanges(reference(), integer(), integer()) :: integer() def xlSheetRemoveRowAndKeepRanges(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetCopyCell(SheetHandle handle, int rowSrc, int colSrc, int rowDst, int colDst); @spec xlSheetCopyCell(reference(), integer(), integer(), integer(), integer()) :: integer() def xlSheetCopyCell(_handle, _rowSrc, _colSrc, _rowDst, _colDst), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetFirstRow(SheetHandle handle); @spec xlSheetFirstRow(reference()) :: integer() def xlSheetFirstRow(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetLastRow(SheetHandle handle); @spec xlSheetLastRow(reference()) :: integer() def xlSheetLastRow(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetFirstCol(SheetHandle handle); @spec xlSheetFirstCol(reference()) :: integer() def xlSheetFirstCol(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetLastCol(SheetHandle handle); @spec xlSheetLastCol(reference()) :: integer() def xlSheetLastCol(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetFirstFilledRow(SheetHandle handle); @spec xlSheetFirstFilledRow(reference()) :: integer() def xlSheetFirstFilledRow(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetLastFilledRow(SheetHandle handle); @spec xlSheetLastFilledRow(reference()) :: integer() def xlSheetLastFilledRow(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetFirstFilledCol(SheetHandle handle); @spec xlSheetFirstFilledCol(reference()) :: integer() def xlSheetFirstFilledCol(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetLastFilledCol(SheetHandle handle); @spec xlSheetLastFilledCol(reference()) :: integer() def xlSheetLastFilledCol(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetDisplayGridlines(SheetHandle handle); @spec xlSheetDisplayGridlines(reference()) :: integer() def xlSheetDisplayGridlines(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetDisplayGridlines(SheetHandle handle, int show); @spec xlSheetSetDisplayGridlines(reference(), integer()) :: nil def xlSheetSetDisplayGridlines(_handle, _show), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPrintGridlines(SheetHandle handle); @spec xlSheetPrintGridlines(reference()) :: integer() def xlSheetPrintGridlines(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintGridlines(SheetHandle handle, int print); @spec xlSheetSetPrintGridlines(reference(), integer()) :: nil def xlSheetSetPrintGridlines(_handle, _print), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetZoom(SheetHandle handle); @spec xlSheetZoom(reference()) :: integer() def xlSheetZoom(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetZoom(SheetHandle handle, int zoom); @spec xlSheetSetZoom(reference(), integer()) :: nil def xlSheetSetZoom(_handle, _zoom), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPrintZoom(SheetHandle handle); @spec xlSheetPrintZoom(reference()) :: integer() def xlSheetPrintZoom(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintZoom(SheetHandle handle, int zoom); @spec xlSheetSetPrintZoom(reference(), integer()) :: nil def xlSheetSetPrintZoom(_handle, _zoom), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetPrintFit(SheetHandle handle, int* wPages, int* hPages); @spec xlSheetGetPrintFit(reference()) :: [any()] def xlSheetGetPrintFit(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintFit(SheetHandle handle, int wPages, int hPages); @spec xlSheetSetPrintFit(reference(), integer(), integer()) :: nil def xlSheetSetPrintFit(_handle, _wPages, _hPages), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetLandscape(SheetHandle handle); @spec xlSheetLandscape(reference()) :: integer() def xlSheetLandscape(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetLandscape(SheetHandle handle, int landscape); @spec xlSheetSetLandscape(reference(), integer()) :: nil def xlSheetSetLandscape(_handle, _landscape), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPaper(SheetHandle handle); @spec xlSheetPaper(reference()) :: integer() def xlSheetPaper(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPaper(SheetHandle handle, int paper); @spec xlSheetSetPaper(reference(), integer()) :: nil def xlSheetSetPaper(_handle, _paper), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetHeader(SheetHandle handle); @spec xlSheetHeader(reference()) :: integer() def xlSheetHeader(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetHeader(SheetHandle handle, const wchar_t* header, double margin); @spec xlSheetSetHeader(reference(), String.t(), integer()) :: integer() def xlSheetSetHeader(_handle, _header, _margin), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetHeaderMargin(SheetHandle handle); @spec xlSheetHeaderMargin(reference()) :: integer() def xlSheetHeaderMargin(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetFooter(SheetHandle handle); @spec xlSheetFooter(reference()) :: integer() def xlSheetFooter(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetFooter(SheetHandle handle, const wchar_t* footer, double margin); @spec xlSheetSetFooter(reference(), String.t(), integer()) :: integer() def xlSheetSetFooter(_handle, _footer, _margin), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetFooterMargin(SheetHandle handle); @spec xlSheetFooterMargin(reference()) :: integer() def xlSheetFooterMargin(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetHCenter(SheetHandle handle); @spec xlSheetHCenter(reference()) :: integer() def xlSheetHCenter(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetHCenter(SheetHandle handle, int hCenter); @spec xlSheetSetHCenter(reference(), integer()) :: nil def xlSheetSetHCenter(_handle, _hCenter), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetVCenter(SheetHandle handle); @spec xlSheetVCenter(reference()) :: integer() def xlSheetVCenter(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetVCenter(SheetHandle handle, int vCenter); @spec xlSheetSetVCenter(reference(), integer()) :: nil def xlSheetSetVCenter(_handle, _vCenter), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetMarginLeft(SheetHandle handle); @spec xlSheetMarginLeft(reference()) :: integer() def xlSheetMarginLeft(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetMarginLeft(SheetHandle handle, double margin); @spec xlSheetSetMarginLeft(reference(), float()) :: nil def xlSheetSetMarginLeft(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetMarginRight(SheetHandle handle); @spec xlSheetMarginRight(reference()) :: integer() def xlSheetMarginRight(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetMarginRight(SheetHandle handle, double margin); @spec xlSheetSetMarginRight(reference(), float()) :: nil def xlSheetSetMarginRight(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetMarginTop(SheetHandle handle); @spec xlSheetMarginTop(reference()) :: integer() def xlSheetMarginTop(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetMarginTop(SheetHandle handle, double margin); @spec xlSheetSetMarginTop(reference(), float()) :: nil def xlSheetSetMarginTop(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded) # double xlSheetMarginBottom(SheetHandle handle); @spec xlSheetMarginBottom(reference()) :: integer() def xlSheetMarginBottom(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetMarginBottom(SheetHandle handle, double margin); @spec xlSheetSetMarginBottom(reference(), float()) :: nil def xlSheetSetMarginBottom(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPrintRowCol(SheetHandle handle); @spec xlSheetPrintRowCol(reference()) :: integer() def xlSheetPrintRowCol(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintRowCol(SheetHandle handle, int print); @spec xlSheetSetPrintRowCol(reference(), integer()) :: nil def xlSheetSetPrintRowCol(_handle, _print), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPrintRepeatRows(SheetHandle handle, int* rowFirst, int* rowLast); @spec xlSheetPrintRepeatRows(reference()) :: [any()] def xlSheetPrintRepeatRows(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintRepeatRows(SheetHandle handle, int rowFirst, int rowLast); @spec xlSheetSetPrintRepeatRows(reference(), integer(), integer()) :: nil def xlSheetSetPrintRepeatRows(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPrintRepeatCols(SheetHandle handle, int* colFirst, int* colLast); @spec xlSheetPrintRepeatCols(reference()) :: [any()] def xlSheetPrintRepeatCols(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintRepeatCols(SheetHandle handle, int colFirst, int colLast); @spec xlSheetSetPrintRepeatCols(reference(), integer(), integer()) :: nil def xlSheetSetPrintRepeatCols(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetPrintArea(SheetHandle handle, int* rowFirst, int* rowLast, int* colFirst, int* colLast); @spec xlSheetPrintArea(reference()) :: [any()] def xlSheetPrintArea(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetPrintArea(SheetHandle handle, int rowFirst, int rowLast, int colFirst, int colLast); @spec xlSheetSetPrintArea(reference(), integer(), integer(), integer(), integer()) :: nil def xlSheetSetPrintArea(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetClearPrintRepeats(SheetHandle handle); @spec xlSheetClearPrintRepeats(reference()) :: nil def xlSheetClearPrintRepeats(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetClearPrintArea(SheetHandle handle); @spec xlSheetClearPrintArea(reference()) :: nil def xlSheetClearPrintArea(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetGetNamedRange(SheetHandle handle, const wchar_t* name, int* rowFirst, int* rowLast, int* colFirst, int* colLast, int scopeId, int* hidden); @spec xlSheetGetNamedRange(reference(), String.t(), integer()) :: [any()] def xlSheetGetNamedRange(_handle, _name, _scopedId), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetNamedRange(SheetHandle handle, const wchar_t* name, int rowFirst, int rowLast, int colFirst, int colLast, int scopeId); @spec xlSheetSetNamedRange(reference(), String.t(), integer(), integer(), integer(), integer(), integer()) :: integer() def xlSheetSetNamedRange(_handle, _name, _rowFirst, _rowLast, _colFirst, _colLast, _scopeId), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetDelNamedRange(SheetHandle handle, const wchar_t* name, int scopeId); @spec xlSheetDelNamedRange(reference(), String.t(), integer()) :: integer() def xlSheetDelNamedRange(_handle, _name, _scopeId), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetNamedRangeSize(SheetHandle handle); @spec xlSheetNamedRangeSize(reference()) :: integer() def xlSheetNamedRangeSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetNamedRange(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast, int* scopeId, int* hidden); @spec xlSheetNamedRange(reference(), integer()) :: [any()] def xlSheetNamedRange(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetTableSize(SheetHandle handle); @spec xlSheetTableSize(reference()) :: integer() def xlSheetTableSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetTable(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast, int* headerRowCount, int* totalsRowCount); @spec xlSheetTable(reference(), integer()) :: [any()] def xlSheetTable(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetHyperlinkSize(SheetHandle handle); @spec xlSheetHyperlinkSize(reference()) :: integer() def xlSheetHyperlinkSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetHyperlink(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast); @spec xlSheetHyperlink(reference(), integer()) :: [any()] def xlSheetHyperlink(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetDelHyperlink(SheetHandle handle, int index); @spec xlSheetDelHyperlink(reference(), integer()) :: integer() def xlSheetDelHyperlink(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetAddHyperlink(SheetHandle handle, const wchar_t* hyperlink, int rowFirst, int rowLast, int colFirst, int colLast); @spec xlSheetAddHyperlink(reference(), String.t(), integer(), integer(), integer(), integer()) :: nil def xlSheetAddHyperlink(_handle, _hyperlink, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetIsAutoFilter(SheetHandle handle); @spec xlSheetIsAutoFilter(reference()) :: integer() def xlSheetIsAutoFilter(_handle), do: :erlang.nif_error(:nif_not_loaded) # AutoFilterHandle xlSheetAutoFilter(SheetHandle handle); @spec xlSheetAutoFilter(reference()) :: integer() def xlSheetAutoFilter(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetApplyFilter(SheetHandle handle); @spec xlSheetApplyFilter(reference()) :: nil def xlSheetApplyFilter(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetRemoveFilter(SheetHandle handle); @spec xlSheetRemoveFilter(reference()) :: nil def xlSheetRemoveFilter(_handle), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetName(SheetHandle handle); @spec xlSheetName(reference()) :: integer() def xlSheetName(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetName(SheetHandle handle, const wchar_t* name); @spec xlSheetSetName(reference(), String.t()) :: nil def xlSheetSetName(_handle, _name), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetProtect(SheetHandle handle); @spec xlSheetProtect(reference()) :: integer() def xlSheetProtect(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetProtect(SheetHandle handle, int protect); @spec xlSheetSetProtect(reference(), integer()) :: nil def xlSheetSetProtect(_handle, _protect), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetProtectEx(SheetHandle handle, int protect, const wchar_t* password, int enhancedProtection); @spec xlSheetSetProtectEx(reference(), integer(), String.t(), integer()) :: nil def xlSheetSetProtectEx(_handle, _protect, _password, _enhancedProtection), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetHidden(SheetHandle handle); @spec xlSheetHidden(reference()) :: integer() def xlSheetHidden(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetSetHidden(SheetHandle handle, int hidden); @spec xlSheetSetHidden(reference(), integer()) :: integer() def xlSheetSetHidden(_handle, _hidden), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetGetTopLeftView(SheetHandle handle, int* row, int* col); @spec xlSheetGetTopLeftView(reference()) :: [any()] def xlSheetGetTopLeftView(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetTopLeftView(SheetHandle handle, int row, int col); @spec xlSheetSetTopLeftView(reference(), integer(), integer()) :: nil def xlSheetSetTopLeftView(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetRightToLeft(SheetHandle handle); @spec xlSheetRightToLeft(reference()) :: integer() def xlSheetRightToLeft(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetRightToLeft(SheetHandle handle, int rightToLeft); @spec xlSheetSetRightToLeft(reference(), integer()) :: nil def xlSheetSetRightToLeft(_handle, _rightToLeft), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetAutoFitArea(SheetHandle handle, int rowFirst, int colFirst, int rowLast, int colLast); @spec xlSheetSetAutoFitArea(reference(), integer(), integer(), integer(), integer()) :: nil def xlSheetSetAutoFitArea(_handle, _rowFirst, _colFirst, _rowLast, _colLast), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetAddrToRowCol(SheetHandle handle, const wchar_t* addr, int* row, int* col, int* rowRelative, int* colRelative); @spec xlSheetAddrToRowCol(reference(), String.t()) :: [any()] def xlSheetAddrToRowCol(_handle, _addr), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlSheetRowColToAddr(SheetHandle handle, int row, int col, int rowRelative, int colRelative); @spec xlSheetRowColToAddr(reference(), String.t(), String.t(), String.t(), String.t()) :: integer() def xlSheetRowColToAddr(_handle, _row, _col, _rowRelative, _colRelative), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetTabColor(SheetHandle handle, int color); @spec xlSheetSetTabColor(reference(), String.t()) :: nil def xlSheetSetTabColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetSetTabRgbColor(SheetHandle handle, int red, int green, int blue); @spec xlSheetSetTabRgbColor(reference(), String.t(), String.t(), String.t()) :: nil def xlSheetSetTabRgbColor(_handle, _red, _green, _blue), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetAddIgnoredError(SheetHandle handle, int rowFirst, int colFirst, int rowLast, int colLast, int iError); @spec xlSheetAddIgnoredError(reference(), String.t(), String.t(), String.t(), String.t(), String.t()) :: integer() def xlSheetAddIgnoredError(_handle, _rowFirst, _colFirst, _rowLast, _colLast, _iError), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetAddDataValidation(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, const wchar_t* value1, const wchar_t* value2); @spec xlSheetAddDataValidation(reference(), String.t(), String.t(), String.t(), String.t(), String.t(), String.t(), String.t(), String.t()) :: nil def xlSheetAddDataValidation(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetAddDataValidationEx(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, const wchar_t* value1, const wchar_t* value2, int allowBlank, int hideDropDown, int showInputMessage, int showErrorMessage, const wchar_t* promptTitle, const wchar_t* prompt, const wchar_t* errorTitle, const wchar_t* error, int errorStyle); @spec xlSheetAddDataValidationEx(reference(), integer(), integer(), integer(), integer(), integer(), integer(), String.t(), String.t(), integer(), integer(), integer(), integer(), String.t(), String.t(), String.t(), String.t(), integer()) :: nil def xlSheetAddDataValidationEx(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2, _allowBlank, _hideDropDown, _showInputMessage, _showErrorMessage, _promptTitle, _prompt, _errorTitle, _error, _errorStyle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetAddDataValidationDouble(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, double value1, double value2); @spec xlSheetAddDataValidationDouble(reference(), integer(), integer(), integer(), integer(), integer(), integer(), float(), float()) :: nil def xlSheetAddDataValidationDouble(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetAddDataValidationDoubleEx(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, double value1, double value2, int allowBlank, int hideDropDown, int showInputMessage, int showErrorMessage, const wchar_t* promptTitle, const wchar_t* prompt, const wchar_t* errorTitle, const wchar_t* error, int errorStyle); @spec xlSheetAddDataValidationDoubleEx(reference(), integer(), integer(), integer(), integer(), integer(), integer(), float(), float(), integer(), integer(), integer(), integer(), String.t(), String.t(), String.t(), String.t(), integer()) :: nil def xlSheetAddDataValidationDoubleEx(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2, _allowBlank, _hideDropDown, _showInputMessage, _showErrorMessage, _promptTitle, _prompt, _errorTitle, _error, _errorStyle), do: :erlang.nif_error(:nif_not_loaded) # void xlSheetRemoveDataValidations(SheetHandle handle); @spec xlSheetRemoveDataValidations(reference()) :: nil def xlSheetRemoveDataValidations(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlSheetFormControlSize(SheetHandle handle); @spec xlSheetFormControlSize(reference()) :: integer() def xlSheetFormControlSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # FormControlHandle xlSheetFormControl(SheetHandle handle, int index); @spec xlSheetFormControl(reference(), integer()) :: reference() | nil def xlSheetFormControl(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # ======================================================================================================================================================== # BookHandle xlCreateBook(void); @spec xlCreateBook() :: reference() | nil def xlCreateBook(), do: :erlang.nif_error(:nif_not_loaded) # BookHandle xlCreateXMLBook(void); @spec xlCreateXMLBook() :: reference() | nil def xlCreateXMLBook(), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoad(BookHandle handle, const wchar_t* filename); @spec xlBookLoad(reference(), String.t()) :: integer() def xlBookLoad(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded) # int xlBookSave(BookHandle handle, const wchar_t* filename); @spec xlBookSave(reference(), String.t()) :: integer() def xlBookSave(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadUsingTempFile(BookHandle handle, const wchar_t* filename, const wchar_t* tempFile); @spec xlBookLoadUsingTempFile(reference(), String.t(), String.t()) :: integer() def xlBookLoadUsingTempFile(_handle, _filename, _tempfile), do: :erlang.nif_error(:nif_not_loaded) # int xlBookSaveUsingTempFile(BookHandle handle, const wchar_t* filename, int useTempFile); @spec xlBookSaveUsingTempFile(reference(), String.t(), integer()) :: integer() def xlBookSaveUsingTempFile(_handle, _filename, _usetempfile), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadPartially(BookHandle handle, const wchar_t* filename, int sheetIndex, int firstRow, int lastRow); @spec xlBookLoadPartially(reference(), String.t(), integer(), integer(), integer()) :: integer() def xlBookLoadPartially(_handle, _filename, _sheetindex, _firstrow, _lastrow), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadPartiallyUsingTempFile(BookHandle handle, const wchar_t* filename, int sheetIndex, int firstRow, int lastRow, const wchar_t* tempFile); @spec xlBookLoadPartiallyUsingTempFile(reference(), String.t(), integer(), integer(), integer(), String.t()) :: integer() def xlBookLoadPartiallyUsingTempFile(_handle, _filename, _sheetindex, _firstrow, _lastrow, _tempfile), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadWithoutEmptyCells(BookHandle handle, const wchar_t* filename); @spec xlBookLoadWithoutEmptyCells(reference(), String.t()) :: integer() def xlBookLoadWithoutEmptyCells(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadInfo(BookHandle handle, const wchar_t* filename); @spec xlBookLoadInfo(reference(), String.t()) :: integer() def xlBookLoadInfo(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadRaw(BookHandle handle, const char* data, unsigned size); @spec xlBookLoadRaw(reference(), String.t(), integer()) :: integer() def xlBookLoadRaw(_handle, _data, _size), do: :erlang.nif_error(:nif_not_loaded) # int xlBookLoadRawPartially(BookHandle handle, const char* data, unsigned size, int sheetIndex, int firstRow, int lastRow); @spec xlBookLoadRawPartially(reference(), String.t(), integer(), integer(), integer(), integer()) :: integer() def xlBookLoadRawPartially(_handle, _data, _size, _sheetindex, _firstrow, _lastrow), do: :erlang.nif_error(:nif_not_loaded) # int xlBookSaveRaw(BookHandle handle, const char** data, unsigned* size); @spec xlBookSaveRaw(reference()) :: [any()] def xlBookSaveRaw(_handle), do: :erlang.nif_error(:nif_not_loaded) # SheetHandle xlBookAddSheet(BookHandle handle, const wchar_t* name, SheetHandle initSheet); @spec xlBookAddSheet(reference(), String.t(), reference() | nil) :: integer() def xlBookAddSheet(_handle, _name, _initsheet), do: :erlang.nif_error(:nif_not_loaded) # SheetHandle xlBookInsertSheet(BookHandle handle, int index, const wchar_t* name, SheetHandle initSheet); @spec xlBookInsertSheet(reference(), integer(), String.t(), reference() | nil) :: integer() def xlBookInsertSheet(_handle, _index, _name, _initsheet), do: :erlang.nif_error(:nif_not_loaded) # SheetHandle xlBookGetSheet(BookHandle handle, int index); @spec xlBookGetSheet(reference(), integer()) :: integer() def xlBookGetSheet(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlBookGetSheetName(BookHandle handle, int index); @spec xlBookGetSheetName(reference(), integer()) :: integer() def xlBookGetSheetName(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookSheetType(BookHandle handle, int index); @spec xlBookSheetType(reference(), integer()) :: integer() def xlBookSheetType(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookMoveSheet(BookHandle handle, int srcIndex, int dstIndex); @spec xlBookMoveSheet(reference(), integer(), integer()) :: integer() def xlBookMoveSheet(_handle, _srcindex, _dstindex), do: :erlang.nif_error(:nif_not_loaded) # int xlBookDelSheet(BookHandle handle, int index); @spec xlBookDelSheet(reference(), integer()) :: integer() def xlBookDelSheet(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookSheetCount(BookHandle handle); @spec xlBookSheetCount(reference()) :: integer() def xlBookSheetCount(_handle), do: :erlang.nif_error(:nif_not_loaded) # FormatHandle xlBookAddFormat(BookHandle handle, FormatHandle initFormat); @spec xlBookAddFormat(reference(), reference() | nil) :: integer() def xlBookAddFormat(_handle, _initformat), do: :erlang.nif_error(:nif_not_loaded) # FontHandle xlBookAddFont(BookHandle handle, FontHandle initFont); @spec xlBookAddFont(reference(), reference() | nil) :: integer() def xlBookAddFont(_handle, _initfont), do: :erlang.nif_error(:nif_not_loaded) # RichStringHandle xlBookAddRichString(BookHandle handle); @spec xlBookAddRichString(reference()) :: integer() def xlBookAddRichString(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlBookAddCustomNumFormat(BookHandle handle, const wchar_t* customNumFormat); @spec xlBookAddCustomNumFormat(reference(), String.t()) :: integer() def xlBookAddCustomNumFormat(_handle, _customnumformat), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlBookCustomNumFormat(BookHandle handle, int fmt); @spec xlBookCustomNumFormat(reference(), integer()) :: integer() def xlBookCustomNumFormat(_handle, _fmt), do: :erlang.nif_error(:nif_not_loaded) # FormatHandle xlBookFormat(BookHandle handle, int index); @spec xlBookFormat(reference(), integer()) :: integer() def xlBookFormat(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookFormatSize(BookHandle handle); @spec xlBookFormatSize(reference()) :: integer() def xlBookFormatSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # FontHandle xlBookFont(BookHandle handle, int index); @spec xlBookFont(reference(), integer()) :: integer() def xlBookFont(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookFontSize(BookHandle handle); @spec xlBookFontSize(reference()) :: integer() def xlBookFontSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # double xlBookDatePack(BookHandle handle, int year, int month, int day, int hour, int min, int sec, int msec); @spec xlBookDatePack(reference(), integer(), integer(), integer(), integer(), integer(), integer(), integer()) :: integer() def xlBookDatePack(_handle, _year, _month, _day, _hour, _min, _sec, _msec), do: :erlang.nif_error(:nif_not_loaded) # int xlBookDateUnpack(BookHandle handle, double value, int* year, int* month, int* day, int* hour, int* min, int* sec, int* msec); @spec xlBookDateUnpack(reference(), float()) :: [any()] def xlBookDateUnpack(_handle, _value), do: :erlang.nif_error(:nif_not_loaded) # int xlBookColorPack(BookHandle handle, int red, int green, int blue); @spec xlBookColorPack(reference(), integer(), integer(), integer()) :: integer() def xlBookColorPack(_handle, _red, _green, _blue), do: :erlang.nif_error(:nif_not_loaded) # void xlBookColorUnpack(BookHandle handle, int color); @spec xlBookColorUnpack(reference(), integer()) :: nil def xlBookColorUnpack(_handle, _color), do: :erlang.nif_error(:nif_not_loaded) # int xlBookActiveSheet(BookHandle handle); @spec xlBookActiveSheet(reference()) :: integer() def xlBookActiveSheet(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetActiveSheet(BookHandle handle, int index); @spec xlBookSetActiveSheet(reference(), integer()) :: nil def xlBookSetActiveSheet(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookPictureSize(BookHandle handle); @spec xlBookPictureSize(reference()) :: integer() def xlBookPictureSize(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlBookGetPicture(BookHandle handle, int index, const char** data, unsigned* size); @spec xlBookGetPicture(reference(), integer()) :: [any()] def xlBookGetPicture(_handle, _index), do: :erlang.nif_error(:nif_not_loaded) # int xlBookAddPicture(BookHandle handle, const wchar_t* filename); @spec xlBookAddPicture(reference(), String.t()) :: integer() def xlBookAddPicture(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded) # int xlBookAddPicture2(BookHandle handle, const char* data, unsigned size); @spec xlBookAddPicture2(reference(), String.t(), integer()) :: integer() def xlBookAddPicture2(_handle, _data, _size), do: :erlang.nif_error(:nif_not_loaded) # int xlBookAddPictureAsLink(BookHandle handle, const wchar_t* filename, int insert); @spec xlBookAddPictureAsLink(reference(), String.t(), integer()) :: integer() def xlBookAddPictureAsLink(_handle, _filename, _insert), do: :erlang.nif_error(:nif_not_loaded) # const wchar_t* xlBookDefaultFont(BookHandle handle, int* fontSize); @spec xlBookDefaultFont(reference()) :: [any()] def xlBookDefaultFont(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetDefaultFont(BookHandle handle, const wchar_t* fontName, int fontSize); @spec xlBookSetDefaultFont(reference(), String.t(), integer()) :: nil def xlBookSetDefaultFont(_handle, _fontname, _fontsize), do: :erlang.nif_error(:nif_not_loaded) # int xlBookRefR1C1(BookHandle handle); @spec xlBookRefR1C1(reference()) :: integer() def xlBookRefR1C1(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetRefR1C1(BookHandle handle, int refR1C1); @spec xlBookSetRefR1C1(reference(), integer()) :: nil def xlBookSetRefR1C1(_handle, _refr1c1), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetKey(BookHandle handle, const wchar_t* name, const wchar_t* key); @spec xlBookSetKey(reference(), String.t(), String.t()) :: nil def xlBookSetKey(_handle, _name, _key), do: :erlang.nif_error(:nif_not_loaded) # int xlBookRgbMode(BookHandle handle); @spec xlBookRgbMode(reference()) :: integer() def xlBookRgbMode(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetRgbMode(BookHandle handle, int rgbMode); @spec xlBookSetRgbMode(reference(), integer()) :: nil def xlBookSetRgbMode(_handle, _rgbmode), do: :erlang.nif_error(:nif_not_loaded) # int xlBookCalcMode(BookHandle handle); @spec xlBookCalcMode(reference()) :: integer() def xlBookCalcMode(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetCalcMode(BookHandle handle, int calcMode); @spec xlBookSetCalcMode(reference(), integer()) :: nil def xlBookSetCalcMode(_handle, _calcmode), do: :erlang.nif_error(:nif_not_loaded) # int xlBookVersion(BookHandle handle); @spec xlBookVersion(reference()) :: integer() def xlBookVersion(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlBookBiffVersion(BookHandle handle); @spec xlBookBiffVersion(reference()) :: integer() def xlBookBiffVersion(_handle), do: :erlang.nif_error(:nif_not_loaded) # int xlBookIsDate1904(BookHandle handle); @spec xlBookIsDate1904(reference()) :: integer() def xlBookIsDate1904(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetDate1904(BookHandle handle, int date1904); @spec xlBookSetDate1904(reference(), integer()) :: nil def xlBookSetDate1904(_handle, _date1904), do: :erlang.nif_error(:nif_not_loaded) # int xlBookIsTemplate(BookHandle handle); @spec xlBookIsTemplate(reference()) :: integer() def xlBookIsTemplate(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookSetTemplate(BookHandle handle, int tmpl); @spec xlBookSetTemplate(reference(), integer()) :: nil def xlBookSetTemplate(_handle, _tmpl), do: :erlang.nif_error(:nif_not_loaded) # int xlBookSetLocale(BookHandle handle, const char* locale); @spec xlBookSetLocale(reference(), String.t()) :: integer() def xlBookSetLocale(_handle, _locate), do: :erlang.nif_error(:nif_not_loaded) # const char* xlBookErrorMessage(BookHandle handle); @spec xlBookErrorMessage(reference()) :: String.t() def xlBookErrorMessage(_handle), do: :erlang.nif_error(:nif_not_loaded) # void xlBookRelease(BookHandle handle); @spec xlBookRelease(reference()) :: nil def xlBookRelease(_handle), do: :erlang.nif_error(:nif_not_loaded) end