gotspl

package
v0.0.0-...-5100518 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 13, 2020 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Overview

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

* Copyright 2020 Anton Globa * * 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.

Index

Constants

View Source 
const (
	BARCODE_NAME               = "BARCODE"
	BARCODE_HUMAN_READABLE_MIN = 0
	BARCODE_HUMAN_READABLE_MAX = 3
	BARCODE_ALIGNMENT_MIN      = 0
	BARCODE_ALIGNMENT_MAX      = 3
)
View Source 
const (
	DATAMATRIX_NAME     = "DMATRIX"
	DATAMATRIX_ROWS_MIN = 10
	DATAMATRIX_ROWS_MAX = 144
	DATAMATRIX_COLS_MIN = 10
	DATAMATRIX_COLS_MAX = 144
)
View Source 
const (
	TEXT_NAME = "TEXT"

	TEXT_ALIGNMENT_DEFAILT TextAlignment = iota
	TEXT_ALIGNMENT_LEFT
	TEXT_ALIGNMENT_CENTER
	TEXT_ALIGNMENT_RIGHT

	TEXT_MULTIPLIER_MIN = 1
	TEXT_MULTIPLIER_MAX = 10
)
View Source 
const (
	BACKFEED_NAME = "BACKFEED"
	BACKFEED_MIN  = 1
	BBACKFEED_MAX = 9999
)
View Source 
const (
	BACKUP_NAME = "BACKUP"
	BACKUP_MIN  = 1
	BACKUP_MAX  = 9999
)
View Source 
const (
	DENSITY_NAME         = "DENSITY"
	DENSITY_DARKNESS_MIN = 0
	DENSITY_DARKNESS_MAX = 15
)
View Source 
const (
	FEED_NAME = "FEED"
	FEED_MIN  = 1
	FEED_MAX  = 9999
)
View Source 
const (
	PRINT_NAME             = "PRINT"
	PRINT_NUMBERLABELS_MIN = 1
	PRINT_NUMBERLABELS_MAX = 999999999
	PRINT_NUMBERCOPIES_MIN = 0
	PRINT_NUMBERCOPIES_MAX = 999999999
)
View Source 
const (
	SHIFT_NAME = "SHIFT"
	SHIFT_MIN  = -300
	SHIFT_MAX  = -300
)
View Source 
const (
	SOUND_NAME         = "SOUND"
	SOUND_LEVEL_MIN    = 0
	SOUND_LEVEL_MAX    = 9
	SOUND_INTERVAL_MIN = 1
	SOUND_INTERVAL_MAX = 4095
)
View Source 
const (
	MEASUREMENT_SYSTEM_METRIC MeasurementSystem = iota + 1
	MEASUREMENT_SYSTEM_DOT
	MEASUREMENT_SYSTEM_ENGLISH

	EMPTY_SPACE           = " "
	VALUE_SEPARATOR       = ","
	EQUAL_SYMBOL          = "="
	DOUBLE_QUOTE          = "\""
	STATUS_COMMAND_PREFIX = "!"

	UNIT_MM  = "mm"
	UNIT_DOT = "dot"
	LF       = 0x0A
	CR       = 0x0D
	ESC      = 0x1B
)
View Source 
const AUTODETECT_NAME = "AUTODETECT"
View Source 
const (
	BAR_NAME = "BAR"
)
View Source 
const BLINEDETECT_NAME = "BLINEDETECT"
View Source 
const BLINE_NAME = "BLINE"
View Source 
const CLS_NAME = "CLS"
View Source 
const (
	CODEPAGE_NAME = "CODEPAGE"
)
View Source 
const CUT_NAME = "CUT"
View Source 
const (
	DELAY_NAME = "DELAY"
)
View Source 
const (
	DIRECTION_NAME = "DIRECTION"
)
View Source 
const END_NAME = "END"
View Source 
const EOJ_NAME = "EOJ"
View Source 
const EOP_NAME = "EOP"
View Source 
const FORMFEED_NAME = "FORMFEED"
View Source 
const GAPDETECT_NAME = "GAPDETECT"
View Source 
const GAP_NAME = "GAP"
View Source 
const HOME_NAME = "HOME"
View Source 
const INITIALPRINTER_NAME = "INITIALPRINTER"
View Source 
const (
	LIMITFEED_NAME = "LIMITFEED"
)
View Source 
const NET_TCP_NETWORK = "tcp"
View Source 
const OFFSET_NAME = "OFFSET"
View Source 
const (
	REFERENCE_NAME = "REFERENCE"
)
View Source 
const RUN_NAME = "RUN"
View Source 
const (
	SIZE_NAME = "SIZE"
)
View Source 
const SPEED_NAME = "SPEED"

