Ktlo

Получение объекта изображения:

Image = Object.Image{xPos=number, yPos=number, Image=table or string[, Term=table, Width=number, Height=number, xOffset=number, yOffset=number, BackgroundColor=number, BorderStyle=string, BorderColor=number, LinesColor=number, Visible=boolean]} 

Обязательные аргументы:

• xPos и yPos — положение верхнего, левого угла изображения,
• Image — таблица изображения или путь до него, можно загружать изображение стандартной программы paint с помощью paintutils.loadImage или изображение формата nft с помощью функции Object.Image.LoadNFT.

​Необязательные аргументы:

• Term — объект окна или монитора, где будет отображаться изображение,
• Width, Height — ширина и высота изображения,
• xOffset, yOffset — смещение изображения по x и y соответственно,
• BackgroundColor — цвет за изображением, если равен нулю, то не используется,
• BorderStyle — стиль рамки вокруг изображения, может быть "none", "box" или "lines",
• BorderColor — цвет рамки,
• LinesColor — цвет линий на рамке,
• Visible — ели false, не рисует изображение автоматически,
• Key — номер кнопки.

Таблица Object.Image также содержит функцию для загрузки nft изображений:

tImage = Object.Image.LoadNFT( "path" ) 

Загрузка изображений отдельно от объекта может понадобиться для хранения всех изображений в одном файле и последующего смещения в каждом объекте, чтобы не создавать несколько одинаковых таблиц.

Все параметры объекта можно поменять, например:

Image.xOffset = Image.xOffset+4 

Также объект содержит только читаемый параметр Image.Path, который устанавливается при указании пути до файла.

Методы:

• Image.Draw() — рисует объект,
• Image.Detect(event=string, tEvent=table) — детектирует следующие действия, связанные с изображением: "mouse_click", "mouse_up", "mouse_drag", "mouse_scroll", "monitor_touch" и "key", где event — ожидаемое действие, а tEvent — таблица с информацией действия полученной от os.pullEvent (tEvent = { os.pullEvent() }), если tEvent не указано, будет прослушивать действие сам.

Для того, чтобы получить кнопку, как объект, нужно использовать следующую функцию:

local Object = require("Имя_файла")

local Button = Object.New.Button{xPos=number, yPos=number, Width=number, Height=number} 

Разберём необходимые параметры:

•  xPos, yPos - числа, обозначающее положение верхнего левого угла кнопки;
• Width, Height - длина и высота соответственно.

Также кнопки есть дополнительные параметры, которые можно не указывать:

• Screen - адрес монитора с кнопкой (переключает видеокарту на другой монитор, если параметр указывает на не подключённый монитор), выдаёт ошибку, если такого монитора нет;
• Text - текст на кнопке, переносится на следующую строку по центру кнопки автоматически;
• TextColor - цвет текста, если не указан, ставит белый;
• BackgroundColor - цвет кнопки, если не указан ставит синий;
• ActiveColor - цвет нажатой кнопки, по стандарту зелёный;
• InactiveColor - цвет неиспользуемой кнопки, по стандарту серый;
• Time - время нажатия, по стандарту 0.3 секунды;
• Style - стиль кнопки. Их всего два, с округлёнными углами (по стандарту) и ровный прямоугольник;
• Visible - параметр видимости, не рисует кнопку автоматически, если false, и рисует, если true.

​Все параметры - ключи таблицы, и по-этому могут быть указаны в любом порядке.

Также вы спокойно можете сделать так:

local Object = require"object"
local params = {xPos=2, yPos=2, Width=10 ,Height=4, Text=54679183}
local Button1 = Object.New.Button(params)
local Button2 = Object.New.Button(params) 

И это будет работать.

Для получения значения одного из параметров, можно сделать следующее:

local Text = Button.Text 

Но вы не можете сделать это в другую сторону, а именно:

Button.Text = "klopsterinator" --Не работает 

Все параметры, которые вы задали при создании кнопки (включая свои, которых нет в списке) - только читаемые.

Кнопка имеет 3 встроенных функции (а можно ведь и свои сделать  ). Первая из них это:

Button.Draw( state ) --Рисует кнопку 

Если параметр state не указан, то будет нарисована обычная кнопка, если "active", то активная, если "inactive", то неактивная.

Далее:

Button.Set{} 

Меняет любые параметры кнопки и добавляет ваши.

