Grids Reference Page/ru: what changed
Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.
| Old | New | Line | |
|---|---|---|---|
| 1 | 1 | ## Цель | |
| 2 | 2 | ||
| 3 | 3 | Этот текст попытается показать пользователю некоторые аспекты использования компонентов сеток (Grid) в Lazarus. Он также предназначен для использования в качестве руководства для пользователей, которые никогда не использовали сетки (опытные пользователи тут обычно получают только информацию по новой функциональности). | |
| 4 | 4 | ||
| 5 | 5 | Таким образом, этот текст пытается достичь следующих целей: | |
| 6 | 6 | ||
| 7 | 7 | 1. Введение в сеточные компоненты для людей с небольшим опытом или без опыта после работы с Delphi. | |
| 8 | 8 | 2. Документирование различий в использовании компонентов сеток в Delphi. | |
| 9 | 9 | 3. Документирование новой функциональности сеток в Lazarus | |
| 10 | 10 | 4. Описание по созданию и примеры использования таких компонентов в Lazarus | |
| 11 | 11 | ||
| 12 | 12 | ## Введение | |
| 13 | 13 | ||
| 14 | 14 | Как компонент сетка обеспечивает средства отображения данных в табличном формате. Наиболее очевидным характеристика сетки является то, что они состоят из клеток, образующих строки и столбцы. | |
| 15 | 15 | ||
| 16 | 16 | Тип информации, которая может быть показана в сетке различна и зависит главным образом от того, что пользователь хочет, чтобы сета отобразила. Вообще эта информация может состоять из текста, цвета, изображения или их комбинации. | |
| 17 | 17 | ||
| 18 | 18 | Учитывая большое разнообразие информации, которая может быть представлена, существует набор различных сеток, цель которых заключается в содействии пользователю в представлении разных видов информации. | |
| 19 | 19 | ||
| 20 | 20 | Например, есть сетка предназначенная для отображения текста: **StringGrid**. Документация для этой сетки может быть найдена [здесь](http://lazarus-ccr.sourceforge.net/docs/lcl/grids/tstringgrid.html) | |
| 21 | 21 | ||
| 22 | 22 | ## Дерево наследования | |
| 23 | 23 | ||
| 24 | - | ||
| 25 | - | ||
| 26 | - | ||
| 27 | - | ||
| 28 | - | ||
| 29 | - | ||
| 30 | - | ||
| 31 | - | ||
| 32 | - | ||
| 33 | - | ||
| 34 | - | ||
| 35 | - | ||
| 36 | - | ||
| 37 | - | ||
| 38 | - | ||
| 24 | + | ```text | |
| 25 | + | TCustomControl | |
| 26 | + | | | |
| 27 | + | | | |
| 28 | + | TCustomGrid | |
| 29 | + | | | |
| 30 | + | +-------------+------------+ | |
| 31 | + | | | | |
| 32 | + | TCustomDrawGrid TCustomDbGrid | |
| 33 | + | | | | |
| 34 | + | +--------+--------+ | | |
| 35 | + | | | TDBGrid | |
| 36 | + | TDrawGrid TCustomStringGrid | |
| 37 | + | | | |
| 38 | + | | | |
| 39 | + | TStringGrid | |
| 40 | + | ``` | |
| 39 | 41 | ||
| 40 | 42 | ## Начальный пример | |
| 41 | 43 | ||
| 42 | 44 | Поскольку одной из целей этой страницы является помощь людям с небольшими или отсутствующими предшествующими знаниями Lazarus'а, давайте сделаем быстрый стартовый пример сетки в действии. Почему бы и нет, давайте сделаем традиционный пример "hello world", используя компонент TStringGrid. | |
| 43 | 45 | ||
| 44 | 46 | 1. Создайте новое приложение. | |
| 45 | 47 | - В главном меню выберите: project-\>New Project | |
| 46 | 48 | - В диалоговом окне Create New Project нажмите кнопку "Create" | |
| 47 | 49 | - Будет показана новая пустая форма.. | |
| 48 | 50 | 2. Поместите сетку в форму | |
| 49 | 51 | - В палитре компонентов выберите вкладку "additional" | |
| 50 | 52 | - Нажмите значок TStringGrid  | |
| 51 | 53 | - Нажмите на форму рядом с левым верхним углом. Появится новая пустая сетка. | |
| 52 | 54 | 3. Поместите кнопку в форму | |
| 53 | 55 | - с помощью палитры компонентов выберите вкладку "Standard" | |
| 54 | 56 | - Нажмите значок TButton  | |
| 55 | 57 | - Нажмите на пустую область формы. Появится новая кнопка. | |
| 56 | 58 | 4. Дважды нажмите кнопку из шага 3 и запишите следующий код в обработчике щелчка кнопки: | |
| 57 | 59 | - ``` pascal | |
| 58 | 60 | StringGrid1.Cells[1,1] := 'Привет, Мир!'; | |
| 59 | 61 | ``` | |
| 60 | 62 | 5. Запустите программу, щелкнув значок воспроизведения  | |
| 61 | 63 | - по нажатию кнопки Button1, текст приветствия будет отображаться в столбце 1 ячейки 1 (обратите внимание, что левый столбец и верхняя строка равны 0) | |
| 62 | 64 | ||
| 63 | 65 | ## Различия между сетками Lazarus и Delphi | |
| 64 | 66 | ||
| 65 | 67 | Текущий компонент сетки отличается от сетки Delphi по нескольким направления. При начальной разработке сетки Lazarus создавались с нуля без какой-либо попытки сделать их полностью совместимыми с Delphi. | |
| 66 | 68 | ||
| 67 | 69 | На более позднем этапе совместимость с сетками Delphi стала желаемой целью, и сетки Lazarus стали более тесно соответствовать интерфейсу сетки Delphi. Однако даже это было сделано без попытки сделать каждое свойство или метод сетки Lazarus сопоставимым с его аналогом в Delphi. Кроме того (поскольку внутренняя структура сетки Lazarus сильно отличается от внутренних элементов сетки Delphi), некоторая функциональность Delphi невозможна или должна быть эмулирована иначе в сетке Lazarus \[в отличие от того\], как это будет сделано в сетке Delphi. Мы достигли большей совместимости с Delphi в процессе эволюции сетки Lazarus, и это соблазнительно. | |
| 68 | 70 | ||
| 69 | 71 | ### Различия | |
| 70 | 72 | ||
| 71 | 73 | Известные различия перечислены ниже, ни в каком специальном порядке. | |
| 72 | 74 | ||
| 73 | 75 | - Редакторы ячеек | |
| 74 | 76 | - Поведение в designtime | |
| 75 | 77 | - Отрисовка ячеек имеет некоторые отличия, см. раздел настройки сетки. | |
| 76 | 78 | ||
| 77 | 79 | ### Новая функциональность | |
| 78 | 80 | ||
| 79 | 81 | - Пользовательские столбцы | |
| 80 | 82 | - События | |
| 81 | 83 | - Редактор сетки | |
| 82 | 84 | ||
| 83 | 85 | ### Способы, которыми вы можете сделать сетку Lazarus более совместимой с Delphi | |
| 84 | 86 | ||
| 85 | 87 | Вы можете сделать сетку Lazarus похожей и ведущей себя подобно \[сетке\] Delphi. Ниже перечислены параметры свойств, которые \[позволят\] достигнуть этого. Эти корректировки основаны на вновь созданной сетке. \[Свойства,\] помеченные тэгом \[Code\], должны быть определены в коде, тэгом \[Design\] могут быть изменены во время разработки. | |
| 86 | 88 | ||
| 87 | 89 | - \[Design\] TitleStyle := tsStandard; | |
| 88 | 90 | - \[Design\] DefaultRowHeight := 24; | |
| 89 | 91 | - \[Code\] EditorBorderStyle := bsNone; // это может работать только в Windows. | |
| 90 | 92 | - \[Code\] UseXORFeatures := true; | |
| 91 | 93 | - \[Code\] AllowOutBoundEvents := False; {SVN-ревизия 10992 или старше} | |
| 92 | 94 | - \[Code\] FastEditing := False; (поддерживается в dbgrid. StringGrid требует SVN-ревизию 10992 или старше) | |
| 93 | 95 | - \[Design\] AutoAdvance := aaNone; | |
| 94 | 96 | ||
| 95 | 97 | ## Справочник по сеткам | |
| 96 | 98 | ||
| 97 | 99 | ### Информация | |
| 98 | 100 | ||
| 99 | 101 | Отправной точкой для \[получения\] справки о TCustomGrid, TDrawGrid, TCustomDrawGrid, TCustomStringGrid и TStringGrid является [справка по модулю Grids.pas](http://lazarus-ccr.sourceforge.net/docs/lcl/grids/index.html) | |
| 100 | 102 | ||
| 101 | 103 | Для TCustomDBGrid и TDBgrid это [справка по модулю DBGrids.pas](http://lazarus-ccr.sourceforge.net/docs/lcl/dbgrids/index.html) | |
| 102 | 104 | ||
| 103 | 105 | В общем, любая ссылка Delphi о сетках должна помочь нам использовать сетки Lazarus (но не забывайте, что есть несколько различий между сетками Delphi и Lazarus, которые мы задокументировали); имея это в виду и в качестве временного места для справочной информации, это место будет использоваться для документирования тех вещей, которые не работают аналогично Delphi, а также любых новых функций. | |
| 104 | 106 | ||
| 105 | 107 | TODO: остальная часть этого раздела должна исчезнуть; его содержание будет перенесено в [справку по модулю Grids.pas](http://lazarus-ccr.sourceforge.net/docs/lcl/grids/index.html) | |
| 106 | 108 | ||
| 107 | 109 | ### TCustomGrid | |
| 108 | 110 | ||
| 109 | 111 | См. полную [[doc:lcl/grids/tcustomgrid.html|справку TCustomGrid]] | |
| 110 | 112 | ||
| 111 | 113 | #### свойство AllowOutboundEvents | |
| 112 | 114 | ||
| 113 | 115 | Protected\[-свойство\] в TCustomGrid, public\[-свойство\] в TCustomDrawGrid и его наследниках. Обычно, когда пользователь нажимает в точку над пустым пространством после ячеек (например, если сетка имеет три строки, но пользователь нажимает на воображаемую четвертую строку), текущий фокус ячейки перемещается ячейку, ближайшую к только что щелкнутой точке. Мы называем это исходящим событием. Значение по умолчанию - true, так как это изначальное поведение сетки. Это свойство было добавлено для моделирования поведения Delphi, когда исходящие события недоступны, поэтому для обеспечения совместимости с Delphi это свойство имеет значение false. | |
| 114 | 116 | ||
| 115 | 117 | #### свойство Columns | |
| 116 | 118 | ||
| 117 | 119 | Lazarus включает свойства **columns** в сетки TStringGrid и TDrawGrid. Это свойство добавляет так называемые пользовательские столбцы. Пользовательские столбцы представляют собой набор объектов, которые содержат свойства, применяемые к целым столбцам, например заголовки столбцов (для StringGrid он переопределяет значение, указанное в соответствующем свойстве Cells \[ColumnIndex, RowTitle\]), выравнивание текста, цвет фона, предпочтительный редактор и т.д. | |
| 118 | 120 | ||
| 119 | 121 | Пользовательские столбцы добавляют дополнительные свойства или заменяют значения свойств по умолчанию в столбцах стандартной сетки. Но не только это; значение **grid.ColCount** может увеличиваться или уменьшаться, чтобы учесть количество настраиваемых столбцов, которые привязаны к сетке. На этом этапе это означает, что **grid.ColCount** = **grid.FixedCols** + **grid.Columns.Count**. | |
| 120 | 122 | ||
| 121 | 123 | Например, если к базовой сетке с ColCount=5 и FixedCols=2 мы: | |
| 122 | 124 | ||
| 123 | 125 | - Добавим 3 пользовательских столбца, базовая сетка будет точно такой же, как раньше, 2 фиксированных столбца и 3 обычных столбца. | |
| 124 | 126 | - Добавим 1 пользовательский столбец, базовая сетка будет иметь ColCount=3, то есть 2 фиксированных столбца и 1 нормальный столбец. | |
| 125 | 127 | - Добавим 4 пользовательских столбца, базовая сетка будет иметь ColCount=6, то есть 2 фиксированных столбца и 4 нормальных столбца. | |
| 126 | 128 | ||
| 127 | 129 | Из этого можно сделать вывод, что: | |
| 128 | 130 | ||
| 129 | 131 | - Свойства фиксированного столбца или счетчики не увеличиваются или не изменяются соответственно пользовательскими столбцами. | |
| 130 | 132 | - **grid.ColCount** обычно отличается от **grid.Columns.Count** (**grid.ColCount**=**grid.Columns.Count**, только когда **FixedCols**=0) | |
| 131 | 133 | ||
| 132 | 134 | Во время разработки пользователь может получить доступ к свойству **columns** в Object Inspector, чтобы вызвать редактор столбцов. Оттуда вы можете добавлять, удалять или изменять настраиваемые столбцы. Редактор отображает список текущих пользовательских столбцов; путем выбора элементов в этом списке инспектор объектов заполняется свойствами, доступными для каждого столбца. Список настраиваемых столбцов также доступен в представлении дерева компонентов Object Inspector, где столбцы можно добавлять, удалять или изменять. Они появляются на нижнем уровне под сеткой контейнера. | |
| 133 | 135 | ||
| 134 | 136 | В runtime столбцы могут быть изменены с помощью кода: | |
| 135 | 137 | ||
| 136 | 138 | ``` pascal | |
| 137 | 139 | var | |
| 138 | 140 | c: TGridColumn; | |
| 139 | 141 | begin | |
| 140 | 142 | // Добавляем пользовательский столбец в сетку | |
| 141 | 143 | c := Grid.Columns.Add; | |
| 142 | 144 | // модифицируем | |
| 143 | 145 | c.title.caption := 'Цена'; // Устанавливаем заголовок столбца | |
| 144 | 146 | c.align := taRightJustify; // Выравниваем содержимое столбца по правому краю | |
| 145 | 147 | c.color := clMoneyGreen; // Изменяем цвет по умолчанию на clMoneyGreen | |
| 146 | 148 | c.Index := 0; // Делаем этот столбец первым | |
| 147 | 149 | // доступ к существующему столбцу | |
| 148 | 150 | grid.columns[0].Width := 60; // Изменяем ширину столбца 0 на 60 пикселей | |
| 149 | 151 | // удаляем существующий столбец | |
| 150 | 152 | grid.columns.delete(0); // Удаляем столбец 0 | |
| 151 | 153 | .... | |
| 152 | 154 | end; | |
| 153 | 155 | ``` | |
| 154 | 156 | ||
| 155 | 157 | Кроме того, когда задействуются пользовательские столбцы, сетки не допускают прямой модификации \[свойства\] **grids.colcount**; добавление или удаление столбцов должно выполняться с использованием свойства **columns**. Объяснение состоит в том, что существует некоторая несогласованность в постепенном удалении пользовательских столбцов с использованием **ColCount**: когда \[значение\] **ColCount** становится равным **FixedCols**, \[это означает, что\] сетка не имеет больше настраиваемых столбцов. Если теперь увеличить **ColCount**, новый столбец будет не настраиваемым, а нормальным столбцом. | |
| 156 | 158 | ||
| 157 | 159 | В настоящее время нет планов, чтобы сетки использовали только настраиваемые столбцы. | |
| 158 | 160 | ||
| 159 | 161 | #### свойство AutoFillColumns | |
| 160 | 162 | ||
| 161 | 163 | Часто сетки шире, чем горизонтальное пространство, необходимое для столбцов - это оставляет неприятную пустую область справа от последнего столбца. Сетки LCL предоставляют механизм для расширения ширины указанных столбцов, так что пустое пространство заполняется автоматически. | |
| 162 | 164 | ||
| 163 | 165 | Для этой цели необходимо либо добавить **Columns**, как описано [[Grids Reference Page/ru|выше]], либо установив свойство `ColCount`, и свойство сетки `AutoFillColumns` должно быть установлено в `true`. Каждый столбец имеет свойство `SizePriority`. Если оно имеет значение `0`, ширина столбца берется из свойства `Width` столбца. Но когда оно имеет ненулевое значение, ширина столбца корректируется до среднего доступного размера, оставшегося для всех столбцов с ненулевым `SizePriority`. | |
| 164 | 166 | ||
| 165 | 167 | ### TCustomDBGrid | |
| 166 | 168 | ||
| 167 | 169 | TCustomDBGrid основан на TDBGrid. | |
| 168 | 170 | ||
| 169 | 171 | Они не отображают свойств Col и Row. Чтобы перейти к определенному столбцу, используйте, например, свойство SelectedIndex. | |
| 170 | 172 | ||
| 171 | 173 | Интересным public-методом является AutoSizeColumns. | |
| 172 | 174 | ||
| 173 | 175 | #### процедура AutoSizeColumns | |
| 174 | 176 | ||
| 175 | 177 | Эта процедура устанавливает ширину столбца по размеру максимально широкого найденного текста. Его можно использовать после загрузки набора данных/установки \[свойства\] Active. | |
| 176 | 178 | ||
| 177 | 179 | Однако, в противоположность \[процедуре\] TCustomStringGrid.AutoSizecolumns (см. ниже), эта \[процедура\] будет устанавливать столбцы максимально широко, пока вы не задействуете \[параметр грида\] **dgAutoSizeColumns**. | |
| 178 | 180 | ||
| 179 | 181 | #### процедура InplaceEditor | |
| 180 | 182 | ||
| 181 | 183 | См. пример из bug 23103 - *и вставьте объяснение того, что он делает/почему это необходимо. Проверить входные значения? Изменить то, что показано?* | |
| 182 | 184 | ||
| 183 | 185 | ``` pascal | |
| 184 | 186 | procedure TForm1.DBGrid1KeyPress(Sender: TObject; var Key: char); | |
| 185 | 187 | var | |
| 186 | 188 | S: String; | |
| 187 | 189 | begin | |
| 188 | 190 | if (Key in [',','.']) then | |
| 189 | 191 | begin | |
| 190 | 192 | //в отличие от Delphi не все InPlaceEditor'ы - это редакторы для строкового типа, поэтому проверьте! | |
| 191 | 193 | if (DBGrid1.InplaceEditor is TStringCellEditor) then | |
| 192 | 194 | begin | |
| 193 | 195 | S := TStringCellEditor(DBGrid1.InplaceEditor).EditText; | |
| 194 | 196 | if Pos(',',S) > 0 then | |
| 195 | 197 | Key := #0 | |
| 196 | 198 | else | |
| 197 | 199 | Key := ','; | |
| 198 | 200 | end; | |
| 199 | 201 | end; | |
| 200 | 202 | end; | |
| 201 | 203 | ``` | |
| 202 | 204 | ||
| 203 | 205 | ### TCustomStringGrid | |
| 204 | 206 | ||
| 205 | 207 | TCustomStringGrid служит основой для TStringGrid. Он может использоваться для \[написания\] производных компонентов \[типа\] TStringGrid, которые хотят скрыть published-свойства. Дополнительную информацию см. в [[new intermediate grids]]. | |
| 206 | 208 | ||
| 207 | 209 | Следующие public-свойства или public-методы являются доступными для TStringGrid. | |
| 208 | 210 | ||
| 209 | 211 | См. полную [[doc:lcl/grids/tcustomstringgrid.html|справку TCustomStringGrid]] | |
| 210 | 212 | ||
| 211 | 213 | #### процедура AutoSizeColumn(aCol: Integer); | |
| 212 | 214 | ||
| 213 | 215 | Эта процедура устанавливает ширину столбца \[в соответствии с\] размером самого широкого текст, который был ею найден во всех строках столбца **aCol**. Совет: см. параметр **goDblClickAutoSize**, чтобы позволить автоматически изменять размер столбцов при двойном нажатии на границу столбца. | |
| 214 | 216 | ||
| 215 | 217 | #### процедура AutoSizeColumns; | |
| 216 | 218 | ||
| 217 | 219 | Автоматически изменяет размеры всех столбцов так, чтобы они растягивались под самый длинный текст для каждого столбца. Это быстрый способ применения AutoSizeColumn() для каждого столбца в сетке. | |
| 218 | 220 | ||
| 219 | 221 | #### процедура Clean; overload; | |
| 220 | 222 | ||
| 221 | 223 | Очищает все ячейки в сетке, \[будь то\] фиксированные или нет. | |
| 222 | 224 | ||
| 223 | 225 | #### процедура Clean(CleanOptions: TGridZoneSet); overload; | |
| 224 | 226 | ||
| 225 | 227 | Очищает все ячейки в сетке в соответствии с данными CleanOptions. Дополнительную информацию см. в [[doc:lcl/grids/tgridzoneset.html|TGridZoneSet]]. Некоторые примеры: | |
| 226 | 228 | ||
| 227 | 229 | - Очистить все ячейки: `grid.Clean([]);` (аналогично `grid.clean`) | |
| 228 | 230 | - Очистить все нефиксированные ячейки: `grid.Clean([gzNormal]);` | |
| 229 | 231 | - Очистить все ячейки, но не касается заголовков столбцов сетки: `Grid.Clean([gzNormal, gzFixedRows]);` | |
| 230 | 232 | ||
| 231 | 233 | #### процедура Clean(StartCol,StartRow,EndCol,EndRow: integer; CleanOptions:TGridZoneSet); overload; | |
| 232 | 234 | ||
| 233 | 235 | делает то же самое, что и `Clean(CleanOptions: TGridZoneSet)`, но ограничивается данными `StartCol, StartRow, EndCol и EndRow`. Примеры: | |
| 234 | 236 | ||
| 235 | 237 | - Очистить индекс столбца с 4 по 6, но не касаться заголовков столбцов сетки, много вариантов: | |
| 236 | 238 | ||
| 237 | 239 | ``` pascal | |
| 238 | 240 | Grid.Clean (4,Grid.FixedRows, 6,Grid.RowCount-1,[]); //или Grid.Clean(4,0,6,Grid.RowCount-1, [gzNormal]); | |
| 239 | 241 | ``` | |
| 240 | 242 | ||
| 241 | 243 | и т.п. | |
| 242 | 244 | ||
| 243 | 245 | #### процедура Clean(aRect: TRect; CleanOptions: TGridZoneSet); overload; | |
| 244 | 246 | ||
| 245 | 247 | То же самое, что и `Clean(StartCol,StartRow,EndCol,EndRow, CleanOptions)`, просто берется \[прямоугольник\] TRect вместо отдельных координат ячейки. Для очистки выделения полезно \[сделать\]: | |
| 246 | 248 | ||
| 247 | 249 | ``` pascal | |
| 248 | 250 | grid.Clean(Grid.Selection,[]); | |
| 249 | 251 | ``` | |
| 250 | 252 | ||
| 251 | 253 | ==== процедура SaveToCSVFile(AFileName: string; ADelimiter:Char=','; WithHeader:boolean=true); ==== Сохраняет содержимое сетки в файл формата данных с разделителями-запятыми (CSV) (добавлен в Lazarus с r32179). | |
| 252 | 254 | ||
| 253 | 255 | Аргумент **AFilename** указывает имя файла, в котором содержимое будет сохранено. Если файл существует, содержимое будет перезаписано. Если он не существует, файл будет создан. | |
| 254 | 256 | ||
| 255 | 257 | **ADelimiter** (необязательный аргумент) используется для предоставления настраиваемого разделителя, если требуется. По умолчанию создается формат CSV (то есть ADelimiter: = ',') для TAB-разделяемого файла ADelimiter должен быть \#9. | |
| 256 | 258 | ||
| 257 | 259 | Параметр **WithHeader** используется для определения необходимости включения или отключения "row header"\[(заголовка строки)\]. Заголовок строки - это список имен полей в начале выходного файла; его содержимое извлекается из последней фиксированной строки в сетке. Существует исключение из этого правила: если сетка имеет пользовательские столбцы, содержимое заголовка строки извлекается из заголовков пользовательских столбцов, а не из содержимого ячейки фиксированной строки. | |
| 258 | 260 | ||
| 259 | 261 | Если WithHeader имеет значение true, а сетка не содержит фиксированную строку или настраиваемые столбцы, содержимое заголовка строки будет взято из первой строки в сетке. | |
| 260 | 262 | ||
| 261 | 263 | Вывод CSV-данных обычно начинается с первой нефиксированной строки в сетке. | |
| 262 | 264 | ||
| 263 | 265 | ==== процедура LoadFromCSVFile(AFileName: string; ADelimiter:Char=','; WithHeader:boolean=true); ==== Загружает содержимое сетки из файла формата данных с разделителями-запятыми (CSV) (добавлен в Lazarus с r32179). | |
| 264 | 266 | ||
| 265 | 267 | Столбцы будут добавлены в сетку или удалены из нее по мере необходимости, в соответствии с количеством полей, включенных в каждую строку файла CSV. Загрузка CSV-файла не будет изменять количество фиксированных строк, которые уже существовали в сетке. | |
| 266 | 268 | ||
| 267 | 269 | Аргумент **Afilename** указывает имя исходного файла с содержимым CSV. | |
| 268 | 270 | ||
| 269 | 271 | Дополнительный параметр **ADelimiter** может использоваться для указания другого разделителя. Например: для файла с TAB-разделителями *ADelimiter* должен быть \#9. Другим популярным файловым форматом является файл с разделителем-запятой. | |
| 270 | 272 | ||
| 271 | 273 | Параметр **WithHeader** используется для определения того, следует ли считать первую строку в файле CSV "строкой заголовка" или нет. Если сетка имеет фиксированные строки, а *WithHeader* - \[значение\] true, заголовки столбцов для последней фиксированной строки будут взяты из строки заголовка. Однако, обратите внимание, что если сетка имеет пользовательские столбцы, строка заголовка будет использоваться как источник заголовков столбцов, а заголовки столбцов всегда \[будут\] отображаются в первой фиксированной строке сетки или \[будут\] скрыты, если в сетке не \[окажется\] фиксированных строк. | |
| 272 | 274 | ||
| 273 | 275 | Если в процедуре *LoadFromCSVFile* возникла проблема с загрузкой файла CSV (например, кавычки или пробелы начинают неправильно интерпретироваться), вы можете загрузить сетку вручную, например, [[CsvDocument/ru|CsvDocument]] ... и, конечно, патч для *LoadFromCSVFile* всегда приветствуется. | |
| 274 | 276 | ||
| 275 | 277 | #### свойство Cols\[index: Integer\]: TStrings read GetCols write SetCols; | |
| 276 | 278 | ||
| 277 | 279 | Получает/устанавливает список строк из/в индекса столбца данной сетки, начиная с индекса строки от 0 до RowCount-1. | |
| 278 | 280 | ||
| 279 | 281 | ##### Примеры | |
| 280 | 282 | ||
| 281 | 283 | - Пример определения \[содержимого строки\]: | |
| 282 | 284 | ||
| 283 | 285 | ``` pascal | |
| 284 | 286 | //задать содержимое третьего столбца в сетке из списка ListBox | |
| 285 | 287 | Grid.Cols[2] := ListBox1.Items; | |
| 286 | 288 | ``` | |
| 287 | 289 | ||
| 288 | 290 | - Пример получения \[содержимого строки\]: | |
| 289 | 291 | ||
| 290 | 292 | ``` pascal | |
| 291 | 293 | //задать содержимое Listbox, [получив значение] из столбца сетки с индексом 4: | |
| 292 | 294 | procedure TForm1.FillListBox1; | |
| 293 | 295 | var | |
| 294 | 296 | StrTempList: TStringList; | |
| 295 | 297 | begin | |
| 296 | 298 | StrTempList := TStringList(Grid.Cols[4]); | |
| 297 | 299 | if StrTempList<>nil then begin | |
| 298 | 300 | ListBox1.Items.Assign(StrTempList); | |
| 299 | 301 | StrTempList.Free; | |
| 300 | 302 | end; | |
| 301 | 303 | end; | |
| 302 | 304 | ``` | |
| 303 | 305 | ||
| 304 | 306 | ##### На заметку | |
| 305 | 307 | ||
| 306 | 308 | Это свойство работает по-разному в Lazarus и Delphi при получении данных из сетки. В Lazarus создается временный объект TStringList для извлечения содержимого столбца. Пользователь должен освобождать этот объект после использования. | |
| 307 | 309 | ||
| 308 | 310 | Это также означает, что изменения в возвращенном списке не будут влиять на содержимое или макет сетки. | |
| 309 | 311 | ||
| 310 | 312 | См. пример получения \[содержимого строки\] выше. | |
| 311 | 313 | ||
| 312 | 314 | #### свойство Rows\[index: Integer\]: TStrings read GetRows write SetRows; | |
| 313 | 315 | ||
| 314 | 316 | Получает/определяет список строк из/в индекса строки данной сетки, начиная с индекса столбца 0 до столбца ColCount-1. | |
| 315 | 317 | ||
| 316 | 318 | ##### На заметку | |
| 317 | 319 | ||
| 318 | 320 | Это свойство работает по-разному в Lazarus и Delphi при получении данных из сетки. В Lazarus создается временный объект TStringList для извлечения содержимого строки. Пользователь должен освобождать этот объект после использования. | |
| 319 | 321 | ||
| 320 | 322 | Это также означает, что изменения в возвращенном списке не будут влиять на содержимое или макет сетки. | |
| 321 | 323 | ||
| 322 | 324 | ##### Примеры | |
| 323 | 325 | ||
| 324 | 326 | - Пример определения \[содержимого строки\]: | |
| 325 | 327 | ||
| 326 | 328 | ``` pascal | |
| 327 | 329 | //задать содержимое третьего столбца в сетке из списка ListBox | |
| 328 | 330 | Grid.Rows[2] := ListBox1.Items; | |
| 329 | 331 | ``` | |
| 330 | 332 | ||
| 331 | 333 | - Пример получения \[содержимого строки\]: | |
| 332 | 334 | ||
| 333 | 335 | ``` pascal | |
| 334 | 336 | //задать содержимое Listbox, [получив значение] из столбца сетки с индексом 4: | |
| 335 | 337 | procedure TForm1.FillListBox1; | |
| 336 | 338 | var | |
| 337 | 339 | StrTempList: TStringList; | |
| 338 | 340 | begin | |
| 339 | 341 | StrTempList := TStringList(Grid.Rows[4]); | |
| 340 | 342 | if StrTempList<>nil then begin | |
| 341 | 343 | ListBox1.Items.Assign(StrTempList); | |
| 342 | 344 | StrTempList.Free; | |
| 343 | 345 | end; | |
| 344 | 346 | end; | |
| 345 | 347 | ``` | |
| 346 | 348 | ||
| 347 | 349 | - Пример, который не работает, и его исправление: список извлеченных строк - только для чтения | |
| 348 | 350 | ||
| 349 | 351 | ``` pascal | |
| 350 | 352 | // это не сработает и вызовет утечку памяти | |
| 351 | 353 | // потому что возвращаемый StringList не освобождается | |
| 352 | 354 | Grid.Rows[1].CommaText := '1,2,3,4,5'; | |
| 353 | 355 | Grid.Rows[2].Text := 'a'+#13#10+'s'+#13#10+'d'+#13#10+'f'+#13#10+'g'; | |
| 354 | 356 | ||
| 355 | 357 | //исправление первого случая | |
| 356 | 358 | Lst:=TStringList.Create; | |
| 357 | 359 | Lst.CommaText := '1,2,3,4,5'; | |
| 358 | 360 | Grid.Rows[1] := Lst; | |
| 359 | 361 | Lst.Free; | |
| 360 | 362 | ``` | |
| 361 | 363 | ||
| 362 | 364 | #### свойство UseXORFeatures; | |
| 363 | 365 | ||
| 364 | 366 | Boolean свойство, значение по умолчанию: False; | |
| 365 | 367 | ||
| 366 | 368 | Это свойство \[отвечает за то\], как прямоугольник фокуса отображается в сетке. Когда \[его значение равно\] True, прямоугольник отрисовывается \[вокруг ячейки\] с использованием растровой операции XOR. Это позволяет нам видеть прямоугольник фокуса, вне зависимости от того, какой цвет фона \[имеют\] ячейки. Когда \[его значение равно\] False, пользователь может управлять цветом точек фокуса прямоугольника с помощью свойства [[FocusColor property]] | |
| 367 | 369 | ||
| 368 | 370 | Он также контролирует внешний вид изменения размера столбца/строки. Когда \[его значение равно\] True, линия визуально показывает размер, который \[только еще\] будет иметь столбец или строка, если пользователь завершит операцию. Когда \[его значение равно\] False, изменение размера столбца или строки вступает в силу \[сразу же\], как \[только\] пользователь \[начнет\] перетаскивать мышь. | |
| 369 | 371 | ||
| 370 | 372 | ### TValueListEditor | |
| 371 | 373 | ||
| 372 | 374 | TValueListEditor - это элемент управления, полученный из TCustomStringGrid для редактирования пар ключ-значение. | |
| 373 | 375 | ||
| 374 | 376 | #### свойство DisplayOptions | |
| 375 | 377 | ||
| 376 | 378 | Управляет различными аспектами внешнего вида TValueListEditor. | |
| 377 | 379 | ||
| 378 | 380 | #### свойство TitleCaptions | |
| 379 | 381 | ||
| 380 | 382 | Устанавливает значения подписи заголовков (если \[свойство\] **doColumnTitles** \[включено в набор свойств\] **DisplayOptions**). Если `DisplayOptions` не \[содержит\] значения `doColumnTitles`, то используются заголовки \[с надписями\] по умолчанию. | |
| 381 | 383 | ||
| 382 | 384 | #### свойство Strings | |
| 383 | 385 | ||
| 384 | 386 | Предоставляет доступ к списку строк, которые содержат пары Key-Value.\ | |
| 385 | 387 | Пары «ключ-значение» должны быть в форме:\ | |
| 386 | 388 | `KeyName=Value` | |
| 387 | 389 | ||
| 388 | 390 | #### свойство ItemProps | |
| 389 | 391 | ||
| 390 | 392 | Вы можете использовать это свойство для управления тем, как элементы в столбцах \[со значением\] "Value" можно редактировать.\ | |
| 391 | 393 | Это контролируется установкой свойств **EditStyle** и **ReadOnly** \[свойства\] **ItemProp**. | |
| 392 | 394 | ||
| 393 | 395 | #### свойство KeyOptions | |
| 394 | 396 | ||
| 395 | 397 | KeyOptions - это набор TKeyOptions, определяющий, может ли пользователь изменять содержимое столбца "Key". | |
| 396 | 398 | ||
| 397 | 399 | - KeyEdit: пользователь может редактировать имя ключа | |
| 398 | 400 | - KeyAdd: пользователь может добавить ключи (нажав Insert в сетке). KeyAdd требует KeyEdit. | |
| 399 | 401 | - KeyDelete: пользователь может удалить пары Key-Value (нажав Ctrl+Delete). | |
| 400 | 402 | - KeyUnique: если установлено, то ключи должны иметь уникальные имена. Попытка ввести дубликат ключа вызовет исключение. | |
| 401 | 403 | ||
| 402 | 404 | #### свойство DropDownRows | |
| 403 | 405 | ||
| 404 | 406 | Если редактор ячейки является списком выбора (ValueEdit1.ItemProps\['key1'\].EditStyle=esPickList), это свойство устанавливает DropDownCount\[(высоту выпадающего)\] отображаемого списка. По умолчанию используется значение 8. | |
| 405 | 407 | ||
| 406 | 408 | #### функция DeleteRow | |
| 407 | 409 | ||
| 408 | 410 | Удаляет пару Key-Value индексированной строки, полностью удаляя строку. | |
| 409 | 411 | ||
| 410 | 412 | #### функция InsertRow | |
| 411 | 413 | ||
| 412 | 414 | Вставляет строку в сетку и устанавливает пару Key-Value. Возвращает индекс вновь вставленной строки. | |
| 413 | 415 | ||
| 414 | 416 | #### функция IsEmptyRow | |
| 415 | 417 | ||
| 416 | 418 | Возвращает \[значение\] true, если ячейки индексированных строк пусты (Keys\[aRrow\]=*; Valves\[aRrow\]=*). | |
| 417 | 419 | ||
| 418 | 420 | #### функция FindRow | |
| 419 | 421 | ||
| 420 | 422 | Возвращает строку с указанным именем ключа. | |
| 421 | 423 | ||
| 422 | 424 | #### функция RestoreCurrentRow | |
| 423 | 425 | ||
| 424 | 426 | Отменяет редактирование в текущей строке (если редактор все еще в фокусе). \[Событие\] случается, когда пользователь нажимает клавишу Escape. | |
| 425 | 427 | ||
| 426 | 428 | #### Измененное поведение некоторых свойств, унаследованных из TCustomStringGrid | |
| 427 | 429 | ||
| 428 | 430 | ##### Параметры Options | |
| 429 | 431 | ||
| 430 | 432 | В соответствии с особенностями TValueListEditor его свойство Options имеет определенные ограничения | |
| 431 | 433 | ||
| 432 | 434 | - goColMoving не доступно в Options (вы не можете установить его). | |
| 433 | 435 | - goAutoAddRows может быть установлен только в том случае, если KeyAdd отмечен в KeyOptions. Установка KeyAdd автоматически установит goAutoAddRows. | |
| 434 | 436 | - goAutoAddRowsSkipContentCheck недоступен (на данный момент это приводит к сбою в TValueListeditor: требуется исправление). | |
| 435 | 437 | ||
| 436 | 438 | ##### свойство FixedRows | |
| 437 | 439 | ||
| 438 | 440 | Может \[иметь значение\] только 1 (показать названия столбцов) или 0 (не показывать заголовки столбцов) | |
| 439 | 441 | ||
| 440 | 442 | ##### свойство ColCount | |
| 441 | 443 | ||
| 442 | 444 | Всегда \[будет значение\] 2. | |
| 443 | 445 | ||
| 444 | 446 | #### Общие замечания по использованию TValueListEditor | |
| 445 | 447 | ||
| 446 | 448 | При манипулировании содержимым ValueListEditor (сетка) рекомендуется манипулировать лежащим в основе свойством Strings.\ | |
| 447 | 449 | Если вы хотите вставлять или удалять строки, то либо делайте это путем прямого доступа к свойству Strings, либо используйте общедоступные методы из `TValueListEditor`: `DeleteRow()`, `InsertRow()`, `MoveRow()` и `ExchangeRow()`.\ | |
| 448 | 450 | Попытка использовать методы предка для управления строками или столбцами (например, Columns.Add) может привести к сбою. | |
| 449 | 451 | ||
| 450 | 452 | #### Saving and loading the contenst of a TValueListEditor | |
| 451 | 453 | ||
| 452 | 454 | ##### Using the Strings property | |
| 453 | 455 | ||
| 454 | 456 | If you just want to save and load the content of the TValueListEditor (e.g. the Key/Value pairs, not the layout) you can use Strings.SaveToFile and StringsLoadFromFile.\ | |
| 455 | 457 | In case of LoadFromFile the `RowCount` property will be autmatically adjusted.\ | |
| 456 | 458 | No sanity checks are performed upon LoadFromFile (so lines that do not represent a Key/Value pair will end up as Keys without Value). | |
| 457 | 459 | ||
| 458 | 460 | ##### Using TValueList.SaveToFile and TValueList.LoadFromFile | |
| 459 | 461 | ||
| 460 | 462 | When using SaveToFile and LoadFromFile you get the additional benefits of also being able to save and load the layout, like with other grids.\ | |
| 461 | 463 | SaveToFiel will also save information about wether or not the TValueListEditor uses ColumnTitles, and if so, it saves them.\ | |
| 462 | 464 | ||
| 463 | 465 | In contrast to it's ancestors TValueList.LoadFromFile performs sanity checks on the file it tries to read. In particular RowCount must be specified and there cannot be a cell with RowIndex \> RowCount or ColumnIndex other than 0 or 1.\ | |
| 464 | 466 | If the file does not seem to be a valid TValueListEditor grid file, and exception is raised.\ | |
| 465 | 467 | ||
| 466 | 468 | TValueList.SaveToFile and TValueList.LoadFromFile do not work correctly in Lazarus versions \<= 2.1 r62044. | |
| 467 | 469 | ||
| 468 | 470 | ##### Using SaveToCSVFile and LoadFromCSV file | |
| 469 | 471 | ||
| 470 | 472 | These methods should not be used at the moment, since for a TValueListEditor they are flawed. | |
| 471 | 473 | ||
| 472 | 474 | ## Работа с сетками | |
| 473 | 475 | ||
| 474 | 476 | ### Настройка сеток | |
| 475 | 477 | ||
| 476 | 478 | Сетка - это компоненты, полученные из класса [TCustomControl](http://lazarus-ccr.sourceforge.net/docs/lcl/controls/tcustomcontrol.html) и не имеющие родственного виджета, связанного с ними, что означает, что сетки не ограничены по виду текущей темы интерфейса. Это может быть как преимуществом, так и недостатком: обычно программисты хотят создавать приложение с одинаково выглядящим интерфейсом. Хорошей новостью является то, что сетки Lazarus достаточно гибки, чтобы получить что-то из обоих миров; программисты могут легко сделать сетки похожими на другие собственные элементы управления, или они могут настроить сетку в мельчайших деталях, чтобы они могли получать почти одинаковый вид в любом интерфейсе платформы или виджета (то есть, за исключением полос прокрутки, поскольку их внешний вид все еще определяется текущей темой). | |
| 477 | 479 | ||
| 478 | 480 | ### Свойства и События для настройки сеток | |
| 479 | 481 | ||
| 480 | 482 | Некоторые свойства могут влиять на то, как выглядит сетка, действуя, когда ячейка собирается быть отрисованной в PrepareCanvas/OnPrepareCanvas, изменяя свойства холста по умолчанию, такие как цвет кисти или шрифт. Ниже приведен список таких свойств: | |
| 481 | 483 | ||
| 482 | 484 | - **AlternateColor.** Этим \[свойством\] пользователь может изменить цвет фона, появляющийся в чередующихся строках. Это позволяет легко считывать данные строк сетки. | |
| 483 | 485 | - **Color.** Это \[свойство\] устанавливает основной цвет, используемый для отрисовки фона нефиксированных ячеек. | |
| 484 | 486 | - **FixedColor.** Это цвет, используемый для создания фона фиксированных ячеек. | |
| 485 | 487 | - **Flat.** Это \[свойство\] устраняет трехмерный вид фиксированных ячеек \[(т.е. делает их плоскими)\].\ | |
| 486 | 488 | - **TitleFont.** Шрифт, используемый для отрисовки текста в фиксированных ячейках.\ | |
| 487 | 489 | - **TitleStyle.** Это свойство изменяет трехмерный вид неподвижных ячеек, имеет 3 значения \[стилей\]: | |
| 488 | 490 | - *tsLazarus.* Это стандартный вид. | |
| 489 | 491 | - *tsNative.* Это \[свойство\] пытается установить внешний вид, соответствующий текущей теме виджетов. | |
| 490 | 492 | - *tsStandard.* Этот стиль представляет собой более контрастный вид, как у сетки Delphi. | |
| 491 | 493 | - **AltColorStartNormal.** Boolean\[-свойство\]. Если \[имеет значение\] true: чередующийся цвет всегда находится во второй строке после фиксированных строк, первая строка после фиксированных строк будет всегда цветной. Если \[имеет значение\] false: цвет по умолчанию установлен в первую строку, как если бы не было фиксированных строк. | |
| 492 | 494 | - **BorderColor.** Это \[свойство\] устанавливает цвет границы сетки, используемую, когда Flat:=True и BorderStyle:=bsSingle; | |
| 493 | 495 | - **EditorBorderStyle.** Если установлено значение bsNone под \[ОС\] windows, редакторы ячейки не будут иметь границы, как в delphi по умолчанию для bsSingle, потому что граница может быть специфичной для темы в некоторых виджетах и обеспечивать единообразный внешний вид.\ | |
| 494 | 496 | - **FocusColor.** Цвет, используемый для отрисовки текущего фокуса ячейки, если \[свойство\] UseXORFeatures не установлено, по умолчанию это clRed. | |
| 495 | 497 | - **FocusRectVisible.** Включает/Выключает отрисовку фокуса ячейки. | |
| 496 | 498 | - **GridLineColor.** Цвет линий сетки в нефиксированной области. | |
| 497 | 499 | - **GridLineStyle.** Стиль Pen используется для отрисовки линий в нефиксированной области, возможны следующие варианты: *psSolid*, *psDash*, *psDot*, *psDashDot*, *psDashDotDot*, *psinsideFrame*, *psPattern*,*psClear*. По умолчанию - *psSolid*. | |
| 498 | 500 | - **SelectedColor.** Цвет, используемый для отрисовки фона ячейки на выбранных ячейках. | |
| 499 | 501 | - **UseXORFeatures.** Если установлено, прямоугольник фокуса рисуется с использованием режима XOR, поэтому он должен сделать видимым прямоугольник фокуса в сочетании с любым цветом ячейки. Это также влияет на просмотр движущихся столбцов. | |
| 500 | 502 | - **DefaultDrawing.** Boolean\[-свойство\]. Обычно сетки готовят холст сетки с использованием некоторых свойств в соответствии с видом окрашиваемой ячейки. Если пользователь пишет обработчик событий OnDrawCell, набор DefaultDrawing также рисует фон ячейки. Если пользователь сам рисует ячейку, лучше отключить это свойство, чтобы отрисовка не дублировалась. В StringGrid набор DefaultDrawing рисует текст в каждой ячейке. | |
| 501 | 503 | - **AutoAdvance.** \[свойство определяет,\] куда установится курсор ячейки при нажатии \[клавиши\] enter или после редактирования. | |
| 502 | 504 | - **TabAdvance.** \[свойство определяет,\] куда переместится курсор ячейки при нажатии \[клавиши\] Tab или Shift-Tab. | |
| 503 | 505 | - **ExtendedColSizing.** Если \[значение равно\] true, пользователь может изменять размер столбцов не только в заголовках, но и по высоте столбцов. | |
| 504 | 506 | ||
| 505 | 507 | Другие свойства, которые также влияют на то, как выглядят сетки. | |
| 506 | 508 | ||
| 507 | 509 | **Options**. | |
| 508 | 510 | ||
| 509 | 511 | ||
| 510 | 512 | Свойство Options - это набор некоторых элементов для обеспечения разнообразной функциональности, но некоторые из них напрямую связаны с внешним видом сетки. Эти параметры можно установить в режиме разработки(designtime) или времени выполнения(runtime). | |
| 511 | 513 | ||
| 512 | 514 | - **goFixedVertLine, goFixedHorzLine** \[свойство\] рисует вертикальную или горизонтальную линию, соответственно разграничивая ячейки или столбцы в фиксированной области, по умолчанию \[значение равно\] active. | |
| 513 | 515 | - **goVertLine, goHorzLine** \[свойство аналогично\] предыдущему, но для нормальной просматриваемой области. Сетка может быть создана для имитации списка, \[если\] отключить оба этих элемента. | |
| 514 | 516 | - **goDrawFocusSelected** если этот элемент включен, фон выделения отрисовывается в сфокусированной ячейке в дополнение к пунктирному прямоугольнику фокуса (обратите внимание, что это не работает, когда установлена опция goRowSelect, в этом случае строка всегда отрисовывается так, как если бы была выбрана опция goDrawFocusSelected) | |
| 515 | 517 | - **goRowSelect** выбирает \[для выделения\] полную строку вместо отдельных ячеек | |
| 516 | 518 | - **goFixedRowNumbering** если \[свойство\] установлено, сетка будет нумеровать строки в первом фиксированном столбце | |
| 517 | 519 | - **goHeaderHotTracking** если \[свойство\] установлено, сетка попытается показать другой вид \[ячейки, когда\] курсор мыши будет находиться над любой фиксированной ячейкой. Для того, чтобы это сработало, желаемая зона ячейки должна быть включена с помощью свойства HeaderHotZones. Попробуйте комбинировать этот параметр с свойством TitleStyle:=tsNative, чтобы получить подсвечивание \[соответственно\] теме \[виджета\]. | |
| 518 | 520 | - **goHeaderPushedLook** если этот параметр установлен, этот элемент включает \[эффект\] "нажатия" при клике \[мышью\] любой фиксированной ячейки. Зона "нажатия" ячеек становится доступной при использовании свойства HeaderPusedZones. | |
| 519 | 521 | ||
| 520 | 522 | (напишите еще) | |
| 521 | 523 | ||
| 522 | 524 | ### Описание процесса отрисовки сетки | |
| 523 | 525 | ||
| 524 | 526 | Как и другие настраиваемые элементы управления, сетка отрисовывается с использованием метода рисования. В общих чертах сетка отрисовывается путем рисования всех строк и каждой строки путем рисования ее отдельных ячеек. | |
| 525 | 527 | ||
| 526 | 528 | Процесс заключается в следующем: | |
| 527 | 529 | ||
| 528 | 530 | - Сначала определяется область видимых ячеек: каждая строка проверяется, пересекает ли она область отсечения холста; если все в порядке, то видимая область окрашивается путем рисования столбцов каждой строки. | |
| 529 | 531 | - Значения столбцов и строк используются для идентификации ячейки, которая должна быть окрашена, и снова каждый столбец проверяется на пересечение с областью отсечения; если все в порядке, некоторые дополнительные свойства, такие как прямоугольная протяженность ячейки и визуальное состояние, передаются в качестве аргументов методу DrawCell. | |
| 530 | 532 | - Когда процесс отрисовки выполняется, визуальное состояние каждой ячейки настраивается в соответствии с параметрами сетки и расположением в сетке. Визуальное состояние сохраняется в виде типа TGridDrawState, который представляет собой набор со следующими элементами: | |
| 531 | 533 | - *gdSelected* У ячейки будет выделенный вид. | |
| 532 | 534 | - *gdFocused* Ячейка будет иметь \[рамку\] фокуса. | |
| 533 | 535 | - *gdFixed* Ячейка будет нарисована \[как\] фиксированная. | |
| 534 | 536 | - *gdHot* \[когда\] мышь находится над этой ячейкой, то она отрисовывается с подсвечиванием. | |
| 535 | 537 | - *gdPushed* \[когда по\] ячейке \[кликают мышью\], она отрисовывается как нажимаемая \[(кликабельная)\] | |
| 536 | 538 | - **DrawCell.** Метод DrawCell является виртуальным и может быть переопределен в унаследованных сетках для выполнения пользовательского рисования. Информация, переданная DrawCell, помогает идентифицировать конкретную ячейку, которая окрашивается, физическую область, занятую экраном, и ее видимый статус. Подробнее см. ссылку DrawCell. Для каждой ячейки происходит следующее: | |
| 537 | 539 | - **PrepareCanvas.** В этом методе, если установлено свойство DefaultDrawing, холст сетки настраивается со свойствами по умолчанию для кисти и шрифта на основе текущего визуального состояния. Для нескольких свойств дизайн-тайма и времени выполнения выравнивание текста устанавливается в соответствии с выбором программиста в пользовательских столбцах, если они существуют. Если DefaultDrawing \[имеет значение\] false, цвет кисти устанавливается в clWindow и цвет шрифта в clWindowText, выравнивание текста задается значением defaultTextStyle сетки. | |
| 538 | 540 | - **OnPrepareCanvas.** Если программист написал обработчик событий для события OnPrepareCanvas, он вызывается в этот момент. Это событие можно использовать для простой настройки, например: изменения цвета фона ячейки, свойств шрифта, таких как цвет, шрифт и стиль, расположение текста, как различные комбинации левого, центрального, верхнего, нижнего, правого выравнивания и т.д. Любые изменения, сделанные на холсте \[ранее\] в этом событии будут потеряны, потому что следующая перерисовка ячейки снова сбросит содержимое холста до состояния по умолчанию. Поэтому безопасно делать изменения только для конкретной ячейки или клеток и забыть об этом для остальных. Использование этого события иногда помогает избежать использования события сетки OnDrawCell, где пользователи будут вынуждены дублировать код отрисовки сетки.\ | |
| 539 | 541 | *Todo*: образцы того, что можно сделать и что оставить для OnDrawCell? ... | |
| 540 | 542 | - **OnDrawCell.** Если не указан обработчик для события OnDrawCell, следующим сетка вызывает метод DefaultDrawCell, который просто рисует фон ячейки, используя текущий цвет и стиль кисти холста. Если обработчик OnDrawCell существует, сетка сначала рисует фон ячейки, но только если установлено свойство DefaultDrawing, \[которое, в свою очередь,\] вызывает событие OnDrawCell для создания пользовательской отрисовки клетки. Обычно программисты хотят делать пользовательскую отрисовку только для определенных ячеек и стандартную отрисовку для других; в этом случае они могут ограничить пользовательскую операцию определенной ячейкой или ячейками, просмотрев аргументы ACol, ARow и AState, а для других ячеек просто вызывают метод DefaultDrawCell и позволяют сетке позаботиться об этом. | |
| 541 | 543 | - **Text.** В этот момент (только для TStringGrid), если свойство DefaultDrawing \[имеет значение\] true, рисуется текстовое содержимое ячейки. | |
| 542 | 544 | - **Grid lines** Последний шаг для каждой ячейки состоит в том, чтобы нарисовать линии сетки: если параметры сетки goVertLine, goHorzLine, goFixedVertLine и goFixedHorzLine указаны, ячейка сетки рисуется в этой точке. Сетки только со строками или только со столбцами могут быть получены путем изменения этих параметров. Если программист предпочел бы иметь "тематический" вид, то это делается и в этот момент (см. свойство TitleStyle). | |
| 543 | 545 | - **FocusRect.** Когда все столбцы текущей строки были отрисованы, наступает время рисовать прямоугольник фокуса для текущей выбранной ячейки или для всей строки, если установлена опция goRowSelect. | |
| 544 | 546 | ||
| 545 | 547 | #### Различия с Delphi | |
| 546 | 548 | ||
| 547 | 549 | - В Lazarus метод TCustomGrid.DrawCell не является абстрактным, и его реализация по умолчанию выполняет базовое заполнение фона ячейки. | |
| 548 | 550 | - В Delphi текст ячейки рисуется перед входом в событие OnDrawCell (см. [bug report \#9619](http://www.freepascal.org/mantis/view.php?id=9619)). | |
| 549 | 551 | ||
| 550 | 552 | ### Выбор ячейки сетки | |
| 551 | 553 | ||
| 552 | 554 | Расположение текущей (сфокусированной) ячейки (или строки) сетки может быть изменено с помощью клавиатуры, мыши или кода. Чтобы успешно сменить фокус ячейки на другую позицию, мы должны проверить целевую позицию, чтобы увидеть, разрешено ли ей получать фокус ячейки. При использовании клавиатуры свойство AutoAdvance выполняет часть процесса, обнаруживая, что должно быть следующей сфокусированной ячейкой. При использовании кликов мыши или перемещения \[посредством\] кода фокус не будет перемещаться из текущей ячейки, если целевой ячейке не разрешено получать фокус. | |
| 553 | 555 | ||
| 554 | 556 | Сетка вызывает функцию SelectCell, чтобы увидеть, является ли ячейка фокусируемой: если эта функция возвращает true, то целевая ячейка, идентифицированная с аргументами aCol и aRow, является фокусируемой (текущая реализация TCustomGrid просто возвращает true). TCustomDrawGrid и, следовательно, TDrawGrid и TStringGrid переопределяют этот метод, чтобы сначала проверить, \[является ли\] ячейка шире, чем 0; обычно вы не хотите, чтобы ячейка с нулевой шириной 0 выбиралась, \[другими словами, вы хотите,\] чтобы ячейка с этими характеристиками пропускалась автоматически в процессе поиска подходящей ячейки. Другая вещь, которую переопределяет метод SelectCell, - это вызов настраиваемое пользователем событие OnSelectCell: это событие принимает координаты ячейки как аргументы и всегда возвращает значение по умолчанию true. | |
| 555 | 557 | ||
| 556 | 558 | Как только \[становится\] известно, что ячейка \[является\] фокусируемой, и мы уверены, что движение будет иметь место, сначала вызывается метод BeforeMoveSelection; это по очереди вызывает событие OnBeforeSelection. Аргументами этого метода являются координаты для новой сфокусированной ячейки. В этот момент \[также будет\] скрыт любой видимый редактор. Слово "перед" означает, что выбор еще не изменен, и к текущим сфокусированным координатам можно получить доступ по свойствам grid.Col и grid.Row. | |
| 557 | 559 | ||
| 558 | 560 | После этого меняются координаты внутренней сфокусированной ячейки, а затем вызывается метод MoveSelection; цель этого метода заключается в том, чтобы инициировать событие OnSelection, если оно установлено (это уведомление, что сфокусированная ячейка к этому времени уже изменилась и координаты ячейки теперь доступны через свойства grid.row и grid.col). | |
| 559 | 561 | ||
| 560 | 562 | Обратите внимание, что неэффективно использовать событие OnSelectCell для обнаружения изменений фокуса ячейки, так как это событие будет срабатывать несколько раз даже для одной и той же ячейки в процессе поиска подходящей ячейки. Для этого лучше использовать события OnBeforeSelection или OnSelection. | |
| 561 | 563 | ||
| 562 | 564 | #### Различия с Delphi | |
| 563 | 565 | ||
| 564 | 566 | - Поведение SelectCell и OnSelectCell, вероятно, различны - в действительности не могу судить о различиях. В Lazarus они используются в таких функциях, как AutoAdvance, которая, насколько я знаю, не существует в Delphi. | |
| 565 | 567 | ||
| 566 | 568 | ### Когда встроенных свойств недостаточно: наследники сетки | |
| 567 | 569 | ||
| 568 | 570 | Наследники сетки обычно должны переопределять следующие методы:\ | |
| 569 | 571 | DrawAllRows: Отрисовывать все видимые строки\ | |
| 570 | 572 | DrawRow: Отрисовывать все ячейки в строке.\ | |
| 571 | 573 | DrawRow отрисовывает все ячейки в строке, предварительно проверив, находится ли ячейка в области отсечения, и только \[потом\] рисует ячейку, если она есть.\ | |
| 572 | 574 | DrawCell:\ | |
| 573 | 575 | DrawCellGrid:\ | |
| 574 | 576 | DrawCellText:\ | |
| 575 | 577 | DrawFocusRect:\ | |
| 576 | 578 | (напишите мне).\ | |
| 577 | 579 | ||
| 578 | 580 | ### Что происходит в методе `TCustomGrid.Paint`? | |
| 579 | 581 | ||
| 580 | 582 | В следующем списке показан внутренний порядок вызовов методов для отрисовки `TCustomGrid` (или потомков). Каждый элемент в списках представляет вызовы методов во время операции отрисовки. Это должно помочь найти правильный точку для изменения поведения, когда дело доходит до \[написания\] наследников `TCustomGrid`. | |
| 581 | 583 | ||
| 582 | 584 | - **`DrawEdges`**: Рисует внешнюю границу сетки. | |
| 583 | 585 | - **`DrawAllRows`** (virtual): Рисует все строки в видимой части сетки. Это единственный метод, вызываемый в процессе отрисовки, который объявлен *`virtual`*. | |
| 584 | 586 | - **`DrawRow`** (virtual): Вызывается для каждой строки внутри текущего окна просмотра. | |
| 585 | 587 | - **`DrawCell`** (virtual): Сначала вызывается для каждой "нормальной" (т.е. не фиксированной) ячейки в строке. | |
| 586 | 588 | - **`PrepareCanvas`** (virtual): Устанавливает стили рисования холста в соответствии с визуальными свойствами текущей ячейки. | |
| 587 | 589 | - **`DrawFillRect`**: Рисует фон ячейки со стилями, установленными в `PrepareCanvas`. | |
| 588 | 590 | - **`DrawCellGrid`** (virtual): Рисует линии границы ячейки. | |
| 589 | 591 | - **`DrawFocusRect`** (virtual): В `TCustomGrid` этот метод ничего не делает. В наследниках сетки этот метод используется для рисования прямоугольника фокуса внутри активной ячейки. | |
| 590 | 592 | - **`DrawCell`** (virtual): (см. выше) Вызывается для каждой фиксированной ячейки в видимом окне просмотра строки. | |
| 591 | 593 | - **`DrawColRowMoving`**: активен только при перемещении столбца или строки. Этот метод рисует линию, которая указывает новую позицию строки/столбца. | |
| 592 | 594 | - **`DrawBorder`**: Если необходимо (`Flat=TRUE` и `BorderStyle=bsSingle`), это отрисовывает внутреннюю линию границы. | |
| 593 | 595 | ||
| 594 | 596 | #### Дополнительные методы для рисования `TCustomGrid` | |
| 595 | 597 | ||
| 596 | 598 | Эти методы объявлены и (частично) реализованы в `TCustomGrid`, но они не вызываются непосредственно отсюда. Они используются классами потомков для отрисовки содержимого ячейки. | |
| 597 | 599 | ||
| 598 | 600 | - **`DrawCellText`** (virtual): Записывает/отрисовывает текст, который передается в качестве параметра в ячейку. Текст отформатирован с использованием стилей, которые активны в `Canvas.TextStyle` (см. также `PrepareCanvas`). | |
| 599 | 601 | - **`DrawThemedCell`** (virtual): Используется только для фиксированных ячеек и если `TitleStyle=tsNative`. \[Метод\] отрисовывает фон ячейки, используя `ThemeServices`. | |
| 600 | 602 | - **`DrawColumnText`** (virtual): Используется только для ячеек заголовков столбцов. | |
| 601 | 603 | - **`DrawColumnTitleImage`**: Если сетке сопоставлен `TitleImageList` и `Columns.Title[x].Title.ImageIndex` содержит допустимое значение, \[указанное в `ImageIndex`\] изображение отрисовывается внутри ячейки. | |
| 602 | 604 | - **`DrawCellText`** : (см. выше) | |
| 603 | 605 | - **`DrawTextInCell`** (virtual): Используется для "нормальных" (т.е. не фиксированных) ячеек. В `TCustomGrid` этот метод ничего не делает. В наследуемых сетках этот метод используется для отрисовки содержимого ячеек. В `TStringGrid` метод вызывает `DrawCellText` (см. выше). | |
| 604 | 606 | ||
| 605 | 607 | #### Методы рисования, введенные `TCustomDrawGrid` | |
| 606 | 608 | ||
| 607 | 609 | Как вы можете видеть, базовый класс `TCustomGrid` не выводит никакого содержимого в ячейки. Это делается в **`TCustomDrawGrid`**. **`TCustomDrawGrid`** переопределяет метод `DrawCell` следующим образом: | |
| 608 | 610 | ||
| 609 | 611 | - **`DrawCell`** (override): | |
| 610 | 612 | - **`PrepareCanvas`**: вызывает унаследованный метод из **`TCustomGrid`**. | |
| 611 | 613 | - **`DefaultDrawCell`** (virtual): Этот метод вызывается только в том случае, если обработчик события для `OnDrawCell` НЕ назначен. | |
| 612 | 614 | - **`DrawFillRect / DrawThemedCell`** (von `TCustomGrid`): Рисует фон ячейки. Если `TitleStyle=tsNative`, фон фиксированных ячеек рисуется с помощью `DrawThemedCell`. | |
| 613 | 615 | - **`DrawCellAutonumbering`** (virtual): Если \[свойство\] `goFixedAutonumbering` \[включено\] в \[набор\] `Options`, номера строк отображаются в первом фиксированном столбце \[с помощью метода\] `TCustomGrid.DrawCellText`. | |
| 614 | 616 | - **`DrawColumnText`** (из `TCustomGrid`): Вызывается только для ячеек заголовков столбцов (см. «Дополнительные методы отрисовки в `TCustomGrid`»). | |
| 615 | 617 | - **`DrawTextInCell`** (из `TCustomGrid`): Вызывается только для "нормальных" (т.е. не фиксированных) ячеек (см. «Дополнительные методы отрисовки в `TCustomGrid`»). | |
| 616 | 618 | - **`DrawCellGrid`** (virtual): Рисует границы ячейки. | |
| 617 | 619 | ||
| 618 | 620 | ### Сохранение и получение содержимого сетки | |
| 619 | 621 | ||
| 620 | 622 | Методы **SaveToFile** и **LoadFromFile** позволяют сетке сохранять и извлекать ее макет и данные в/из файла формата XML. TStringGrid, как унаследованный от TCustomStringGrid, также имеет возможность "экспортировать" и "импортировать" свой контент в файл формата Comma Separated Values, наиболее известный как CSV-файлы. Это описано в ссылке методов [[Grids Reference Page/ru|SaveToCSVFile]] и [[Grids Reference Page/ru|LoadFromCSVFile]]. | |
| 621 | 623 | ||
| 622 | 624 | Тип информации, которая может быть сохранена, а затем извлечена при использовании **SaveToFile** и **LoadFromFile**, определяется свойством SaveOptions (тип TSaveOptions), которое представляет собой набор параметров, описанных ниже: | |
| 623 | 625 | ||
| 624 | - | ||
| 625 | - | ||
| 626 | - | ||
| 627 | - | ||
| 628 | - | ||
| 629 | - | ||
| 626 | + | ``` pascal | |
| 627 | + | soDesign: Сохраняет и загружает ColCount,RowCount,FixedCols,FixedRows, | |
| 628 | + | ColWidths, RowHeights и Options (TCustomGrid) | |
| 629 | + | soPosition: Сохраняет и загружает Scroll position, Row, Col и Selection (TCustomGrid) | |
| 630 | + | soAttributes: Сохраняет и загружает Colors, Text Alignment и Layout, и т.д. (TCustomDrawGrid) | |
| 631 | + | soContent: Сохраняет и загружает текст (TCustomStringGrid) | |
| 632 | + | soAll: набор всех параметров (soAll:=[soDesign,soPosition,soAttributes,soContent];) | |
| 633 | + | ``` | |
| 630 | 634 | ||
| 631 | 635 | Не все параметры применимы ко всем типам сеток, например, soContent не применяется к наследникам сеток TCustomGrid, таким как TDrawGrid, поскольку такая сетка не имеет понятия "контент". TStringGrid - это специальный вид сетки, который "знает", как обрабатывать строки, и может использовать параметр soContent, если он указан. | |
| 632 | 636 | ||
| 633 | 637 | Опция soAttributes не используется в стандартных сетках Lazarus, \[она предназначена\] для наследников сеток. | |
| 634 | 638 | ||
| 635 | 639 | При использовании **LoadFromFile** сетка также использует свойство SaveOptions, чтобы знать, какая информация должна извлекаться из файла, поэтому вполне возможно указать SaveOptions:=\[soDesign,soContent\] при сохранении и только SaveOptions:=\[soContent\] при загрузке. | |
| 636 | 640 | ||
| 637 | 641 | Для TStringGrid значение SaveOptions по умолчанию - \[soContent\], для других видов сеток SaveOptions - это пустой набор. | |
| 638 | 642 | ||
| 639 | 643 | **На заметку:** Одна из распространенных проблем при сохранении и извлечении данных сетки возникает \[тогда\], когда пользователь определяет свойство SaveOptions перед \[методом\] **SaveToFile**, но не раньше \[вызова метода\] **LoadFromFile**. При использовании **LoadFromFile** через некоторое время после **SaveToFile**, свойство SaveOptions устанавливается должным образом, но если **LoadFromFile** выполняется при следующем запуске программы, свойство SaveOptions может настроиться неправильно, по этой причине рекомендуется всегда указывать свойство SaveOptions непосредственно перед \[вызовом метода\] **LoadFromFile** или делать это глобально при запуске программы, как в следующем примере: | |
| 640 | 644 | ||
| 641 | 645 | ------------------------------------------------------------------------ | |
| 642 | 646 | ||
| 643 | 647 | **Пример:** | |
| 644 | 648 | ||
| 645 | 649 | 1. Сначала перейдите в меню "File -\> New -\> Application"; | |
| 646 | 650 | 2. Бросьте пустой TStringGrid в форму; | |
| 647 | 651 | 3. Бросьте TButton и TOpenDialog на форму; | |
| 648 | 652 | 4. Добавьте событие OnCreate для формы; | |
| 649 | 653 | 5. Добавьте событие OnClick для кнопки. | |
| 650 | 654 | ||
| 651 | 655 | ``` pascal | |
| 652 | 656 | unit Unit1; | |
| 653 | 657 | ||
| 654 | 658 | {$mode objfpc}{$H+} | |
| 655 | 659 | ||
| 656 | 660 | interface | |
| 657 | 661 | ||
| 658 | 662 | uses | |
| 659 | 663 | Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, Grids, | |
| 660 | 664 | Buttons, StdCtrls, XMLCfg; | |
| 661 | 665 | ||
| 662 | 666 | type | |
| 663 | 667 | ||
| 664 | 668 | { TForm1 } | |
| 665 | 669 | TForm1 = class(TForm) | |
| 666 | 670 | StringGrid1: TStringGrid; | |
| 667 | 671 | Button1: TButton; | |
| 668 | 672 | OpenDialog1: TOpenDialog; | |
| 669 | 673 | procedure Button1Click(Sender: TObject); | |
| 670 | 674 | procedure Form1Create(Sender: TObject); | |
| 671 | 675 | private | |
| 672 | 676 | { private declarations } | |
| 673 | 677 | public | |
| 674 | 678 | { public declarations } | |
| 675 | 679 | end; | |
| 676 | 680 | ||
| 677 | 681 | var | |
| 678 | 682 | Form1: TForm1; | |
| 679 | 683 | ||
| 680 | 684 | implementation | |
| 681 | 685 | ||
| 682 | 686 | { TForm1 } | |
| 683 | 687 | ||
| 684 | 688 | procedure TForm1.Form1Create(Sender: TObject); | |
| 685 | 689 | begin | |
| 686 | 690 | //устанавливаем SaveOptions во время создания формы | |
| 687 | 691 | stringgrid1.SaveOptions := [soDesign,soPosition,soAttributes,soContent]; | |
| 688 | 692 | end; | |
| 689 | 693 | ||
| 690 | 694 | procedure TForm1.Button1Click(Sender: TObject); | |
| 691 | 695 | begin | |
| 692 | 696 | //Спрашиваем, был ли запущен метод Execute [компонента] OpenDialog | |
| 693 | 697 | //когда это происходит, пользователь выбирает файл XML для загрузки | |
| 694 | 698 | //имя, которое было сохранено в объявлении FileName. | |
| 695 | 699 | ||
| 696 | 700 | if opendialog1.Execute then | |
| 697 | 701 | begin | |
| 698 | 702 | //Очищаем сетку | |
| 699 | 703 | StringGrid1.Clear; | |
| 700 | 704 | //Загружаем XML | |
| 701 | 705 | StringGrid1.LoadFromFile(OpenDialog1.FileName); | |
| 702 | 706 | //Обновляем сетку | |
| 703 | 707 | StringGrid1.Refresh; | |
| 704 | 708 | end; | |
| 705 | 709 | end; | |
| 706 | 710 | ||
| 707 | 711 | initialization | |
| 708 | 712 | {$I unit1.lrs} | |
| 709 | 713 | ||
| 710 | 714 | end. | |
| 711 | 715 | ``` | |
| 712 | 716 | ||
| 713 | 717 | ------------------------------------------------------------------------ | |
| 714 | 718 | ||
| 715 | 719 | **Образец xml-файла:** (Скопируйте текст ниже в текстовый файл. Не забудьте поставить заголовок xml :-)) | |
| 716 | 720 | ||
| 717 | 721 | ``` xml | |
| 718 | 722 | <?xml version="1.0"?> | |
| 719 | 723 | <CONFIG> | |
| 720 | 724 | <grid version="3"> | |
| 721 | 725 | <saveoptions create="True" position="True" content="True"/> | |
| 722 | 726 | <design columncount="2" rowcount="5" fixedcols="1" fixedrows="1" defaultcolwidth="64" defaultRowHeight="20"> | |
| 723 | 727 | <options> | |
| 724 | 728 | <goFixedVertLine value="True"/> | |
| 725 | 729 | <goFixedHorzLine value="True"/> | |
| 726 | 730 | <goVertLine value="True"/> | |
| 727 | 731 | <goHorzLine value="True"/> | |
| 728 | 732 | <goRangeSelect value="True"/> | |
| 729 | 733 | <goDrawFocusSelected value="False"/> | |
| 730 | 734 | <goRowSizing value="False"/> | |
| 731 | 735 | <goColSizing value="False"/> | |
| 732 | 736 | <goRowMoving value="False"/> | |
| 733 | 737 | <goColMoving value="False"/> | |
| 734 | 738 | <goEditing value="False"/> | |
| 735 | 739 | <goTabs value="False"/> | |
| 736 | 740 | <goRowSelect value="False"/> | |
| 737 | 741 | <goAlwaysShowEditor value="False"/> | |
| 738 | 742 | <goThumbTracking value="False"/> | |
| 739 | 743 | <goColSpanning value="False"/> | |
| 740 | 744 | <goRelaxedRowSelect value="False"/> | |
| 741 | 745 | <goDblClickAutoSize value="False"/> | |
| 742 | 746 | <goSmoothScroll value="True"/> | |
| 743 | 747 | </options> | |
| 744 | 748 | </design> | |
| 745 | 749 | <position topleftcol="1" topleftrow="1" col="1" row="1"> | |
| 746 | 750 | <selection left="1" top="1" right="1" bottom="1"/> | |
| 747 | 751 | </position> | |
| 748 | 752 | <content> | |
| 749 | 753 | <cells cellcount="10"> | |
| 750 | 754 | <cell1 column="0" row="0" text="Title Col1"/> | |
| 751 | 755 | <cell2 column="0" row="1" text="value(1.1)"/> | |
| 752 | 756 | <cell3 column="0" row="2" text="value(2.1)"/> | |
| 753 | 757 | <cell4 column="0" row="3" text="value(3.1)"/> | |
| 754 | 758 | <cell5 column="0" row="4" text="value(4.1)"/> | |
| 755 | 759 | <cell6 column="1" row="0" text="Title Col2"/> | |
| 756 | 760 | <cell7 column="1" row="1" text="value(1.2)"/> | |
| 757 | 761 | <cell8 column="1" row="2" text="value(2.2)"/> | |
| 758 | 762 | <cell9 column="1" row="3" text="value(3.2)"/> | |
| 759 | 763 | <cell10 column="1" row="4" text="value(4.2)"/> | |
| 760 | 764 | </cells> | |
| 761 | 765 | </content> | |
| 762 | 766 | </grid> | |
| 763 | 767 | </CONFIG> | |
| 764 | 768 | ``` | |
| 765 | 769 | ||
| 766 | 770 | ### Редактор ячеек сетки | |
| 767 | 771 | ||
| 768 | 772 | В сетке используются редакторы ячеек для изменения содержимого ячеек. | |
| 769 | 773 | ||
| 770 | 774 | Для специализированной сетки, такой как TStringGrid, редактор является обычным однострочным текстовым контролом, но иногда желательно иметь другие средства для ввода информации. Например: | |
| 771 | 775 | ||
| 772 | 776 | 1. показать диалоговое окно открытия файла, чтобы найти местоположение файла, чтобы пользователь не вводил полный путь вручную | |
| 773 | 777 | 2. если текст в ячейке представляет дату, \[вызвать\] всплывающий календарь, чтобы мы могли легко выбрать конкретную дату. | |
| 774 | 778 | ||
| 775 | 779 | Иногда информация, которую пользователь должен ввести в ячейку, ограничена определенным списком слов; в этом случае ввод информации напрямую может привести к ошибкам и, возможно, потребуется выполнить процедуру проверки. Мы можем избежать этого, используя редактор ячейки, который представляет пользователю список, содержащий только легальные значения. | |
| 776 | 780 | ||
| 777 | 781 | Это также относится к общим сеткам типа TDrawGrid, где пользователю нужна какая-то структура для хранения данных, которые будут отображаться в сетке. В этой ситуации информация, введенная в редакторе ячейки, обновляет внутреннюю структуру, чтобы отображать изменения в сетке. | |
| 778 | 782 | ||
| 779 | 783 | #### Встроенный редактор ячейки | |
| 780 | 784 | ||
| 781 | 785 | Модуль grids.pas уже включает некоторые из наиболее используемых редакторов ячеек, готовых для использования в сетках. Также возможно создавать новые редакторы ячеек (настраиваемые редакторы ячеек), если встроенные редакторы не подходят для конкретной задачи. | |
| 782 | 786 | ||
| 783 | 787 | Встроенные редакторы ячеек - это Button, Edit и Picklist. | |
| 784 | 788 | ||
| 785 | 789 | #### Использование редакторов ячейки | |
| 786 | 790 | ||
| 787 | 791 | Пользователи могут указать, какой редактор будет использоваться для ячейки, используя один из двух методов. | |
| 788 | 792 | ||
| 789 | 793 | 1. **Using a custom column and selecting the ButtonStyle property of the column** (*использование настраиваемого столбца и выбор свойства ButtonStyle для столбца*). В этом методе пользователь может выбрать стиль редактора, который будет показан. Доступными значениями являются: cbsAuto, cbsEllipsis, cbsNone, cbsPickList, cbsCheckboxColumn, cbsButtonColumn. | |
| 790 | 794 | 2. **Using OnSelectEditor grid event** (*Использование события сетки OnSelectEditor*). Здесь пользователь указывает в параметре Editor, какой редактор использовать для ячейки, обозначаемой столбцом aCol и строкой ARow наследуемой сетки TCustomDrawGrid или TColumn в TCustomDBGrid. Для этой цели существует полезная public-функция сетки EditorByStyle(), которая принимает в качестве параметра одно из следующих значений: cbsAuto, cbsEllipsis, cbsNone, cbsPickList, cbsCheckboxColumn, cbsButtonColumn. Этот метод имеет приоритет над первым при использовании пользовательских столбцов. Редактор пользовательских ячеек можно указать здесь (см. главу 5 [этого документа](http://www.freepascal.org/~michael/articles/grids/grids.pdf) (автор Michaël Van Canneyt), в которой объясняется, как правильно реализовывать пользовательский редактор). Это событие также позволяет настраивать редактор со значениями, специфичными для ячейки, строки или столбца (например, пользовательское всплывающее меню для редактора ячейки). | |
| 791 | 795 | ||
| 792 | 796 | Установка свойства *ButtonStyle* работает только в том случае, если столбец создан с помощью инструкции `StringGrid1.Columns.Add`. Использование выражения типа `StringGrid1.ColCount:=X;` вызовет исключение. Установка свойства ButtonStyle может быть выполнена с помощью подобного кода: | |
| 793 | 797 | ||
| 794 | 798 | ``` pascal | |
| 795 | 799 | if ColCB< StringGrid1.Columns.Count | |
| 796 | 800 | then StringGrid1.Columns.Items[ColCB].ButtonStyle:=cbsCheckboxColumn; | |
| 797 | 801 | ``` | |
| 798 | 802 | ||
| 799 | 803 | #### Описание стилей редактора | |
| 800 | 804 | ||
| 801 | 805 | Ниже приводится описание стилей редактора. Они являются значениями перечисляемого типа TColumnButtonStyle и поэтому имеют префикс 'cbs'. Этот тип использовался, чтобы оставаться совместимым с DBGrid Delphi. | |
| 802 | 806 | ||
| 803 | 807 | - **cbsAuto** | |
| 804 | 808 | ||
| 805 | 809 | ||
| 806 | 810 | Это стиль редактора по умолчанию для сеток-наследников TCustomGrid. Фактический класс редактора, который будет использоваться для редактирования содержимого ячейки, зависит от нескольких факторов. Для TCustomGrids он использует класс TStringCellEditor, полученный из TCustomMaskEdit. Этот редактор специализирован для редактирования строк одной строки. Затем он используется по умолчанию в TStringGrid и TDrawGrid. При использовании пользовательских столбцов, если программист заполнил свойство PickList столбца, \[редактор\] ведет себя так, как если бы был установлен стиль редактора cbsPickList. Для TCustomDBGrid, который имеет поле типа boolean, он ведет себя так, как если бы был указан стиль редактора cbsCheckBoxColumn. Это рекомендуемое значение для Custom Cell Editors. TODO: сослаться на OnEditingDone. | |
| 807 | 811 | ||
| 808 | 812 | - **cbsEllipsis** | |
| 809 | 813 | ||
| 810 | 814 | ||
| 811 | 815 | Этот стиль редактора является наиболее общим. При \[его\] использовании в ячейке редактирования появляется кнопка, и программисты могут использовать событие сетки OnEditButtonClick, чтобы определить, когда пользователь нажал кнопку, и выполнить любое действие, запрограммированное для такой ячейки. Например, программист может использовать этот стиль редактора, чтобы открыть диалог календаря, чтобы пользователь мог легко выбрать конкретную дату. Другие возможности могут заключаться в том, чтобы показать диалог открытия файла для поиска файлов, калькулятор, чтобы пользователь мог ввести числовой результат вычислений и т.д. | |
| 812 | 816 | ||
| 813 | 817 | ||
| 814 | 818 | OnEditButtonClick - это просто уведомление, чтобы узнать, в какой ячейке нажата кнопка, взглянув на свойства grid.Row и grid.Col. | |
| 815 | 819 | ||
| 816 | 820 | ||
| 817 | 821 | DBGrid имеет определенные свойства для извлечения активного столбца или поля, и, поскольку это событие происходит в активной записи, оно может обновлять информацию в активном поле. | |
| 818 | 822 | ||
| 819 | 823 | ||
| 820 | 824 | Этот стиль редактора реализован с использованием TButtonCellEditor, прямого потомка TButton. | |
| 821 | 825 | ||
| 822 | 826 | - **cbsNone** | |
| 823 | 827 | ||
| 824 | 828 | ||
| 825 | 829 | Этот стиль редактора указывает, что сетка не должна использовать какой-либо редактор для конкретной ячейки или столбца; \[это поведение аналогично тому\], как если бы такая ячейка или столбец сетки были только для чтения. | |
| 826 | 830 | ||
| 827 | 831 | - **cbsPickList** | |
| 828 | 832 | ||
| 829 | 833 | ||
| 830 | 834 | Используется для представления пользователю списка значений, которые могут быть введены. Этот стиль редактора реализован с использованием TPickListCellEditor, компонента, полученного из TCustomComboBox. Список отображаемых значений заполняется одним из двух способов в зависимости от метода, используемого для выбора стиля редактора. | |
| 831 | 835 | ||
| 832 | 836 | 1. При использовании настраиваемых столбцов программисты могут вводить список значений, используя свойство PickList столбца. \[ДЛЯ НОВИЧКОВ: TODO: точная процедура для редактирования списка\] | |
| 833 | 837 | 2. В OnSelectEditor программисты получают экземпляр TPickListCellEditor, используя функцию EditorByStyle(cbsPickList). [[Grids Reference Page/ru|См. пример здесь]] | |
| 834 | 838 | ||
| 835 | 839 | Значение в сетке TStringGrid будет автоматически отображать выбранное значение. При необходимости программист может определить момент, когда значение выбрано, путем написания обработчика для события OnPickListSelect сетки, поэтому могут быть предприняты дополнительные шаги (например, для обработки нового значения). TODO: связать с OnEditingDone. | |
| 836 | 840 | ||
| 837 | 841 | - **cbsCheckboxColumn** | |
| 838 | 842 | ||
| 839 | 843 | ||
| 840 | 844 | Это может быть полезно, когда содержимое данных, связанное с столбцом, ограничено парой значений, например да-нет, true-false, вкл-выкл, 1-0 и т.д. Вместо того, чтобы принуждать пользователя вводить значения для данных такого типа в StringCellEditor или выбирать один из списка, cbsCheckboxColumn используется для изменения данных столбца с помощью представления флажка, которое пользователь может переключать, используя щелчок мыши или нажимая клавишу SPACE (если столбец, содержащий этот флажок, а также StringGrid доступны для редактирования). | |
| 841 | 845 | ||
| 842 | 846 | Получение или установка значения флажка в ячейке осуществляется следующим образом: | |
| 843 | 847 | ||
| 844 | 848 | ``` pascal | |
| 845 | 849 | StringGrid1.Cell[x,y]:='Z'; | |
| 846 | 850 | ``` | |
| 847 | 851 | ||
| 848 | 852 | ||
| 849 | 853 | где Z заменяется на **0** для *Unchecked*, **1** для *Checked* и пустую строку для *Grayed*. Обратите внимание, что любое значение (строка), отличное от *0* и *1*, будет отображаться как серый сheckbox. | |
| 850 | 854 | ||
| 851 | 855 | ||
| 852 | 856 | Если для свойства столбцов ButtonStyle установлено значение cbsAuto, и DBGrid обнаруживает, что поле, связанное с столбцом, является логическим полем, то сетка автоматически использует этот стиль редактора. Этот автоматический выбор может быть отключен или активирован с использованием свойства OptionGxtra DBGrid; установка элемента dgeCheckboxColumn в false отключает эту функцию. | |
| 853 | 857 | ||
| 854 | 858 | ||
| 855 | 859 | Значения, используемые для распознавания *checked* или *unchecked* состояний, задаются в свойствах столбца ValueChecked и ValueUnchecked \[соответственно\]. | |
| 856 | 860 | ||
| 857 | 861 | ||
| 858 | 862 | В любой момент значение поля может находиться в одном-трех состояниях: Unchecked, Checked или Grayed. Внутренне эти состояния идентифицируются следующими значениями типа TDBGridCheckBoxState: gcbpUnChecked, gcbpChecked и gcbpGrayed. | |
| 859 | 863 | ||
| 860 | 864 | ||
| 861 | 865 | Этот стиль редактора не использует реальные компоненты TCheckbox для обработки взаимодействия с пользователем: визуальное представление задается тремя встроенными растровыми изображениями, которые соответствуют возможным состояниям флажка. Использованные растровые изображения можно настроить, написав обработчик для события OnUserCheckboxBitmap \[компонента\] DBGrid; обработчик этого события получает состояние флажка в параметре CheckedState типа TDBGridCheckboxState и параметр растрового изображения, который программист может использовать для указания пользовательских растровых изображений. | |
| 862 | 866 | ||
| 863 | 867 | - **cbsButtonColumn** | |
| 864 | 868 | ||
| 865 | 869 | ||
| 866 | 870 | Этот стиль редактора используется для отображения кнопки в каждой ячейке в столбце. Как и в случае cbsCheckboxColumn, этот редактор не использует реальные кнопки, внешний вид определяется текущей темой widgetset. | |
| 867 | 871 | ||
| 868 | 872 | ||
| 869 | 873 | Пользователь знает, какая конкретная кнопка была нажата благодаря обработчику OnEditButtonClick сетки и проверке столбца и строки. Обратите внимание, что в этом конкретном случае столбец и строка сетки идентифицируют не текущую выбранную ячейку, а ячейку нажатой кнопки. Как только событие OnEditButtonClick будет обработано, и если пользователь не изменил столбец или строку в этом обработчике, сетка автоматически сбрасывает столбец и строку, чтобы отобразить выбранную ячейку. Пока обработчик OnEditButtonClick текущего выделения сетки доступен в grid.Selection, который является свойством TRect, левое и правое \[значения\] представляют \[собой\] индексы столбцов, а верхний и нижний - индексы строк. | |
| 870 | 874 | ||
| 871 | 875 | ||
| 872 | 876 | Заголовок кнопки - соответствующая строка ячейки. | |
| 873 | 877 | ||
| 874 | 878 | ### Редактирование сеток | |
| 875 | 879 | ||
| 876 | 880 | Эффект редактирования отличается в зависимости от того, какая сетка используется, например, TStringGrid сохраняет отредактированный текст внутри, а TDBGrid влияет на записи в наборе данных. TDrawGrid "не знает", что делать с отредактированным текстом: если программист не контролирует его, \[отредактированный текст\] просто отбрасывается.\ | |
| 877 | 881 | Для TDrawGrid (хотя это должно работать для всех классов сетки), чтобы получить доступ к отредактированному тексту, программист может использовать событие **OnSetEditText**, которое запускается каждый раз, когда пользователь что-то изменяет в редакторе, параметры *aCol* и *Row* этого события определяют редактируемую ячейку, параметр *value* содержит \[редактируемый\] текст - это рекомендуемый метод. Другой способ доступа к отредактированному тексту - прием его непосредственно из редактора после завершения процесса редактирования с использованием события **OnEditingDone**. Это можно сделать, обратившись к внутреннему редактору, используемому для редактирования, в данном случае, по умолчанию "String Cell Editor" \[("Редактору строк ячеек")\]. Для этого существует два метода: первый - с использованием события **OnSelectEditor**, где параметр *Editor* - это экземпляр, который будет использоваться для редактирования ячейки; вы должны сохранить этот экземпляр в переменной, например TheEditor (типа *TStringCellEditor*), для последующего использования в **OnEditingDone**. Второй вариант - использование метода **EditorByStyle** сетки, этот метод принимает "стиль редактора" в качестве параметра и возвращает экземпляр редактора, соответствующего этому стилю. В нашем случае, зная, что стиль cbsAuto возвращает редактор ячейки по умолчанию, в обработчике события **OnEditingDone** можно использовать непосредственно TheEditor:=Grid.EditorByStyle(cbsAuto). Затем вы можете получить текст с помощью *TheEditor.Text*. Если вы \[будете\] использовать этот метод, обратите внимание на то, что "великая сила несет большую ответственность". | |
| 878 | 882 | ||
| 879 | 883 | #### Параметры и свойства, которые влияют на редактирование | |
| 880 | 884 | ||
| 881 | 885 | Поведение редактирования контролируется рядом свойств и параметров, фактически любая настройка или параметры, которые влияют на редактирование, требуют редактирования сетки или такая настройка может быть проигнорирована.\ | |
| 882 | 886 | При запуске редактируемое состояние сетки различно \[в разных видах сетках\], поскольку редактирование TDrawGrid и TStringGrid отключено, для TDbGrid включено по умолчанию.\ | |
| 883 | 887 | Свойство **Options** имеет несколько элементов, которые касаются редактирования, они описаны ниже:\ | |
| 884 | 888 | ***goEditing, dgEditing (в DbGrid)**. Эта опция изменяет редактируемое состояние сетки, ее можно изменить во время выполнения, поскольку она проверяет, когда начнется редактирование. | |
| 885 | 889 | ||
| 886 | 890 | - **goAlwaysShowEditor**. Обычно редактор скрыт и становится видимым только тогда, когда это необходимо. С помощью этой опции редактор будет отображаться все время, если сетка не редактируется, этот параметр игнорируется, и редактор всегда скрыт. | |
| 887 | 891 | ||
| 888 | 892 | ### Хинты (подсказки) ячейки | |
| 889 | 893 | ||
| 890 | 894 | В дополнение к стандартным хинтам большинства элементов управления потомки TCustomGrid могут отображать специальную подсказку для ячейки, над которой курсирует мышь. Эта функция управляется параметрами сетки **goCellHints** и **goTruncCellHints** (или **dgCellHints** и **gdTruncCellHints** для DBGrid соответственно): | |
| 891 | 895 | ||
| 892 | 896 | - **goCellHints** оценивает событие **OnGetCellHint** для извлечения отображаемого текста для ячейки, указанной переданными параметрами. В случае TDrawGrid и TStringGrid задаются индексы столбцов и строк, тогда как в случае TDBGrid текст ячейки может быть извлечен из поля, назначенного указанному объекту столбца. | |
| 893 | 897 | - **goTruncCellHints** отображает подсказку только в том случае, если текст не помещается \[полностью\] в ячейку и \[поэтому\] усечен; текст подсказки - это не обрезанный ячейкой текст. В Lazarus 1.9+ этот текст передается событию **OnGetCellHint** для дальнейшего уточнения (например, отображает весь текст memo в подсказке). В случае обрезания ячейкой текстов рекомендуется также активировать опцию **goCellEllipsis** (или **dgCellEllipsis** для DBGrid), которая добавляет «...» к обрезанному ячейкой тексту. | |
| 894 | 898 | ||
| 895 | 899 | Если сетка имеет значение в своем стандартном свойстве **Hint**, тогда свойство **HintPriority** можно использовать для управления тем, как все эти тексты подсказок могут быть объединены в одно всплывающее окно: | |
| 896 | 900 | ||
| 897 | 901 | - **chpAll** помещает стандартную подсказку в первую строку, подсказку, определяемую событием OnGetCellHint во вторую строку, и подсказку для усеченных ячеек в третью строку | |
| 898 | 902 | - **chpAllNoDefault** отображает подсказки только ячейки, заданные событием OnGetCellHint, и усеченными ячейками. | |
| 899 | 903 | - **chpTruncOnly** отображает подсказки только для усеченных ячеек; это настройки по умолчанию. | |
| 900 | 904 | ||
| 901 | 905 | В дополнение, стандартное свойство **ShowHint** сетки должно быть установлено в true, чтобы отображать подсказки на ячейки. | |
| 902 | 906 | ||
| 903 | 907 | ## "Как сделать..." и Примеры | |
| 904 | 908 | ||
| 905 | 909 | ### Фокусировка ячейки | |
| 906 | 910 | ||
| 907 | 911 | Фокусировка ячейки в TStringGrid очень проста. Обратите внимание, что подсчет начинается с нуля, а не 1. Таким образом, чтобы перевести фокус на строку 10, столбец 9, выполните: | |
| 908 | 912 | ||
| 909 | 913 | ``` pascal | |
| 910 | 914 | StringGrid1.row := 9; | |
| 911 | 915 | StringGrid1.col := 8; | |
| 912 | 916 | ``` | |
| 913 | 917 | ||
| 914 | 918 | ### Пример: Как настроить собственный редактор ячеек. | |
| 915 | 919 | ||
| 916 | 920 | см. lazarus/examples/gridexamples/gridcelleditor/gridcelleditor.lpi (начиная с laz 1.2) | |
| 917 | 921 | ||
| 918 | 922 | ### Пример: Как установить memo-редактор для dbgrids | |
| 919 | 923 | ||
| 920 | 924 | Разумеется, вы можете использовать другой контрол вместо TMemo. Откорректируйте \[на свой\] вкус. Адаптирован из [1](http://forum.lazarus.freepascal.org/index.php?topic=3640.0) (упрощенное использование свойства SelectedFieldRect, см. [2](http://forum.lazarus.freepascal.org/index.php/topic,8713.msg43288.html#msg43288)) | |
| 921 | 925 | ||
| 922 | 926 | - Поместите элемент управления memo (или любой другой контрол, который вы хотите) на свою форму, установите любые свойства, которые вы хотите, и установите значение visible:= false. Этот \[контрол\] будет использоваться при редактировании ячейки сетки. В этом примере мы будем использовать GridCellMemo. | |
| 923 | 927 | - В событии OnSelectEditor поместите следующий код - адаптируйте, если вы не хотите редактировать логический столбец 3, физический столбец 4: | |
| 924 | 928 | ||
| 925 | 929 | ``` pascal | |
| 926 | 930 | if (Column.DesignIndex = 3) then | |
| 927 | 931 | begin | |
| 928 | 932 | GridCellMemo.BoundsRect := DbGrid.SelectedFieldRect; | |
| 929 | 933 | GridCellMemo.Text:=Column.Field.AsString; | |
| 930 | 934 | Editor := GridCellMemo; | |
| 931 | 935 | end; | |
| 932 | 936 | ``` | |
| 933 | 937 | ||
| 934 | 938 | - Предположим, что ваш источник данных называется Datasource1, а DBGrid называется ResultsGrid. Тогда в событии OnEditingDone для GridCellMemo введите следующее: | |
| 935 | 939 | ||
| 936 | 940 | (В исходном сообщении форума используется событие OnChange, которое будет срабатывать при каждом изменении содержимого. Использование OnEditingDone запускается только после того, как пользователь закончил свои правки.) | |
| 937 | 941 | ||
| 938 | 942 | ``` pascal | |
| 939 | 943 | if not(Datasource1.State in [dsEdit, dsInsert]) then Datasource1.Edit; | |
| 940 | 944 | ||
| 941 | 945 | Datasource1.DataSet.FieldByName(ResultsGrid.SelectedField.FieldName).AsString:=GridCellMemo.Text; | |
| 942 | 946 | ``` | |
| 943 | 947 | ||
| 944 | 948 | **Осторожно** Использование обычного элемента управления в качестве настраиваемого редактора имеет множество недостатков: при изменении размеров столбцов или скроллинге сетки он не будет изменять размер или положение, вам придется позаботиться о том, чтобы изменить данные в сетке (как объяснялось выше), он не работает должным образом с DbGrids и препятствует нормальной навигации по сетке с помощью клавиатуры. Сетка взаимодействует с редактором, используя некоторые специальные сообщения сетки, поэтому лучше \[выделить этот контрол в\] подкласс для упорядочивания управления этими сообщениями, как описано в пятой главе [этого документа](http://www.freepascal.org/~michael/articles/grids/grids.pdf). | |
| 945 | 949 | ||
| 946 | 950 | **Осторожно** Если у вас более одной сетки в одной и той же форме, используйте разные настраиваемые редакторы для каждой из них: если вы \[будете\] использовать один и тот же элемент управления, начнут происходить плохие вещи с того момента, когда обе сетки попытаются использовать его одновременно. | |
| 947 | 951 | ||
| 948 | 952 | ### Пример: как добавить кнопку редактора | |
| 949 | 953 | ||
| 950 | 954 | ``` pascal | |
| 951 | 955 | // Условно показываем кнопку редактора в столбцах индекс 1 или 2, если | |
| 952 | 956 | // ячейка в столбце index 1 пуста | |
| 953 | 957 | procedure TForm1.StringGrid1SelectEditor(Sender: TObject; aCol, aRow: Integer; | |
| 954 | 958 | var Editor: TWinControl); | |
| 955 | 959 | begin | |
| 956 | 960 | if (aCol = 1) or (aCol = 2) then | |
| 957 | 961 | if StringGrid1.Cells[1,aRow] = '' then | |
| 958 | 962 | begin | |
| 959 | 963 | Editor := StringGrid1.EditorByStyle(cbsEllipsis); | |
| 960 | 964 | end; | |
| 961 | 965 | end; | |
| 962 | 966 | ||
| 963 | 967 | // Запуск действия ... | |
| 964 | 968 | procedure TForm1.StringGrid1EditButtonClick(Sender: TObject); | |
| 965 | 969 | begin | |
| 966 | 970 | if StringGrid1.Col = 1 then Showmessage('щелкнут редактор столбца 1'); | |
| 967 | 971 | if StringGrid1.Col = 2 then Showmessage('щелкнут редактор столбца 2'); | |
| 968 | 972 | end; | |
| 969 | 973 | ``` | |
| 970 | 974 | ||
| 971 | 975 | ### Пример: Запрет отображения текстовых полей как "(Memo)" для DBGrids | |
| 972 | 976 | ||
| 973 | 977 | Когда вы используете SQL-выражения, такие как `"Select * from A"`, вы можете увидеть "(Memo)" вместо своего содержимого в ячейке сетки. Есть много способов исправить это, но, может быть, самым простым является изменение вашего выражения `"Select * from A"` на `"Select Cast(Column as TEXT) as Column from A"`. Это обычная проблема при использовании компонента DBGrid. | |
| 974 | 978 | ||
| 975 | 979 | ``` pascal | |
| 976 | 980 | var | |
| 977 | 981 | sql : UTF8String; | |
| 978 | 982 | Query : TSQLQuery; | |
| 979 | 983 | ..... | |
| 980 | 984 | sql := 'SELECT cast(Name as TEXT) as Name FROM Client'; | |
| 981 | 985 | Query.SQL.Text:=sql; | |
| 982 | 986 | ``` | |
| 983 | 987 | ||
| 984 | 988 | ### Пример: Работа с Picklist, Как сделать его только для чтения и Как заполнить его в runtime. | |
| 985 | 989 | ||
| 986 | 990 | Используя событие сетки OnSelectEditor, вы можете настроить, как поведет себя редактор PickList (см. стиль кнопки cbsPickList). В следующем примере редактор списка выбора из столбца 1 изменяется на нечетных строках таким образом, что пользователь может вводить значения, набирая \[их с клавиатуры\], а на четных строках \[вводимые\] значения ограничиваются теми, которые содержатся в его списке. Кроме того, в этом примере показано, как заполнить список разными значениями в зависимости от обрабатываемой строки. | |
| 987 | 991 | ||
| 988 | 992 | ``` pascal | |
| 989 | 993 | procedure TForm1.gridSelectEditor(Sender: TObject; aCol, aRow: Integer; | |
| 990 | 994 | var Editor: TWinControl); | |
| 991 | 995 | begin | |
| 992 | 996 | if aCol=1 then begin | |
| 993 | 997 | if (Editor is TCustomComboBox) then | |
| 994 | 998 | with Editor as TCustomComboBox do begin | |
| 995 | 999 | if (aRow mod 2=0) then | |
| 996 | 1000 | Style := csDropDown | |
| 997 | 1001 | else | |
| 998 | 1002 | Style := csDropDownList; | |
| 999 | 1003 | case aRow of | |
| 1000 | 1004 | 1: | |
| 1001 | 1005 | Items.CommaText := 'ONE,TWO,THREE,FOUR'; | |
| 1002 | 1006 | 2: | |
| 1003 | 1007 | Items.CommaText := 'A,B,C,D,E'; | |
| 1004 | 1008 | 3: | |
| 1005 | 1009 | Items.CommaText := 'MX,ES,NL,UK'; | |
| 1006 | 1010 | 4: | |
| 1007 | 1011 | Items.CommaText := 'RED,GREEN,BLUE,YELLOW'; | |
| 1008 | 1012 | end; | |
| 1009 | 1013 | end; | |
| 1010 | 1014 | end; | |
| 1011 | 1015 | end; | |
| 1012 | 1016 | ``` | |
| 1013 | 1017 | ||
| 1014 | 1018 | ### Выравнивание текста в StringGrids | |
| 1015 | 1019 | ||
| 1016 | 1020 | Этот код показывает, как использовать разное выравнивание текста в столбцах 2 и 3. | |
| 1017 | 1021 | ||
| 1018 | 1022 | ``` pascal | |
| 1019 | 1023 | procedure TForm1.StringGrid1PrepareCanvas(sender: TObject; aCol, aRow: Integer; | |
| 1020 | 1024 | aState: TGridDrawState); | |
| 1021 | 1025 | var | |
| 1022 | 1026 | MyTextStyle: TTextStyle; | |
| 1023 | 1027 | begin | |
| 1024 | 1028 | if (aCol=2) or (aCol=3) then | |
| 1025 | 1029 | begin | |
| 1026 | 1030 | MyTextStyle := StringGrid1.Canvas.TextStyle; | |
| 1027 | 1031 | if aCol=2 then | |
| 1028 | 1032 | MyTextStyle.Alignment := taRightJustify | |
| 1029 | 1033 | else | |
| 1030 | 1034 | if aCol=3 then | |
| 1031 | 1035 | MyTextStyle.Alignment := taCenter; | |
| 1032 | 1036 | StringGrid1.Canvas.TextStyle := MyTextStyle; | |
| 1033 | 1037 | end; | |
| 1034 | 1038 | end; | |
| 1035 | 1039 | ``` | |
| 1036 | 1040 | ||
| 1037 | 1041 | ### Многострочность в Grids, DBGrid | |
| 1038 | 1042 | ||
| 1039 | 1043 | В этом примере показано, как сделать многострочный текст в ячейке \[3,2\]. Он работает так же для DBGrid, где \[событие\] OnPrepareCanvas имеет параметры для работы с столбцами, а оттуда и с TFields. | |
| 1040 | 1044 | ||
| 1041 | 1045 | ``` pascal | |
| 1042 | 1046 | procedure TForm1.StringGrid1PrepareCanvas(sender: TObject; aCol, aRow: Integer; | |
| 1043 | 1047 | aState: TGridDrawState); | |
| 1044 | 1048 | var | |
| 1045 | 1049 | MyTextStyle: TTextStyle; | |
| 1046 | 1050 | begin | |
| 1047 | 1051 | if (aRow=2) or (aCol=3) then | |
| 1048 | 1052 | begin | |
| 1049 | 1053 | MyTextStyle := StringGrid1.Canvas.TextStyle; | |
| 1050 | 1054 | MyTextStyle.SingleLine := false; | |
| 1051 | 1055 | StringGrid1.Canvas.TextStyle := MyTextStyle; | |
| 1052 | 1056 | end; | |
| 1053 | 1057 | end; | |
| 1054 | 1058 | ``` | |
| 1055 | 1059 | ||
| 1056 | 1060 | ### Проверка введенных значений | |
| 1057 | 1061 | ||
| 1058 | 1062 | Lazarus версии 0.9.29 для StringGrid ввел событие OnValidateEntry типа TValidateEntryEvent, которое имеет следующее объявление: | |
| 1059 | 1063 | ||
| 1060 | 1064 | ``` pascal | |
| 1061 | 1065 | TValidateEntryEvent = | |
| 1062 | 1066 | procedure(sender: TObject; aCol, aRow: Integer; | |
| 1063 | 1067 | const OldValue: string; var NewValue: string) of object; | |
| 1064 | 1068 | ``` | |
| 1065 | 1069 | ||
| 1066 | 1070 | где | |
| 1067 | 1071 | ||
| 1068 | - | ||
| 1069 | - | ||
| 1070 | - | ||
| 1072 | + | ```text | |
| 1073 | + | aCol,aRow являются координатами проверяемой ячейки. | |
| 1074 | + | OldValue это значение, которое было в ячейках [aCol, aRow] до начала редактирования. | |
| 1075 | + | NewValue это значение, которое будет окончательно вставлено в ячейки [aCol, aRow]. | |
| 1076 | + | ``` | |
| 1071 | 1077 | ||
| 1072 | 1078 | Из-за того, что StringGrid работает, устанавливая значение ячейки во время редактирования пользователем (см. событие OnSetEditText и метод SetEditText сетки), то когда событие OnValidateEntry запускается, ячейка уже содержит введенное значение (корректное или нет); используя аргументы события OldValue и NewValue, значение ячейки может быть проверено и изменено, если необходимо. | |
| 1073 | 1079 | ||
| 1074 | 1080 | Обычно проверка выполняется, когда пользователь перемещается \[с редактируемой ячейки\] в другую. Если проверка закончилась неудачей, желательно сохранить редактор ячейки видимым/сфокусированным, чтобы введенное значение могло быть исправлено пользователем. Чтобы сетка "узнала", что проверка не прошла, необходимо создать исключение. Сетка будет обрабатывать исключение из Application.HandleException, и любое перемещение отменится. | |
| 1075 | 1081 | ||
| 1076 | 1082 | Например, предположим, что ячейка \[1,1\] должна содержать только значения 'A' или 'B', \[тогда\] валидация может быть выполнена с помощью: | |
| 1077 | 1083 | ||
| 1078 | 1084 | ``` pascal | |
| 1079 | 1085 | procedure TForm1.GridValidateEntry(sender: TObject; aCol, | |
| 1080 | 1086 | aRow: Integer; const OldValue: string; var NewValue: String); | |
| 1081 | 1087 | begin | |
| 1082 | 1088 | if (aCol=1) and (aRow=1) then begin | |
| 1083 | 1089 | if grid.Cells[aCol,aRow]<>'A') and grid.Cells[aCol,aRow]<>'B') then begin | |
| 1084 | 1090 | // устанавливаем новое допустимое значение, чтобы пользователь мог просто нажать RETURN для продолжения, например | |
| 1085 | 1091 | NewValue := 'A'; | |
| 1086 | 1092 | // другой вариант - вернуться предыдущему значению ячейки (которое считается допустимым) | |
| 1087 | 1093 | // NewValue := OldValue; | |
| 1088 | 1094 | // Используйте EAbort, а не другой тип исключения, чтобы избежать [возникновения] ложных | |
| 1089 | 1095 | // диалоговых окон ошибок и [диалоговых окон] обратной отладки | |
| 1090 | 1096 | raise EAbort.Create('Разрешены только A или B'); | |
| 1091 | 1097 | end else begin | |
| 1092 | 1098 | // если исключение не создано, предполагается, что значение действительно, но при необходимости | |
| 1093 | 1099 | // окончательное значение все равно можно изменить, заполнив NewValue другим значением | |
| 1094 | 1100 | ||
| 1095 | 1101 | // компьютер знает лучше :) | |
| 1096 | 1102 | if grid.Cells[1,1]='A' then | |
| 1097 | 1103 | NewValue := 'B' | |
| 1098 | 1104 | else | |
| 1099 | 1105 | NewValue := 'A'; | |
| 1100 | 1106 | end; | |
| 1101 | 1107 | end; | |
| 1102 | 1108 | end; | |
| 1103 | 1109 | ``` | |
| 1104 | 1110 | ||
| 1105 | 1111 | ### Сортировка столбцов или строк | |
| 1106 | 1112 | ||
| 1107 | 1113 | Свойство ColumnClickSorts позволяет сортировать сетку автоматически, когда пользователь щелкает по заголовку столбца. Многократный щелчок по тому же столбцу переключает порядок сортировки. По умолчанию отображаются значки сортировки, показывающие, какой столбец был нажат. | |
| 1108 | 1114 | ||
| 1109 | 1115 | В коде вы можете использовать метод SortColRow(). | |
| 1110 | 1116 | ||
| 1111 | 1117 | Первый параметр IsColumn - это логическое значение, которое указывает: | |
| 1112 | 1118 | ||
| 1113 | 1119 | - True если будет отсортирован столбец | |
| 1114 | 1120 | - False если будет отсортирована строка | |
| 1115 | 1121 | ||
| 1116 | 1122 | Второй параметр, index, является целым значением: | |
| 1117 | 1123 | ||
| 1118 | 1124 | - Index указывает колонку или строку для сортировки. | |
| 1119 | 1125 | ||
| 1120 | 1126 | Последние два параметра являются необязательными, \[они\] определяют поддиапазон строк или столбцов для сортировки. | |
| 1121 | 1127 | ||
| 1122 | 1128 | - FromIndex (От столбца или строки) | |
| 1123 | 1129 | - ToIndex (До столбца или строки) | |
| 1124 | 1130 | ||
| 1125 | 1131 | Если последние два параметра не указаны, сортируется весь столбец или строка. | |
| 1126 | 1132 | ||
| 1127 | 1133 | Сортировка использует алгоритм QuickSort, его можно изменить, если сетка-наследник переопределяет метод sort() и вызывает doCompareCells для сравнения с ячейкой. | |
| 1128 | 1134 | ||
| 1129 | 1135 | По умолчанию \[метод SortColRow()\] сортирует содержимое ячейки как строки в порядке возрастания или убывания, которое можно выбрать с помощью свойства SortOrder. По умолчанию он использует порядок \[сортировки\] по возрастанию. | |
| 1130 | 1136 | ||
| 1131 | 1137 | ``` pascal | |
| 1132 | 1138 | // Сортировка столбца 3 в порядке возрастания | |
| 1133 | 1139 | grid.SortColRow(true, 3); | |
| 1134 | 1140 | ||
| 1135 | 1141 | // Сортировка столбца 3 в порядке убывания, пропустить фиксированные строки сверху | |
| 1136 | 1142 | grid.SortOrder := soDescending; // или soAscending | |
| 1137 | 1143 | grid.SortColRow(true, 3, grid.FixedRows, grid.RowCount-1); | |
| 1138 | 1144 | ``` | |
| 1139 | 1145 | ||
| 1140 | 1146 | Для пользовательской сортировки чисел, дат, состояний и т.д.: у StringGrid есть событие OnCompareCells, с которым пользователи могут обращаться, например, следующим образом: | |
| 1141 | 1147 | ||
| 1142 | 1148 | ``` pascal | |
| 1143 | 1149 | procedure TForm1.GridCompareCells(Sender: TObject; ACol, ARow, BCol, BRow: Integer; var Result: integer); | |
| 1144 | 1150 | begin | |
| 1145 | 1151 | // Результат будет либо <0, = 0, либо >0 для нормального порядка. | |
| 1146 | 1152 | result := StrToIntDef(Grid.Cells[ACol,ARow],0)-StrToIntDef(Grid.Cells[BCol,BRow],0); | |
| 1147 | 1153 | // Для обратного порядка просто [присвойте] негативный результат (напр., на основе SortOrder сетки). | |
| 1148 | 1154 | if StringGrid1.SortOrder = soDescending then | |
| 1149 | 1155 | result := -result; | |
| 1150 | 1156 | end; | |
| 1151 | 1157 | ``` | |
| 1152 | 1158 | ||
| 1153 | 1159 | Вы также можете использовать OnCompareCells, когда автоматическая сортировка столбцов включена через свойство ColumnClickSorts. | |
| 1154 | 1160 | ||
| 1155 | 1161 | ### Переопределить автоматическую сортировку (ColumnClickSorts установлен в False). Исключить сортировку некоторых столбцов. Показать стрелки сортировки в заголовке столбца | |
| 1156 | 1162 | ||
| 1157 | 1163 | (ColumnClickSorts, установленный в False, НЕ будет показывать стрелки сортировки в заголовке столбца, поэтому мы должны установить стрелки.) | |
| 1158 | 1164 | ||
| 1159 | 1165 | ``` pascal | |
| 1160 | 1166 | procedure TForm1.StringGrid1HeaderClick(Sender: TObject; IsColumn: Boolean; | |
| 1161 | 1167 | Index: Integer); | |
| 1162 | 1168 | begin | |
| 1163 | 1169 | if isColumn then with StringGrid1 do | |
| 1164 | 1170 | begin | |
| 1165 | 1171 | col:=Index; // Задаем столбец для сортировки | |
| 1166 | 1172 | if Tag = 0 then Tag :=-1 // Предположим, что данные в столбце возрастают | |
| 1167 | 1173 | else Tag := Tag * -1; // Используем StringGrid1.Tag для хранения порядка сортировки | |
| 1168 | 1174 | // Первый щелчок заголовка сортирует по убыванию | |
| 1169 | 1175 | ||
| 1170 | 1176 | // Активируем CompareCells (активируем сортировку) | |
| 1171 | 1177 | case Index of | |
| 1172 | 1178 | 0: col:=-1; // Не сортируем столбец 0 и не показываем стрелку сортировки | |
| 1173 | 1179 | 1: SortColRow(True, Index); // Сортировка будет происходить в CompareCells, как только будет выполнен оператор | |
| 1174 | 1180 | 2: SortColRow(True, Index); | |
| 1175 | 1181 | 3: SortColRow(True, Index); | |
| 1176 | 1182 | 4: SortColRow(True, Index); | |
| 1177 | 1183 | 5: col:=-1; // Не сортируем столбец 5 и не показываем стрелку сортировки | |
| 1178 | 1184 | end; | |
| 1179 | 1185 | end; | |
| 1180 | 1186 | end; | |
| 1181 | 1187 | ||
| 1182 | 1188 | // Compare возвращает одно из следующих значений: | |
| 1183 | 1189 | // if A<B return: -1 ( Восходящий ) | |
| 1184 | 1190 | // if A=B return: 0 | |
| 1185 | 1191 | // if A>B return: 1 ( Нисходящий ) | |
| 1186 | 1192 | ||
| 1187 | 1193 | // Как сортировать: Text, Integer, Float, DateTime: | |
| 1188 | 1194 | ||
| 1189 | 1195 | procedure TForm1.StringGrid1CompareCells(Sender: TObject; ACol, ARow, BCol, | |
| 1190 | 1196 | BRow: Integer; var Result: integer); | |
| 1191 | 1197 | ||
| 1192 | 1198 | function CompareTextAsText: Integer; // Text | |
| 1193 | 1199 | begin | |
| 1194 | 1200 | CompareText(Cells[ACol,ARow], Cells[BCol,BRow]); | |
| 1195 | 1201 | end; | |
| 1196 | 1202 | ||
| 1197 | 1203 | function CompareTextAsInteger: Integer; | |
| 1198 | 1204 | var i1,i2:Integer; | |
| 1199 | 1205 | begin | |
| 1200 | 1206 | if TryStrToInt(StringGrid1.Cells[ACol,ARow],i1) and // Integer | |
| 1201 | 1207 | TryStrToInt(StringGrid1.Cells[BCol,BRow],i2) then | |
| 1202 | 1208 | Result := CompareValue(i1, i2) | |
| 1203 | 1209 | else Exit(0); | |
| 1204 | 1210 | end; | |
| 1205 | 1211 | ||
| 1206 | 1212 | function CompareTextAsFloat: Integer; // Float | |
| 1207 | 1213 | var f1,f2:Extended; | |
| 1208 | 1214 | begin | |
| 1209 | 1215 | if TryStrToFloat(StringGrid1.Cells[ACol,ARow],f1) and | |
| 1210 | 1216 | TryStrToFloat(StringGrid1.Cells[BCol,BRow],f2) then | |
| 1211 | 1217 | Result := CompareValue(f1, f2) | |
| 1212 | 1218 | else Exit(0); | |
| 1213 | 1219 | end; | |
| 1214 | 1220 | ||
| 1215 | 1221 | function CompareTextAsDateTime: Integer; // DateTime | |
| 1216 | 1222 | var | |
| 1217 | 1223 | D1, D2 : TDateTime; | |
| 1218 | 1224 | begin | |
| 1219 | 1225 | if Trim(StringGrid1.Cells[ACol,ARow]) <> Trim(StringGrid1.Cells[BCol,BRow]) then | |
| 1220 | 1226 | begin | |
| 1221 | 1227 | if trim(StringGrid1.Cells[ACol,ARow]) = '' then Exit(1); | |
| 1222 | 1228 | if Trim(StringGrid1.Cells[BCol,BRow]) = '' then Exit(-1); | |
| 1223 | 1229 | end | |
| 1224 | 1230 | else Exit(0); | |
| 1225 | 1231 | ||
| 1226 | 1232 | if TryStrToDate(StringGrid1.Cells[ACol,ARow], D1, 'yy/mm/dd') and | |
| 1227 | 1233 | TryStrToDate(StringGrid1.Cells[BCol,BRow], D2, 'yy/mm/dd') then | |
| 1228 | 1234 | Result := CompareDateTime(D1, D2) | |
| 1229 | 1235 | else Exit(0); | |
| 1230 | 1236 | end; | |
| 1231 | 1237 | ||
| 1232 | 1238 | begin // Не делайте здесь ничего другого, сортировка может быть выполнена некорректно | |
| 1233 | 1239 | With StringGrid1 do | |
| 1234 | 1240 | begin | |
| 1235 | 1241 | case ACol of | |
| 1236 | 1242 | 0 : ; // Не сортируйте столбец 0 | |
| 1237 | 1243 | 1 : Result := CompareTextAsText; // Text | |
| 1238 | 1244 | 2 : Result := CompareTextAsInteger; // Integer | |
| 1239 | 1245 | 3 : Result := CompareTextAsFloat; // Float | |
| 1240 | 1246 | 4 : Result := CompareTextAsDateTime; // DateTime | |
| 1241 | 1247 | end; {Case} | |
| 1242 | 1248 | end; | |
| 1243 | 1249 | if StringGrid1.Tag = -1 then Result := -Result; // Переключаем порядок сортировки | |
| 1244 | 1250 | end; | |
| 1245 | 1251 | ||
| 1246 | 1252 | // DrawCell сделает трюк, предыдущие изображения стрелки будут удалены: | |
| 1247 | 1253 | procedure TForm1.StringGrid1DrawCell(Sender: TObject; aCol, aRow: Integer; | |
| 1248 | 1254 | aRect: TRect; aState: TGridDrawState); | |
| 1249 | 1255 | ||
| 1250 | 1256 | procedure DrawArrow(ImgIndex:Integer); // Нужны стрелки вверх/вниз в ImageList | |
| 1251 | 1257 | begin | |
| 1252 | 1258 | with StringGrid1 do | |
| 1253 | 1259 | TitleImageList.Draw(Canvas, // TitleImageList из StringGrid | |
| 1254 | 1260 | ARect.Right - TitleImageList.Width, | |
| 1255 | 1261 | (ARect.Bottom - ARect.Top - TitleImageList.Height) div 2 + 2, // Положение стрелки, может быть отрегулировано | |
| 1256 | 1262 | ImgIndex ); | |
| 1257 | 1263 | end; | |
| 1258 | 1264 | begin | |
| 1259 | 1265 | if Col > 0 then // В этом демо нет стрелок в col 0 | |
| 1260 | 1266 | if (ARow = 0) and // Предположим, строка 0 в качестве заголовка строк | |
| 1261 | 1267 | Assigned(TitleImageList) then // Нужны стрелки вверх/вниз в ImageList | |
| 1262 | 1268 | case Columns.Items[aCol].Tag of // Использовать тег столбца как индекс Восходящей/Нисходящей стрелки | |
| 1263 | 1269 | -1: DrawArrow(1); // Заменяем Index указателем стрелки вниз | |
| 1264 | 1270 | 0: DrawArrow(-1); // Удаляем предыдущее изображение | |
| 1265 | 1271 | 1: DrawArrow(2); // Заменяем Index указателем стрелки вверх | |
| 1266 | 1272 | end; | |
| 1267 | 1273 | end; | |
| 1268 | 1274 | ``` | |
| 1269 | 1275 | ||
| 1270 | 1276 | ### Сортировка столбцов или строк в DBGrid со стрелками сортировки в заголовке столбца | |
| 1271 | 1277 | ||
| 1272 | 1278 | Вот пример, который будет сортировать **DBgrid**, используя событие **OnTitleClick** и **TSQLQuery** и индексы. Это также должно работать для любого совместимого набора данных, такого как **TbufDataset**. Функция использует свойство **column.tag** для хранения состояния сортировки для каждого столбца, на который вы нажимаете, поэтому, когда вы вернетесь к тому \[столбцу\], который вы уже отсортировали, \[заголовок столбца\] отобразит правильную стрелку сортировки для отображения. | |
| 1273 | 1279 | ||
| 1274 | 1280 | **Предпосылки:** | |
| 1275 | 1281 | ||
| 1276 | 1282 | - Для хранения \[изображений\] стрелок вверх/вниз вам понадобится imagelist. Присвойте свой imagelist свойству **TitleImageList** dbgrid'а. | |
| 1277 | 1283 | - Убедитесь, что **[[doc:fcl/sqldb/tsqlquery.maxindexescount.html|TSQLQuery.MaxIndexesCount]]** достаточно велик, чтобы хранить новые индексы, которые вы будете создавать. Для этого примера я установил значение 100. | |
| 1278 | 1284 | - Вам также понадобится переменная-поле \[(в разделе интерфейса private)\] для хранения последнего столбца, который используется для сортировки, для этого примера я назвал его **FLastColumn**. | |
| 1279 | 1285 | ||
| 1280 | 1286 | В этом примере используемый **TSQLQuery** называется OpenQuery. | |
| 1281 | 1287 | ||
| 1282 | 1288 | > **Note:** По состоянию на 21 марта 2013 года **TSQLQuery** не имеет возможности очищать индексы, но в качестве обходного пути вы можете установить \[значение его свойства\] **unidirectional** в true, а затем в false: это очистит индексы. | |
| 1283 | 1289 | ||
| 1284 | 1290 | Чтобы повторно использовать компонент **TSQLQuery** с другим оператором SQL, индексы должны быть очищены после сортировки, \[иначе\] при открытии **TSQLQuery** с помощью другого оператора SQL будет вызвано исключение. | |
| 1285 | 1291 | ||
| 1286 | 1292 | ``` pascal | |
| 1287 | 1293 | FLastColumn: TColumn; //сохраняем последний столбец сетки, который мы отсортировали | |
| 1288 | 1294 | ||
| 1289 | 1295 | procedure TSQLForm.ResultsGridTitleClick(Column: TColumn); | |
| 1290 | 1296 | const | |
| 1291 | 1297 | ImageArrowUp=0; //должен соответствовать изображению в imagelist | |
| 1292 | 1298 | ImageArrowDown=1; //должен соответствовать изображению в imagelist | |
| 1293 | 1299 | var | |
| 1294 | 1300 | ASC_IndexName, DESC_IndexName:string; | |
| 1295 | 1301 | procedure UpdateIndexes; | |
| 1296 | 1302 | begin | |
| 1297 | 1303 | // Обеспечиваем обновление индексов | |
| 1298 | 1304 | OpenQuery.IndexDefs.Updated:=false; {<<<--Эта строка - решающая. IndexDefs.Update не будет | |
| 1299 | 1305 | обновляться, если уже true, что произойдет в первом отсортированном столбце.} | |
| 1300 | 1306 | Openquery.IndexDefs.Update; | |
| 1301 | 1307 | end; | |
| 1302 | 1308 | begin | |
| 1303 | 1309 | ASC_IndexName:='ASC_'+Column.FieldName; | |
| 1304 | 1310 | DESC_IndexName:='DESC_'+Column.FieldName; | |
| 1305 | 1311 | // индексы не могут сортировать двоичные типы, такие как ftMemo, ftBLOB | |
| 1306 | 1312 | if (Column.Field.DataType in [ftBLOB,ftMemo,ftWideMemo]) then | |
| 1307 | 1313 | exit; | |
| 1308 | 1314 | // проверяем, существует ли восходящий индекс для этого столбца | |
| 1309 | 1315 | // если нет, создадим [его] | |
| 1310 | 1316 | if OpenQuery.IndexDefs.IndexOf(ASC_IndexName) = -1 then | |
| 1311 | 1317 | begin | |
| 1312 | 1318 | OpenQuery.AddIndex(ASC_IndexName,column.FieldName,[]); | |
| 1313 | 1319 | UpdateIndexes; //обеспечиваем обновление индексов | |
| 1314 | 1320 | end; | |
| 1315 | 1321 | // проверяем, существует ли нисходящий индекс для этого столбца | |
| 1316 | 1322 | // если нет, создадим [его] | |
| 1317 | 1323 | if OpenQuery.IndexDefs.IndexOf(DESC_IndexName) = -1 then | |
| 1318 | 1324 | begin | |
| 1319 | 1325 | OpenQuery.AddIndex(DESC_IndexName,column.FieldName,[ixDescending]); | |
| 1320 | 1326 | UpdateIndexes; //обеспечиваем обновление индексов | |
| 1321 | 1327 | end; | |
| 1322 | 1328 | ||
| 1323 | 1329 | // Используем тег столбца для переключения ASC/DESC | |
| 1324 | 1330 | column.tag := not column.tag; | |
| 1325 | 1331 | if boolean(column.tag) then | |
| 1326 | 1332 | begin | |
| 1327 | 1333 | Column.Title.ImageIndex:=ImageArrowUp; | |
| 1328 | 1334 | Openquery.IndexName:=ASC_IndexName; | |
| 1329 | 1335 | end | |
| 1330 | 1336 | else | |
| 1331 | 1337 | begin | |
| 1332 | 1338 | Column.Title.ImageIndex:=ImageArrowDown; | |
| 1333 | 1339 | OpenQuery.IndexName:=DESC_IndexName; | |
| 1334 | 1340 | end; | |
| 1335 | 1341 | // Удаляем стрелку сортировки из предыдущего столбца, который мы отсортировали | |
| 1336 | 1342 | if (FLastColumn <> nil) and (FlastColumn <> Column) then | |
| 1337 | 1343 | FLastColumn.Title.ImageIndex:=-1; | |
| 1338 | 1344 | FLastColumn:=column; | |
| 1339 | 1345 | end; | |
| 1340 | 1346 | ``` | |
| 1341 | 1347 | ||
| 1342 | 1348 | ### Выбор записей в DBGrid с использованием checkbox'ов | |
| 1343 | 1349 | ||
| 1344 | 1350 | Цель состоит в том, чтобы иметь возможность выбирать произвольные записи в dbgrid с помощью checkbox'ов, сетка имеет возможность показывать checkbox'ы автоматически, когда обнаруживает наличие логических полей, а для других типов полей пользователь может вручную \[в свойстве\] ButtonStyle столбца выбрать \[значение\] cbsCheckboxColumn. Для таких столбцов пользователь просто помечает checkbox, и содержимое поля изменяется соответствующим образом. | |
| 1345 | 1351 | ||
| 1346 | 1352 | Но что произойдет, если в нашем наборе данных нет такого доступного поля? или мы не хотим, чтобы сетка входила в состояние редактирования при изменении состояния checkbox'а?. Добавление столбца без полей с помощью ButtonStyle=cbsCheckboxColumn покажет все checkbox'ы с неопределенным значением и отключенными, потому что нет поля, связанного с этим столбцом, и поэтому ничего не нужно изменять. Поскольку мы хотим самостоятельно обрабатывать состояние checkbox'а, нам нужно где-то сохранить состояние для каждой записи. Для этого мы можем использовать класс TBookmarklist (определенный в модуле dbgrids.pas), где свойство CurrentRowSelected может определить, выбрана ли текущая запись или нет. Используя события dbgrid'а OnCellClick и OnUserCheckboxState, мы можем отслеживать состояние checkbox'а. | |
| 1347 | 1353 | ||
| 1348 | 1354 | Обратите внимание, что этой методике нужен Lazarus r31148 или более поздней версии, которая реализует событие OnUserCheckboxState. | |
| 1349 | 1355 | ||
| 1350 | 1356 | ``` pascal | |
| 1351 | 1357 | ... | |
| 1352 | 1358 | uses ..., dbgrids, stdctrls, ... | |
| 1353 | 1359 | ||
| 1354 | 1360 | type | |
| 1355 | 1361 | ||
| 1356 | 1362 | { TForm1 } | |
| 1357 | 1363 | ||
| 1358 | 1364 | TForm1 = class(TForm) | |
| 1359 | 1365 | ... | |
| 1360 | 1366 | procedure DBGrid1CellClick(Column: TColumn); | |
| 1361 | 1367 | procedure DBGrid1UserCheckboxState(sender: TObject; column: TColumn; var AState: TCheckboxState); | |
| 1362 | 1368 | procedure FormCreate(Sender: TObject); | |
| 1363 | 1369 | procedure FormDestroy(Sender: TObject); | |
| 1364 | 1370 | ... | |
| 1365 | 1371 | private | |
| 1366 | 1372 | RecList: TBookmarklist; | |
| 1367 | 1373 | ... | |
| 1368 | 1374 | end; | |
| 1369 | 1375 | ||
| 1370 | 1376 | procedure TForm1.DBGrid1CellClick(Column: TColumn); | |
| 1371 | 1377 | begin | |
| 1372 | 1378 | if Column.Index=1 then | |
| 1373 | 1379 | RecList.CurrentRowSelected := not RecList.CurrentRowSelected; | |
| 1374 | 1380 | end; | |
| 1375 | 1381 | ||
| 1376 | 1382 | procedure TForm1.FormCreate(Sender: TObject); | |
| 1377 | 1383 | begin | |
| 1378 | 1384 | RecList := TBookmarkList.Create(DbGrid1); | |
| 1379 | 1385 | end; | |
| 1380 | 1386 | ||
| 1381 | 1387 | procedure TForm1.FormDestroy(Sender: TObject); | |
| 1382 | 1388 | begin | |
| 1383 | 1389 | RecList.Free; | |
| 1384 | 1390 | end; | |
| 1385 | 1391 | ||
| 1386 | 1392 | procedure TForm1.DBGrid1UserCheckboxState(sender: TObject; column: TColumn; var AState: TCheckboxState); | |
| 1387 | 1393 | begin | |
| 1388 | 1394 | if RecList.CurrentRowSelected then | |
| 1389 | 1395 | AState := cbChecked | |
| 1390 | 1396 | else | |
| 1391 | 1397 | AState := cbUnchecked; | |
| 1392 | 1398 | end; | |
| 1393 | 1399 | ``` | |
| 1394 | 1400 | ||
| 1395 | 1401 | ### Подсветка выделенного столбца и строки ячейки | |
| 1396 | 1402 | ||
| 1397 | 1403 | В версии Lazarus 40276 добавлена опция (**gdRowHighlight**), она работает аналогично **goRowSelect**, но использует более светлый тон для выделения, а прямоугольник фокуса - только выбранная ячейка, а не в целая строка. Это отлично работает для строк, но как насчет столбцов? | |
| 1398 | 1404 | ||
| 1399 | 1405 | В этом разделе показан способ выделения столбцов, строк или и того, и другого (пример, который выделяет только столбцы и заголовки строк, можно найти в lazarus/examples/gridexamples/spreadsheet, этот способ действительно является расширением этого примера). Он использует два события сетки: **OnBeforeSelection** и **OnPrepareCanvas**, рисунок не нужен. | |
| 1400 | 1406 | ||
| 1401 | 1407 | Событие **OnBeforeSelection** запускается, когда начинается смена выделения, в этом случае мы можем узнать, какая ячейка выбрана в данный момент и какая ячейка будет выбрана следующей. Мы используем эту информацию для перерисовки всей строки или столбца как старой, так и новой ячеек. Когда начнется следующий цикл отрисовки, сетке будет предложено перерисовать ячейки, принадлежащие недействительным областям. Одним из первых шагов для перерисовки является вызов события **OnPrepareCanvas** (если он существует) для настройки свойств холста по умолчанию. Мы используем это событие для настройки выделенной строки или столбца: | |
| 1402 | 1408 | ||
| 1403 | 1409 | ``` pascal | |
| 1404 | 1410 | procedure TForm1.gridBeforeSelection(Sender: TObject; aCol, aRow: Integer); | |
| 1405 | 1411 | begin | |
| 1406 | 1412 | // мы можем здесь принять решение, если хотим выделить столбцы, строки или и те, и другие | |
| 1407 | 1413 | // в этом примере мы выделяем и те, и другие | |
| 1408 | 1414 | if Grid.Col<>aCol then | |
| 1409 | 1415 | begin | |
| 1410 | 1416 | // обнаружено изменение текущего столбца | |
| 1411 | 1417 | grid.InvalidateCol(aCol); // перерисовываем новый выбранный столбец ячейки | |
| 1412 | 1418 | grid.InvalidateCol(grid.Col); // перерисовываем текущий (это будет 'старый') выбранный столбец | |
| 1413 | 1419 | end; | |
| 1414 | 1420 | if Grid.Row<>aRow then | |
| 1415 | 1421 | begin | |
| 1416 | 1422 | grid.InvalidateRow(aRow); // перерисовываем новую выбранную строку ячейки | |
| 1417 | 1423 | grid.InvalidateRow(grid.Row); // перерисовываем текущую (это будет 'старая') выбранную строку | |
| 1418 | 1424 | end; | |
| 1419 | 1425 | end; | |
| 1420 | 1426 | ||
| 1421 | 1427 | procedure TForm1.gridPrepareCanvas(sender: TObject; aCol, aRow: Integer; | |
| 1422 | 1428 | aState: TGridDrawState); | |
| 1423 | 1429 | begin | |
| 1424 | 1430 | if gdFixed in aState then | |
| 1425 | 1431 | begin | |
| 1426 | 1432 | if (aCol=grid.Col) or (aRow=grid.Row) then | |
| 1427 | 1433 | grid.Canvas.Brush.Color := clInactiveCaption; // это подсветило бы также заголовки столбцов или строк | |
| 1428 | 1434 | end else | |
| 1429 | 1435 | if gdFocused in aState then begin | |
| 1430 | 1436 | // мы оставляем в покое текущую выделенную/сфокусированную ячейку | |
| 1431 | 1437 | end else | |
| 1432 | 1438 | if (aCol=Grid.Col) or (aRow=grid.Row) then | |
| 1433 | 1439 | grid.Canvas.Brush.Color := clSkyBlue; // подсветка строк и столбцов цветом clSkyBlue | |
| 1434 | 1440 | end; | |
| 1435 | 1441 | ``` | |
| 1436 | 1442 | ||
| 1437 | 1443 | ## DBGrids "Как сделать..." и Примеры | |
| 1438 | 1444 | ||
| 1439 | 1445 | #### Пример: как установить редактор memo для dbgrids | |
| 1440 | 1446 | ||
| 1441 | 1447 | Конечно, вы можете использовать другой элемент управления вместо TMemo. Отрегулируйте по вкусу. Адаптировано из [3](http://forum.lazarus.freepascal.org/index.php?topic=3640.0) (упрощено использование свойства SelectedFieldRect, см. [4](http://forum.lazarus.freepascal.org/index.php/topic,8713.msg43288.html#msg43288)) | |
| 1442 | 1448 | ||
| 1443 | 1449 | - Поместите элемент управления memo (или любой другой элемент управления) на форму, установите любые свойства, которые вы хотите, и установите видимым значение false. Он будет использоваться при редактировании ячейки сетки. Мы будем использовать GridCellMemo в этом примере. | |
| 1444 | 1450 | - В событии OnSelectEditor вставьте следующий код - адаптируйте, если вы не хотите редактировать логический столбец 3, физический столбец 4: | |
| 1445 | 1451 | ||
| 1446 | 1452 | ``` pascal | |
| 1447 | 1453 | if (Column.DesignIndex = 3) then | |
| 1448 | 1454 | begin | |
| 1449 | 1455 | GridCellMemo.BoundsRect := DbGrid.SelectedFieldRect; | |
| 1450 | 1456 | GridCellMemo.Text:=Column.Field.AsString; | |
| 1451 | 1457 | Editor := GridCellMemo; | |
| 1452 | 1458 | end; | |
| 1453 | 1459 | ``` | |
| 1454 | 1460 | ||
| 1455 | 1461 | - Предположим, ваш источник данных называется Datasource1, а DBGrid называется ResultsGrid. Затем в событие OnEditingDone для GridCellMemo поместите следующее: | |
| 1456 | 1462 | ||
| 1457 | 1463 | (В исходном сообщении на форуме использовалось событие OnChange, которое будет запускаться каждый раз при изменении содержимого. Использование OnEditingDone срабатывает только после того, как пользователь завершит редактирование.) | |
| 1458 | 1464 | ||
| 1459 | 1465 | ``` pascal | |
| 1460 | 1466 | if not(Datasource1.State in [dsEdit, dsInsert]) then Datasource1.Edit; | |
| 1461 | 1467 | ||
| 1462 | 1468 | Datasource1.DataSet.FieldByName(ResultsGrid.SelectedField.FieldName).AsString:=GridCellMemo.Text; | |
| 1463 | 1469 | ``` | |
| 1464 | 1470 | ||
| 1465 | 1471 | **Осторожно** Использование обычного элемента управления в качестве пользовательского редактора имеет много недостатков: он не будет изменять размеры или перемещать себя при изменении размера столбцов или прокрутке сетки, вы должны позаботиться о модификации данных в сетке. (как объяснено выше), он не работает должным образом с DbGrids и мешает нормальной навигации по сетке с помощью клавиатуры. Сетка взаимодействует с редактором с помощью некоторых специальных сообщений сетки, поэтому для управления этими сообщениями лучше выделить подкласс элемента управления, как объясняется в пятой главе [этого документа](http://www.freepascal.org/~michael/articles/grids/grids.pdf). | |
| 1466 | 1472 | ||
| 1467 | 1473 | **Осторожно** Если у вас несколько сеток в одной форме, используйте для каждой свой собственный редактор: если вы используете один и тот же элемент управления, могут произойти плохие вещи, поскольку обе сетки попытаются использовать его одновременно. | |
| 1468 | 1474 | ||
| 1469 | 1475 | ### Пример: исключение отображения текстовых полей как «(Memo)» для DBGrids | |
| 1470 | 1476 | ||
| 1471 | 1477 | Когда вы используете операторы SQL, такие как `"Select * from A"`, вы можете увидеть «(Memo)» вместо текстового содержимого в ячейке сетки. Есть много способов исправить это, но, возможно, самый простой - изменить выражение `"Select * from A"` на `Select Cast(Column as TEXT) as Column from A`. Это распространенная проблема при использовании компонента DBGrid. | |
| 1472 | 1478 | ||
| 1473 | 1479 | ``` pascal | |
| 1474 | 1480 | var | |
| 1475 | 1481 | sql : UTF8String; | |
| 1476 | 1482 | Query : TSQLQuery; | |
| 1477 | 1483 | ..... | |
| 1478 | 1484 | sql := 'SELECT cast(Name as TEXT) as Name FROM Client'; | |
| 1479 | 1485 | Query.SQL.Text:=sql; | |
| 1480 | 1486 | ``` | |
| 1481 | 1487 | ||
| 1482 | 1488 | ### Сортировка столбцов или строк в DBGrid со стрелками сортировки в заголовке столбца | |
| 1483 | 1489 | ||
| 1484 | 1490 | Вот пример, который будет сортировать **DBgrid**, используя событие **OnTitleClick** и **TSQLQuery** и индексы. Это также должно работать для любого совместимого набора данных, такого как **TbufDataset**. Функция использует свойство **column.tag** для хранения состояния сортировки для каждого столбца, по которому вы щелкнули, поэтому, когда вы вернетесь к тому, который уже отсортирован, она выберет правильную стрелку сортировки для отображения. | |
| 1485 | 1491 | ||
| 1486 | 1492 | **Предварительные условия:** | |
| 1487 | 1493 | ||
| 1488 | 1494 | - Вам понадобится список изображений для хранения стрелок вверх/вниз. Присвойте свой список изображений свойству dbgrid **TitleImageList**. | |
| 1489 | 1495 | - Убедитесь, что свойство **[[doc:fcl/sqldb/tsqlquery.maxindexescount.html|TSQLQuery.MaxIndexesCount]]** достаточно велико для хранения новых индексов, которые вы будете создавать. Для этого примера у меня было установлено значение 100. | |
| 1490 | 1496 | - Вам также понадобится поле-переменная в разделе private класса для хранения последнего столбца, использованного для сортировки, для этого примера я назвал ее **FLastColumn**. | |
| 1491 | 1497 | ||
| 1492 | 1498 | В этом примере используемый **TSQLQuery** назван OpenQuery. | |
| 1493 | 1499 | ||
| 1494 | 1500 | > **Note:** по состоянию на 21 марта 2013 года **TSQLQuery** не имеет возможности очищать индексы, но в качестве обходного пути вы можете установить свойство **unidirectional** в значение true, а затем установить его в значение false, и это очистит индексы. | |
| 1495 | 1501 | ||
| 1496 | 1502 | Чтобы повторно использовать компонент **TSQLQuery** с другим оператором SQL, индексы должны быть очищены после сортировки, иначе будет возбуждено исключение при открытии **TSQLQuery** с другим оператором SQL. | |
| 1497 | 1503 | ||
| 1498 | 1504 | ``` pascal | |
| 1499 | 1505 | FLastColumn: TColumn; //сохраняем последний столбец сетки, по которому мы делали сортировку | |
| 1500 | 1506 | ||
| 1501 | 1507 | procedure TSQLForm.ResultsGridTitleClick(Column: TColumn); | |
| 1502 | 1508 | const | |
| 1503 | 1509 | ImageArrowUp=0; //должно соответствовать изображению в imagelist | |
| 1504 | 1510 | ImageArrowDown=1; //должно соответствовать изображению в imagelist | |
| 1505 | 1511 | var | |
| 1506 | 1512 | ASC_IndexName, DESC_IndexName:string; | |
| 1507 | 1513 | procedure UpdateIndexes; | |
| 1508 | 1514 | begin | |
| 1509 | 1515 | // Убедитесь, что индексы обновлены | |
| 1510 | 1516 | OpenQuery.IndexDefs.Updated:=false; {<<<--Эта строчка имеет решающее значение. IndexDefs.Update не будет обновляться, если уже имеет значение true, что произойдет в первом отсортированном столбце.} | |
| 1511 | 1517 | Openquery.IndexDefs.Update; | |
| 1512 | 1518 | end; | |
| 1513 | 1519 | begin | |
| 1514 | 1520 | ASC_IndexName:='ASC_'+Column.FieldName; | |
| 1515 | 1521 | DESC_IndexName:='DESC_'+Column.FieldName; | |
| 1516 | 1522 | // индексы не могут сортировать двоичные типы, такие как ftMemo, ftBLOB | |
| 1517 | 1523 | if (Column.Field.DataType in [ftBLOB,ftMemo,ftWideMemo]) then | |
| 1518 | 1524 | exit; | |
| 1519 | 1525 | // проверяем, существует ли восходящий индекс для этого столбца. | |
| 1520 | 1526 | // если нет, создаем | |
| 1521 | 1527 | if OpenQuery.IndexDefs.IndexOf(ASC_IndexName) = -1 then | |
| 1522 | 1528 | begin | |
| 1523 | 1529 | OpenQuery.AddIndex(ASC_IndexName,column.FieldName,[]); | |
| 1524 | 1530 | UpdateIndexes; //ensure index defs are up to date | |
| 1525 | 1531 | end; | |
| 1526 | 1532 | // проверяем, существует ли нисходящий индекс для этого столбца. | |
| 1527 | 1533 | // если нет, создаем | |
| 1528 | 1534 | if OpenQuery.IndexDefs.IndexOf(DESC_IndexName) = -1 then | |
| 1529 | 1535 | begin | |
| 1530 | 1536 | OpenQuery.AddIndex(DESC_IndexName,column.FieldName,[ixDescending]); | |
| 1531 | 1537 | UpdateIndexes; //ensure index defs are up to date | |
| 1532 | 1538 | end; | |
| 1533 | 1539 | ||
| 1534 | 1540 | // Используем тег столбца для переключения направления сортировки ASC/DESC | |
| 1535 | 1541 | column.tag := not column.tag; | |
| 1536 | 1542 | if boolean(column.tag) then | |
| 1537 | 1543 | begin | |
| 1538 | 1544 | Column.Title.ImageIndex:=ImageArrowUp; | |
| 1539 | 1545 | Openquery.IndexName:=ASC_IndexName; | |
| 1540 | 1546 | end | |
| 1541 | 1547 | else | |
| 1542 | 1548 | begin | |
| 1543 | 1549 | Column.Title.ImageIndex:=ImageArrowDown; | |
| 1544 | 1550 | OpenQuery.IndexName:=DESC_IndexName; | |
| 1545 | 1551 | end; | |
| 1546 | 1552 | // Удаляем стрелку сортировки из предыдущего столбца, который мы отсортировали | |
| 1547 | 1553 | if (FLastColumn <> nil) and (FlastColumn <> Column) then | |
| 1548 | 1554 | FLastColumn.Title.ImageIndex:=-1; | |
| 1549 | 1555 | FLastColumn:=column; | |
| 1550 | 1556 | end; | |
| 1551 | 1557 | ``` | |
| 1552 | 1558 | ||
| 1553 | 1559 | ### Выбор записей в DBGrid с помощью флажков(чекбоксов) | |
| 1554 | 1560 | ||
| 1555 | 1561 | Цель состоит в том, чтобы иметь возможность выбирать произвольные записи в dbgrid с помощью флажков, сетка имеет возможность автоматически отображать флажки, когда обнаруживает наличие логических полей, для других типов полей пользователь может вручную выбрать значение cbsCheckboxColumn свойства ButtonStyle для столбца. Для этого типа столбцов пользователь просто устанавливает флажок, и содержимое поля изменяется соответствующим образом. | |
| 1556 | 1562 | ||
| 1557 | 1563 | Но что произойдет, если в нашем наборе данных нет такого доступного поля? Или мы не хотим, чтобы сетка входила в состояние редактирования при установке флажка? При добавлении столбца без полей с помощью `ButtonStyle = cbsCheckboxColumn` все флажки будут выделены серым цветом и отключены, поскольку поле, связанное с этим столбцом, отсутствует и поэтому изменять нечего. Поскольку мы хотим обрабатывать состояние флажка самостоятельно, нам нужно хранить состояние где-то для каждой записи. Для этого мы можем использовать класс TBookmarklist (определенный в модуле dbgrids.pas), где свойство CurrentRowSelected может сказать, выбрана текущая запись или нет. Используя события dbgrid OnCellClick и OnUserCheckboxState, мы можем отслеживать состояние флажка. | |
| 1558 | 1564 | ||
| 1559 | 1565 | > **Note:** эта хитрость требует наличие Lazarus r31148 или новее, который реализует событие OnUserCheckboxState. | |
| 1560 | 1566 | ||
| 1561 | 1567 | ``` pascal | |
| 1562 | 1568 | ... | |
| 1563 | 1569 | uses ..., dbgrids, stdctrls, ... | |
| 1564 | 1570 | ||
| 1565 | 1571 | type | |
| 1566 | 1572 | ||
| 1567 | 1573 | { TForm1 } | |
| 1568 | 1574 | ||
| 1569 | 1575 | TForm1 = class(TForm) | |
| 1570 | 1576 | ... | |
| 1571 | 1577 | procedure DBGrid1CellClick(Column: TColumn); | |
| 1572 | 1578 | procedure DBGrid1UserCheckboxState(sender: TObject; column: TColumn; var AState: TCheckboxState); | |
| 1573 | 1579 | procedure FormCreate(Sender: TObject); | |
| 1574 | 1580 | procedure FormDestroy(Sender: TObject); | |
| 1575 | 1581 | ... | |
| 1576 | 1582 | private | |
| 1577 | 1583 | RecList: TBookmarklist; | |
| 1578 | 1584 | ... | |
| 1579 | 1585 | end; | |
| 1580 | 1586 | ||
| 1581 | 1587 | procedure TForm1.DBGrid1CellClick(Column: TColumn); | |
| 1582 | 1588 | begin | |
| 1583 | 1589 | if Column.Index=1 then | |
| 1584 | 1590 | RecList.CurrentRowSelected := not RecList.CurrentRowSelected; | |
| 1585 | 1591 | end; | |
| 1586 | 1592 | ||
| 1587 | 1593 | procedure TForm1.FormCreate(Sender: TObject); | |
| 1588 | 1594 | begin | |
| 1589 | 1595 | RecList := TBookmarkList.Create(DbGrid1); | |
| 1590 | 1596 | end; | |
| 1591 | 1597 | ||
| 1592 | 1598 | procedure TForm1.FormDestroy(Sender: TObject); | |
| 1593 | 1599 | begin | |
| 1594 | 1600 | RecList.Free; | |
| 1595 | 1601 | end; | |
| 1596 | 1602 | ||
| 1597 | 1603 | procedure TForm1.DBGrid1UserCheckboxState(sender: TObject; column: TColumn; var AState: TCheckboxState); | |
| 1598 | 1604 | begin | |
| 1599 | 1605 | if RecList.CurrentRowSelected then | |
| 1600 | 1606 | AState := cbChecked | |
| 1601 | 1607 | else | |
| 1602 | 1608 | AState := cbUnchecked; | |
| 1603 | 1609 | end; | |
| 1604 | 1610 | ``` | |
| 1605 | 1611 | ||
| 1606 | 1612 | ### Пример: Как экспортировать данные из DBGrid в текстовый файл | |
| 1607 | 1613 | ||
| 1608 | 1614 | Есть несколько способов создать текстовый файл из содержимого DBGrid. В большинстве случаев люди будут говорить вам, что вместо того, чтобы думать о DBGrid, как о контейнере данных, лучше поискать связанный набор данных. | |
| 1609 | 1615 | ||
| 1610 | 1616 | Но что произойдет, когда вам понадобится текстовое представление, которое должно соответствовать внешнему виду сетки: видимость колонок, ширина или порядок? | |
| 1611 | 1617 | ||
| 1612 | 1618 | Одним из решений является использование пакета LazReport, в котором есть компонент, специально предназначенный для создания отчета из DbGrid. Затем этот отчет можно экспортировать в несколько других форматов, включая текстовый формат. Здесь представлено простое решение, которое также может быть использовано в качестве основы для других экспортеров текстового формата, например, простого экспортера HTML. | |
| 1613 | 1619 | ||
| 1614 | 1620 | ``` pascal | |
| 1615 | 1621 | // aGrid: Сетка для экспорта | |
| 1616 | 1622 | // lpp: строк на странице. Не включает текстовый заголовок | |
| 1617 | 1623 | // pageBreak: вставляет разрыв страницы, который некоторые принтеры могут использовать для запуска новой страницы | |
| 1618 | 1624 | // require: uses LazUTF8 | |
| 1619 | 1625 | function GridTextExporter(aGrid: TDbGrid; lpp: Integer; pageBreak:boolean): TStringList; | |
| 1620 | 1626 | const | |
| 1621 | 1627 | PX_PER_CHAR = 7; | |
| 1622 | 1628 | ||
| 1623 | 1629 | var | |
| 1624 | 1630 | Ds: TDataset; | |
| 1625 | 1631 | book: TBookMark; | |
| 1626 | 1632 | recCount: Integer; | |
| 1627 | 1633 | line: string; | |
| 1628 | 1634 | column: TColumn; | |
| 1629 | 1635 | ||
| 1630 | 1636 | function WidthToChar(aWidth: Integer): integer; | |
| 1631 | 1637 | begin | |
| 1632 | 1638 | result := trunc(aWidth/PX_PER_CHAR); | |
| 1633 | 1639 | end; | |
| 1634 | 1640 | ||
| 1635 | 1641 | procedure AddNext(theText: string; alignment: TAlignment); | |
| 1636 | 1642 | var | |
| 1637 | 1643 | width: Integer; | |
| 1638 | 1644 | begin | |
| 1639 | 1645 | if (line<>'') and (line<>#12) then | |
| 1640 | 1646 | line := line + ' '; | |
| 1641 | 1647 | ||
| 1642 | 1648 | width := WidthToChar(Column.Width); | |
| 1643 | 1649 | ||
| 1644 | 1650 | case Alignment of | |
| 1645 | 1651 | taRightJustify: line := line + UTF8PadLeft(theText, width); | |
| 1646 | 1652 | taCenter: line := line + UTF8PadCenter(theText, width); | |
| 1647 | 1653 | else line := line + UTF8PadRight(theText, width); | |
| 1648 | 1654 | end; | |
| 1649 | 1655 | end; | |
| 1650 | 1656 | ||
| 1651 | 1657 | procedure CollectHeader; | |
| 1652 | 1658 | begin | |
| 1653 | 1659 | AddNext(Column.Title.Caption, Column.Title.Alignment); | |
| 1654 | 1660 | end; | |
| 1655 | 1661 | ||
| 1656 | 1662 | procedure CollectField; | |
| 1657 | 1663 | var | |
| 1658 | 1664 | field: TField; | |
| 1659 | 1665 | begin | |
| 1660 | 1666 | field := Column.Field; | |
| 1661 | 1667 | ||
| 1662 | 1668 | if (field.DataType=ftMemo) and (dgDisplayMemoText in aGrid.Options) then | |
| 1663 | 1669 | AddNext(field.AsString, Column.Alignment) | |
| 1664 | 1670 | else if Field.DataType<>ftBlob then | |
| 1665 | 1671 | AddNext(field.DisplayText, Column.Alignment) | |
| 1666 | 1672 | else | |
| 1667 | 1673 | AddNext('(blob)', Column.Alignment); | |
| 1668 | 1674 | end; | |
| 1669 | 1675 | ||
| 1670 | 1676 | procedure LoopColumns(printingRecord: boolean); | |
| 1671 | 1677 | var | |
| 1672 | 1678 | c: TCollectionItem; | |
| 1673 | 1679 | begin | |
| 1674 | 1680 | if (not printingRecord) and pageBreak and (result.count>0) then | |
| 1675 | 1681 | line := #12 | |
| 1676 | 1682 | else | |
| 1677 | 1683 | line := ''; | |
| 1678 | 1684 | for c in aGrid.Columns do begin | |
| 1679 | 1685 | Column := TColumn(c); | |
| 1680 | 1686 | if Column.Visible and (Column.Width>=PX_PER_CHAR) then begin | |
| 1681 | 1687 | if printingRecord then CollectField | |
| 1682 | 1688 | else CollectHeader; | |
| 1683 | 1689 | end; | |
| 1684 | 1690 | end; | |
| 1685 | 1691 | result.add(line); | |
| 1686 | 1692 | end; | |
| 1687 | 1693 | ||
| 1688 | 1694 | begin | |
| 1689 | 1695 | result := TStringList.create; | |
| 1690 | 1696 | Ds := aGrid.DataSource.DataSet; | |
| 1691 | 1697 | Ds.DisableControls; | |
| 1692 | 1698 | book := Ds.GetBookmark; | |
| 1693 | 1699 | try | |
| 1694 | 1700 | Ds.First; | |
| 1695 | 1701 | recCount := 0; | |
| 1696 | 1702 | while not DS.EOF do begin | |
| 1697 | 1703 | if RecCount mod lpp = 0 then | |
| 1698 | 1704 | LoopColumns(false); | |
| 1699 | 1705 | LoopColumns(true); | |
| 1700 | 1706 | inc(recCount); | |
| 1701 | 1707 | Ds.Next; | |
| 1702 | 1708 | end; | |
| 1703 | 1709 | finally | |
| 1704 | 1710 | Ds.GotoBookmark(book); | |
| 1705 | 1711 | Ds.FreeBookmark(book); | |
| 1706 | 1712 | Ds.EnableControls; | |
| 1707 | 1713 | end; | |
| 1708 | 1714 | end; | |
| 1709 | 1715 | ``` | |
| 1710 | 1716 | ||
| 1711 | 1717 | Чтобы использовать это просто сделайте: | |
| 1712 | 1718 | ||
| 1713 | 1719 | ``` pascal | |
| 1714 | 1720 | var | |
| 1715 | 1721 | L: TStringList; | |
| 1716 | 1722 | begin | |
| 1717 | 1723 | L := GridTextExporter(grid, 80, true); | |
| 1718 | 1724 | L.SaveToFile('grid.txt'); | |
| 1719 | 1725 | L.Free; | |
| 1720 | 1726 | end; | |
| 1721 | 1727 | ``` | |
| 1722 | 1728 | ||
| 1723 | 1729 | --- | |
| 1724 | 1730 | *From the Free Pascal wiki, page "Grids Reference Page/ru", as it stood on 2022-01-21 after a change by Slawek, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).* |