Variables

View Source 
var (
	LINE_ENDING_BYTES = []byte{LF}
	ROTATION_ANGLES   = []int{0, 90, 180, 270}
)

Functions

func TSPLInitialize 

func TSPLInitialize(mSystem MeasurementSystem)

Types

type AutoDetectBuilder 

type AutoDetectBuilder interface {
	TSPLCommand
	PaperLength(paperLength float64) AutoDetectBuilder
	GapLength(gapLength float64) AutoDetectBuilder
}

func AutoDetectCmd 

func AutoDetectCmd() AutoDetectBuilder

type AutoDetectImpl 

type AutoDetectImpl struct {
	// contains filtered or unexported fields
}

func (AutoDetectImpl) GapLength 

func (gi AutoDetectImpl) GapLength(gapLength float64) AutoDetectBuilder

func (AutoDetectImpl) GetMessage 

func (gi AutoDetectImpl) GetMessage() ([]byte, error)

func (AutoDetectImpl) PaperLength 

func (gi AutoDetectImpl) PaperLength(paperLength float64) AutoDetectBuilder

type BackFeedBuilder 

type BackFeedBuilder interface {
	TSPLCommand
	Length(length int) BackFeedBuilder
}

func BackFeedCmd 

func BackFeedCmd() BackFeedBuilder

type BackFeedImpl 

type BackFeedImpl struct {
	// contains filtered or unexported fields
}

func (BackFeedImpl) GetMessage 

func (f BackFeedImpl) GetMessage() ([]byte, error)

func (BackFeedImpl) Length 

func (f BackFeedImpl) Length(length int) BackFeedBuilder

type BackupBuilder 

type BackupBuilder interface {
	TSPLCommand
	Length(length int) BackupBuilder
}

func BackupCmd 

func BackupCmd() BackupBuilder

type BackupImpl 

type BackupImpl struct {
	// contains filtered or unexported fields
}

func (BackupImpl) GetMessage 

func (f BackupImpl) GetMessage() ([]byte, error)

func (BackupImpl) Length 

func (f BackupImpl) Length(length int) BackupBuilder

type BarBuilder 

type BarBuilder interface {
	TSPLCommand
	XCoordinate(x int) BarBuilder
	YCoordinate(y int) BarBuilder
	Width(width int) BarBuilder
	Height(height int) BarBuilder
}

func BarCmd 

func BarCmd() BarBuilder

type BarImpl 

type BarImpl struct {
	// contains filtered or unexported fields
}

func (BarImpl) GetMessage 

func (b BarImpl) GetMessage() ([]byte, error)

func (BarImpl) Height 

func (b BarImpl) Height(height int) BarBuilder

func (BarImpl) Width 

func (b BarImpl) Width(width int) BarBuilder

func (BarImpl) XCoordinate 

func (b BarImpl) XCoordinate(x int) BarBuilder

func (BarImpl) YCoordinate 

func (b BarImpl) YCoordinate(y int) BarBuilder

type BarcodeBuilder 

type BarcodeBuilder interface {
	TSPLCommand
	XCoordinate(x int) BarcodeBuilder
	YCoordinate(y int) BarcodeBuilder
	Height(height int) BarcodeBuilder
	CodeType(codeType string) BarcodeBuilder
	HumanReadable(humanReadable int) BarcodeBuilder
	Rotation(angle int) BarcodeBuilder
	Narrow(narrow int) BarcodeBuilder
	Wide(wide int) BarcodeBuilder
	Alignment(align int) BarcodeBuilder
	Content(content string, quote bool) BarcodeBuilder
}

func BarcodeCmd 

func BarcodeCmd() BarcodeBuilder

type BarcodeImpl 

type BarcodeImpl struct {
	// contains filtered or unexported fields
}

func (BarcodeImpl) Alignment 

func (b BarcodeImpl) Alignment(align int) BarcodeBuilder

func (BarcodeImpl) CodeType 

func (b BarcodeImpl) CodeType(codeType string) BarcodeBuilder

func (BarcodeImpl) Content 

func (b BarcodeImpl) Content(content string, quote bool) BarcodeBuilder

func (BarcodeImpl) GetMessage 

func (b BarcodeImpl) GetMessage() ([]byte, error)

func (BarcodeImpl) Height 

func (b BarcodeImpl) Height(height int) BarcodeBuilder

func (BarcodeImpl) HumanReadable 

func (b BarcodeImpl) HumanReadable(humanReadable int) BarcodeBuilder

func (BarcodeImpl) Narrow 

func (b BarcodeImpl) Narrow(narrow int) BarcodeBuilder

func (BarcodeImpl) Rotation 