Button.Detect{Action=string} 

Детектирует действия на экране, связанные с кнопкой, возвращает true, если действие с кнопкой произошло, false, если нет, и значение CurrentButton. Имеет несколько параметров.

Необходимые:

• Action - действие, может быть "touch", "drag", "scroll" и "drop".

Дополнительные:

• Button - целевая кнопка мыши или целевое направление действия "scroll".

Следующие несколько параметров нужны, если вы используете несколько кнопок одновременно.

• Screen - экран, полученный из функции event.pull(),
• x, y - координаты точки, полученные из функции event.pull(),
• CurrentButton - то же, что и Button, только полученное из event.pull().

​

Пример кода

local Object = require"object"
local event = require"event"

local Button = Object.New.Button{xPos=2, yPos=2, Width=11, Height=4, Text="Я - кнопка,и я работаю!!!"}
local detect = { }
detect.Action = "touch"
_, detect.Screen, detect.x, detect.y, detect.CurrentButton = event.pull(detect.Action)
if Button.Detect(detect) then
	Button.Set{Text="Нажата"}
	Button.Draw("inactive")
end 

1. И так создаем новую функцию и называем её к примеру class.

function class() --Объявление класса
	--Тело класса
end --Конец класса

Пока это просто пустая функция.

2.Теперь пропишем в теле класса следующее:

function class() --Объявление класса
	local Me = { } --Создание объекта
	return Me --Возвращение объекта (производного класса)
end --Конец класса

Теперь мы создали пустую таблицу и заставили функцию вернуть её. Для создания полноценного объекта нам не хватает заполнить его свойствами и методами. Таблица будущего объекта должна быть локальной.

3.Создадим свойства и методы к нему:

function class() --Объявление класса
	local Me = {  --Таблица для методов и переменных
		["Var"] = "HelloWorld"; --Публичная переменная
	}
	local Secret = "Cake = Lie"  --Скрытая переменная
	function Me.PrintVar()
		print(Me.Var)
	end
	function Me.PrintSecret()
		print(Secret)
	end
	return Me --Возвращение объекта (производного класса)
end --Конец класса

Мы создали два свойства одно скрытое (Secret), а второе публичное (Me.Var) и два метода один для вывода на экран свойства Me.Var, а второй для вывода свойства Secret. Скрытые свойства обязательно должны быть локальными, а публичные находиться в таблице объекта. Также вы можете создать локальную функцию, которую смогут использовать только методы этого объекта.

5.Вы можете хранить этот класс в отдельном файле и вызывать его с помощью функции require(), таким образом, чувствовать себя программистом на C, где обычно каждый класс находится в отдельном файле  . Выглядит это примерно так:

local class = require("имя_библиотеки").class -- загрузили класс из другого файла (если его нет в этом)
local Object = class() -- Создание объекта на основе класса
Object.PrintVar() --Вызов первого метода
--> HelloWorld

Object.PrintSecret() --Вызов второго метода
--> Cake = Lie

Object.Var = "BuyWorld" --Изменение значения свойства Var
Object.PrintVar() --Вызов первого метода
--> BuyWorld

Здесь же я вызвал все методы объекта, поменял значение свойства Var и снова вызвал. Попробуйте сами, всё должно работать и с несколькими объектами тоже.

Сначала необходимо познакомиться с самим термином. Наследование - это перенимание всех свойств и методов одного класса другим.

Давайте напишем новый класс и назовём его parent.

function parent() --Класс предок для будущего класса наследника
	local Me = { }
        local private = {
            ["Secret"] = 42
        }
	Me.Var = "HelloWorld"
	function Me.PrintVar()
		print(Me.Var)
	end
	return Me
end 

В этом классе есть свойство Var и метод PrintVar(), а также скрытое свойство в таблице private.

Теперь пишем класс наследник:

function class()
	local Me = parent() --Перенимаем таблицу объекта из класса parent(), то есть наследуем.
	return Me
end 

Всё! Поздравляю, вы наследовали класс!   Но на самом деле не полностью, т. к. остаётся наше скрытое свойство. Я не просто так засунул его в таблицу. Мы можем передать эту таблицу как и сам объект, но отдельно.