func (b BarcodeImpl) Rotation(angle int) BarcodeBuilder

func (BarcodeImpl) Wide 

func (b BarcodeImpl) Wide(wide int) BarcodeBuilder

func (BarcodeImpl) XCoordinate 

func (b BarcodeImpl) XCoordinate(x int) BarcodeBuilder

func (BarcodeImpl) YCoordinate 

func (b BarcodeImpl) YCoordinate(y int) BarcodeBuilder

type BlineBuilder 

type BlineBuilder interface {
	TSPLCommand
	LineHeight(lineHeight float64) BlineBuilder
	FeedingLength(feedingLength float64) BlineBuilder
}

func BlineCmd 

func BlineCmd() BlineBuilder

type BlineDetectBuilder 

type BlineDetectBuilder interface {
	TSPLCommand
	PaperLength(paperLength float64) BlineDetectBuilder
	GapLength(gapLength float64) BlineDetectBuilder
}

func BlineDetectCmd 

func BlineDetectCmd() BlineDetectBuilder

type BlineDetectImpl 

type BlineDetectImpl struct {
	// contains filtered or unexported fields
}

func (BlineDetectImpl) GapLength 

func (gi BlineDetectImpl) GapLength(gapLength float64) BlineDetectBuilder

func (BlineDetectImpl) GetMessage 

func (gi BlineDetectImpl) GetMessage() ([]byte, error)

func (BlineDetectImpl) PaperLength 

func (gi BlineDetectImpl) PaperLength(paperLength float64) BlineDetectBuilder

type BlineImpl 

type BlineImpl struct {
	// contains filtered or unexported fields
}

func (BlineImpl) FeedingLength 

func (gi BlineImpl) FeedingLength(feedingLength float64) BlineBuilder

func (BlineImpl) GetMessage 

func (gi BlineImpl) GetMessage() ([]byte, error)

func (BlineImpl) LineHeight 

func (gi BlineImpl) LineHeight(lineHeight float64) BlineBuilder

type ClsBuilder 

type ClsBuilder interface {
	TSPLCommand
}

func ClsCmd 

func ClsCmd() ClsBuilder

type ClsImpl 

type ClsImpl struct {
}

func (ClsImpl) GetMessage 

func (c ClsImpl) GetMessage() ([]byte, error)

type CodePageBuilder 

type CodePageBuilder interface {
	TSPLCommand
	CodePage(codePage string) CodePageBuilder
}

func CodePageCmd 

func CodePageCmd() CodePageBuilder

type CodePageImpl 

type CodePageImpl struct {
	// contains filtered or unexported fields
}

func (CodePageImpl) CodePage 

func (c CodePageImpl) CodePage(codePage string) CodePageBuilder

func (CodePageImpl) GetMessage 

func (c CodePageImpl) GetMessage() ([]byte, error)

type ConfigParam 

type ConfigParam string
const (
	RESPONSE_OFF   ConfigParam = "RESPONSE OFF"
	RESPONSE_ON    ConfigParam = "RESPONSE ON"
	PEEL_ON        ConfigParam = "PEEL ON"
	PEEL_OFF       ConfigParam = "PEEL ON"
	BACK_ON        ConfigParam = "BACK ON"
	BACK_OFF       ConfigParam = "BACK OFF"
	TEAR_ON        ConfigParam = "TEAR ON"
	TEAR_OFF       ConfigParam = "TEAR OFF"
	STRIPER_ON     ConfigParam = "STRIPER ON"
	STRIPER_OFF    ConfigParam = "STRIPER OFF"
	REWIND_ON      ConfigParam = "REWIND ON"
	REWIND_OFF     ConfigParam = "REWIND OFF"
	REWIND_RS232   ConfigParam = "REWIND RS232"
	BLINE_REVERSE  ConfigParam = "BLINE REVERSE"
	BLINE_OBVERSE  ConfigParam = "BLINE OBVERSE"
	HEAD_OFF       ConfigParam = "HEAD OFF"
	HEAD_ON        ConfigParam = "HEAD ON"
	RIBBON_ON      ConfigParam = "RIBBON ON"
	RIBBON_OFF     ConfigParam = "RIBBON OFF"
	RIBBON_INSIDE  ConfigParam = "RIBBON INSIDE"
	RIBBON_OUTSIDE ConfigParam = "RIBBON OUTSIDE"
)

func (ConfigParam) GetMessage 

func (r ConfigParam) GetMessage() ([]byte, error)

type CountryCommand 

type CountryCommand string
const (
	COUNTRY_NAME                                  = "COUNTRY"
	COUNTRY_USA                    CountryCommand = "001"
	COUNTRY_CANADIAN_FRENCH        CountryCommand = "002"
	COUNTRY_SPANISH_LATHIN_AMERICA CountryCommand = "003"
	COUNTRY_DUTCH                  CountryCommand = "031"
	COUNTRY_BELGIAN                CountryCommand = "032"
	COUNTRY_FRENCH_FRANCE          CountryCommand = "033"
	COUNTRY_SPANISH_SPAIN          CountryCommand = "034"
	COUNTRY_HUNGARIAN              CountryCommand = "036"
	COUNTRY_YUGOSLAVIAN            CountryCommand = "038"
	COUNTRY_ITALIAN                CountryCommand = "039"
	COUNTRY_SWITZERLAND            CountryCommand = "041"
	COUNTRY_SLOVAK                 CountryCommand = "042"
	COUNTRY_UNITED_KINGDOM         CountryCommand = "044"
	COUNTRY_DANISH                 CountryCommand = "045"
	COUNTRY_SWEDISH                CountryCommand = "046"
	COUNTRY_NORWEGIAN              CountryCommand = "047"
	COUNTRY_POLISH                 CountryCommand = "048"
	COUNTRY_GERMAN                 CountryCommand = "049"
	COUNTRY_BRAZIL                 CountryCommand = "055"
	COUNTRY_ENGLISH_INTERNATIONAL  CountryCommand = "061"
	COUNTRY_PORTUGUESE             CountryCommand = "351"
	COUNTRY_FINNISH                CountryCommand = "358"
)

func (CountryCommand) GetMessage 

func (cc CountryCommand) GetMessage() ([]byte, error)

type CutBuilder 

type CutBuilder interface {
	TSPLCommand
}

func CutCmd 

func CutCmd() CutBuilder

type CutImpl 

type CutImpl struct {
}

func (CutImpl) GetMessage 

func (c CutImpl) GetMessage() ([]byte, error)

type DataMatrixBuilder 

type DataMatrixBuilder interface {
	TSPLCommand
	XCoordinate(x int) DataMatrixBuilder
	YCoordinate(y int) DataMatrixBuilder
	Width(width int) DataMatrixBuilder
	Height(height int) DataMatrixBuilder
	EscapeSequenceCharacter(chr int) DataMatrixBuilder
	ModuleSize(size int) DataMatrixBuilder
	Rotation(angle int) DataMatrixBuilder
	IsRectangle(rectangle bool) DataMatrixBuilder
	NumberCols(cols int) DataMatrixBuilder
	NumberRows(rows int) DataMatrixBuilder
	Content(content string, quote bool) DataMatrixBuilder
}

func DataMatrixCmd 

func DataMatrixCmd() DataMatrixBuilder

type DataMatrixImpl 

type DataMatrixImpl struct {
	// contains filtered or unexported fields
}

func (DataMatrixImpl) Content 

func (d DataMatrixImpl) Content(content string, quote bool) DataMatrixBuilder

func (DataMatrixImpl) EscapeSequenceCharacter 

func (d DataMatrixImpl) EscapeSequenceCharacter(chr int) DataMatrixBuilder

func (DataMatrixImpl) GetMessage 

func (d DataMatrixImpl) GetMessage() ([]byte, error)

func (DataMatrixImpl) Height 

func (d DataMatrixImpl) Height(height int) DataMatrixBuilder

func (DataMatrixImpl) IsRectangle 

func (d DataMatrixImpl) IsRectangle(rectangle bool) DataMatrixBuilder

func (DataMatrixImpl) ModuleSize 

func (d DataMatrixImpl) ModuleSize(size int) DataMatrixBuilder

func (DataMatrixImpl) NumberCols 

func (d DataMatrixImpl) NumberCols(cols int) DataMatrixBuilder

func (DataMatrixImpl) NumberRows 

func (d DataMatrixImpl) NumberRows(rows int) DataMatrixBuilder

func (DataMatrixImpl) Rotation 

func (d DataMatrixImpl) Rotation(angle int) DataMatrixBuilder

func (DataMatrixImpl) Width 

func (d DataMatrixImpl) Width(width int) DataMatrixBuilder

func (DataMatrixImpl) XCoordinate 

func (d DataMatrixImpl) XCoordinate(x int) DataMatrixBuilder

func (DataMatrixImpl) YCoordinate 

func (d DataMatrixImpl) YCoordinate(y int) DataMatrixBuilder

type DelayBuilder 

type DelayBuilder interface {
	TSPLCommand
	Duration(duration int) DelayBuilder
}

func DelayCmd 

func DelayCmd() DelayBuilder

type DelayImpl 

type DelayImpl struct {
	// contains filtered or unexported fields
}

func (DelayImpl) Duration 

func (d DelayImpl) Duration(duration int) DelayBuilder