function parent()--Класс предок
	local Me = {
		["Var"] = "HelloWorld" --Публичное свойство
	}
	local private = {
		["Secret"] = 42 --Скрытое свойство
	}
	function Me.PrintVar() --Метод
		print(Me.Var)
	end
	return Me, private --Возвращение объекта, а затем таблицы со скрытыми переменными
end
function class() --Класс наследник
	local Me, private = parent() --Наследование
	function Me.getVar() --Функция, возвращающая свойство Var из класса parent
		return Me.Var
	end
	function Me.getSecret()
		return private.Secret --Функция, возвращающая скрытое свойство Secret класса parent
	end
	return Me, private --Этот класс можно наследовать тоже, таким образом, получится двойное наследование
end 

Теперь тестим:

local class = require("filename").class --Нужно, если вы разместили класс в другом файле
--[[
Если вы разместили классы в разных файлах, то следует загружать каждый отдельно, но так как они у меня в одном файле, я вызову только наследника, и это всё равно будет работать.
]]

local object = class() --Создаём объект
object.PrintVar() --Тестим метод из класса предка
--> HelloWorld

print(object.getVar()) --Тестим метод класса class, работающий с Var
--> HelloWorld

print(Me.getSecret()) --Получаем значение скрытого свойства
--> 42

Как видите, всё должно работать. Вы можете сами попробовать построить этот класс и вызывать его методы.

В принципе тут больше нечего объяснять, я думаю. Если что-то не понятно, спрашивайте, отвечу.

Представим класс:

function class()
    return {
        ["foo"] = function()
            --Здесь очень много кода, вычислений, инструкций и т.д.
        end;
        ["var"] = "какая-то переменная, для примера"
    }
    --Оформил тело объекта так, для разнообразия
end 

Главный минус таких "классов" в том, что они тратят оперативную память, бессмысленно создавая идентичные функции, которые сохраняются отдельно. Но этого можно избежать почти полностью. Почему почти, вы сейчас уведите.

Представим класс в несколько ином виде, как блок do <тело класса> end.

do --Начало класса
    local function class_foo(self) --Наша "тяжёлая" функция
        --Здесь очень много кода, вычислений, инструкций и т.д.
    end
    function class() --Функция для вызова класса

    end end --Конец класса 

Вот и всё! Сложная функция записывается только один раз, а методы ссылаются на неё. Также вы можете не использовать блок do, но тогда функции будут доступны вне класса.

Это последнее, о чём стоит написать в этой теме. Только читаемые свойства могут понадобится для возвращения результатов объекта не используя функции, и при этом, не предоставляя возможность редактировать эти самые свойства. Это можно сделать используя магию метатаблиц. Не знаете, что это? Тогда бегом читать! Хотя сейчас можно обойтись и без этого  . Объяснить на словах, как это сделать, трудно, так что просто смотрите код:

function class()
    local private = { } --Таблица со скрытыми свойствами
    private.__index = { --Таблица внутри таблицы скрытых свойств с читаемыми переменными. !!!Важно! Таблица должна сохраняться под ключом __index!!!
        ReadOnly = true; --Читаемое свойство
        Set = function( var ) --Читаемый метод, который изменяет значение читаемого свойства
            private.__index.ReadOnly = var
        end;
    }
    private.secret = 42823 --Скрытое свойство
    private.__newindex = function() end --Метаметод, непозволяющий менять значение таблицы объекта, если приравняете не к функции, а к таблице будет выводить в неё все попытки замены свойств.
    local Me = { } --Сам объект, да он пуст
    setmetatable( Me, private ) --Магия метатаблиц: устанавливает метатаблицу private для объекта
    return Me, private --Зачем я возвращаю таблицу со скрытыми свойствами, смотрите в наследовании
end 

Надеюсь комментарии к коду выше вполне понятны и всё объясняют. Так что мы можем перейти к тестированию.

Тестируем:

local class = require 'class'.class --Загрузка класса, если он в другом файле.

local object = class() --Получаем объект на основе нашего класса
object.Set( "test" ) --Устанавливаем значение для читаемого свойства читаемой функцией. Напрямую мы это сделать не сможем.
print(object.ReadOnly) --Выводим значение ReadOnly
--> test

object.ReadOnly = "He he!"
--Изменяем значение, надеясь, что это сработает

print(object.ReadOnly) --Но он выводит старое значение
--> test

На этом всё. Теперь вы можете использовать читаемые свойства для того, чтобы не создавать специальные для этого методы.