func (DelayImpl) GetMessage 

func (d DelayImpl) GetMessage() ([]byte, error)

type DensityBuilder 

type DensityBuilder interface {
	TSPLCommand
	Darkness(darkness int) DensityBuilder
}

func DensityCmd 

func DensityCmd() DensityBuilder

type DensityImpl 

type DensityImpl struct {
	// contains filtered or unexported fields
}

func (DensityImpl) Darkness 

func (di DensityImpl) Darkness(darkness int) DensityBuilder

func (DensityImpl) GetMessage 

func (di DensityImpl) GetMessage() ([]byte, error)

type DirectionBuilder 

type DirectionBuilder interface {
	TSPLCommand
	Direction(direction bool) DirectionBuilder
	Mirror(mirror bool) DirectionBuilder
}

func DirectionCmd 

func DirectionCmd() DirectionBuilder

type DirectionImpl 

type DirectionImpl struct {
	// contains filtered or unexported fields
}

func (DirectionImpl) Direction 

func (d DirectionImpl) Direction(direction bool) DirectionBuilder

func (DirectionImpl) GetMessage 

func (d DirectionImpl) GetMessage() ([]byte, error)

func (DirectionImpl) Mirror 

func (d DirectionImpl) Mirror(mirror bool) DirectionBuilder

type DownloadBuilder 

type DownloadBuilder interface {
	TSPLCommand
	Storage(storage DownloadStorage) DownloadBuilder
	Name(name string) DownloadBuilder
}

func DownloadCmd 

func DownloadCmd() DownloadBuilder

type DownloadImpl 

type DownloadImpl struct {
	// contains filtered or unexported fields
}

func (DownloadImpl) GetMessage 

func (d DownloadImpl) GetMessage() ([]byte, error)

func (DownloadImpl) Name 

func (d DownloadImpl) Name(name string) DownloadBuilder

func (DownloadImpl) Storage 

func (d DownloadImpl) Storage(storage DownloadStorage) DownloadBuilder

type DownloadStorage 

type DownloadStorage string
const (
	DOWNLOAD_NAME                                     = "DOWNLOAD"
	DOWNLOAD_STORGAE_DRAM             DownloadStorage = ""
	DOWNLOAD_STORAGE_FLASH            DownloadStorage = "F"
	DOWNLOAD_STORAGE_EXPANSION_MODULE DownloadStorage = "E"
)

type EndBuilder 

type EndBuilder interface {
	TSPLCommand
}

func EndCmd 

func EndCmd() EndBuilder

type EndImpl 

type EndImpl struct {
}

func (EndImpl) GetMessage 

func (c EndImpl) GetMessage() ([]byte, error)

type EojBuilder 

type EojBuilder interface {
	TSPLCommand
}

func EojCmd 

func EojCmd() EojBuilder

type EojImpl 

type EojImpl struct {
}

func (EojImpl) GetMessage 

func (c EojImpl) GetMessage() ([]byte, error)

type EopBuilder 

type EopBuilder interface {
	TSPLCommand
}

type EopImpl 

type EopImpl struct {
}

func (EopImpl) GetMessage 

func (h EopImpl) GetMessage() ([]byte, error)

type EthernetTSPLClient 

type EthernetTSPLClient struct {
	// contains filtered or unexported fields
}

func (*EthernetTSPLClient) AddResponseListener 

func (c *EthernetTSPLClient) AddResponseListener(listener chan *RawResponseEvent)

func (*EthernetTSPLClient) Connect 

func (c *EthernetTSPLClient) Connect() error

func (*EthernetTSPLClient) Disconnect 

func (c *EthernetTSPLClient) Disconnect() error

func (*EthernetTSPLClient) IsConnected 

func (c *EthernetTSPLClient) IsConnected() bool

func (*EthernetTSPLClient) ReadData 

func (c *EthernetTSPLClient) ReadData(data []byte) (int, error)

func (*EthernetTSPLClient) SendCommand 

func (c *EthernetTSPLClient) SendCommand(command TSPLCommand) error

func (*EthernetTSPLClient) SendCommandSequence 

func (c *EthernetTSPLClient) SendCommandSequence(commandSequence TSPLCommandSequence) error

func (*EthernetTSPLClient) SendData 

func (c *EthernetTSPLClient) SendData(data []byte) error

type FeedBuilder 

type FeedBuilder interface {
	TSPLCommand
	Length(length int) FeedBuilder
}

func FeedCmd 

func FeedCmd() FeedBuilder

type FeedImpl 

type FeedImpl struct {
	// contains filtered or unexported fields
}

func (FeedImpl) GetMessage 

func (f FeedImpl) GetMessage() ([]byte, error)

func (FeedImpl) Length 

func (f FeedImpl) Length(length int) FeedBuilder

type FormFeedBuilder 

type FormFeedBuilder interface {
	TSPLCommand
}

func FormFeedCmd 

func FormFeedCmd() FormFeedBuilder

type FormFeedImpl 

type FormFeedImpl struct {
}

func (FormFeedImpl) GetMessage 

func (c FormFeedImpl) GetMessage() ([]byte, error)

type GapBuilder 

type GapBuilder interface {
	TSPLCommand
	LabelDistance(labelDistance float64) GapBuilder
	LabelOffsetDistance(labelOffsetDistance float64) GapBuilder
}

func GapCmd 

func GapCmd() GapBuilder

type GapDetectBuilder 

type GapDetectBuilder interface {
	TSPLCommand
	PaperLength(paperLength float64) GapDetectBuilder
	GapLength(gapLength float64) GapDetectBuilder
}

func GapDetectCmd 

func GapDetectCmd() GapDetectBuilder

type GapDetectImpl 

type GapDetectImpl struct {
	// contains filtered or unexported fields
}

func (GapDetectImpl) GapLength 

func (gi GapDetectImpl) GapLength(gapLength float64) GapDetectBuilder

func (GapDetectImpl) GetMessage 

func (gi GapDetectImpl) GetMessage() ([]byte, error)

func (GapDetectImpl) PaperLength 

func (gi GapDetectImpl) PaperLength(paperLength float64) GapDetectBuilder

type GapImpl 

type GapImpl struct {
	// contains filtered or unexported fields
}

func (GapImpl) GetMessage 

func (gi GapImpl) GetMessage() ([]byte, error)

func (GapImpl) LabelDistance 

func (gi GapImpl) LabelDistance(labelDistance float64) GapBuilder

func (GapImpl) LabelOffsetDistance 

func (gi GapImpl) LabelOffsetDistance(labelOffsetDistance float64) GapBuilder

type HomeBuilder 

type HomeBuilder interface {
	TSPLCommand
}

func EopCmd 

func EopCmd() HomeBuilder

func HomeCmd 

func HomeCmd() HomeBuilder

type HomeImpl 

type HomeImpl struct {
}

func (HomeImpl) GetMessage 

func (h HomeImpl) GetMessage() ([]byte, error)

type InitialPrinterBuilder 

type InitialPrinterBuilder interface {
	TSPLCommand
}

func InitialPrinterCmd 

func InitialPrinterCmd() InitialPrinterBuilder

type InitialPrinterImpl 

type InitialPrinterImpl struct {
}

func (InitialPrinterImpl) GetMessage 

func (c InitialPrinterImpl) GetMessage() ([]byte, error)

type LimitFeedBuilder 

type LimitFeedBuilder interface {
	TSPLCommand
	LengthSensorDetect(length float64) LimitFeedBuilder
	LengthPaper(length float64) LimitFeedBuilder
	LengthGap(length float64) LimitFeedBuilder
}

func LimitFeedCmd 

func LimitFeedCmd() LimitFeedBuilder

type LimitFeedImpl 

type LimitFeedImpl struct {
	// contains filtered or unexported fields
}

func (LimitFeedImpl) GetMessage 

func (l LimitFeedImpl) GetMessage() ([]byte, error)

func (LimitFeedImpl) LengthGap 

func (l LimitFeedImpl) LengthGap(length float64) LimitFeedBuilder

func (LimitFeedImpl) LengthPaper 

func (l LimitFeedImpl) LengthPaper(length float64) LimitFeedBuilder

func (LimitFeedImpl) LengthSensorDetect 

func (l LimitFeedImpl) LengthSensorDetect(length float64) LimitFeedBuilder

type MeasurementSystem 

type MeasurementSystem int

type OffSetBuilder 

type OffSetBuilder interface {
	TSPLCommand
	Distance(distance float64) OffSetBuilder
}

func OffSetCmd 

func OffSetCmd() OffSetBuilder

type OffSetImpl 

type OffSetImpl struct {
	// contains filtered or unexported fields
}

func (OffSetImpl) Distance 

func (os OffSetImpl) Distance(distance float64) OffSetBuilder

func (OffSetImpl) GetMessage 

func (os OffSetImpl) GetMessage() ([]byte, error)

type PrintBuilder 

type PrintBuilder interface {
	TSPLCommand
	NumberLabels(numberLabels int) PrintBuilder
	NumberCopies(numberCopies int) PrintBuilder
}

func PrintCmd 

func PrintCmd() PrintBuilder

type PrintImpl 

type PrintImpl struct {
	// contains filtered or unexported fields
}

func (PrintImpl) GetMessage 

func (p PrintImpl) GetMessage() ([]byte, error)

func (PrintImpl) NumberCopies 

func (p PrintImpl) NumberCopies(numberCopies int) PrintBuilder

func (PrintImpl) NumberLabels 

func (p PrintImpl) NumberLabels(numberLabels int) PrintBuilder

type PrinterEvent 

type PrinterEvent interface {
	RawValue() []byte
	EventType() reflect.Type
	Value() interface{}
}

type RawResponseEvent 

type RawResponseEvent struct {
	Size int
	Data []byte
}

type ReferenceBuilder 

type ReferenceBuilder interface {
	TSPLCommand
	Horizontal(horizontal int) ReferenceBuilder
	Vertical(vertical int) ReferenceBuilder
}

func ReferenceCmd 

func ReferenceCmd() ReferenceBuilder

type ReferenceImpl 

type ReferenceImpl struct {
	// contains filtered or unexported fields
}

func (ReferenceImpl) GetMessage 

func (r ReferenceImpl) GetMessage() ([]byte, error)

func (ReferenceImpl) Horizontal 

func (r ReferenceImpl) Horizontal(horizontal int) ReferenceBuilder

func (ReferenceImpl) Vertical 

func (r ReferenceImpl) Vertical(vertical int) ReferenceBuilder

type ResponseEvent 

type ResponseEvent struct {
	ErrorCode int
	Count     int
	IDString  string
}

type RunBuilder 

type RunBuilder interface {
	TSPLCommand
	File(name string) RunBuilder
}

func RunCmd 

func RunCmd() RunBuilder

type RunImpl 

type RunImpl struct {
	// contains filtered or unexported fields
}

func (RunImpl) File 

func (r RunImpl) File(name string) RunBuilder

func (RunImpl) GetMessage 

func (r RunImpl) GetMessage() ([]byte, error)

type SelfTestCommand 

type SelfTestCommand string
const (
	SELFTEST_NAME                     = "SELFTEST"
	SELFTEST          SelfTestCommand = ""
	SELFTEST_PATTERN  SelfTestCommand = "PATTERN"
	SELFTEST_ETHERNET SelfTestCommand = "ETHERNET"
	SELFTEST_WLAN     SelfTestCommand = "WLAN"
	SELFTEST_RS232    SelfTestCommand = "RS232"
	SELFTEST_SYSTEM   SelfTestCommand = "SYSTEM"
	SELFTEST_Z        SelfTestCommand = "Z"
	SELFTEST_BT       SelfTestCommand = "BT"
)

func (SelfTestCommand) GetMessage 

func (st SelfTestCommand) GetMessage() ([]byte, error)

type ShiftBuilder 

type ShiftBuilder interface {
	TSPLCommand
	Horizontal(horizontal int) ShiftBuilder
	Vertical(vertical int) ShiftBuilder
}

func ShiftCmd 

func ShiftCmd() ShiftBuilder

type ShiftImpl 

type ShiftImpl struct {
	// contains filtered or unexported fields
}

func (ShiftImpl) GetMessage 

func (s ShiftImpl) GetMessage() ([]byte, error)

func (ShiftImpl) Horizontal 

func (s ShiftImpl) Horizontal(horizontal int) ShiftBuilder

func (ShiftImpl) Vertical 

func (s ShiftImpl) Vertical(vertical int) ShiftBuilder

type SizeBuilder 

type SizeBuilder interface {
	TSPLCommand
	LabelWidth(labelWidth float64) SizeBuilder
	LabelLength(labelLength float64) SizeBuilder
}

func SizeCmd 

func SizeCmd() SizeBuilder

type SizeImpl 

type SizeImpl struct {
	// contains filtered or unexported fields
}

func (SizeImpl) GetMessage 

func (si SizeImpl) GetMessage() ([]byte, error)

func (SizeImpl) LabelLength 

func (si SizeImpl) LabelLength(labelLength float64) SizeBuilder

func (SizeImpl) LabelWidth 

func (si SizeImpl) LabelWidth(labelWidth float64) SizeBuilder

type SoundBuilder 

type SoundBuilder interface {
	TSPLCommand
	VolumeLevel(volumeLevel int) SoundBuilder
	TimingInterval(timingInterval int) SoundBuilder
}

func SoundCmd 

func SoundCmd() SoundBuilder

type SoundImpl 

type SoundImpl struct {
	// contains filtered or unexported fields
}

func (SoundImpl) GetMessage 

func (s SoundImpl) GetMessage() ([]byte, error)

func (SoundImpl) TimingInterval 

func (s SoundImpl) TimingInterval(timingInterval int) SoundBuilder

func (SoundImpl) VolumeLevel 

func (s SoundImpl) VolumeLevel(volumeLevel int) SoundBuilder

type SpeedBuilder 

type SpeedBuilder interface {
	TSPLCommand
	PrintSpeed(printSpeed float64) SpeedBuilder
}

func SpeedCmd 

func SpeedCmd() SpeedBuilder

type SpeedImpl 

type SpeedImpl struct {
	// contains filtered or unexported fields
}

func (SpeedImpl) GetMessage 

func (s SpeedImpl) GetMessage() ([]byte, error)

func (SpeedImpl) PrintSpeed 

func (s SpeedImpl) PrintSpeed(printSpeed float64) SpeedBuilder

type StatusCommand 

type StatusCommand string
const (
	PAUSE           StatusCommand = "P"
	CANCEL_PAUSE    StatusCommand = "O"
	CANCEL_PRINTING StatusCommand = "."
)

func (StatusCommand) GetMessage 

func (s StatusCommand) GetMessage() ([]byte, error)

type TSPLClient 

type TSPLClient interface {
	Connect() error
	Disconnect() error
	SendData(data []byte) error
	ReadData(data []byte) (int, error)
	SendCommandSequence(commandSequence TSPLCommandSequence) error
	SendCommand(command TSPLCommand) error
	IsConnected() bool
	AddResponseListener(listener chan *RawResponseEvent)
}

func NewEthernetTSPLClient 

func NewEthernetTSPLClient(address string) TSPLClient

func NewTcpTSPLClient 

func NewTcpTSPLClient(address string, measurementSystem MeasurementSystem) TSPLClient

type TSPLCommand 

type TSPLCommand interface {
	GetMessage() ([]byte, error)
}

type TSPLCommandSequence 

type TSPLCommandSequence interface {
	// contains filtered or unexported methods
}

type TSPLLabel 

type TSPLLabel struct {
	// contains filtered or unexported fields
}

func (TSPLLabel) Cmd 

func (T TSPLLabel) Cmd(command TSPLCommand) TSPLLabelBuilder

type TSPLLabelBuilder 

type TSPLLabelBuilder interface {
	TSPLCommandSequence
	Cmd(command TSPLCommand) TSPLLabelBuilder
}

func NewTSPLLabel 

func NewTSPLLabel() TSPLLabelBuilder

type TextAlignment 

type TextAlignment int

type TextBuilder 

type TextBuilder interface {
	TSPLCommand
	XCoordinate(x int) TextBuilder
	YCoordinate(y int) TextBuilder
	FontName(name string) TextBuilder
	Rotation(angle int) TextBuilder
	XMultiplier(xm float64) TextBuilder
	YMultiplier(ym float64) TextBuilder
	Alignment(align TextAlignment) TextBuilder
	Content(content string, quote bool) TextBuilder
}

func Text 

func Text() TextBuilder

type TextImpl 

type TextImpl struct {
	// contains filtered or unexported fields
}

func (TextImpl) Alignment 

func (t TextImpl) Alignment(align TextAlignment) TextBuilder

func (TextImpl) Content 

func (t TextImpl) Content(content string, quote bool) TextBuilder

func (TextImpl) FontName 

func (t TextImpl) FontName(name string) TextBuilder

func (TextImpl) GetMessage 

func (t TextImpl) GetMessage() ([]byte, error)

func (TextImpl) Rotation 

func (t TextImpl) Rotation(angle int) TextBuilder

func (TextImpl) XCoordinate 

func (t TextImpl) XCoordinate(x int) TextBuilder

func (TextImpl) XMultiplier 

func (t TextImpl) XMultiplier(xm float64) TextBuilder

func (TextImpl) YCoordinate 

func (t TextImpl) YCoordinate(y int) TextBuilder

func (TextImpl) YMultiplier 

func (t TextImpl) YMultiplier(ym float64) TextBuilder

type VariableBuilder 

type VariableBuilder interface {
	TSPLCommand
	Name(name string) VariableBuilder
	Value(value string, quote bool) VariableBuilder
}

func IntVariable 

func IntVariable(name string, value int) VariableBuilder

func StringVariable 

func StringVariable(name string, value string) VariableBuilder

func Variable 

func Variable(name string, value string, quote bool) VariableBuilder

func VariableCmd 

func VariableCmd() VariableBuilder

type VariableImpl 

type VariableImpl struct {
	// contains filtered or unexported fields
}

func (VariableImpl) GetMessage 

func (v VariableImpl) GetMessage() ([]byte, error)

func (VariableImpl) Name 

func (v VariableImpl) Name(name string) VariableBuilder

func (VariableImpl) Value 

func (v VariableImpl) Value(value string, quote bool) VariableBuilder

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.