1 // Written in the D programming language. 2 // MGW Мохов Геннадий Владимирович 2016 3 // Версия v0.01 - 20.02.16 12:45 4 5 module qte5; 6 7 import std.conv; // Convert to string 8 9 // Отладка 10 import std.stdio; 11 12 13 int verQt5Eu = 0; 14 int verQt5El = 03; 15 string verQt5Ed = "25.04.16 07:53"; 16 17 alias PTRINT = int; 18 alias PTRUINT = uint; 19 20 struct QtObj__ { PTRINT dummy; } alias QtObjH = QtObj__*; 21 22 23 private void*[400] pFunQt; /// Масив указателей на функции из DLL 24 25 immutable int QMETHOD = 0; // member type codes 26 immutable int QSLOT = 1; 27 immutable int QSIGNAL = 2; 28 29 // ----- Описание типов, фактически указание компилятору как вызывать ----- 30 // ----- The description of types, actually instructions to the compiler how to call ----- 31 32 // Give type Qt. There is an implicit transformation. cast (GetObjQt_t) Z == *Z on any type. 33 // alias GetObjQt_t = void**; // Дай тип Qt. Происходит неявное преобразование. cast(GetObjQt_t)Z == *Z на любой тип. 34 35 private extern (C) @nogc alias t_QObject_connect = void function(void*, char*, void*, char*, int); 36 37 private extern (C) @nogc alias t_v__i = void function(int); 38 private extern (C) @nogc alias t_v__qp = void function(QtObjH); 39 private extern (C) @nogc alias t_v__qp_qp = void function(QtObjH, QtObjH); 40 private extern (C) @nogc alias t_v__qp_vp = void function(QtObjH, void*); 41 private extern (C) @nogc alias t_v__qp_i = void function(QtObjH, int); 42 private extern (C) @nogc alias t_v__vp_c = void function(void*, char); 43 44 private extern (C) @nogc alias t_vp__qp = void* function(void*); 45 private extern (C) @nogc alias t_v__vp_vp_vp = void function(void*, void*, void*); 46 private extern (C) @nogc alias t_v__qp_i_i = void function(QtObjH, int, int); 47 private extern (C) @nogc alias t_v__qp_qp_i_i = void function(QtObjH, QtObjH, int, int); 48 49 private extern (C) @nogc alias t_b__qp = bool function(QtObjH); 50 private extern (C) @nogc alias t_b__qp_i = bool function(QtObjH, int); 51 52 private extern (C) @nogc alias t_v__qp_qp_i = void function(QtObjH, QtObjH, int); 53 private extern (C) @nogc alias t_v__qp_qp_qp_i = void function(QtObjH, QtObjH, QtObjH, int); 54 private extern (C) @nogc alias t_v__qp_qp_qp = void function(QtObjH, QtObjH, QtObjH); 55 private extern (C) @nogc alias t_v__qp_i_i_i_i_i = void function(QtObjH, int, int, int, int, int); 56 57 58 59 private extern (C) @nogc alias t_i__vp_vp_vp = int function(void*, void*, void*); 60 private extern (C) @nogc alias t_i__vp_i = int function(void*, int); 61 private extern (C) @nogc alias t_i__qp_i = int function(QtObjH, int); 62 private extern (C) @nogc alias t_i__qp_i_i = int function(QtObjH, int, int); 63 private extern (C) @nogc alias t_qp__qp_qp = QtObjH function(QtObjH, QtObjH); 64 private extern (C) @nogc alias t_vp__vp_c_i = void* function(void*, char, int); 65 private extern (C) @nogc alias t_vp__vp_cp_i = void* function(void*, char*, int); 66 67 private extern (C) @nogc alias t_vpp__vp = void** function(void*); 68 private extern (C) @nogc alias t_qp__qp = QtObjH function(QtObjH); 69 private extern (C) @nogc alias t_c_vp__vp = const void* function(void*); 70 71 private extern (C) @nogc alias t_vp__vp_i_i = void* function(void*, int, int); 72 private extern (C) @nogc alias t_vp__vp_i_vp = void* function(void*, int, void*); 73 74 private extern (C) @nogc alias t_vp__vp_vp_i = void* function(void*, void*, int); 75 private extern (C) @nogc alias t_qp__qp_qp_i = QtObjH function(QtObjH, QtObjH, int); 76 private extern (C) @nogc alias t_vp__vp_i = void* function(void*, int); 77 private extern (C) @nogc alias t_qp__qp_i = QtObjH function(QtObjH, int); 78 private extern (C) @nogc alias t_qp__qp_i_i = QtObjH function(QtObjH, int, int); 79 private extern (C) @nogc alias t_vp__v = void* function(); 80 private extern (C) @nogc alias t_qp__v = QtObjH function(); 81 private extern (C) @nogc alias t_i__vp = int function(void*); 82 private extern (C) @nogc alias t_i__qp = int function(QtObjH); 83 84 private extern (C) @nogc alias t_v__qp_b_i_i = void function(QtObjH, bool, int, int); 85 private extern (C) @nogc alias t_v__qp_b_i = void function(QtObjH, bool, int); 86 87 private extern (C) @nogc alias t_vp__i_i = void* function(int, int); 88 private extern (C) @nogc alias t_qp__i_i = QtObjH function(int, int); 89 private extern (C) @nogc alias t_qp__i = QtObjH function(int); 90 91 private extern (C) @nogc alias t_vp__i_i_i_i = void* function(int, int, int, int); 92 93 private extern (C) @nogc alias t_v__vp_i_bool = void function(void*, int, bool); 94 private extern (C) @nogc alias t_v__vp_i_i_i_i = void function(void*, int, int, int, int); 95 private extern (C) @nogc alias t_v__qp_i_i_i_i = void function(QtObjH, int, int, int, int); 96 private extern (C) @nogc alias t_v__qp_i_i_i = void function(QtObjH, int, int, int); 97 private extern (C) @nogc alias t_v__vp_i_i_vp = void function(void*, int, int, void*); 98 private extern (C) @nogc alias t_v__i_vp_vp = void function(int, void*, void*); 99 private extern (C) @nogc alias t_vp__vp_vp_bool = void* function(void*, void*, bool); 100 private extern (C) @nogc alias t_vp__i_vp_bool = void* function(int, void*, bool); 101 private extern (C) @nogc alias t_i__v = int function(); 102 private extern (C) @nogc alias t_i__vp_vbool_i = int function(void*, bool*, int); 103 104 private extern (C) @nogc alias t_vp__vp_i_vp_i = void* function(void*, int, void*, int); 105 private extern (C) @nogc alias t_vp__vp_i_i_vp = void* function(void*, int, int, void*); 106 private extern (C) @nogc alias t_vp__vp_vp_i_i = void* function(void*, void*, int, int); 107 private extern (C) @nogc alias t_i__vp_vp_i_i = int function(void*, void*, int, int); 108 109 private extern (C) @nogc alias t_vp__vp_vp_us_i = void* function(void*, void*, ushort, int); 110 private extern (C) @nogc alias t_v__vp_vp_us_i = void function(void*, void*, ushort, int); 111 private extern (C) @nogc alias t_bool__vp = bool function(void*); 112 private extern (C) @nogc alias t_bool__vp_c = bool function(void*, char); 113 private extern (C) @nogc alias t_bool__vp_vp = bool function(void*, void*); 114 private extern (C) @nogc alias t_v__qp_bool = void function(QtObjH, bool); 115 private extern (C) @nogc alias t_v__vp_i_vp_us_i = void function(void*, int, void*, ushort, int); 116 private extern (C) @nogc alias t_vp__vp_vp_vp = void* function(void*, void*, void*); 117 118 private extern (C) @nogc alias t_l__vp_vp_l = long function(void*, void*, long); 119 private extern (C) @nogc alias t_l__vp = long function(void*); 120 121 private extern (C) @nogc alias t_vp__vp_vp_vp_vp_vp_vp_vp = void* function(void*, void*, void*, void*, void*, void*, void*); 122 private extern (C) @nogc alias t_vp__vp_vp_vp_vp_vp_vp_vp_vp = void* function(void*, void*, void*, void*, void*, void*, void*, void*); 123 124 private extern (C) @nogc alias t_ub__qp = ubyte* function(QtObjH); 125 126 version (Windows) { 127 private import core.sys.windows.windows: GetProcAddress; 128 } 129 version (linux) { 130 private import core.sys.posix.dlfcn: dlopen, dlsym, RTLD_GLOBAL, RTLD_LAZY; 131 // На Linux эти функции не определены в core.runtime, вот и пришлось дописать. 132 // странно, почему их там нет... Похоже они в основном Windows крутят. 133 // On Linux these functions aren't defined in core.runtime, here and it was necessary to add. 134 // It is strange why they aren't present there... 135 // Probably they in the main Windows twist. 136 private extern (C) void* rt_loadLibrary(const char* name) { return dlopen(name, RTLD_GLOBAL || RTLD_LAZY); } 137 private void* GetProcAddress(void* hLib, const char* nameFun) { return dlsym(hLib, nameFun); } 138 } 139 version (OSX) { 140 private import core.sys.posix.dlfcn: dlopen, dlsym, RTLD_GLOBAL, RTLD_LAZY; 141 // На Linux эти функции не определены в core.runtime, вот и пришлось дописать. 142 // странно, почему их там нет... Похоже они в основном Windows крутят. 143 // On Linux these functions aren't defined in core.runtime, here and it was necessary to add. 144 // It is strange why they aren't present there... 145 // Probably they in the main Windows twist. 146 private extern (C) void* rt_loadLibrary(const char* name) { return dlopen(name, RTLD_GLOBAL || RTLD_LAZY); } 147 private void* GetProcAddress(void* hLib, const char* nameFun) { return dlsym(hLib, nameFun); } 148 } 149 // Загрузить DLL. Load DLL (.so) 150 private void* GetHlib(T)(T name) { 151 import core.runtime; 152 return Runtime.loadLibrary(name); 153 } 154 155 // Найти адреса функций в DLL. To find addresses of executed out functions in DLL 156 private void* GetPrAddres(T)(bool isLoad, void* hLib, T nameFun) { 157 // // Искать или не искать функцию. Find or not find function in library 158 if (isLoad) return GetProcAddress(hLib, nameFun.ptr); 159 return cast(void*) 1; 160 } 161 // Сообщить об ошибке загрузки. Message on error. 162 private void MessageErrorLoad(bool showError, string s, string nameDll = "" ) { 163 if (showError) { 164 if (!nameDll.length) writeln("Error load: " ~ s); 165 else writeln("Error find function: " ~ nameDll ~ " ---> " ~ s); 166 } 167 } /// Message on error. s - text error, sw=1 - error load dll and sw=2 - error find function 168 169 char* MSS(string s, int n) { 170 if (n == QMETHOD) return cast(char*)("0" ~ s ~ "\0").ptr; 171 if (n == QSLOT) return cast(char*)("1" ~ s ~ "\0").ptr; 172 if (n == QSIGNAL) return cast(char*)("2" ~ s ~ "\0").ptr; 173 return null; 174 } /// Моделирует макросы QT. Model macros Qt. For n=2->SIGNAL(), n=1->SLOT(), n=0->METHOD(). 175 176 // Qt5Core & Qt5Gui & Qt5Widgets - Are loaded always 177 enum dll { 178 QtE5Widgets = 0x1 179 } /// Загрузка DLL. Необходимо выбрать какие грузить. Load DLL, we mast change load 180 181 // Найти и сохранить адрес функции DLL 182 void funQt(int n, bool b, void* h, string s, string name, bool she) { 183 pFunQt[n] = GetPrAddres(b, h, name); if (!pFunQt[n]) MessageErrorLoad(she, name, s); 184 } 185 186 int LoadQt(dll ldll, bool showError) { /// Загрузить DLL-ки Qt и QtE 187 bool bCore5, bGui5, bWidget5, bQtE5Widgets; 188 string sCore5, sGui5, sWidget5, sQtE5Widgets; 189 void* hCore5, hGui5, hWidget5, hQtE5Widgets; 190 191 // Add path to directory with realy file Qt5 DLL 192 version (Windows) { 193 version (X86) { // ... 32 bit code ... 194 sCore5 = "Qt5Core.dll"; 195 sGui5 = "Qt5Gui.dll"; 196 sWidget5 = "Qt5Widgets.dll"; 197 sQtE5Widgets = "QtE5Widgets32.dll"; 198 } 199 version (X86_64) { // ... 64 bit code 200 sCore5 = "Qt5Core.dll"; 201 sGui5 = "Qt5Gui.dll"; 202 sWidget5 = "Qt5Widgets.dll"; 203 sQtE5Widgets = "QtE5Widgets64.dll"; 204 } 205 } 206 // Use symlink for create link on realy file Qt5 207 version (linux) { 208 version (X86) { // ... 32 bit code ... 209 sCore5 = "libQt5Core.so"; 210 sGui5 = "libQt5Gui.so"; 211 sWidget5 = "libQt5Widgets.so"; 212 sQtE5Widgets = "libQtE5Widgets32.so"; 213 } 214 version (X86_64) { // ... 64 bit code 215 sCore5 = "libQt5Core.so"; 216 sGui5 = "libQt5Gui.so"; 217 sWidget5 = "libQt5Widgets.so"; 218 sQtE5Widgets = "libQtE5Widgets64.so"; 219 } 220 } 221 // Use symlink for create link on realy file Qt5 222 // Only 64 bit version Mac OS X (10.9.5 Maveric) 223 version (OSX) { 224 sCore5 = "libQt5Core.dylib"; 225 sGui5 = "libQt5Gui.dylib"; 226 sWidget5 = "libQt5Widgets.dylib"; 227 sQtE5Widgets = "libQtE5Widgets64.dylib"; 228 } 229 230 // Если на входе указана dll.QtE5Widgets то автоматом надо грузить и bCore5, bGui5, bWidget5 231 // If on an input it is specified dll.QtE5Widgets then automatic loaded bCore5, bGui5, bWidget5 232 bQtE5Widgets= ldll && dll.QtE5Widgets; 233 if(bQtE5Widgets) { bCore5 = true; bGui5 = true; bWidget5 = true; } 234 235 // Load library in memory 236 /* 237 if (bCore5) { 238 hCore5 = GetHlib(sCore5); if (!hCore5) { MessageErrorLoad(showError, sCore5); return 1; } 239 } 240 if (bGui5) { 241 hGui5 = GetHlib(sGui5); if (!hGui5) { MessageErrorLoad(showError, sGui5); return 1; } 242 } 243 if (bWidget5) { 244 hWidget5 = GetHlib(sWidget5); if (!hWidget5) { MessageErrorLoad(showError, sWidget5); return 1; } 245 } 246 */ 247 if (bQtE5Widgets) { 248 hQtE5Widgets = GetHlib(sQtE5Widgets); if (!hQtE5Widgets) { MessageErrorLoad(showError, sQtE5Widgets); return 1; } 249 } 250 // Find name function in DLL 251 252 // ------- QApplication ------- 253 funQt(0, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_create1", showError); 254 funQt(1, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_exec", showError); 255 funQt(2, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_aboutQt", showError); 256 funQt(3, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_delete1", showError); 257 funQt(4, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_sizeof", showError); 258 funQt(20, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_appDirPath", showError); 259 funQt(21, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQApplication_appFilePath",showError); 260 // ------- QWidget ------- 261 funQt(5, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_create1", showError); 262 funQt(6, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setVisible", showError); 263 funQt(7, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_delete1", showError); 264 funQt(11, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setWindowTitle", showError); 265 funQt(12, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_isVisible", showError); 266 funQt(30, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setStyleSheet", showError); 267 funQt(31, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setMMSize", showError); 268 funQt(32, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setEnabled", showError); 269 funQt(33, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setToolTip", showError); 270 funQt(40, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setLayout", showError); 271 funQt(78, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setSizePolicy", showError); 272 funQt(79, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setMax1", showError); 273 funQt(87, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_exWin1", showError); 274 funQt(94, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_exWin2", showError); 275 276 funQt(49, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setKeyPressEvent",showError); 277 funQt(50, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setPaintEvent", showError); 278 funQt(51, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setCloseEvent", showError); 279 funQt(52, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setResizeEvent", showError); 280 281 funQt(131,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_setFont", showError); 282 funQt(148,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_winid", showError); 283 284 funQt(172,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQWidget_getPr", showError); 285 286 // ------- QString ------- 287 funQt(8, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQString_create1", showError); 288 funQt(9, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQString_create2", showError); 289 funQt(10, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQString_delete", showError); 290 funQt(18, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQString_data", showError); 291 funQt(19, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQString_size", showError); 292 // ------- QColor ------- 293 funQt(13, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQColor_create1", showError); 294 funQt(14, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQColor_delete", showError); 295 funQt(15, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQColor_setRgb", showError); 296 // ------- QPalette ------- 297 funQt(16, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPalette_create1", showError); 298 funQt(17, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPalette_delete", showError); 299 // ------- QPushButton ------- 300 funQt(22, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPushButton_create1", showError); 301 funQt(23, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPushButton_delete", showError); 302 funQt(210,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPushButton_setXX", showError); 303 304 // ------- QSlot ------- 305 funQt(24, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSlot_create", showError); 306 funQt(25, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "QSlot_setSlotN", showError); 307 funQt(26, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSlot_delete", showError); 308 funQt(27, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteConnect", showError); 309 funQt(81, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "QSlot_setSlotN2", showError); 310 // ------- QAbstractButton ------- 311 funQt(28, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractButton_setText", showError); 312 funQt(29, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractButton_text", showError); 313 funQt(209,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractButton_setXX", showError); 314 funQt(211,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractButton_setIcon", showError); 315 funQt(224,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractButton_getXX", showError); 316 317 // ------- QLayout ------- 318 funQt(34, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout", showError); 319 funQt(35, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQVBoxLayout", showError); 320 funQt(36, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQHBoxLayout", showError); 321 funQt(37, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_delete", showError); 322 funQt(38, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_addWidget", showError); 323 funQt(39, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_addLayout", showError); 324 funQt(74, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_setSpasing", showError); 325 funQt(75, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_spasing", showError); 326 funQt(76, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_setMargin", showError); 327 funQt(77, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_margin", showError); 328 // ------- QFrame ------- 329 funQt(41, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFrame_create1", showError); 330 funQt(42, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFrame_delete1", showError); 331 funQt(43, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFrame_setFrameShape", showError); 332 funQt(44, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFrame_setFrameShadow", showError); 333 funQt(45, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFrame_setLineWidth", showError); 334 // ------- QLabel -------- 335 funQt(46, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLabel_create1", showError); 336 funQt(47, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLabel_delete1", showError); 337 funQt(48, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLabel_setText", showError); 338 // ------- QEvent ------- 339 funQt(53, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQEvent_type", showError); 340 funQt(157,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQEvent_ia", showError); 341 // ------- QResizeEvent ------- 342 funQt(54, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQResizeEvent_size", showError); 343 funQt(55, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQResizeEvent_oldSize", showError); 344 // ------- QSize ------- 345 funQt(56, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSize_create1", showError); 346 funQt(57, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSize_delete1", showError); 347 funQt(58, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSize_width", showError); 348 funQt(59, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSize_heigth", showError); 349 funQt(60, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSize_setWidth", showError); 350 funQt(61, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSize_setHeigth", showError); 351 // ------- QKeyEvent ------- 352 funQt(62, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQKeyEvent_key", showError); 353 funQt(63, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQKeyEvent_count", showError); 354 // ------- QAbstractScrollArea ------- 355 funQt(64, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractScrollArea_create1", showError); 356 funQt(65, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractScrollArea_delete1", showError); 357 // ------- QPlainTextEdit ------- 358 funQt(66, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_create1", showError); 359 funQt(67, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_delete1", showError); 360 funQt(68, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_appendPlainText", showError); 361 funQt(69, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_appendHtml", showError); 362 funQt(70, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_setPlainText", showError); 363 funQt(71, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_insertPlainText", showError); 364 funQt(72, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_cutn", showError); 365 funQt(73, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_toPlainText", showError); 366 funQt(80, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_setKeyPressEvent",showError); 367 funQt(225,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_setKeyReleaseEvent",showError); 368 funQt(226,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_document", showError); 369 funQt(230,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_textCursor", showError); 370 funQt(235,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_cursorRect", showError); 371 funQt(235,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_cursorRect", showError); 372 funQt(236,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPlainTextEdit_setTabStopWidth",showError); 373 // ------- QLineEdit ------- 374 funQt(82, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLineEdit_create1", showError); 375 funQt(83, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLineEdit_delete1", showError); 376 funQt(84, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLineEdit_set", showError); 377 funQt(85, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLineEdit_clear", showError); 378 funQt(86, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLineEdit_text", showError); 379 funQt(158,bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLineEdit_setKeyPressEvent", showError); 380 // ------- QMainWindow ------- 381 funQt(88, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMainWindow_create1", showError); 382 funQt(89, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMainWindow_delete1", showError); 383 funQt(90, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMainWindow_setXX", showError); 384 funQt(126, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMainWindow_addToolBar", showError); 385 // ------- QStatusBar ------- 386 funQt(91, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQStatusBar_create1", showError); 387 funQt(92, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQStatusBar_delete1", showError); 388 funQt(93, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQStatusBar_showMessage", showError); 389 // ------- QAction ------- 390 funQt(95, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAction_create", showError); 391 funQt(96, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAction_delete", showError); 392 funQt(97, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAction_setXX1", showError); 393 funQt(98, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAction_setSlotN2", showError); 394 funQt(105, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets,"qteQAction_setHotKey", showError); 395 funQt(109, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets,"qteQAction_setEnabled", showError); 396 funQt(113, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets,"qteQAction_setIcon", showError); 397 // ------- QMenu ------- 398 funQt(99, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenu_create", showError); 399 funQt(100, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenu_delete", showError); 400 funQt(101, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenu_addAction", showError); 401 funQt(106, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenu_setTitle", showError); 402 funQt(107, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenu_addSeparator", showError); 403 funQt(108, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenu_addMenu", showError); 404 // ------- QMenuBar ------- 405 funQt(102, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenuBar_create", showError); 406 funQt(103, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenuBar_delete", showError); 407 funQt(104, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMenuBar_addMenu", showError); 408 // ------- QIcon ------- 409 funQt(110, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQIcon_create", showError); 410 funQt(111, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQIcon_delete", showError); 411 funQt(112, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQIcon_addFile", showError); 412 // ------- QToolBar ------- 413 funQt(114, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQToolBar_create", showError); 414 funQt(115, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQToolBar_delete", showError); 415 funQt(116, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQToolBar_setXX1", showError); 416 417 funQt(124, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQToolBar_setAllowedAreas", showError); 418 funQt(125, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQToolBar_setToolButtonStyle", showError); 419 420 funQt(132, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQToolBar_addSeparator", showError); 421 422 // ------- QDialog ------- 423 funQt(117, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQDialog_create", showError); 424 funQt(118, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQDialog_delete", showError); 425 funQt(119, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQDialog_exec", showError); 426 // ------- QDialog ------- 427 funQt(120, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMessageBox_create", showError); 428 funQt(121, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMessageBox_delete", showError); 429 funQt(122, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMessageBox_setXX1", showError); 430 funQt(123, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMessageBox_setStandartButtons", showError); 431 // ------- QFont ------- 432 funQt(127, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFont_create", showError); 433 funQt(128, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFont_delete", showError); 434 funQt(129, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFont_setPointSize", showError); 435 funQt(130, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFont_setFamily", showError); 436 // ------- QProgressBar ------- 437 funQt(133, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQProgressBar_create", showError); 438 funQt(134, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQProgressBar_delete", showError); 439 funQt(135, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQProgressBar_setPr", showError); 440 // ------- QDate ------- 441 funQt(136, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQDate_create", showError); 442 funQt(137, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQDate_delete", showError); 443 funQt(140, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQDate_toString", showError); 444 445 // ------- QTime ------- 446 funQt(138, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTime_create", showError); 447 funQt(139, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTime_delete", showError); 448 funQt(141, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTime_toString", showError); 449 450 // ------- QFileDialog ------- 451 funQt(142, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFileDialog_create", showError); 452 funQt(143, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFileDialog_delete", showError); 453 funQt(144, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFileDialog_setNameFilter", showError); 454 funQt(145, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFileDialog_setViewMode", showError); 455 funQt(146, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFileDialog_getOpenFileName", showError); 456 funQt(147, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQFileDialog_getSaveFileName", showError); 457 // ------- QAbstractScrollArea ------- 458 funQt(149, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractScrollArea_create", showError); 459 funQt(150, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractScrollArea_delete", showError); 460 // ------- QMdiArea ------- 461 funQt(151, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMdiArea_create", showError); 462 funQt(152, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMdiArea_delete", showError); 463 464 funQt(155, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMdiArea_addSubWindow", showError); 465 // ------- QMdiSubWindow ------- 466 funQt(153, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMdiSubWindow_create", showError); 467 funQt(154, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMdiSubWindow_delete", showError); 468 funQt(156, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQMdiSubWindow_addLayout", showError); 469 // ------- QTableView ------- 470 funQt(159, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableView_create", showError); 471 funQt(160, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableView_delete", showError); 472 473 funQt(174, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableView_setN1", showError); 474 funQt(175, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableView_getN1", showError); 475 funQt(182, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableView_ResizeMode", showError); 476 477 // ------- QTableWidget ------- 478 funQt(161, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_create", showError); 479 funQt(162, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_delete", showError); 480 funQt(163, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_setRC", showError); 481 funQt(167, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_setitem", showError); 482 483 funQt(176, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_setHVheaderItem", showError); 484 funQt(241, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_setCurrentCell", showError); 485 486 // ------- QTableWidgetItem ------- 487 funQt(164, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_create", showError); 488 funQt(165, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_delete", showError); 489 490 funQt(166, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_setXX", showError); 491 funQt(168, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_setYY", showError); 492 funQt(169, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidget_item", showError); 493 funQt(170, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_text", showError); 494 funQt(171, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_setAligment", showError); 495 funQt(180, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableWidgetItem_setBackground", showError); 496 497 // ------- QBrush ------- 498 funQt(177, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_create1", showError); 499 funQt(178, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_delete", showError); 500 funQt(179, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_setColor", showError); 501 funQt(181, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_setStyle", showError); 502 503 // ------- QComboBox ------- 504 funQt(183, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQComboBox_create", showError); 505 funQt(184, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQComboBox_delete", showError); 506 funQt(185, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQComboBox_setXX", showError); 507 funQt(186, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQComboBox_getXX", showError); 508 funQt(187, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQComboBox_text", showError); 509 // ------- QPainter ------- 510 funQt(188, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_drawPoint", showError); 511 funQt(189, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_drawLine", showError); 512 funQt(190, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_setXX1", showError); 513 funQt(196, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_setText", showError); 514 funQt(197, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_end", showError); 515 funQt(243, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_drawRect1", showError); 516 funQt(244, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_drawRect2", showError); 517 funQt(245, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_fillRect2", showError); 518 funQt(246, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPainter_fillRect3", showError); 519 // ------- QPen ------- 520 funQt(191, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPen_create1", showError); 521 funQt(192, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPen_delete", showError); 522 funQt(193, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPen_setColor", showError); 523 funQt(194, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPen_setStyle", showError); 524 funQt(195, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQPen_setWidth", showError); 525 // ------- QLCDNumber ------- 526 funQt(198, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_create1", showError); 527 funQt(199, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_delete1", showError); 528 funQt(200, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_create2", showError); 529 funQt(201, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_display", showError); 530 funQt(202, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_setSegmentStyle", showError); 531 funQt(203, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_setDigitCount", showError); 532 funQt(204, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQLCDNumber_setMode", showError); 533 // ------- QAbstractSlider ------- 534 funQt(205, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractSlider_setXX", showError); 535 funQt(208, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractSlider_getXX", showError); 536 // ------- QSlider ------- 537 funQt(206, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSlider_create1", showError); 538 funQt(207, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSlider_delete1", showError); 539 // ------- QGroupBox ------- 540 funQt(212, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQGroupBox_create", showError); 541 funQt(213, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQGroupBox_delete", showError); 542 funQt(214, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQGroupBox_setTitle", showError); 543 funQt(215, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQGroupBox_setAlignment", showError); 544 // ------- QCheckBox ------- 545 funQt(216, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQCheckBox_create1", showError); 546 funQt(217, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQCheckBox_delete", showError); 547 funQt(218, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQCheckBox_checkState", showError); 548 funQt(219, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQCheckBox_setCheckState", showError); 549 funQt(220, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQCheckBox_setTristate", showError); 550 funQt(221, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQCheckBox_isTristate", showError); 551 // ------- QRadioButton ------- 552 funQt(222, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQRadioButton_create1", showError); 553 funQt(223, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQRadioButton_delete", showError); 554 // ------- QTextCursor ------- 555 funQt(227, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextCursor_create1", showError); 556 funQt(228, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextCursor_delete", showError); 557 funQt(229, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextCursor_create2", showError); 558 funQt(231, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextCursor_getXX1", showError); 559 // ------- QRect ------- 560 funQt(232, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQRect_create1", showError); 561 funQt(233, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQRect_delete", showError); 562 funQt(234, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQRect_setXX1", showError); 563 funQt(242, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQRect_setXX2", showError); 564 565 // ------- QTextBlock ------- 566 funQt(237, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextBlock_text", showError); 567 funQt(238, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextBlock_create", showError); 568 funQt(239, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextBlock_delete", showError); 569 funQt(240, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTextBlock_create2", showError); 570 571 // ------- QSpinBox ------- 572 funQt(247, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSpinBox_create", showError); 573 funQt(248, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSpinBox_delete", showError); 574 funQt(249, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSpinBox_setXX1", showError); 575 funQt(250, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSpinBox_getXX1", showError); 576 funQt(251, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQSpinBox_setXX2", showError); 577 578 // ------- QAbstractSpinBox ------- 579 funQt(252, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQAbstractSpinBox_setReadOnly", showError); 580 581 // Последний = 252 582 return 0; 583 } /// Загрузить DLL-ки Qt и QtE. Найти в них адреса функций и заполнить ими таблицу 584 585 static void msgbox(string text = null, string caption = null, 586 QMessageBox.Icon icon = QMessageBox.Icon.Information, QWidget parent = null) { 587 string cap, titl; 588 QMessageBox soob = new QMessageBox(parent); 589 if (caption is null) soob.setWindowTitle("Внимание!"); else soob.setWindowTitle(caption); 590 if (text is null) soob.setText(". . . . ."); else soob.setText(text); 591 soob.setIcon(icon).setStandardButtons(QMessageBox.StandardButton.Ok); 592 try { soob.exec(); } catch {} 593 } 594 595 /++ 596 Класс констант. В нем кое что из Qt:: 597 +/ 598 class QtE { 599 enum WindowType { 600 Widget = 0x00000000, 601 Window = 0x00000001, 602 Dialog = 0x00000002 | Window, 603 Sheet = 0x00000004 | Window, 604 Drawer = Sheet | Dialog, 605 Popup = 0x00000008 | Window, 606 Tool = Popup | Dialog, 607 ToolTip = Popup | Sheet, 608 SplashScreen = ToolTip | Dialog, 609 Desktop = 0x00000010 | Window, 610 SubWindow = 0x00000012, 611 ForeignWindow = 0x00000020 | Window, 612 CoverWindow = 0x00000040 | Window, 613 CustomizeWindowHint = 0x02000000, // Turns off the default window title hints. 614 WindowTitleHint = 0x00001000, // Gives the window a title bar. 615 WindowSystemMenuHint = 0x00002000, // Adds a window system menu, and possibly a close button (for example on Mac). If you need to hide or show a close button, it is more portable to use WindowCloseButtonHint. 616 WindowMinimizeButtonHint = 0x00004000, // Adds a minimize button. On some platforms this implies Qt::WindowSystemMenuHint for it to work. 617 WindowMaximizeButtonHint = 0x00008000, // Adds a maximize button. On some platforms this implies Qt::WindowSystemMenuHint for it to work. 618 WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint, // Adds a minimize and a maximize button. On some platforms this implies Qt::WindowSystemMenuHint for it to work. 619 WindowCloseButtonHint = 0x08000000, // Adds a close button. On some platforms this implies Qt::WindowSystemMenuHint for it to work. 620 WindowContextHelpButtonHint = 0x00010000, // Adds a context help button to dialogs. On some platforms this implies Qt::WindowSystemMenuHint for it to work. 621 MacWindowToolBarButtonHint = 0x10000000, // On OS X adds a tool bar button (i.e., the oblong button that is on the top right of windows that have toolbars). 622 WindowFullscreenButtonHint = 0x80000000, // On OS X adds a fullscreen button. 623 BypassGraphicsProxyWidget = 0x20000000, // Prevents the window and its children from automatically embedding themselves into a QGraphicsProxyWidget if the parent widget is already embedded. You can set this flag if you want your widget to always be a toplevel widget on the desktop, regardless of whether the parent widget is embedded in a scene or not. 624 WindowShadeButtonHint = 0x00020000, // Adds a shade button in place of the minimize button if the underlying window manager supports it. 625 WindowStaysOnTopHint = 0x00040000, // Informs the window system that the window should stay on top of all other windows. Note that on some window managers on X11 you also have to pass Qt::X11BypassWindowManagerHint for this flag to work correctly. 626 WindowStaysOnBottomHint = 0x04000000 // Informs the window system that the window should stay on bottom of all other windows. Note that on X11 this hint will work only in window managers that support _NET_WM_STATE_BELOW atom. If a window always on the bottom has a parent, the parent will also be left on the bottom. This window hint is currently not impl 627 // .... Qt5/QtCore/qnamespace.h 628 } 629 enum KeyboardModifier { 630 NoModifier = 0x00000000, 631 ShiftModifier = 0x02000000, 632 ControlModifier = 0x04000000, 633 AltModifier = 0x08000000, 634 MetaModifier = 0x10000000, 635 KeypadModifier = 0x20000000, 636 GroupSwitchModifier = 0x40000000, 637 // Do not extend the mask to include 0x01000000 638 KeyboardModifierMask = 0xfe000000 639 } 640 // Политика контексного меню 641 enum ContextMenuPolicy { 642 NoContextMenu = 0, // нет контексного меню 643 DefaultContextMenu = 1, // 644 ActionsContextMenu = 2, // 645 CustomContextMenu = 3, // 646 PreventContextMenu = 4 // 647 } 648 enum Key { 649 Key_ControlModifier = 0x04000000, 650 Key_Escape = 0x01000000, // misc keys 651 Key_Tab = 0x01000001, 652 Key_Backtab = 0x01000002, 653 Key_Backspace = 0x01000003, 654 Key_Return = 0x01000004, 655 Key_Enter = 0x01000005, 656 Key_Insert = 0x01000006, 657 Key_Delete = 0x01000007, 658 Key_Pause = 0x01000008, 659 Key_Print = 0x01000009, 660 Key_SysReq = 0x0100000a, 661 Key_Clear = 0x0100000b, 662 Key_Home = 0x01000010, // cursor movement 663 Key_End = 0x01000011, 664 Key_Left = 0x01000012, 665 Key_Up = 0x01000013, 666 Key_Right = 0x01000014, 667 Key_Down = 0x01000015, 668 Key_PageUp = 0x01000016, 669 Key_Shift = 0x01000020, // modifiers 670 Key_Control = 0x01000021, 671 Key_Meta = 0x01000022, 672 Key_Alt = 0x01000023, 673 Key_CapsLock = 0x01000024, 674 Key_NumLock = 0x01000025, 675 Key_ScrollLock = 0x01000026, 676 Key_F1 = 0x01000030, // function keys 677 Key_F2 = 0x01000031, 678 Key_F3 = 0x01000032, 679 Key_F4 = 0x01000033, 680 Key_F5 = 0x01000034, 681 Key_F6 = 0x01000035, 682 Key_F7 = 0x01000036, 683 Key_F8 = 0x01000037, 684 Key_F9 = 0x01000038, 685 Key_F10 = 0x01000039, 686 Key_F11 = 0x0100003a, 687 Key_F12 = 0x0100003b, 688 Key_F13 = 0x0100003c, 689 Key_F14 = 0x0100003d, 690 Key_F15 = 0x0100003e, 691 Key_F16 = 0x0100003f, 692 Key_F17 = 0x01000040, 693 Key_F18 = 0x01000041, 694 Key_F19 = 0x01000042, 695 Key_F20 = 0x01000043, 696 Key_F21 = 0x01000044, 697 Key_F22 = 0x01000045, 698 Key_F23 = 0x01000046, 699 Key_F24 = 0x01000047, 700 Key_F25 = 0x01000048, // F25 .. F35 only on X11 701 Key_F26 = 0x01000049, 702 Key_F27 = 0x0100004a, 703 Key_F28 = 0x0100004b, 704 Key_F29 = 0x0100004c, 705 Key_F30 = 0x0100004d, 706 Key_F31 = 0x0100004e, 707 Key_F32 = 0x0100004f, 708 Key_F33 = 0x01000050, 709 Key_F34 = 0x01000051, 710 Key_F35 = 0x01000052, 711 Key_Super_L = 0x01000053, // extra keys 712 Key_Super_R = 0x01000054, 713 Key_Menu = 0x01000055, 714 Key_Hyper_L = 0x01000056, 715 Key_Hyper_R = 0x01000057, 716 Key_Help = 0x01000058, 717 Key_Direction_L = 0x01000059, 718 Key_Direction_R = 0x01000060, 719 Key_Space = 0x20, // 7 bit printable ASCII 720 Key_Any = Key_Space, 721 Key_Exclam = 0x21, 722 Key_QuoteDbl = 0x22, 723 Key_NumberSign = 0x23, 724 Key_Dollar = 0x24, 725 Key_Percent = 0x25, 726 Key_Ampersand = 0x26, 727 Key_Apostrophe = 0x27, 728 Key_ParenLeft = 0x28, 729 Key_ParenRight = 0x29, 730 Key_Asterisk = 0x2a, 731 Key_Plus = 0x2b, 732 Key_Comma = 0x2c, 733 Key_Minus = 0x2d, 734 Key_Period = 0x2e, 735 Key_Slash = 0x2f, 736 Key_0 = 0x30,Key_1 = 0x31,Key_2 = 0x32,Key_3 = 0x33,Key_4 = 0x34,Key_5 = 0x35, 737 Key_6 = 0x36,Key_7 = 0x37,Key_8 = 0x38,Key_9 = 0x39,Key_Colon = 0x3a, 738 Key_Semicolon = 0x3b, 739 Key_Less = 0x3c, 740 Key_Equal = 0x3d, 741 Key_Greater = 0x3e, 742 Key_Question = 0x3f, 743 Key_At = 0x40, 744 Key_A = 0x41, 745 Key_B = 0x42, 746 Key_C = 0x43, 747 Key_D = 0x44, 748 Key_E = 0x45, 749 Key_F = 0x46, 750 Key_G = 0x47, 751 Key_H = 0x48, 752 Key_I = 0x49, 753 Key_J = 0x4a, 754 Key_K = 0x4b, 755 Key_L = 0x4c, 756 Key_M = 0x4d, 757 Key_N = 0x4e, 758 Key_O = 0x4f, 759 Key_P = 0x50, 760 Key_Q = 0x51, 761 Key_R = 0x52, 762 Key_S = 0x53, 763 Key_T = 0x54, 764 Key_U = 0x55, 765 Key_V = 0x56, 766 Key_W = 0x57, 767 Key_X = 0x58, 768 Key_Y = 0x59, 769 Key_Z = 0x5a, 770 Key_BracketLeft = 0x5b, 771 Key_Backslash = 0x5c, 772 Key_BracketRight = 0x5d, 773 Key_AsciiCircum = 0x5e, 774 Key_Underscore = 0x5f, 775 Key_QuoteLeft = 0x60, 776 Key_BraceLeft = 0x7b, 777 Key_Bar = 0x7c, 778 Key_BraceRight = 0x7d, 779 Key_AsciiTilde = 0x7e, 780 Key_nobreakspace = 0x0a0, 781 Key_exclamdown = 0x0a1, 782 Key_cent = 0x0a2, 783 Key_sterling = 0x0a3, 784 Key_currency = 0x0a4, 785 Key_yen = 0x0a5, 786 Key_brokenbar = 0x0a6, 787 Key_section = 0x0a7, 788 Key_diaeresis = 0x0a8, 789 Key_copyright = 0x0a9, 790 Key_ordfeminine = 0x0aa, 791 Key_guillemotleft = 0x0ab, // left angle quotation mark 792 Key_notsign = 0x0ac, 793 Key_hyphen = 0x0ad, 794 Key_registered = 0x0ae, 795 Key_macron = 0x0af, 796 Key_degree = 0x0b0, 797 Key_plusminus = 0x0b1, 798 Key_twosuperior = 0x0b2, 799 Key_threesuperior = 0x0b3, 800 Key_acute = 0x0b4, 801 Key_mu = 0x0b5, 802 Key_paragraph = 0x0b6, 803 Key_periodcentered = 0x0b7, 804 Key_cedilla = 0x0b8, 805 Key_onesuperior = 0x0b9, 806 Key_masculine = 0x0ba, 807 Key_guillemotright = 0x0bb, // right angle quotation mark 808 Key_onequarter = 0x0bc, 809 Key_onehalf = 0x0bd, 810 Key_threequarters = 0x0be, 811 Key_questiondown = 0x0bf, 812 Key_Agrave = 0x0c0, 813 Key_Aacute = 0x0c1, 814 Key_Acircumflex = 0x0c2, 815 Key_Atilde = 0x0c3, 816 Key_Adiaeresis = 0x0c4, 817 Key_Aring = 0x0c5, 818 Key_AE = 0x0c6, 819 Key_Ccedilla = 0x0c7, 820 Key_Egrave = 0x0c8, 821 Key_Eacute = 0x0c9, 822 Key_Ecircumflex = 0x0ca, 823 Key_Ediaeresis = 0x0cb, 824 Key_Igrave = 0x0cc, 825 Key_Iacute = 0x0cd, 826 Key_Icircumflex = 0x0ce, 827 Key_Idiaeresis = 0x0cf, 828 Key_ETH = 0x0d0, 829 Key_Ntilde = 0x0d1, 830 Key_Ograve = 0x0d2, 831 Key_Oacute = 0x0d3, 832 Key_Ocircumflex = 0x0d4, 833 Key_Otilde = 0x0d5, 834 Key_Odiaeresis = 0x0d6, 835 Key_multiply = 0x0d7, 836 Key_Ooblique = 0x0d8, 837 Key_Ugrave = 0x0d9, 838 Key_Uacute = 0x0da, 839 Key_Ucircumflex = 0x0db, 840 Key_Udiaeresis = 0x0dc, 841 Key_Yacute = 0x0dd, 842 Key_THORN = 0x0de, 843 Key_ssharp = 0x0df, 844 Key_division = 0x0f7, 845 Key_ydiaeresis = 0x0ff, 846 Key_AltGr = 0x01001103, 847 Key_Multi_key = 0x01001120, // Multi-key character compose 848 Key_Codeinput = 0x01001137, 849 Key_SingleCandidate = 0x0100113c, 850 Key_MultipleCandidate = 0x0100113d, 851 Key_PreviousCandidate = 0x0100113e, 852 Key_unknown = 0x01ffffff 853 } 854 enum Orientation { 855 Horizontal = 0x1, 856 Vertical = 0x2 857 } 858 enum AlignmentFlag { 859 AlignLeft = 0x0001, 860 AlignLeading = AlignLeft, 861 AlignRight = 0x0002, 862 AlignTrailing = AlignRight, 863 AlignHCenter = 0x0004, 864 AlignJustify = 0x0008, 865 AlignAbsolute = 0x0010, 866 AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute, 867 868 AlignTop = 0x0020, 869 AlignBottom = 0x0040, 870 AlignVCenter = 0x0080, 871 AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter, 872 AlignCenter = AlignVCenter | AlignHCenter, 873 AlignAuto = AlignLeft, 874 AlignExpanding = AlignLeft & AlignTop 875 } 876 enum GlobalColor { 877 color0, 878 color1, 879 black, 880 white, 881 darkGray, 882 gray, 883 lightGray, 884 red, 885 green, 886 blue, 887 cyan, 888 magenta, 889 yellow, 890 darkRed, 891 darkGreen, 892 darkBlue, 893 darkCyan, 894 darkMagenta, 895 darkYellow, 896 transparent 897 } 898 enum PenStyle { 899 NoPen = 0, // Запретить рисование 900 SolidLine = 1, // Сплошная непрерывная линия 901 DashLine = 2, // Штрихова, длинные штрихи 902 DotLine = 3, // Пунктир, точки 903 DashDotLine = 4, // Штрих пунктиреая, длинный штрих + точка 904 DashDotDotLine = 5, // штрих 2 точки штрих 2 точки 905 CustomDashLine = 6 // A custom pattern defined using QPainterPathStroker::setDashPattern(). 906 } 907 enum CheckState { 908 Unchecked = 0, // Не выбранный 909 PartiallyChecked = 1, // The item is partially checked. Items in hierarchical models may be partially checked if some, but not all, of their children are checked. 910 Checked = 2 // Выбран The item is checked. 911 } 912 } 913 // ================ QObject ================ 914 /++ 915 Базовый класс. Хранит в себе ссылку на реальный объект в Qt C++ 916 Base class. Stores in itself the link to real object in Qt C ++ 917 +/ 918 class QObject { 919 // Тип связи сигнал - слот 920 enum ConnectionType { 921 AutoConnection = 0, // default. Если thred другой, то в очередь, иначе сразу выполнение 922 DirectConnection = 1, // Выполнить немедленно 923 QueuedConnection = 2, // Сигнал в очередь 924 BlockingQueuedConnection = 4, // Только для разных thred 925 UniqueConnection = 0x80, // Как AutoConnection, но обязательно уникальный 926 AutoCompatConnection = 3 // совместимость с Qt3 927 } 928 929 private QtObjH p_QObject; /// Адрес самого объекта из C++ Qt 930 private bool fNoDelete; /// Если T - не вызывать деструктор 931 private void* adrThis; /// Адрес собственного экземпляра 932 933 this() {} /// спец Конструктор, что бы не делать реальный объект из Qt при наследовании 934 ~this() { 935 // writeln("~QObject ", this); 936 } 937 // Ни чего в голову не лезет ... Нужно сделать объект, записав в него пришедший 938 // с наружи указатель. Дабы отличить нужный конструктор, специально делаю 939 // этот конструктор "вычурным" 940 // this(char ch, void* adr) { 941 // if(ch == '+') setQtObj(cast(QtObjH)adr); 942 //} 943 void setNoDelete(bool f) { fNoDelete = f; } 944 945 void setQtObj(QtObjH adr) { p_QObject = adr; } /// Заменить указатель в объекте на новый указатель 946 947 @property QtObjH QtObj() { 948 return p_QObject; 949 } /// Выдать указатель на реальный объект Qt C++ 950 @property void* aQtObj() { 951 return &p_QObject; 952 } /// Выдать указатель на p_QObject 953 QObject connect(void* obj1, char* ssignal, void* obj2, char* sslot, 954 QObject.ConnectionType type = QObject.ConnectionType.AutoConnection) { 955 (cast(t_QObject_connect) pFunQt[27])(obj1, ssignal, obj2, sslot, cast(int)type); 956 return this; 957 } 958 QObject connects(QObject obj1, string ssignal, QObject obj2, string sslot) { 959 (cast(t_QObject_connect) pFunQt[27])( 960 (cast(QObject)obj1).QtObj, MSS(ssignal, QSIGNAL), 961 (cast(QObject)obj2).QtObj, MSS(sslot, QSLOT), 962 cast(int)QObject.ConnectionType.AutoConnection); 963 return this; 964 } 965 /// Запомнить указатель на собственный экземпляр 966 void saveThis(void* adr) { 967 adrThis = adr; 968 } 969 @property void* aThis() { 970 return &adrThis; 971 } /// Выдать указатель на p_QObject 972 } 973 // ================ gSlot ================ 974 /++ 975 gSlot - это набор слотов, хранящих в себе адрес вызываемой функции из D. 976 <br>В D нет возможности создать слот, по этому в QtE.dll создан класс, который есть набор слотов 977 с разными типами вызовов функции на D. Без аргументов, с одним аргументом с двумя и т.д. 978 для реакции на события. 979 gSlot - is a set of the slots storing in the address of called function from D. 980 In D there is no possibility to create the slot, on it in QtE.dll the class which 981 set of slots with different types of calls of function on D is is created. 982 Without arguments, with one argument with two etc. 983 "SlotN()" --> call(n) где n есть запомненный параметр (n save parametr) 984 "Slot_Bool(bool b)" --> call(b) где b есть параметрр сигнала (b signal parametr) 985 "Slot_Int(int i)" --> call(i) где i есть параметрр сигнала (i signal parametr) 986 987 Example: 988 connect(xxx, "send(n)", QSlot, "Slot_Int(int)"); for integet argument signal 989 connect(xxx, "send(b)", QSlot, "Slot_Bool(bool)"); for bool argument signal 990 +/ 991 class QSlot : QObject { 992 this() { setQtObj((cast(t_qp__qp)pFunQt[24])(null)); 993 } 994 ~this() { 995 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[26])(QtObj); setQtObj(null); } 996 } /// Деструктор 997 this(void* adr, int n = 0) { 998 setQtObj((cast(t_qp__qp)pFunQt[24])(null)); 999 (cast(t_v__qp_qp_i)pFunQt[25])(QtObj, cast(QtObjH)adr, n); 1000 } /// Установить слот с параметром 1001 1002 // Эксперементаьный, попытка вызвать метод, не используя Extern "C" 1003 this(void* adr, void* adrThis, int n = 0) { 1004 setQtObj((cast(t_qp__qp)pFunQt[24])(null)); 1005 (cast(t_v__qp_qp_qp_i)pFunQt[81])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis, n); 1006 } /// Установить слот с параметром 1007 1008 1009 // При установке setSlotN устанавливается адрес callback и параметр n 1010 // который будет возвращен при срабатывании слота и позволит идентифицировать того, кто 1011 // вызвал callback 1012 // At installation setSlotN callback address and parametre n which 1013 // is established will be returned at operation of the slot and will 1014 // allow to identify the one who has called callback 1015 QSlot setSlotN(void* adr, int n = 0) { 1016 (cast(t_v__qp_qp_i)pFunQt[25])(QtObj, cast(QtObjH)adr, n); return this; 1017 } /// Установить слот с параметром 1018 1019 1020 1021 /* 1022 void emitSignal0() { 1023 (cast(t_eSlot_setSignal0) pFunQt[25])(p_QObject); 1024 } /// Послать сигнал "Signal0()"без аргументов 1025 */ 1026 } 1027 1028 // ================ QPalette ================ 1029 /++ 1030 QPalette - Палитры цветов 1031 +/ 1032 class QPalette : QObject { 1033 1034 enum ColorGroup { 1035 Active, 1036 Disabled, 1037 Inactive, 1038 NColorGroups, 1039 Current, 1040 All, 1041 Normal = Active 1042 } 1043 1044 enum ColorRole { 1045 WindowText, 1046 Button, 1047 Light, 1048 Midlight, 1049 Dark, 1050 Mid, 1051 Text, 1052 BrightText, 1053 ButtonText, 1054 Base, 1055 Window, 1056 Shadow, 1057 Highlight, 1058 HighlightedText, 1059 Link, 1060 LinkVisited, // ### Qt 5: remove 1061 AlternateBase, 1062 NoRole, // ### Qt 5: value should be 0 or -1 1063 ToolTipBase, 1064 ToolTipText, 1065 NColorRoles = ToolTipText + 1, 1066 Foreground = WindowText, 1067 Background = Window // ### Qt 5: remove 1068 } 1069 1070 this() { 1071 setQtObj((cast(t_qp__v) pFunQt[16])()); 1072 } /// Конструктор 1073 ~this() { 1074 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[17])(QtObj); setQtObj(null); } 1075 } /// Деструктор 1076 } 1077 1078 // ================ QColor ================ 1079 /++ 1080 QColor - Цвет 1081 +/ 1082 class QColor : QObject { 1083 this() { 1084 setQtObj((cast(t_qp__v) pFunQt[13])()); 1085 } /// Конструктор 1086 ~this() { 1087 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[14])(QtObj); setQtObj(null); } 1088 } /// Деструктор 1089 void setRgb(int r, int g, int b, int a = 255) { 1090 (cast(t_v__qp_i_i_i_i) pFunQt[15])(QtObj, r, g, b, a); 1091 } /// Sets the RGB value to r, g, b and the alpha value to a. All the values must be in the range 0-255. 1092 } 1093 // ================ QBrush ================ 1094 /++ 1095 QBrush - Оформление 1096 +/ 1097 class QBrush : QObject { 1098 1099 enum BrushStyle { 1100 NoBrush = 0, // No brush pattern. 1101 SolidPattern = 1, // Однообразный 1102 Dense1Pattern = 2, // Исключительно плотный 1103 Dense2Pattern = 3, // Довольно плотный 1104 Dense3Pattern = 4, // Somewhat dense brush pattern. 1105 Dense4Pattern = 5, // Half dense brush pattern. 1106 Dense5Pattern = 6, // Somewhat sparse brush pattern. 1107 Dense6Pattern = 7, // Very sparse brush pattern. 1108 Dense7Pattern = 8, // Extremely sparse brush pattern. 1109 HorPattern = 9, // Горизонтальная штриховка 1110 VerPattern = 10, // Вертикальная штриховка 1111 CrossPattern = 11, // Сетка 1112 BDiagPattern = 12, // Backward diagonal lines. 1113 FDiagPattern = 13, // Forward diagonal lines. 1114 DiagCrossPattern = 14, // Crossing diagonal lines. 1115 LinearGradientPattern = 15, // Linear gradient (set using a dedicated QBrush constructor). 1116 ConicalGradientPattern= 17, // Conical gradient (set using a dedicated QBrush constructor). 1117 RadialGradientPattern= 16, // Radial gradient (set using a dedicated QBrush constructor). 1118 TexturePattern =24 // Custom pattern (see QBrush::setTexture()). 1119 } 1120 1121 this() { 1122 setQtObj((cast(t_qp__v) pFunQt[177])()); 1123 } /// Конструктор 1124 ~this() { 1125 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[178])(QtObj); setQtObj(null); } 1126 } /// Деструктор 1127 QBrush setColor(QColor color) { 1128 (cast(t_v__qp_qp) pFunQt[179])(QtObj, color.QtObj); 1129 return this; 1130 } 1131 QBrush setStyle(BrushStyle style = BrushStyle.SolidPattern) { 1132 (cast(t_v__qp_i) pFunQt[181])(QtObj, style); 1133 return this; 1134 } 1135 } 1136 1137 /* // ------- QBrush ------- 1138 funQt(177, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_create1", showError); 1139 funQt(178, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_delete", showError); 1140 funQt(179, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBrush_setColor", showError); 1141 */ 1142 1143 1144 1145 // ================ QPaintDevice ================ 1146 class QPaintDevice: QObject { 1147 this(){} 1148 } 1149 1150 // ================ gWidget ================ 1151 /++ 1152 QWidget (Окно), но немного модифицированный в QtE.DLL. 1153 <br>Хранит в себе ссылку на реальный С++ класс gWidget из QtE.dll 1154 <br>Добавлены свойства хранящие адреса для вызова обратных функций 1155 для реакции на события. 1156 +/ 1157 class QWidget: QPaintDevice { 1158 enum PolicyFlag { 1159 GrowFlag = 1, 1160 ExpandFlag = 2, 1161 ShrinkFlag = 4, 1162 IgnoreFlag = 8 1163 } 1164 enum Policy { 1165 Fixed = 0, 1166 Minimum = PolicyFlag.GrowFlag, 1167 Maximum = PolicyFlag.ShrinkFlag, 1168 Preferred = PolicyFlag.GrowFlag | PolicyFlag.ShrinkFlag, 1169 MinimumExpanding = PolicyFlag.GrowFlag | PolicyFlag.ExpandFlag, 1170 Expanding = PolicyFlag.GrowFlag | PolicyFlag.ShrinkFlag | PolicyFlag.ExpandFlag, 1171 Ignored = PolicyFlag.ShrinkFlag | PolicyFlag.GrowFlag | PolicyFlag.IgnoreFlag 1172 } 1173 1174 // Жуткое откровение dmd. Оказывается, выходя за границы блока объект 1175 // не разрушается, а продолжает существовать, по GC его не прикончит. 1176 // В связи с этим надо вызывать ~this() если надо явно разрушить объект. 1177 1178 // Qt - тоже ещё тот "подарок". При указании родителя (того самого parent) 1179 // происходит связывание в дерево. При удалении родительского объекта Qt 1180 // удаляются каскадно все вложенные в него подобъекты. Однако dmd об этом 1181 // ни чего не знает. По этому пришлось вставить fNoDelete, который надо 1182 // установить в T если объект подвергся вставке и значит будет удален каскадно. 1183 this(){} 1184 ~this() { 1185 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[7])(QtObj); setQtObj(null); } 1186 } 1187 1188 1189 this(QWidget parent = null, QtE.WindowType fl = QtE.WindowType.Widget) { 1190 if (parent) { 1191 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1192 setQtObj((cast(t_qp__qp_i)pFunQt[5])(parent.QtObj, cast(int)fl)); 1193 } else { 1194 setQtObj((cast(t_qp__qp_i)pFunQt[5])(null, cast(int)fl)); 1195 } 1196 } /// QWidget::QWidget(QWidget * parent = 0, Qt::WindowFlags f = 0) 1197 bool isVisible() { 1198 return (cast(t_bool__vp)pFunQt[12])(QtObj); 1199 } /// QWidget::isVisible(); 1200 QWidget setVisible(bool f) { // Скрыть, Показать виджет 1201 (cast(t_v__qp_bool)pFunQt[6])(QtObj, f); return this; 1202 } /// On/Off - это реальный setVisible from QtWidget.dll 1203 //QWidget show() { setVisible(true); return this; } /// Показать виджет 1204 //QWidget hide() { setVisible(false); return this; } /// Скрыть виджет 1205 QWidget setWindowTitle(QString qstr) { // Установить заголовок окна 1206 (cast(t_v__qp_qp) pFunQt[11])(QtObj, qstr.QtObj); return this; 1207 } /// Установить заголовок окна 1208 QWidget setWindowTitle(T)(T str) { 1209 return setWindowTitle(new QString(to!string(str))); 1210 } /// Установить текст Заголовка 1211 QWidget setStyleSheet(QString str) { 1212 (cast(t_v__qp_qp)pFunQt[30])(QtObj, str.QtObj); return this; 1213 } /// При помощи строки задать описание эл. Цвет и т.д. 1214 QWidget setStyleSheet(T)(T str) { 1215 (cast(t_v__qp_qp)pFunQt[30])(QtObj, (new QString(to!string(str))).QtObj); return this; 1216 } /// При помощи строки задать описание эл. Цвет и т.д. 1217 QWidget setToolTip(QString str) { 1218 (cast(t_v__qp_qp)pFunQt[33])(QtObj, str.QtObj); return this; 1219 } /// При помощи строки задать описание эл. Цвет и т.д. 1220 QWidget setToolTip(T)(T str) { 1221 (cast(t_v__qp_qp)pFunQt[33])(QtObj, (new QString(to!string(str))).QtObj); return this; 1222 } /// При помощи строки задать описание эл. Цвет и т.д. 1223 QWidget setMinimumSize(int w, int h) { 1224 (cast(t_v__qp_b_i_i) pFunQt[31])(QtObj, true, w, h); return this; 1225 } /// Минимальный размер в лайоутах 1226 QWidget setMaximumSize(int w, int h) { 1227 (cast(t_v__qp_b_i_i) pFunQt[31])(QtObj, false, w, h); return this; 1228 } /// Максимальный размер в лайоутах 1229 QWidget setEnabled(bool fl) { 1230 (cast(t_v__qp_bool) pFunQt[32])(QtObj, fl); return this; 1231 } /// Доступен или нет 1232 QWidget setLayout(QBoxLayout layout) { 1233 layout.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1234 (cast(t_v__qp_qp) pFunQt[40])(QtObj, layout.QtObj); return this; 1235 } /// Вставить в виджет выравниватель 1236 /++ Установить обработчик на событие ResizeWidget. Здесь <u>adr</u> - адрес на функцию D 1237 + обрабатывающую событие. Обработчик получает аргумент. См. док. Qt 1238 + Пример: 1239 <code> 1240 + <br>. . . 1241 + <br>void ОбработкаСобытия(void* adrQResizeEvent) { 1242 + <br> writeln("Изменен размер виджета"); 1243 + <br> 1244 } 1245 + <br>. . . 1246 + <br>gWidget w = new gWidget(null, 0); 1247 w.setOnClick(&ОбработкаСобытия); 1248 + <br>. . . 1249 + </code> 1250 +/ 1251 QWidget setResizeEvent(void* adr) { 1252 (cast(t_v__qp_vp) pFunQt[52])(QtObj, adr); 1253 return this; 1254 } /// Установить обработчик на событие ResizeWidget 1255 1256 QWidget setKeyReleaseEvent(void* adr, void* adrThis = null) { 1257 (cast(t_v__qp_qp_qp) pFunQt[225])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis); 1258 return this; 1259 } 1260 1261 QWidget setKeyPressEvent(void* adr, void* adrThis = null) { 1262 //(cast(t_v__qp_qp_qp) pFunQt[80])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis); 1263 return this; 1264 // (cast(t_v__qp_qp) pFunQt[49])(QtObj, cast(QtObjH)adr); return this; 1265 } /// Установить обработчик на событие KeyPressEvent. Здесь <u>adr</u> - адрес на функцию D +/ 1266 QWidget setPaintEvent(void* adr, void* adrThis = null) { 1267 (cast(t_v__qp_qp_qp) pFunQt[50])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis); return this; 1268 } /// Установить обработчик на событие PaintEvent. Здесь <u>adr</u> - адрес на функцию D +/ 1269 QWidget setCloseEvent(void* adr, void* adrThis = null) { 1270 (cast(t_v__qp_qp_qp) pFunQt[51])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis); return this; 1271 } /// Установить обработчик на событие CloseEvent. Здесь <u>adr</u> - адрес на функцию D +/ 1272 QWidget setSizePolicy(int w, int h) { 1273 (cast(t_v__qp_i_i) pFunQt[78])(QtObj, w, h); return this; 1274 } /// Установить обработчик на событие CloseEvent. Здесь <u>adr</u> - адрес на функцию D +/ 1275 QWidget setMaximumWidth(int w) { 1276 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 0, w); return this; 1277 } /// setMaximumWidth(); 1278 QWidget setMinimumWidth(int w) { 1279 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 1, w); return this; 1280 } /// setMinimumWidth(); 1281 QWidget setFixedWidth(int w) { 1282 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 5, w); return this; 1283 } /// setFixedWidth(); 1284 QWidget setMaximumHeight(int h) { 1285 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 2, h); return this; 1286 } /// setMaximumHeight(); 1287 QWidget setMinimumHeight(int h) { 1288 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 3, h); return this; 1289 } /// setMinimumHeight(); 1290 QWidget setFixedHeight(int h) { 1291 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 4, h); return this; 1292 } /// setFixedHeight(); 1293 QWidget setToolTipDuration(int msek) { 1294 (cast(t_v__qp_i_i) pFunQt[79])(QtObj, 6, msek); return this; 1295 } /// Время показа в МилиСекундах 1296 QWidget setFocus() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 0); return this; } /// Установить фокус 1297 QWidget close() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 1); return this; } /// Закрыть окно 1298 QWidget hide() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 2); return this; } 1299 QWidget show() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 3); return this; } 1300 QWidget showFullScreen() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 4); return this; } 1301 QWidget showMaximized() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 5); return this; } 1302 QWidget showMinimized() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 6); return this; } 1303 QWidget showNormal() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 7); return this; } /// 1304 QWidget update() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 8); return this; } /// 1305 QWidget raise() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 9); return this; } /// Показать окно на вершине 1306 QWidget lower() { (cast(t_v__qp_i) pFunQt[87])(QtObj, 10); return this; } /// Скрыть в стеке 1307 1308 QWidget move(int x, int y) { 1309 (cast(t_v__qp_i_i_i) pFunQt[94])(QtObj, 0, x, y); return this; 1310 } /// This property holds the size of the widget excluding any window frame 1311 QWidget resize(int w, int h) { 1312 (cast(t_v__qp_i_i_i) pFunQt[94])(QtObj, 1, w, h); return this; 1313 } /// This property holds the size of the widget excluding any window frame 1314 QWidget setFont(QFont font) { 1315 (cast(t_v__qp_qp) pFunQt[131])(QtObj, font.QtObj); return this; 1316 } 1317 void* winid() { 1318 return (cast(t_vp__qp) pFunQt[148])(QtObj); 1319 } 1320 int x() { 1321 return (cast(t_i__qp_i) pFunQt[172])(QtObj, 0); 1322 } 1323 int y() { 1324 return (cast(t_i__qp_i) pFunQt[172])(QtObj, 1); 1325 } 1326 int width() { 1327 return (cast(t_i__qp_i) pFunQt[172])(QtObj, 2); 1328 } 1329 int height() { 1330 return (cast(t_i__qp_i) pFunQt[172])(QtObj, 3); 1331 } 1332 1333 } 1334 // ============ QAbstractButton ======================================= 1335 class QAbstractButton : QWidget { 1336 this() { } 1337 this(QWidget parent) { } 1338 ~this() { if (QtObj) setQtObj(null); } 1339 1340 QAbstractButton setText(T: QString)(T str) { 1341 (cast(t_v__qp_qp) pFunQt[28])(QtObj, str.QtObj); 1342 return this; 1343 } /// Установить текст на кнопке 1344 QAbstractButton setText(T)(T str) { 1345 (cast(t_v__qp_qp) pFunQt[28])(QtObj, (new QString(to!string(str))).QtObj); 1346 return this; 1347 } /// Установить текст на кнопке 1348 T text(T: QString)() { 1349 QString qs = new QString(); (cast(t_v__qp_qp)pFunQt[29])(QtObj, qs.QtObj); 1350 return qs; 1351 } 1352 T text(T)() { return to!T(text!QString().String); 1353 } 1354 QAbstractButton setAutoExclusive(bool pr) { 1355 (cast(t_v__qp_b_i) pFunQt[209])(QtObj, pr, 0); return this; 1356 } /// 1357 QAbstractButton setAutoRepeat(bool pr) { 1358 (cast(t_v__qp_b_i) pFunQt[209])(QtObj, pr, 1); return this; 1359 } /// 1360 QAbstractButton setCheckable(bool pr) { 1361 (cast(t_v__qp_b_i) pFunQt[209])(QtObj, pr, 2); return this; 1362 } /// 1363 QAbstractButton setDown(bool pr) { 1364 (cast(t_v__qp_b_i) pFunQt[209])(QtObj, pr, 3); return this; 1365 } /// 1366 QAbstractButton setChecked(bool pr) { //-> Включить кнопку 1367 (cast(t_v__qp_b_i) pFunQt[209])(QtObj, pr, 4); return this; 1368 } /// 1369 QAbstractButton setIcon(QIcon ik) { 1370 (cast(t_v__qp_qp) pFunQt[211])(QtObj, ik.QtObj); return this; 1371 } /// 1372 bool autoExclusive() { //-> T - Эксклюзивное использование 1373 return (cast(t_b__qp_i) pFunQt[224])(QtObj, 0); 1374 } 1375 bool autoRepeat() { //-> T - Повторяющеяся 1376 return (cast(t_b__qp_i) pFunQt[224])(QtObj, 1); 1377 } 1378 bool isCheckable() { //-> T - Может нажиматься 1379 return (cast(t_b__qp_i) pFunQt[224])(QtObj, 2); 1380 } 1381 bool isChecked() { //-> T - Нажата 1382 return (cast(t_b__qp_i) pFunQt[224])(QtObj, 3); 1383 } 1384 bool isDown() { //-> T - Нажата 1385 return (cast(t_b__qp_i) pFunQt[224])(QtObj, 4); 1386 } 1387 1388 1389 1390 /* 1391 bool isChecked() { 1392 return (cast(t_b__vp) pFunQt[265])(QtObj); 1393 } /// T = нажата 1394 */ 1395 } 1396 1397 // ================ QPushButton ================ 1398 /++ 1399 QPushButton (Нажимаемая кнопка), но немного модифицированный в QtE.DLL. 1400 <br>Хранит в себе ссылку на реальный С++ класс QPushButtong из QtGui.dll 1401 <br>Добавлены свойства хранящие адреса для вызова обратных функций 1402 для реакции на события. 1403 +/ 1404 class QPushButton : QAbstractButton { 1405 this(){} 1406 this(T: QString)(T str, QWidget parent = null) { 1407 // super(); // Это фактически заглушка, что бы сделать наследование, 1408 // не создавая промежуточного экземпляра в Qt 1409 if (parent) { 1410 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1411 setQtObj((cast(t_qp__qp_qp) pFunQt[22])(parent.QtObj, str.QtObj)); 1412 } else { 1413 setQtObj((cast(t_qp__qp_qp) pFunQt[22])(null, str.QtObj)); 1414 } 1415 } /// Создать кнопку. 1416 ~this() { 1417 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[23])(QtObj); setQtObj(null); } 1418 // write("B- "); stdout.flush(); 1419 } 1420 this(T)(T str, QWidget parent = null) { 1421 // super(); // Это фактически заглушка, что бы сделать наследование, 1422 // не создавая промежуточного экземпляра в Qt 1423 if (parent) { 1424 setQtObj((cast(t_qp__qp_qp) pFunQt[22])(parent.QtObj, (new QString(to!string(str))).QtObj)); 1425 } else { 1426 setQtObj((cast(t_qp__qp_qp) pFunQt[22])(null, (new QString(to!string(str))).QtObj)); 1427 } 1428 } 1429 QPushButton setAutoDefault(bool pr) { 1430 (cast(t_v__qp_b_i) pFunQt[210])(QtObj, pr, 0); return this; 1431 } /// 1432 QPushButton setDefault(bool pr) { 1433 (cast(t_v__qp_b_i) pFunQt[210])(QtObj, pr, 1); return this; 1434 } /// 1435 QPushButton setFlat(bool pr) { 1436 (cast(t_v__qp_b_i) pFunQt[210])(QtObj, pr, 2); return this; 1437 } /// 1438 1439 } 1440 1441 // ================ QApplication ================ 1442 /++ 1443 Класс приложения. <b>Внимание:</b> 1444 +/ 1445 private struct stQApplication { 1446 void* rref; 1447 int alloc; 1448 int size; 1449 char* data; // Вот собственно за чем нам это нужно, указатель на массив байтов 1450 // char array[1]; 1451 } 1452 class QApplication : QObject { 1453 this(int* m_argc, char** m_argv, int gui) { 1454 setQtObj((cast(t_qp__qp_qp_i) pFunQt[0])(cast(QtObjH)m_argc, cast(QtObjH)m_argv, gui)); 1455 } /// QApplication::QApplication(argc, argv, param); 1456 ~this() { 1457 if(!fNoDelete) { (cast(t_v__qp) pFunQt[3])(QtObj); setQtObj(null); } 1458 } /// QApplication::~QApplication(); 1459 int exec() { 1460 return (cast(t_i__qp) pFunQt[1])(QtObj); 1461 } /// QApplication::exec() 1462 void aboutQt() { 1463 (cast(t_v__qp) pFunQt[2])(QtObj); 1464 } /// QApplication::aboutQt() 1465 int sizeOfQtObj() { 1466 return (cast(t_i__vp) pFunQt[4])(QtObj); 1467 } /// Размер объекта QApplicatin. Size of QApplicatin 1468 T appDirPath(T)() { 1469 QString qs = new QString(); 1470 (cast(t_v__qp_qp)pFunQt[20])(QtObj, qs.QtObj); 1471 return qs; 1472 } 1473 T appDirPath(T)() { return to!T((appDirPath!QString()).String); 1474 } 1475 T appFilePath(T: QString)() { 1476 QString qs = new QString(); 1477 (cast(t_v__qp_qp)pFunQt[21])(QtObj, qs.QtObj); 1478 return qs; 1479 } 1480 T appFilePath(T)() { return to!T((appFilePath!QString()).String); 1481 } 1482 } 1483 1484 // ================ QString ================ 1485 class QString: QObject { 1486 import std.utf: toUTF16, toUTF8; 1487 1488 this() { 1489 setQtObj((cast(t_qp__v)pFunQt[8])()); 1490 } /// Конструктор пустого QString 1491 this(T)(T s) { 1492 wstring ps = toUTF16(to!string(s)); 1493 setQtObj((cast(t_qp__qp_i)pFunQt[9])(cast(QtObjH)ps.ptr, cast(int)ps.length)); 1494 } /// Конструктор где s - Utf-8. Пример: QString qs = new QString("Привет!"); 1495 this(QtObjH adr) { setQtObj(adr); 1496 } /// Изготовить QString из пришедшего из вне указателя на C++ QString 1497 ~this() { 1498 if(!fNoDelete) { (cast(t_v__qp) pFunQt[10])(QtObj); setQtObj(null); } 1499 } 1500 int size() { return (cast(t_i__qp) pFunQt[19])(QtObj); 1501 } /// Размер в UNICODE символах 1502 ubyte* data() { return (cast(t_ub__qp) pFunQt[18])(QtObj); 1503 } /// Указатель на UNICODE 1504 string toUtf8() { 1505 wchar[] wss; wchar* wc = cast(wchar*) data(); 1506 for (int i; i != size(); i++) wss ~= *(wc + i); 1507 return toUTF8(wss); 1508 } /// Конвертировать внутреннее представление в wstring 1509 @property string String() { return toUtf8(); 1510 } /// return string D from QString 1511 } 1512 // ================ QBoxLayout ================ 1513 /++ 1514 QBoxLayout - это класс выравнивателей. Они управляют размещением 1515 элементов на форме. 1516 +/ 1517 class QBoxLayout : QObject { 1518 enum Direction { 1519 LeftToRight = 0, 1520 RightToLeft = 1, 1521 TopToBottom = 2, 1522 BottomToTop = 3 1523 } /// enum Direction { LeftToRight, RightToLeft, TopToBottom, BottomToTop } 1524 this() { } 1525 this(QWidget parent, QBoxLayout.Direction dir = QBoxLayout.Direction.TopToBottom) { 1526 // super(); 1527 if (parent) { 1528 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1529 setQtObj((cast(t_qp__qp_i) pFunQt[34])(parent.QtObj, dir)); 1530 } else { 1531 setQtObj((cast(t_qp__qp_i) pFunQt[34])(null, dir)); 1532 } 1533 } /// Создаёт выравниватель, типа dir и вставляет в parent 1534 ~this() { 1535 if(!fNoDelete) { (cast(t_v__qp) pFunQt[37])(QtObj); setQtObj(null); } 1536 } 1537 QBoxLayout addWidget(QWidget wd, int stretch = 0, QtE.AlignmentFlag alignment = QtE.AlignmentFlag.AlignExpanding) { 1538 wd.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1539 (cast(t_v__qp_qp_i_i) pFunQt[38])(QtObj, wd.QtObj, cast(int)stretch, cast(int)alignment); 1540 return this; 1541 } /// Добавить виджет в выравниватель 1542 QBoxLayout addLayout(QBoxLayout layout) { 1543 layout.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1544 (cast(t_v__qp_qp) pFunQt[39])(QtObj, layout.QtObj); 1545 return this; 1546 } /// Добавить выравниватель в выравниватель 1547 QBoxLayout setSpasing(int spasing) { 1548 (cast(t_v__qp_i) pFunQt[74])(QtObj, spasing); return this; 1549 } /// Это расстояние между элементами в выравнивателе, например расстояние меж кнопками 1550 int spasing() { 1551 return (cast(t_i__qp) pFunQt[75])(QtObj); 1552 } /// 1553 QBoxLayout setMargin(int spasing) { 1554 (cast(t_v__qp_i) pFunQt[76])(QtObj, spasing); return this; 1555 } /// Это расстояние вокруг всех элементов данного выравнивателя 1556 int margin() { 1557 return (cast(t_i__qp) pFunQt[77])(QtObj); 1558 } /// 1559 1560 /* funQt(74, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_setSpasing", showError); 1561 funQt(75, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQBoxLayout_spasing", showError); 1562 */ 1563 1564 1565 } 1566 class QVBoxLayout : QBoxLayout { 1567 this() { 1568 setQtObj((cast(t_qp__v)pFunQt[35])()); 1569 } 1570 } 1571 class QHBoxLayout : QBoxLayout { 1572 this() { 1573 setQtObj((cast(t_qp__v)pFunQt[36])()); 1574 } 1575 } 1576 // ================ QFrame ================ 1577 class QFrame : QWidget { 1578 enum Shape { 1579 NoFrame = 0, // no frame 1580 Box = 0x0001, // rectangular box 1581 Panel = 0x0002, // rectangular panel 1582 WinPanel = 0x0003, // rectangular panel (Windows) 1583 HLine = 0x0004, // horizontal line 1584 VLine = 0x0005, // vertical line 1585 StyledPanel = 0x0006 // rectangular panel depending on the GUI style 1586 } 1587 enum Shadow { 1588 Plain = 0x0010, // plain line 1589 Raised = 0x0020, // raised shadow effect 1590 Sunken = 0x0030 // sunken shadow effect 1591 } 1592 this() { } 1593 ~this() { 1594 if(!fNoDelete) { (cast(t_v__qp) pFunQt[42])(QtObj); setQtObj(null); } 1595 } 1596 this(QWidget parent, QtE.WindowType fl = QtE.WindowType.Widget) { 1597 if (parent) { 1598 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1599 setQtObj((cast(t_qp__qp_i) pFunQt[41])(parent.QtObj, fl)); 1600 } else { 1601 setQtObj((cast(t_qp__qp_i) pFunQt[41])(null, fl)); 1602 } 1603 } /// Конструктор 1604 QFrame setFrameShape(Shape sh) { 1605 (cast(t_v__qp_i) pFunQt[43])(QtObj, sh); 1606 return this; 1607 } 1608 QFrame setFrameShadow(Shadow sh) { 1609 (cast(t_v__qp_i) pFunQt[44])(QtObj, sh); 1610 return this; 1611 } 1612 QFrame setLineWidth(int sh) { 1613 if (sh > 3) sh = 3; (cast(t_v__qp_i) pFunQt[45])(QtObj, sh); 1614 return this; 1615 } /// Установить толщину окантовки в пикселах от 0 до 3 1616 } 1617 // ============ QLabel ======================================= 1618 class QLabel : QFrame { 1619 ~this() { 1620 if(!fNoDelete) { (cast(t_v__qp) pFunQt[47])(QtObj); setQtObj(null); } 1621 } 1622 this(char ch, void* adr) { 1623 if(ch == '+') setQtObj(cast(QtObjH)adr); 1624 } 1625 this(QWidget parent, QtE.WindowType fl = QtE.WindowType.Widget) { 1626 super(); 1627 if (parent) { 1628 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1629 setQtObj((cast(t_qp__qp_i) pFunQt[46])(parent.QtObj, fl)); 1630 } else { 1631 setQtObj((cast(t_qp__qp_i) pFunQt[46])(null, fl)); 1632 } 1633 } /// Конструктор 1634 QWidget setText(T: QString)(T str) { 1635 (cast(t_v__qp_qp) pFunQt[48])(QtObj, str.QtObj); 1636 return this; 1637 } /// Установить текст на кнопке 1638 QWidget setText(T)(T str) { 1639 (cast(t_v__qp_qp) pFunQt[48])(QtObj, (new QString(to!string(str))).QtObj); 1640 return this; 1641 } /// Установить текст на кнопке 1642 } 1643 // ============ QSize ======================================= 1644 class QSize : QObject { 1645 this(int width, int heigth) { 1646 setQtObj((cast(t_qp__i_i) pFunQt[56])(width, heigth)); 1647 } 1648 this(char ch, void* adr) { 1649 if(ch == '+') setQtObj(cast(QtObjH)adr); 1650 } /// При создании своего объекта сохраняет в себе объект событие QEvent пришедшее из Qt 1651 ~this() { 1652 if(!fNoDelete) { (cast(t_v__qp) pFunQt[57])(QtObj); setQtObj(null); } 1653 } 1654 @property int width() { 1655 return (cast(t_i__qp) pFunQt[58])(QtObj); 1656 } /// QSize::wieth(); 1657 @property int heigth() { 1658 return (cast(t_i__qp) pFunQt[59])(QtObj); 1659 } /// QSize::heigth(); 1660 QSize setWidth(int width) { 1661 (cast(t_v__qp_i) pFunQt[60])(QtObj, width); return this; 1662 } /// QSize::setWidth(); 1663 QSize setHeigth(int heigth) { 1664 (cast(t_v__qp_i) pFunQt[61])(QtObj, width); return this; 1665 } /// QSize::setHeigth(); 1666 } 1667 // ============ QPainter ======================================= 1668 class QPainter : QObject { 1669 this() { } 1670 this(char ch, void* adr) { 1671 if(ch == '+') setQtObj(cast(QtObjH)adr); 1672 } /// При создании своего объекта сохраняет в себе объект событие QPainter пришедшее из Qt 1673 ~this() { 1674 } 1675 QPainter drawPoint(int x, int y) { 1676 (cast(t_v__qp_i_i_i) pFunQt[188])(QtObj, x, y, 0); return this; 1677 } 1678 QPainter setBrushOrigin(int x, int y) { 1679 (cast(t_v__qp_i_i_i) pFunQt[188])(QtObj, x, y, 1); return this; 1680 } 1681 QPainter drawLine(int x1, int y1, int x2, int y2) { 1682 (cast(t_v__qp_i_i_i_i) pFunQt[189])(QtObj, x1, y1, x2, y2); return this; 1683 } 1684 1685 QPainter drawRect(int x1, int y1, int w, int h) { //-> Четырехугольник 1686 (cast(t_v__qp_i_i_i_i) pFunQt[243])(QtObj, x1, y1, w, h); return this; 1687 } 1688 QPainter drawRect(QRect qr) { //-> Четырехугольник 1689 (cast(t_v__qp_qp) pFunQt[244])(QtObj, qr.QtObj); return this; 1690 } 1691 QPainter fillRect(QRect qr, QColor cl) { //-> Четырехугольник заполнить цветом 1692 (cast(t_v__qp_qp_qp) pFunQt[245])(QtObj, qr.QtObj, cl.QtObj); return this; 1693 } 1694 QPainter fillRect(QRect qr, QtE.GlobalColor gc) { //-> Четырехугольник заполнить цветом 1695 (cast(t_v__qp_qp_i) pFunQt[246])(QtObj, qr.QtObj, gc); return this; 1696 } 1697 1698 1699 1700 QPainter setBrush(QBrush qb) { 1701 (cast(t_v__qp_qp_i) pFunQt[190])(QtObj, qb.QtObj, 0); return this; 1702 } 1703 QPainter setPen(QPen qp) { 1704 (cast(t_v__qp_qp_i) pFunQt[190])(QtObj, qp.QtObj, 1); return this; 1705 } 1706 QPainter setText(int x, int y, QString qs) { 1707 (cast(t_v__qp_qp_i_i) pFunQt[196])(QtObj, qs.QtObj, x, y); return this; 1708 } 1709 QPainter setText(int x, int y, string s) { 1710 (cast(t_v__qp_qp_i_i) pFunQt[196])(QtObj, (new QString(s)).QtObj, x, y); return this; 1711 } 1712 bool end() { 1713 return (cast(t_b__qp) pFunQt[197])(QtObj); 1714 } 1715 /* @property int type() { 1716 return (cast(t_i__qp) pFunQt[53])(QtObj); 1717 } /// QPainter::type(); Вернуть тип события 1718 void ignore() { 1719 (cast(t_v__qp_i) pFunQt[157])(QtObj, 0); 1720 } /// Игнорировать событие 1721 void accept() { 1722 (cast(t_v__qp_i) pFunQt[157])(QtObj, 1); 1723 } /// Игнорировать событие 1724 */ 1725 } 1726 1727 // ============ QEvent ======================================= 1728 class QEvent : QObject { 1729 this() { } 1730 this(char ch, void* adr) { 1731 if(ch == '+') setQtObj(cast(QtObjH)adr); 1732 } /// При создании своего объекта сохраняет в себе объект событие QEvent пришедшее из Qt 1733 ~this() { 1734 } 1735 @property int type() { 1736 return (cast(t_i__qp) pFunQt[53])(QtObj); 1737 } /// QEvent::type(); Вернуть тип события 1738 void ignore() { 1739 (cast(t_v__qp_i) pFunQt[157])(QtObj, 0); 1740 } /// Игнорировать событие 1741 void accept() { 1742 (cast(t_v__qp_i) pFunQt[157])(QtObj, 1); 1743 } /// Игнорировать событие 1744 } 1745 // ============ QResizeEvent ======================================= 1746 /* 1747 // Test event события QResizeEvent 1748 extern (C) void onQResizeEvent(void* ev) { 1749 // 1 - Схватить событие пришедшее из Qt и сохранить его в моём классе 1750 // Catch event from Qt and save it in my class D 1751 QResizeEvent qe = new QResizeEvent('+', ev); 1752 // 2 - Выдать тип события. Show type event 1753 writeln(toCON("Событие: ширина: "), qe.size().width, toCON(" высота: "), qe.size().heigth); 1754 } 1755 */ 1756 class QResizeEvent : QEvent { 1757 this() {} 1758 this(char ch, void* adr) { 1759 if(ch == '+') setQtObj(cast(QtObjH)adr); 1760 } /// При создании своего объекта сохраняет в себе объект событие QEvent пришедшее из Qt 1761 ~this() { 1762 } 1763 QSize size() { 1764 return new QSize('+', (cast(t_qp__qp)pFunQt[54])(QtObj)); 1765 } /// QResizeEvent::size(); 1766 QSize oldSize() { 1767 return new QSize('+', (cast(t_qp__qp)pFunQt[55])(QtObj)); 1768 } /// QResizeEvent::oldSize(); 1769 } 1770 // ============ QKeyEvent ======================================= 1771 class QKeyEvent : QEvent { 1772 this() {} 1773 this(char ch, void* adr) { 1774 if(ch == '+') setQtObj(cast(QtObjH)adr); 1775 } /// При создании своего объекта сохраняет в себе объект событие QEvent пришедшее из Qt 1776 ~this() { 1777 } 1778 @property uint key() { 1779 return cast(uint)(cast(t_qp__qp)pFunQt[62])(QtObj); 1780 } /// QKeyEvent::key(); 1781 @property uint count() { 1782 return cast(uint)(cast(t_qp__qp)pFunQt[63])(QtObj); 1783 } /// QKeyEvent::counte(); 1784 } 1785 // ================ QAbstractScrollArea ================ 1786 class QAbstractScrollArea : QFrame { 1787 this() {} 1788 ~this() { 1789 if(!fNoDelete) { (cast(t_v__qp) pFunQt[65])(QtObj); setQtObj(null); } 1790 } 1791 this(char ch, void* adr) { 1792 if(ch == '+') setQtObj(cast(QtObjH)adr); 1793 } 1794 this(QWidget parent) { 1795 if (parent) { 1796 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1797 setQtObj((cast(t_qp__qp) pFunQt[64])(parent.QtObj)); 1798 } else { 1799 setQtObj((cast(t_qp__qp) pFunQt[64])(null)); 1800 } 1801 } /// Конструктор 1802 } 1803 // ================ QPlainTextEdit ================ 1804 /++ 1805 Чистый QPlainTextEdit (ТекстовыйРедактор). 1806 +/ 1807 1808 class QPlainTextEdit : QAbstractScrollArea { 1809 this(){} 1810 ~this() { 1811 if(!fNoDelete) { (cast(t_v__qp) pFunQt[67])(QtObj); setQtObj(null); } 1812 } 1813 // this() { super(); } 1814 this(char ch, void* adr) { 1815 if(ch == '+') setQtObj(cast(QtObjH)adr); 1816 } 1817 this(QWidget parent) { 1818 if (parent) { 1819 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1820 setQtObj((cast(t_qp__qp) pFunQt[66])(parent.QtObj)); 1821 } else { 1822 setQtObj((cast(t_qp__qp) pFunQt[66])(null)); 1823 } 1824 } /// Конструктор 1825 1826 override QPlainTextEdit setKeyPressEvent(void* adr, void* adrThis = null) { 1827 (cast(t_v__qp_qp_qp) pFunQt[80])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis); return this; 1828 } /// Установить обработчик на событие KeyPressEvent. Здесь <u>adr</u> - адрес на функцию D +/ 1829 1830 QPlainTextEdit appendPlainText(T: QString)(T str) { //-> Добавить текст в конец 1831 (cast(t_v__qp_qp) pFunQt[68])(QtObj, str.QtObj); return this; 1832 } /// Добавать текст в конец 1833 QPlainTextEdit appendPlainText(T)(T str) { //-> Добавить текст в конец 1834 (cast(t_v__qp_qp) pFunQt[68])(QtObj, (new QString(to!string(str))).QtObj); return this; 1835 } /// Добавать текст в конец 1836 QPlainTextEdit appendHtml(T: QString)(T str) { //-> Добавать html в конец 1837 (cast(t_v__qp_qp) pFunQt[69])(QtObj, str.QtObj); return this; 1838 } /// Добавать html в конец 1839 QPlainTextEdit appendHtml(T)(T str) { //-> Добавать html в конец 1840 (cast(t_v__qp_qp) pFunQt[69])(QtObj, (new QString(to!string(str))).QtObj); return this; 1841 } /// Добавать html в конец 1842 QPlainTextEdit setPlainText(T: QString)(T str) { //-> Удалить всё и вставить с начала 1843 (cast(t_v__qp_qp) pFunQt[70])(QtObj, str.QtObj); return this; 1844 } /// Удалить всё и вставить с начала 1845 QPlainTextEdit setPlainText(T)(T str) { //-> Удалить всё и вставить с начала 1846 (cast(t_v__qp_qp) pFunQt[70])(QtObj, (new QString(to!string(str))).QtObj); return this; 1847 } /// Удалить всё и вставить с начала 1848 QPlainTextEdit insertPlainText(T: QString)(T str) { //-> Вставить сразу за курсором 1849 (cast(t_v__qp_qp) pFunQt[71])(QtObj, str.QtObj); return this; 1850 } /// Вставить сразу за курсором 1851 QPlainTextEdit insertPlainText(T)(T str) { //-> Вставить сразу за курсором 1852 (cast(t_v__qp_qp) pFunQt[71])(QtObj, (new QString(to!string(str))).QtObj); return this; 1853 } /// Вставить сразу за курсором 1854 QPlainTextEdit cut() { //-> Вырезать кусок 1855 (cast(t_v__qp_i) pFunQt[72])(QtObj, 0); return this; 1856 } /// cut() 1857 QPlainTextEdit clear() { //-> Очистить всё 1858 (cast(t_v__qp_i) pFunQt[72])(QtObj, 1); return this; 1859 } /// clear() 1860 QPlainTextEdit paste() { //-> Вставить из буфера 1861 (cast(t_v__qp_i) pFunQt[72])(QtObj, 2); return this; 1862 } /// paste() 1863 QPlainTextEdit copy() { //-> Скопировать в буфер 1864 (cast(t_v__qp_i) pFunQt[72])(QtObj, 3); return this; 1865 } /// copy() 1866 QPlainTextEdit selectAll() { 1867 (cast(t_v__qp_i) pFunQt[72])(QtObj, 4); return this; 1868 } /// selectAll() 1869 QPlainTextEdit selectionChanged() { 1870 (cast(t_v__qp_i) pFunQt[72])(QtObj, 5); return this; 1871 } /// selectionChanged() 1872 QPlainTextEdit centerCursor() { 1873 (cast(t_v__qp_i) pFunQt[72])(QtObj, 6); return this; 1874 } /// centerCursor() 1875 QPlainTextEdit undo() { 1876 (cast(t_v__qp_i) pFunQt[72])(QtObj, 7); return this; 1877 } /// undo() 1878 QPlainTextEdit redo() { 1879 (cast(t_v__qp_i) pFunQt[72])(QtObj, 8); return this; 1880 } /// redo() 1881 T toPlainText(T: QString)() { 1882 QString qs = new QString(); (cast(t_v__qp_qp)pFunQt[73])(QtObj, qs.QtObj); return qs; 1883 } /// Выдать содержимое в QString 1884 T toPlainText(T)() { return to!T(toPlainText!QString().String); 1885 } /// Выдать всё содержимое в String 1886 void* document() { //-> Вернуть указатель на QTextDocument 1887 return (cast(t_qp__qp) pFunQt[226])(QtObj); 1888 } 1889 QTextCursor textCursor(QTextCursor tk) { 1890 (cast(t_v__qp_qp) pFunQt[230])(QtObj, tk.QtObj); 1891 return tk; 1892 } 1893 QRect cursorRect(QRect tk) { 1894 (cast(t_v__qp_qp) pFunQt[235])(QtObj, tk.QtObj); 1895 return tk; 1896 } 1897 QPlainTextEdit setTabStopWidth(int width) { //-> Размер табуляции в пикселах 1898 (cast(t_v__qp_i) pFunQt[236])(QtObj, width); return this; 1899 } 1900 } 1901 // ================ QLineEdit ================ 1902 /++ 1903 QLineEdit (Строка ввода с редактором), но немного модифицированный в QtE.DLL. 1904 <br>Хранит в себе ссылку на реальный С++ класс QLineEdit из QtGui.dll 1905 <br>Добавлены свойства хранящие адреса для вызова обратных функций 1906 для реакции на события. 1907 +/ 1908 class QLineEdit : QWidget { 1909 enum EchoMode { 1910 Normal = 0, // Показывать символы при вводе. По умолчанию 1911 NoEcho = 1, // Ни чего не показывать, что бы длинна пароля была не понятной 1912 Password = 2, // Звездочки вместо символов 1913 PasswordEchoOnEdit = 3 // Показывает только один символ, а остальные скрыты 1914 } 1915 this(char ch, void* adr) { 1916 if(ch == '+') setQtObj(cast(QtObjH)adr); 1917 } 1918 this(QWidget parent) { 1919 writeln(""); 1920 // super(); // Это фактически заглушка, что бы сделать наследование, 1921 // не создавая промежуточного экземпляра в Qt 1922 if(parent) { 1923 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1924 p_QObject = (cast(t_qp__qp) pFunQt[82])(parent.QtObj); 1925 } else { 1926 p_QObject = (cast(t_qp__qp) pFunQt[82])(null); 1927 } 1928 } /// Создать LineEdit. 1929 ~this() { 1930 if(!fNoDelete) { (cast(t_v__qp) pFunQt[83])(QtObj); setQtObj(null); } 1931 } 1932 QLineEdit setText(T: QString)(T str) { 1933 (cast(t_v__qp_qp) pFunQt[84])(QtObj, str.QtObj); 1934 return this; 1935 } /// Установить текст на кнопке 1936 QLineEdit setText(T)(T str) { 1937 (cast(t_v__qp_qp) pFunQt[84])(QtObj, (new QString(to!string(str))).QtObj); 1938 return this; 1939 } /// Установить текст на кнопке 1940 QLineEdit clear() { 1941 (cast(t_v__qp) pFunQt[85])(QtObj); 1942 return this; 1943 } /// Очистить строку 1944 T text(T: QString)() { 1945 QString qs = new QString(); (cast(t_v__qp_qp)pFunQt[86])(QtObj, qs.QtObj); return qs; 1946 } /// Выдать содержимое в QString 1947 T text(T)() { return to!T(text!QString().String); 1948 } /// Выдать всё содержимое в String 1949 override QLineEdit setKeyPressEvent(void* adr, void* adrThis = null) { 1950 (cast(t_v__qp_qp_qp) pFunQt[158])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis); return this; 1951 } /// Установить обработчик на событие KeyPressEvent. Здесь <u>adr</u> - адрес на функцию D +/ 1952 1953 } 1954 // ===================== QMainWindow ===================== 1955 /++ 1956 QMainWindow - основное окно приложения 1957 +/ 1958 class QMainWindow : QWidget { 1959 // this(){ super(); } 1960 ~this() { 1961 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[89])(QtObj); setQtObj(null); } 1962 } 1963 this(QWidget parent = null, QtE.WindowType fl = QtE.WindowType.Widget) { 1964 if (parent) { 1965 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 1966 setQtObj((cast(t_qp__qp_i)pFunQt[88])(parent.QtObj, cast(int)fl)); 1967 } else { 1968 setQtObj((cast(t_qp__qp_i)pFunQt[88])(null, cast(int)fl)); 1969 } 1970 } /// QMainWindow::QMainWindow(QWidget * parent = 0, Qt::WindowFlags f = 0) 1971 QMainWindow setCentralWidget(QWidget wd) { 1972 (cast(t_v__qp_qp_i) pFunQt[90])(QtObj, wd.QtObj, 0); 1973 return this; 1974 } /// 1975 QMainWindow setStatusBar(QStatusBar wd) { 1976 (cast(t_v__qp_qp_i) pFunQt[90])(QtObj, wd.QtObj, 2); 1977 return this; 1978 } /// 1979 QMainWindow setMenuBar(QMenuBar wd) { 1980 (cast(t_v__qp_qp_i) pFunQt[90])(QtObj, wd.QtObj, 1); 1981 return this; 1982 } /// 1983 QMainWindow addToolBar(QToolBar wd) { 1984 (cast(t_v__qp_qp_i) pFunQt[90])(QtObj, wd.QtObj, 3); 1985 return this; 1986 } /// 1987 QMainWindow setToolBar(QToolBar wd) { 1988 addToolBar(wd); 1989 return this; 1990 } /// 1991 QMainWindow addToolBar(QToolBar.ToolBarArea st, QToolBar wd) { 1992 (cast(t_v__qp_qp_i) pFunQt[126])(QtObj, wd.QtObj, st); 1993 return this; 1994 } /// добавить ToolBar используя рамещение внизу,вверху т т.д. 1995 1996 } 1997 // ================ QStatusBar ================ 1998 /++ 1999 QStatusBar - строка сообщений 2000 +/ 2001 class QStatusBar : QWidget { 2002 ~this() { 2003 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[92])(QtObj); setQtObj(null); } 2004 } 2005 this(QWidget parent) { 2006 // super(); 2007 if (parent) { 2008 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2009 setQtObj((cast(t_qp__qp)pFunQt[91])(parent.QtObj)); 2010 } else { 2011 setQtObj((cast(t_qp__qp)pFunQt[91])(null)); 2012 } 2013 } /// QStatusBar::QStatusBar(QWidget * parent) 2014 QStatusBar showMessage(T: QString)(T str, int timeout = 0) { 2015 (cast(t_v__qp_qp_i) pFunQt[93])(QtObj, str.QtObj, timeout); 2016 return this; 2017 } /// Установить текст на кнопке 2018 QStatusBar showMessage(T)(T str, int timeout = 0) { 2019 showMessage!QString(new QString(to!string(str)), timeout); 2020 return this; 2021 } /// Установить текст на кнопке 2022 } 2023 2024 // ================ QAction ================ 2025 /++ 2026 QAction - это класс выполнителей (действий). Объеденяют в себе 2027 различные формы вызовов: 2028 из меню, из горячих кнопок, их панели с кнопками 2029 и т.д. Реально представляет собой строку меню в вертикальном боксе. 2030 +/ 2031 class QAction : QObject { 2032 ~this() { 2033 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[96])(QtObj); setQtObj(null); } 2034 } 2035 // Эксперементаьный, попытка вызвать метод, не используя Extern "C" 2036 // Любой слот всегда! передаёт в обработчик D два параметра, 2037 // 1 - Адрес объекта и 2 - N установленный при инициадизации 2038 2039 // Специализированные слоты для обработки сообщений с параметрами 2040 // всегда передают Адрес и N (см выше) и дальше сами параметры 2041 this(QWidget parent, void* adr, void* adrThis, int n = 0) { 2042 if (parent) { 2043 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2044 setQtObj((cast(t_qp__qp)pFunQt[95])(parent.QtObj)); 2045 } else { 2046 setQtObj((cast(t_qp__qp)pFunQt[95])(null)); 2047 } 2048 (cast(t_v__qp_qp_qp_i)pFunQt[98])(QtObj, cast(QtObjH)adr, cast(QtObjH)adrThis, n); 2049 } /// Установить слот с параметром 2050 2051 // ---------------------------------------------------- 2052 QAction setText(T: QString)(T str) { 2053 (cast(t_v__qp_qp_i) pFunQt[97])(QtObj, str.QtObj, 0); 2054 return this; 2055 } /// Установить текст 2056 QAction setText(T)(T str) { 2057 (cast(t_v__qp_qp_i) pFunQt[97])(QtObj, (new QString(to!string(str))).QtObj, 0); 2058 return this; 2059 } /// Установить текст 2060 QAction setToolTip(T: QString)(T str) { 2061 (cast(t_v__qp_qp_i) pFunQt[97])(QtObj, str.QtObj, 1); 2062 return this; 2063 } /// Установить текст 2064 QAction setToolTip(T)(T str) { 2065 (cast(t_v__qp_qp_i) pFunQt[97])(QtObj, (new QString(to!string(str))).QtObj, 1); 2066 return this; 2067 } /// Установить текст 2068 QAction setHotKey(QtE.Key key) { 2069 (cast(t_v__qp_i) pFunQt[105])(p_QObject, cast(int) key); 2070 return this; 2071 } /// Определить горячую кнопку 2072 // ---------------------------------------------------- 2073 QAction setEnabled(bool f) { 2074 (cast(t_v__qp_bool) pFunQt[109])(QtObj, f); 2075 return this; 2076 } /// Включить/выключить пункт меню 2077 QAction setIcon(QIcon ico) { 2078 (cast(t_v__qp_qp) pFunQt[113])(QtObj, ico.QtObj); 2079 return this; 2080 } /// Добавить иконку 2081 QAction setIcon(string fileIco) { 2082 QIcon ico = new QIcon(); ico.addFile(fileIco); setIcon(ico); 2083 return this; 2084 } /// Добавить иконку используя имя файла и неявное создание 2085 } 2086 // ============ QMenu ======================================= 2087 /++ 2088 QMenu - колонка меню. Вертикальная. 2089 +/ 2090 class QMenu : QWidget { 2091 ~this() { 2092 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[100])(QtObj); setQtObj(null); } 2093 } 2094 this(QWidget parent) { 2095 if (parent) { 2096 this.setNoDelete(true); 2097 setQtObj((cast(t_qp__qp)pFunQt[99])(parent.QtObj)); 2098 } else { 2099 setQtObj((cast(t_qp__qp)pFunQt[99])(null)); 2100 } 2101 } /// QMenu::QMenu(QWidget* parent) 2102 QMenu addAction(QAction act) { 2103 (cast(t_v__qp_qp) pFunQt[101])(QtObj, act.QtObj); 2104 return this; 2105 } /// Вставить вертикальное меню 2106 QMenu setTitle(T: QString)(T str) { 2107 (cast(t_v__qp_qp_i) pFunQt[106])(QtObj, str.QtObj, 1); 2108 return this; 2109 } /// Установить текст 2110 QMenu setTitle(T)(T str) { 2111 (cast(t_v__qp_qp_i) pFunQt[106])(QtObj, (new QString(to!string(str))).QtObj, 1); 2112 return this; 2113 } /// Установить текст 2114 QMenu addSeparator() { 2115 (cast(t_v__qp) pFunQt[107])(QtObj); 2116 return this; 2117 } 2118 QMenu addMenu(QMenu menu) { 2119 (cast(t_v__qp_qp) pFunQt[108])(QtObj, menu.QtObj); 2120 return this; 2121 } 2122 2123 /* 2124 void addSeparator() { 2125 (cast(t_v__vp) pFunQt[85])(p_QObject); 2126 } /// Добавить сепаратор 2127 void setTitle(QString str) { 2128 (cast(t_v__vp_vp) pFunQt[86])(p_QObject, cast(void*) str.QtObj); 2129 } 2130 2131 void setTitle(string str) { 2132 (cast(t_v__vp_vp) pFunQt[86])(QtObj, (new QString(str)).QtObj); 2133 } /// Установить текст 2134 */ 2135 2136 } 2137 2138 // ============ QMenuBar ======================================= 2139 /++ 2140 QMenuBar - строка меню самого верхнего уровня. Горизонтальная. 2141 +/ 2142 class QMenuBar : QWidget { 2143 ~this() { 2144 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[103])(QtObj); setQtObj(null); } 2145 } 2146 this(QWidget parent) { 2147 if (parent) { 2148 this.setNoDelete(true); 2149 setQtObj((cast(t_qp__qp)pFunQt[102])(parent.QtObj)); 2150 } else { 2151 setQtObj((cast(t_qp__qp)pFunQt[102])(null)); 2152 } 2153 } /// QMenuBar::QMenuBar(QWidget* parent) 2154 QMenuBar addMenu(QMenu mn) { 2155 (cast(t_v__qp_qp) pFunQt[104])(QtObj, mn.QtObj); 2156 return this; 2157 } /// Вставить вертикальное меню 2158 } 2159 // ================ QFont ================ 2160 class QFont : QObject { 2161 ~this() { 2162 if(!fNoDelete) { (cast(t_v__qp) pFunQt[128])(QtObj); setQtObj(null); } 2163 } 2164 this() { 2165 setQtObj((cast(t_qp__v)pFunQt[127])()); 2166 } 2167 QFont setPointSize(int size) { 2168 (cast(t_v__qp_i) pFunQt[129])(QtObj, size); 2169 return this; 2170 } /// Установить размер шрифта в поинтах 2171 QFont setFamily(T: QString)(T str) { 2172 (cast(t_v__qp_qp) pFunQt[130])(QtObj, str.QtObj); 2173 return this; 2174 } /// Наименование шрифта Например: "True Times" 2175 QFont setFamily(T)(T str) { 2176 setFamily((new QString(to!string(str))).QtObj); 2177 return this; 2178 } /// Наименование шрифта Например: "True Times" 2179 } 2180 2181 // ================ QIcon ================ 2182 class QIcon : QObject { 2183 ~this() { 2184 if(!fNoDelete) { (cast(t_v__qp) pFunQt[111])(QtObj); setQtObj(null); } 2185 } 2186 this() { 2187 setQtObj((cast(t_qp__v)pFunQt[110])()); 2188 } 2189 QIcon addFile(T: QString)(T str, QSize qs = null) { 2190 if(qs is null) { 2191 (cast(t_v__qp_qp_qp) pFunQt[112])(QtObj, str.QtObj, null); 2192 } else { 2193 (cast(t_v__qp_qp_qp) pFunQt[112])(QtObj, str.QtObj, qs.QtObj); 2194 } 2195 return this; 2196 } 2197 QIcon addFile(T)(T str, QSize qs = null) { 2198 if(qs is null) { 2199 (cast(t_v__qp_qp_qp) pFunQt[112])(QtObj, (new QString(to!string(str))).QtObj, null); 2200 } else { 2201 (cast(t_v__qp_qp_qp) pFunQt[112])(QtObj, (new QString(to!string(str))).QtObj, qs.QtObj); 2202 } 2203 return this; 2204 } 2205 } 2206 // ================ QToolBar ================ 2207 class QToolBar : QWidget { 2208 enum ToolButtonStyle { 2209 ToolButtonIconOnly = 0, // Only display the icon. 2210 ToolButtonTextOnly = 1, // Only display the text. 2211 ToolButtonTextBesideIcon = 2, // The text appears beside the icon. 2212 ToolButtonTextUnderIcon = 3, // The text appears under the icon. 2213 ToolButtonFollowStyle = 4 // Follow the style. 2214 } 2215 enum ToolBarArea { 2216 LeftToolBarArea = 0x1, 2217 RightToolBarArea = 0x2, 2218 TopToolBarArea = 0x4, 2219 BottomToolBarArea = 0x8, 2220 NoToolBarArea = 0 2221 } 2222 2223 ~this() { 2224 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[115])(QtObj); setQtObj(null); } 2225 } 2226 this(QWidget parent) { 2227 if (parent) { 2228 this.setNoDelete(true); 2229 setQtObj((cast(t_qp__qp)pFunQt[114])(parent.QtObj)); 2230 } else { 2231 setQtObj((cast(t_qp__qp)pFunQt[114])(null)); 2232 } 2233 } /// QToolBar::QToolBar(QWidget* parent) 2234 QToolBar addAction(QAction ac) { 2235 (cast(t_v__qp_qp_i) pFunQt[116])(QtObj, ac.QtObj, 0); 2236 return this; 2237 } /// Вставить Action 2238 QToolBar addWidget(QWidget wd) { 2239 (cast(t_v__qp_qp_i) pFunQt[116])(QtObj, wd.QtObj, 1); 2240 return this; 2241 } /// Добавить виджет в QToolBar 2242 2243 QToolBar setToolButtonStyle(QToolBar.ToolButtonStyle st) { 2244 (cast(t_v__qp_i) pFunQt[125])(QtObj, st); 2245 return this; 2246 } /// Установить стиль кнопок в ToolBar 2247 QToolBar setAllowedAreas(QToolBar.ToolBarArea st) { 2248 (cast(t_v__qp_i) pFunQt[124])(QtObj, st); 2249 return this; 2250 } /// Где возможно размещение ToolBar, а не где он будет размещён 2251 QToolBar addSeparator() { 2252 (cast(t_v__qp_i) pFunQt[132])(QtObj, 0); 2253 return this; 2254 } /// 2255 QToolBar clear() { 2256 (cast(t_v__qp_i) pFunQt[132])(QtObj, 1); 2257 return this; 2258 } /// 2259 } 2260 // ================ QDialog ================ 2261 class QDialog : QWidget { 2262 this() {} 2263 ~this() { 2264 if(!fNoDelete) { (cast(t_v__qp) pFunQt[118])(QtObj); setQtObj(null); } 2265 } 2266 this(QWidget parent, QtE.WindowType fl = QtE.WindowType.Widget) { 2267 if (parent) { 2268 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2269 setQtObj((cast(t_qp__qp_i) pFunQt[117])(parent.QtObj, fl)); 2270 } else { 2271 setQtObj((cast(t_qp__qp_i) pFunQt[117])(null, fl)); 2272 } 2273 } /// Конструктор 2274 int exec() { 2275 return (cast(t_i__qp) pFunQt[119])(QtObj); 2276 } /// Обычный QDialog::exec() 2277 } 2278 // ================ QMessageBox ================ 2279 /++ 2280 QMessageBox - это стандартный класс сообщений. 2281 +/ 2282 class QMessageBox : QDialog { 2283 enum Icon { 2284 NoIcon = 0, 2285 Information = 1, 2286 Warning = 2, 2287 Critical = 3, 2288 Question = 4 2289 } 2290 2291 enum ButtonRole { 2292 // keep this in sync with QDialogButtonBox::ButtonRole 2293 InvalidRole = -1, 2294 AcceptRole, 2295 RejectRole, 2296 DestructiveRole, 2297 ActionRole, 2298 HelpRole, 2299 YesRole, 2300 NoRole, 2301 ResetRole, 2302 ApplyRole, 2303 2304 NRoles 2305 } 2306 2307 enum StandardButton { 2308 // keep this in sync with QDialogButtonBox::StandardButton 2309 NoButton = 0x00000000, 2310 Ok = 0x00000400, 2311 Save = 0x00000800, 2312 SaveAll = 0x00001000, 2313 Open = 0x00002000, 2314 Yes = 0x00004000, 2315 YesToAll = 0x00008000, 2316 No = 0x00010000, 2317 NoToAll = 0x00020000, 2318 Abort = 0x00040000, 2319 Retry = 0x00080000, 2320 Ignore = 0x00100000, 2321 Close = 0x00200000, 2322 Cancel = 0x00400000, 2323 Discard = 0x00800000, 2324 Help = 0x01000000, 2325 Apply = 0x02000000, 2326 Reset = 0x04000000, 2327 RestoreDefaults = 0x08000000, 2328 2329 FirstButton = Ok, // internal 2330 LastButton = RestoreDefaults, // internal 2331 2332 YesAll = YesToAll, // obsolete 2333 NoAll = NoToAll, // obsolete 2334 2335 Default = 0x00000100, // obsolete 2336 Escape = 0x00000200, // obsolete 2337 FlagMask = 0x00000300, // obsolete 2338 ButtonMask = ~FlagMask // obsolete 2339 } 2340 2341 alias Button = StandardButton; 2342 2343 this() {} 2344 ~this() { 2345 if(!fNoDelete) { (cast(t_v__qp) pFunQt[121])(QtObj); setQtObj(null); } 2346 } 2347 this(QWidget parent) { 2348 if (parent) { 2349 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2350 setQtObj((cast(t_qp__qp) pFunQt[120])(parent.QtObj)); 2351 } else { 2352 setQtObj((cast(t_qp__qp) pFunQt[120])(null)); 2353 } 2354 } /// Конструктор 2355 QMessageBox setText(T: QString)(T str) { 2356 (cast(t_v__qp_qp_i) pFunQt[122])(QtObj, str.QtObj, 0); 2357 return this; 2358 } /// Установить текст 2359 QMessageBox setText(T)(T str) { 2360 QMessageBox.setText(new QString(to!string(str))); 2361 return this; 2362 } /// Установить текст 2363 QMessageBox setWindowTitle(T: QString)(T str) { 2364 (cast(t_v__qp_qp_i) pFunQt[122])(QtObj, str.QtObj, 1); 2365 return this; 2366 } /// Установить текст 2367 QMessageBox setWindowTitle(T)(T str) { 2368 QMessageBox.setWindowTitle(new QString(to!string(str))); 2369 return this; 2370 } /// Установить текст 2371 QMessageBox setInformativeText(T: QString)(T str) { 2372 (cast(t_v__qp_qp_i) pFunQt[122])(QtObj, str.QtObj, 2); 2373 return this; 2374 } /// Установить текст 2375 QMessageBox setInformativeText(T)(T str) { 2376 QMessageBox.setInformativeText(new QString(to!string(str))); 2377 return this; 2378 } /// Установить текст 2379 QMessageBox setStandardButtons(QMessageBox.StandardButton buttons) { 2380 (cast(t_v__qp_qp_i) pFunQt[123])(QtObj, cast(QtObjH)buttons, 0); 2381 return this; 2382 } /// Установить стандартный набор кнопок 2383 QMessageBox setDefaultButton(QMessageBox.StandardButton buttons) { 2384 (cast(t_v__qp_qp_i) pFunQt[123])(QtObj, cast(QtObjH)buttons, 1); 2385 return this; 2386 } /// Установить кнопку по умолчанию 2387 QMessageBox setEscapeButton(QMessageBox.StandardButton buttons) { 2388 (cast(t_v__qp_qp_i) pFunQt[123])(QtObj, cast(QtObjH)buttons, 2); 2389 return this; 2390 } /// Установить кнопку отмены 2391 QMessageBox setIcon(QMessageBox.Icon icon) { 2392 (cast(t_v__qp_qp_i) pFunQt[123])(QtObj, cast(QtObjH)icon, 3); 2393 return this; 2394 } /// Установить стандартную иконку из числа QMessage.Icon. (NoIcon, Information, Warning, Critical, Question) 2395 } 2396 2397 // ================ QProgressBar ================ 2398 /++ 2399 QProgressBar - это .... 2400 +/ 2401 class QProgressBar : QWidget { 2402 this() {} 2403 ~this() { 2404 if(!fNoDelete) { (cast(t_v__qp) pFunQt[134])(QtObj); setQtObj(null); } 2405 } 2406 this(QWidget parent) { 2407 if (parent) { 2408 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2409 setQtObj((cast(t_qp__qp) pFunQt[133])(parent.QtObj)); 2410 } else { 2411 setQtObj((cast(t_qp__qp) pFunQt[133])(null)); 2412 } 2413 } /// Конструктор 2414 QProgressBar setMinimum(int n) { 2415 (cast(t_v__qp_i_i) pFunQt[135])(QtObj, n, 0); return this; 2416 } /// Установить нижнию границу 2417 QProgressBar setMaximum(int n) { 2418 (cast(t_v__qp_i_i) pFunQt[135])(QtObj, n, 1); return this; 2419 } /// Установить верхнию границу 2420 QProgressBar setValue(int n) { 2421 (cast(t_v__qp_i_i) pFunQt[135])(QtObj, n, 2); return this; 2422 } /// Установить текущее положение 2423 2424 } 2425 // ============ QDate =============== 2426 /* 2427 d the day as number without a leading zero (1 to 31) 2428 dd the day as number with a leading zero (01 to 31) 2429 ddd the abbreviated localized day name (e.g. 'Mon' to 'Sun'). Uses the system locale to localize the name, i.e. QLocale::system(). 2430 dddd the long localized day name (e.g. 'Monday' to 'Sunday'). Uses the system locale to localize the name, i.e. QLocale::system(). 2431 M the month as number without a leading zero (1 to 12) 2432 MM the month as number with a leading zero (01 to 12) 2433 MMM the abbreviated localized month name (e.g. 'Jan' to 'Dec'). Uses the system locale to localize the name, i.e. QLocale::system(). 2434 MMMM the long localized month name (e.g. 'January' to 'December'). Uses the system locale to localize the name, i.e. QLocale::system(). 2435 yy the year as two digit number (00 to 99) 2436 yyyy the year as four digit number. If the year is negative, a minus sign is prepended in addition. 2437 */ 2438 class QDate : QObject { 2439 ~this() { 2440 if(!fNoDelete) { (cast(t_v__qp) pFunQt[137])(QtObj); setQtObj(null); } 2441 } 2442 this() { 2443 setQtObj((cast(t_qp__v)pFunQt[136])()); 2444 } 2445 QString toQString(QString shabl) { 2446 QString qs = new QString(); 2447 (cast(t_v__qp_qp_qp)pFunQt[140])(QtObj, qs.QtObj, shabl.QtObj); 2448 return qs; 2449 } /// Выдать содержимое в QString 2450 string toString(T1)(T1 shabl) { 2451 QString qs = toQString(new QString(to!string(shabl))); 2452 return to!string(qs.String); 2453 } /// Выдать всё содержимое в String 2454 2455 } 2456 // ============ QTime =============== 2457 /* 2458 h the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display) 2459 hh the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display) 2460 H the hour without a leading zero (0 to 23, even with AM/PM display) 2461 HH the hour with a leading zero (00 to 23, even with AM/PM display) 2462 m the minute without a leading zero (0 to 59) 2463 mm the minute with a leading zero (00 to 59) 2464 s the second without a leading zero (0 to 59) 2465 ss the second with a leading zero (00 to 59) 2466 z the milliseconds without leading zeroes (0 to 999) 2467 zzz the milliseconds with leading zeroes (000 to 999) 2468 AP or A use AM/PM display. A/AP will be replaced by either "AM" or "PM". 2469 ap or a use am/pm display. a/ap will be replaced by either "am" or "pm". 2470 t the timezone (for example "CEST") 2471 */ 2472 class QTime : QObject { 2473 ~this() { 2474 if(!fNoDelete) { (cast(t_v__qp) pFunQt[139])(QtObj); setQtObj(null); } 2475 } 2476 this() { 2477 setQtObj((cast(t_qp__v)pFunQt[138])()); 2478 } 2479 QString toQString(QString shabl) { 2480 QString qs = new QString(); 2481 (cast(t_v__qp_qp_qp)pFunQt[141])(QtObj, qs.QtObj, shabl.QtObj); 2482 return qs; 2483 } /// Выдать содержимое в QString 2484 string toString(T1)(T1 shabl) { 2485 QString qs = toQString(new QString(to!string(shabl))); 2486 return to!string(qs.String); 2487 } /// Выдать всё содержимое в String 2488 } 2489 // ================ QFileDialog ================ 2490 class QFileDialog : QDialog { 2491 enum ViewMode { 2492 Detail = 0, // Displays an icon, a name, and details for each item in the directory. 2493 List = 1 // Displays only an icon and a name for each item in the directory. 2494 } /// На сколько детаьно паказывать имена файлов 2495 2496 enum Option { 2497 Null = 0, 2498 ShowDirsOnly = 0x00000001, // Only show directories in the file dialog. By default both files and directories are shown. (Valid only in the Directory file mode.) 2499 DontResolveSymlinks = 0x00000002, // Don't resolve symlinks in the file dialog. By default symlinks are resolved. 2500 DontConfirmOverwrite = 0x00000004, // Don't ask for confirmation if an existing file is selected. By default confirmation is requested. 2501 DontUseNativeDialog = 0x00000010, // Don't use the native file dialog. By default, the native file dialog is used unless you use a subclass of QFileDialog that contains the Q_OBJECT macro, or the platform does not have a native dialog of the type that you require. 2502 ReadOnly = 0x00000020, // Indicates that the model is readonly. 2503 HideNameFilterDetails = 0x00000040, //Indicates if the file name filter details are hidden or not. 2504 DontUseSheet = 0x00000008, // In previous versions of Qt, the static functions would create a sheet by default if the static function was given a parent. This is no longer supported and does nothing in Qt 4.5, The static functions will always be an application modal dialog. If you want to use sheets, use QFileDialog::open() instead. 2505 DontUseCustomDirectoryIcons = 0x00000080 //Always use the default directory icon. Some platforms allow the user to set a different icon. Custom icon lookup cause a big performance impact over network or removable drives. Setting this will enable the QFileIconProvider::DontUseCustomDirectoryIcons option in the icon provider. This enum value was added in Qt 5.2. 2506 } 2507 private extern (C) @nogc alias 2508 t_v__qp_qp_qp_qp_qp_qp_qp_i = 2509 void function(QtObjH, QtObjH, QtObjH, QtObjH, QtObjH, QtObjH, QtObjH, int); 2510 2511 this() {} 2512 ~this() { 2513 if(!fNoDelete) { (cast(t_v__qp) pFunQt[143])(QtObj); setQtObj(null); } 2514 } 2515 this(QWidget parent, QtE.WindowType fl = QtE.WindowType.Widget) { 2516 if (parent) { 2517 this.setNoDelete(true); 2518 setQtObj((cast(t_qp__qp_i) pFunQt[142])(parent.QtObj, fl)); 2519 } else { 2520 setQtObj((cast(t_qp__qp_i) pFunQt[142])(null, fl)); 2521 } 2522 } /// Конструктор 2523 QFileDialog setNameFilter(QString shabl) { 2524 (cast(t_v__qp_qp_i)pFunQt[144])(QtObj, shabl.QtObj, 0); 2525 return this; 2526 } /// Установить фильтр для выбираемых файлов 2527 QFileDialog setNameFilter(T1)(T1 shabl) { 2528 setNameFilter(new QString(to!string(shabl))); 2529 return this; 2530 } /// Установить фильтр для выбираемых файлов 2531 QFileDialog selectFile(QString shabl) { 2532 (cast(t_v__qp_qp_i)pFunQt[144])(QtObj, shabl.QtObj, 1); 2533 return this; 2534 } /// Выбрать строго конкретное имя файла 2535 QFileDialog selectFile(T1)(T1 shabl) { 2536 setNameFilter(new QString(to!string(shabl))); 2537 return this; 2538 } /// Выбрать строго конкретное имя файла 2539 QFileDialog setDirectory(QString shabl) { 2540 (cast(t_v__qp_qp_i)pFunQt[144])(QtObj, shabl.QtObj, 2); 2541 return this; 2542 } /// Открыть конкретный каталог 2543 QFileDialog setDirectory(T1)(T1 shabl) { 2544 setNameFilter(new QString(to!string(shabl))); 2545 return this; 2546 } /// Открыть конкретный каталог 2547 QFileDialog setDefaultSuffix(QString shabl) { 2548 (cast(t_v__qp_qp_i)pFunQt[144])(QtObj, shabl.QtObj, 3); 2549 return this; 2550 } /// "txt" - добавит эту строку к имени файла, если нет расширения 2551 QFileDialog setDefaultSuffix(T1)(T1 shabl) { 2552 setNameFilter(new QString(to!string(shabl))); 2553 return this; 2554 } /// "txt" - добавит эту строку к имени файла, если нет расширения 2555 QFileDialog setViewMode(QFileDialog.ViewMode pr) { 2556 (cast(t_v__qp_i)pFunQt[145])(QtObj, pr); 2557 return this; 2558 } 2559 2560 // Выбор файла для открытия 2561 string getOpenFileName( 2562 string caption = "", // Заголовок 2563 string dir = "", // Начальный каталог 2564 string filter = "*", // Фильтр "*.d;;*.f" 2565 string selectedFilter = "", 2566 Option options = Option.Null) { 2567 QString qrez = new QString(); 2568 QString qcaption = new QString(caption); 2569 QString qdir = new QString(dir); 2570 QString qfilter = new QString(filter); 2571 QString qselectedFilter = new QString(selectedFilter); 2572 2573 (cast(t_v__qp_qp_qp_qp_qp_qp_qp_i)pFunQt[146]) 2574 (QtObj, QtObj, qrez.QtObj, 2575 qcaption.QtObj, qdir.QtObj, qfilter.QtObj, 2576 qselectedFilter.QtObj, options); 2577 return qrez.String; 2578 } 2579 // Выбор файла для сохранения. Позволяет выбрать не существующий файл 2580 string getSaveFileName( 2581 string caption = "", // Заголовок 2582 string dir = "", // Начальный каталог 2583 string filter = "*", // Фильтр "*.d;;*.f" 2584 string selectedFilter = "", 2585 Option options = Option.Null) { 2586 QString qrez = new QString(); 2587 QString qcaption = new QString(caption); 2588 QString qdir = new QString(dir); 2589 QString qfilter = new QString(filter); 2590 QString qselectedFilter = new QString(selectedFilter); 2591 2592 (cast(t_v__qp_qp_qp_qp_qp_qp_qp_i)pFunQt[147]) 2593 (QtObj, QtObj, qrez.QtObj, 2594 qcaption.QtObj, qdir.QtObj, qfilter.QtObj, 2595 qselectedFilter.QtObj, options); 2596 return qrez.String; 2597 } 2598 } 2599 // ================ QMdiArea ================ 2600 class QMdiArea : QAbstractScrollArea { 2601 ~this() { 2602 if(!fNoDelete) { (cast(t_v__qp) pFunQt[152])(QtObj); setQtObj(null); } 2603 } 2604 this(QWidget parent) { 2605 if (parent) { 2606 this.setNoDelete(true); 2607 setQtObj((cast(t_qp__qp) pFunQt[151])(parent.QtObj)); 2608 } else { 2609 setQtObj((cast(t_qp__qp) pFunQt[151])(null)); 2610 } 2611 } /// Конструктор 2612 void addSubWindow(QWidget wd, QtE.WindowType fl = QtE.WindowType.Widget) { 2613 (cast(t_v__qp_qp_i)pFunQt[155])(QtObj, wd.QtObj, cast(int)fl); 2614 } 2615 } 2616 // ================ QMdiSubWindow ================ 2617 class QMdiSubWindow : QWidget { 2618 ~this() { 2619 if(!fNoDelete) { (cast(t_v__qp) pFunQt[154])(QtObj); setQtObj(null); } 2620 } 2621 this(QWidget parent, QtE.WindowType fl = QtE.WindowType.Widget) { 2622 if (parent) { 2623 this.setNoDelete(true); 2624 setQtObj((cast(t_qp__qp_i) pFunQt[153])(parent.QtObj, fl)); 2625 } else { 2626 setQtObj((cast(t_qp__qp_i) pFunQt[153])(null, fl)); 2627 } 2628 } /// Конструктор 2629 } 2630 // ============ QAbstractItemView ================== 2631 class QAbstractItemView : QAbstractScrollArea { 2632 this(){} 2633 ~this() { 2634 // if(!fNoDelete) { (cast(t_v__qp) pFunQt[67])(QtObj); setQtObj(null); } 2635 } 2636 // this() { super(); } 2637 this(char ch, void* adr) { 2638 if(ch == '+') setQtObj(cast(QtObjH)adr); 2639 } 2640 this(QWidget parent) { 2641 /* if (parent) { 2642 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2643 setQtObj((cast(t_qp__qp) pFunQt[66])(parent.QtObj)); 2644 } else { 2645 setQtObj((cast(t_qp__qp) pFunQt[66])(null)); 2646 } 2647 */ } /// Конструктор 2648 } 2649 // ============ QHeaderView ================= 2650 class QHeaderView : QAbstractItemView { 2651 enum ResizeMode { 2652 Interactive = 0, 2653 Fixed = 2, 2654 Stretch = 1, 2655 ResizeToContents = 3 2656 } 2657 this(){} 2658 // ~this() { 2659 // if(!fNoDelete) { (cast(t_v__qp) pFunQt[160])(QtObj); setQtObj(null); } 2660 // } 2661 // this() { super(); } 2662 this(char ch, void* adr) { 2663 if(ch == '+') setQtObj(cast(QtObjH)adr); 2664 } 2665 /* this(QWidget parent) { 2666 this.setNoDelete(true); 2667 setQtObj((cast(t_qp__qp) pFunQt[159])(parent ? parent.QtObj : null)); 2668 } /// Конструктор 2669 */ 2670 } 2671 // ============ QTableView ================== 2672 class QTableView : QAbstractItemView { 2673 this(){} 2674 ~this() { 2675 if(!fNoDelete) { (cast(t_v__qp) pFunQt[160])(QtObj); setQtObj(null); } 2676 } 2677 // this() { super(); } 2678 this(char ch, void* adr) { 2679 if(ch == '+') setQtObj(cast(QtObjH)adr); 2680 } 2681 this(QWidget parent) { 2682 this.setNoDelete(true); 2683 setQtObj((cast(t_qp__qp) pFunQt[159])(parent ? parent.QtObj : null)); 2684 } /// Конструктор 2685 QTableView setColumnWidth(int column, int width) { 2686 (cast(t_v__qp_i_i_i) pFunQt[174])(QtObj, column, width, 0); return this; 2687 } 2688 int columnWidth(int column) { 2689 return (cast(t_i__qp_i_i) pFunQt[175])(QtObj, column, 0); 2690 } 2691 QTableView setRowHeight(int row, int height) { 2692 (cast(t_v__qp_i_i_i) pFunQt[174])(QtObj, row, height, 1); return this; 2693 } 2694 int rowHeight(int row) { 2695 return (cast(t_i__qp_i_i) pFunQt[175])(QtObj, row, 1); 2696 } 2697 int columnAt(int column) { 2698 return (cast(t_i__qp_i_i) pFunQt[175])(QtObj, column, 2); 2699 } 2700 int rowAt(int row) { 2701 return (cast(t_i__qp_i_i) pFunQt[175])(QtObj, row, 3); 2702 } 2703 QTableView showColumn(int column) { 2704 (cast(t_v__qp_i_i) pFunQt[175])(QtObj, column, 4); return this; 2705 } 2706 QTableView hideColumn(int column) { 2707 (cast(t_v__qp_i_i) pFunQt[175])(QtObj, column, 5); return this; 2708 } 2709 QTableView showRow(int row) { 2710 (cast(t_v__qp_i_i) pFunQt[175])(QtObj, row, 6); return this; 2711 } 2712 QTableView hideRow(int row) { 2713 (cast(t_v__qp_i_i) pFunQt[175])(QtObj, row, 7); return this; 2714 } 2715 QTableView ResizeModeColumn(int column, QHeaderView.ResizeMode rm = QHeaderView.ResizeMode.Stretch) { 2716 (cast(t_v__qp_i_i_i) pFunQt[182])(QtObj, column, rm, 0); return this; 2717 } 2718 QTableView ResizeModeRow(int row, QHeaderView.ResizeMode rm = QHeaderView.ResizeMode.Stretch) { 2719 (cast(t_v__qp_i_i_i) pFunQt[182])(QtObj, row, rm, 1); return this; 2720 } 2721 2722 // funQt(182, bQtE5Widgets, hQtE5Widgets, sQtE5Widgets, "qteQTableView_ResizeMode", showError); 2723 2724 } 2725 // ============ QTableWidget ================== 2726 class QTableWidget : QTableView { 2727 this(){} 2728 ~this() { 2729 if(!fNoDelete) { (cast(t_v__qp) pFunQt[162])(QtObj); setQtObj(null); } 2730 } 2731 // this() { super(); } 2732 this(char ch, void* adr) { 2733 if(ch == '+') setQtObj(cast(QtObjH)adr); 2734 } 2735 this(QWidget parent) { 2736 this.setNoDelete(true); 2737 setQtObj((cast(t_qp__qp) pFunQt[161])(parent ? parent.QtObj : null)); 2738 } /// Конструктор 2739 QTableWidget setRowCount(int row) { 2740 (cast(t_v__qp_i_i) pFunQt[163])(QtObj, row, 1); return this; 2741 } 2742 QTableWidget setColumnCount(int col) { 2743 (cast(t_v__qp_i_i) pFunQt[163])(QtObj, col, 0); return this; 2744 } 2745 QTableWidget insertRow(int row) { 2746 (cast(t_v__qp_i_i) pFunQt[163])(QtObj, row, 3); return this; 2747 } 2748 QTableWidget insertColumn(int col) { 2749 (cast(t_v__qp_i_i) pFunQt[163])(QtObj, col, 2); return this; 2750 } 2751 QTableWidget clear() { 2752 (cast(t_v__qp_i_i) pFunQt[163])(QtObj, 0, 4); return this; 2753 } 2754 QTableWidget clearContents() { 2755 (cast(t_v__qp_i_i) pFunQt[163])(QtObj, 0, 5); return this; 2756 } /// Удалено содержание, но заголовки и прочее остаётся 2757 2758 QTableWidget setItem(int r, int c, QTableWidgetItem twi) { 2759 (cast(t_v__qp_qp_i_i) pFunQt[167])(QtObj, twi.QtObj, r, c); return this; 2760 } 2761 QTableWidget setHorizontalHeaderItem(int c, QTableWidgetItem twi) { 2762 (cast(t_v__qp_qp_i_i) pFunQt[176])(QtObj, twi.QtObj, c, 0); return this; 2763 } 2764 QTableWidget setVerticalHeaderItem(int row, QTableWidgetItem twi) { 2765 (cast(t_v__qp_qp_i_i) pFunQt[176])(QtObj, twi.QtObj, row, 1); return this; 2766 } 2767 QTableWidget setCurrentCell(int row, int column) { 2768 (cast(t_v__qp_i_i) pFunQt[241])(QtObj, row, column); return this; 2769 } 2770 2771 2772 /* QString toQString(QString shabl) { 2773 QString qs = new QString(); 2774 (cast(t_v__qp_qp_qp)pFunQt[141])(QtObj, qs.QtObj, shabl.QtObj); 2775 return qs; 2776 } 2777 */} 2778 2779 // =========== QTableWidgetItem ======== 2780 class QTableWidgetItem : QObject { 2781 ~this() { 2782 if(!fNoDelete) { (cast(t_v__qp) pFunQt[165])(QtObj); setQtObj(null); } 2783 } 2784 this(QTableWidget tw, int row, int col) { 2785 setQtObj((cast(t_qp__qp_i_i)pFunQt[169])(tw.QtObj, row, col)); 2786 } /// Создать item забрав его по координатам 2787 this(int Type) { 2788 setQtObj((cast(t_qp__i)pFunQt[164])(Type)); 2789 } 2790 this(char ch, void* adr) { 2791 if(ch == '+') setQtObj(cast(QtObjH)adr); 2792 } 2793 QTableWidgetItem setText(T: QString)(T str) { 2794 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, str.QtObj, 0); 2795 return this; 2796 } /// Установить текст в ячейке 2797 QTableWidgetItem setText(T)(T str) { 2798 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, (new QString(to!string(str))).QtObj, 0); 2799 return this; 2800 } /// Установить текст в ячейке 2801 QTableWidgetItem setToolTip(T: QString)(T str) { 2802 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, str.QtObj, 1); 2803 return this; 2804 } 2805 QTableWidgetItem setToolTip(T)(T str) { 2806 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, (new QString(to!string(str))).QtObj, 1); 2807 return this; 2808 } 2809 QTableWidgetItem setStatusTip(T: QString)(T str) { 2810 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, str.QtObj, 2); 2811 return this; 2812 } 2813 QTableWidgetItem setStatusTip(T)(T str) { 2814 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, (new QString(to!string(str))).QtObj, 2); 2815 return this; 2816 } 2817 QTableWidgetItem setWhatsThis(T: QString)(T str) { 2818 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, str.QtObj, 3); 2819 return this; 2820 } 2821 QTableWidgetItem setWhatsThis(T)(T str) { 2822 (cast(t_v__qp_qp_i) pFunQt[166])(QtObj, (new QString(to!string(str))).QtObj, 3); 2823 return this; 2824 } 2825 int column() { 2826 return (cast(t_i__qp_i) pFunQt[168])(QtObj, 0); 2827 } 2828 int row() { 2829 return (cast(t_i__qp_i) pFunQt[168])(QtObj, 1); 2830 } 2831 int textAlignment() { 2832 return (cast(t_i__qp_i) pFunQt[168])(QtObj, 2); 2833 } 2834 int type() { 2835 return (cast(t_i__qp_i) pFunQt[168])(QtObj, 3); 2836 } 2837 T text(T: QString)() { 2838 QString qs = new QString(); (cast(t_v__qp_qp)pFunQt[170])(QtObj, qs.QtObj); return qs; 2839 } /// Выдать содержимое в QString 2840 T text(T)() { return to!T(text!QString().String); 2841 } /// Выдать всё содержимое в String 2842 2843 QTableWidgetItem setTextAlignment(QtE.AlignmentFlag alig = QtE.AlignmentFlag.AlignLeft) { 2844 (cast(t_v__qp_i)pFunQt[171])(QtObj, alig); 2845 return this; 2846 } 2847 QTableWidgetItem setBackground(QBrush brush) { 2848 (cast(t_v__qp_qp_i)pFunQt[180])(QtObj, brush.QtObj, 0); 2849 return this; 2850 } 2851 QTableWidgetItem setForeground(QBrush brush) { 2852 (cast(t_v__qp_qp_i)pFunQt[180])(QtObj, brush.QtObj, 1); 2853 return this; 2854 } 2855 } 2856 // ================ QComboBox ================ 2857 /++ 2858 QComboBox (Выподающий список), но немного модифицированный в QtE.DLL. 2859 +/ 2860 class QComboBox : QWidget { 2861 this() {} 2862 ~this() { 2863 if(!fNoDelete) { (cast(t_v__qp) pFunQt[184])(QtObj); setQtObj(null); } 2864 } 2865 this(QWidget parent) { 2866 if (parent) { 2867 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2868 setQtObj((cast(t_qp__qp) pFunQt[183])(parent.QtObj)); 2869 } else { 2870 setQtObj((cast(t_qp__qp) pFunQt[183])(null)); 2871 } 2872 } /// Конструктор 2873 QComboBox addItem(QString str, int i) { 2874 (cast(t_v__qp_qp_i_i) pFunQt[185])(QtObj, str.QtObj, i, 0); return this; 2875 } /// Добавить строку str с значением i 2876 QComboBox addItem(string s, int i) { 2877 (cast(t_v__qp_qp_i_i) pFunQt[185])(QtObj, (new QString(s)).QtObj, i, 0); return this; 2878 } 2879 QComboBox setItemText(QString str, int n) { 2880 (cast(t_v__qp_qp_i_i) pFunQt[185])(QtObj, str.QtObj, n, 1); return this; 2881 } /// Заменить строку, значение i не меняется 2882 QComboBox setItemText(string s, int n) { 2883 (cast(t_v__qp_qp_i_i) pFunQt[185])(QtObj, (new QString(s)).QtObj, n, 1); return this; 2884 } 2885 QComboBox setMaxCount(int n) { 2886 (cast(t_v__qp_qp_i_i) pFunQt[185])(QtObj, null, n, 2); return this; 2887 } 2888 QComboBox setMaxVisibleItems(int n) { 2889 (cast(t_v__qp_qp_i_i) pFunQt[185])(QtObj, null, n, 3); return this; 2890 } 2891 int currentIndex() { 2892 return (cast(t_i__qp_i) pFunQt[186])(QtObj, 0); 2893 } 2894 int count() { 2895 return (cast(t_i__qp_i) pFunQt[186])(QtObj, 1); 2896 } 2897 int maxCount() { 2898 return (cast(t_i__qp_i) pFunQt[186])(QtObj, 2); 2899 } 2900 int maxVisibleItems() { 2901 return (cast(t_i__qp_i) pFunQt[186])(QtObj, 3); 2902 } 2903 int currentData() { 2904 return (cast(t_i__qp_i) pFunQt[186])(QtObj, 4); 2905 } 2906 QComboBox clear() { 2907 (cast(t_i__qp_i) pFunQt[186])(QtObj, 5); return this; 2908 } 2909 T text(T: QString)() { 2910 QString qs = new QString(); (cast(t_v__qp_qp)pFunQt[187])(QtObj, qs.QtObj); return qs; 2911 } /// Выдать содержимое в QString 2912 T text(T)() { return to!T(text!QString().String); 2913 } /// Выдать всё содержимое в String 2914 2915 // setQtObj((cast(t_qp__qp) pFunQt[161])(parent ? parent.QtObj : null)); 2916 } 2917 // ================ QPen ================ 2918 class QPen : QObject { 2919 this() { 2920 setQtObj((cast(t_qp__v) pFunQt[191])()); 2921 } /// Конструктор 2922 ~this() { 2923 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[192])(QtObj); setQtObj(null); } 2924 } /// Деструктор 2925 QPen setColor(QColor color) { 2926 (cast(t_v__qp_qp) pFunQt[193])(QtObj, color.QtObj); 2927 return this; 2928 } 2929 QPen setStyle(QtE.PenStyle ps = QtE.PenStyle.SolidLine) { 2930 (cast(t_v__qp_i) pFunQt[194])(QtObj, ps); 2931 return this; 2932 } 2933 QPen setWidth(int w) { 2934 (cast(t_v__qp_i) pFunQt[195])(QtObj, w); 2935 return this; 2936 } 2937 } 2938 // ============ QLCDNumber ======================================= 2939 class QLCDNumber : QFrame { 2940 enum Mode { Hex, Dec, Oct, Bin } 2941 enum SegmentStyle { 2942 Outline, // Выпуклый Цвета фона - а именно прозрачноБесцветный 2943 Filled, // Выпуклый Цвета текста 2944 Flat // Плоский 2945 } 2946 ~this() { 2947 if(!fNoDelete) { (cast(t_v__qp) pFunQt[199])(QtObj); setQtObj(null); } 2948 } 2949 this(char ch, void* adr) { 2950 if(ch == '+') setQtObj(cast(QtObjH)adr); 2951 } 2952 this(QWidget parent) { 2953 super(); 2954 if (parent) { 2955 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2956 setQtObj((cast(t_qp__qp) pFunQt[198])(parent.QtObj)); 2957 } else { 2958 setQtObj((cast(t_qp__qp) pFunQt[198])(null)); 2959 } 2960 } /// Конструктор 2961 this(QWidget parent, int kolNumber) { 2962 super(); 2963 if (parent) { 2964 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 2965 setQtObj((cast(t_qp__qp_i) pFunQt[200])(parent.QtObj, kolNumber)); 2966 } else { 2967 setQtObj((cast(t_qp__qp_i) pFunQt[200])(null, kolNumber)); 2968 } 2969 } /// Конструктор 2970 QLCDNumber display(int n) { 2971 (cast(t_v__qp_i) pFunQt[201])(QtObj, n); return this; 2972 } /// Отобразить число 2973 QLCDNumber setSegmentStyle(QLCDNumber.SegmentStyle style) { 2974 (cast(t_v__qp_i) pFunQt[202])(QtObj, cast(int)style); return this; 2975 } /// Способ изображения сегментов 2976 QLCDNumber setDigitCount(int kolNumber) { 2977 (cast(t_v__qp_i) pFunQt[203])(QtObj, kolNumber); return this; 2978 } /// Установить количество показываемых цифр 2979 QLCDNumber setMode(QLCDNumber.Mode mode) { 2980 (cast(t_v__qp_i) pFunQt[204])(QtObj, cast(int)mode); return this; 2981 } /// Способ изображения сегментов 2982 2983 } 2984 // ============ QAbstractSlider ======================================= 2985 class QAbstractSlider : QWidget { 2986 this() {} 2987 this(QWidget parent) {} 2988 ~this() { 2989 if(!fNoDelete) {} 2990 } 2991 QAbstractSlider setMaximum( int n ) { 2992 (cast(t_v__qp_i_i) pFunQt[205])(QtObj, n, 0); return this; 2993 } 2994 QAbstractSlider setMinimum( int n ) { 2995 (cast(t_v__qp_i_i) pFunQt[205])(QtObj, n, 1); return this; 2996 } 2997 QAbstractSlider setPageStep( int n ) { 2998 (cast(t_v__qp_i_i) pFunQt[205])(QtObj, n, 2); return this; 2999 } 3000 QAbstractSlider setSingleStep( int n ) { 3001 (cast(t_v__qp_i_i) pFunQt[205])(QtObj, n, 3); return this; 3002 } 3003 QAbstractSlider setSliderPosition( int n ) { 3004 (cast(t_v__qp_i_i) pFunQt[205])(QtObj, n, 4); return this; 3005 } 3006 int maximum() { return (cast(t_i__qp_i) pFunQt[208])(QtObj, 0); } 3007 int minimum() { return (cast(t_i__qp_i) pFunQt[208])(QtObj, 1); } 3008 int pageStep() { return (cast(t_i__qp_i) pFunQt[208])(QtObj, 2); } 3009 int singleStep() { return (cast(t_i__qp_i) pFunQt[208])(QtObj, 3); } 3010 int sliderPosition() { return (cast(t_i__qp_i) pFunQt[208])(QtObj, 4); } 3011 int value() { return (cast(t_i__qp_i) pFunQt[208])(QtObj, 5); } 3012 } 3013 // ============ QSlider ======================================= 3014 class QSlider : QAbstractSlider { 3015 ~this() { 3016 if(!fNoDelete) { (cast(t_v__qp) pFunQt[207])(QtObj); setQtObj(null); } 3017 } 3018 this(char ch, void* adr) { 3019 if(ch == '+') setQtObj(cast(QtObjH)adr); 3020 } /// Конструктор 3021 this(QWidget parent, QtE.Orientation n = QtE.Orientation.Horizontal) { 3022 super(); 3023 if (parent) { 3024 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 3025 setQtObj((cast(t_qp__qp_i) pFunQt[206])(parent.QtObj, cast(int)n)); 3026 } else { 3027 setQtObj((cast(t_qp__qp_i) pFunQt[206])(null, cast(int)n)); 3028 } 3029 } /// Конструктор 3030 } 3031 // ================ QGroupBox ================ 3032 class QGroupBox : QWidget { 3033 ~this() { 3034 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[213])(QtObj); setQtObj(null); } 3035 } 3036 this(char ch, void* adr) { 3037 if(ch == '+') setQtObj(cast(QtObjH)adr); 3038 } /// Конструктор 3039 this(QWidget parent) { 3040 if (parent) { 3041 this.setNoDelete(true); 3042 setQtObj((cast(t_qp__qp)pFunQt[212])(parent.QtObj)); 3043 } else { 3044 setQtObj((cast(t_qp__qp)pFunQt[212])(null)); 3045 } 3046 } 3047 QGroupBox setText(T: QString)(T str) { 3048 (cast(t_v__qp_qp) pFunQt[214])(QtObj, str.QtObj); 3049 return this; 3050 } /// Установить текст 3051 QGroupBox setText(T)(T str) { 3052 (cast(t_v__qp_qp) pFunQt[214])(QtObj, (new QString(to!string(str))).QtObj); 3053 return this; 3054 } /// Установить текст 3055 QGroupBox setAlignment(QtE.AlignmentFlag fl) { 3056 (cast(t_v__qp_i) pFunQt[215])(QtObj, fl); 3057 return this; 3058 } /// Выровнять текст 3059 3060 } 3061 // ================ QCheckBox ================ 3062 class QCheckBox : QAbstractButton { //=> Кнопки CheckBox независимые 3063 this(){} 3064 this(T: QString)(T str, QWidget parent = null) { 3065 // super(); // Это фактически заглушка, что бы сделать наследование, 3066 // не создавая промежуточного экземпляра в Qt 3067 if (parent) { 3068 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 3069 setQtObj((cast(t_qp__qp_qp) pFunQt[216])(parent.QtObj, str.QtObj)); 3070 } else { 3071 setQtObj((cast(t_qp__qp_qp) pFunQt[216])(null, str.QtObj)); 3072 } 3073 } /// Создать кнопку. 3074 ~this() { 3075 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[217])(QtObj); setQtObj(null); } 3076 // write("B- "); stdout.flush(); 3077 } 3078 this(T)(T str, QWidget parent = null) { 3079 // super(); // Это фактически заглушка, что бы сделать наследование, 3080 // не создавая промежуточного экземпляра в Qt 3081 if (parent) { 3082 setQtObj((cast(t_qp__qp_qp) pFunQt[216])(parent.QtObj, (new QString(to!string(str))).QtObj)); 3083 } else { 3084 setQtObj((cast(t_qp__qp_qp) pFunQt[216])(null, (new QString(to!string(str))).QtObj)); 3085 } 3086 } 3087 QtE.CheckState checkState() { //-> Состояние переключателя/кнопки 3088 return cast(QtE.CheckState)(cast(t_i__qp) pFunQt[218])(QtObj); 3089 } 3090 QCheckBox setCheckState(QtE.CheckState st = QtE.CheckState.Unchecked) { //-> Установить состояние переключателя/кнопки 3091 (cast(t_v__qp_i) pFunQt[219])(QtObj, st); return this; 3092 } 3093 bool isTristate() { //-> Есть в третичном состоянии? 3094 return (cast(t_b__qp) pFunQt[221])(QtObj); 3095 } 3096 QCheckBox setTristate(bool state = true) { //-> Установить/отменить третичное состояние 3097 (cast(t_v__qp_bool)pFunQt[220])(QtObj, state); return this; 3098 } 3099 } 3100 // ================ QRadioButton ================ 3101 class QRadioButton : QAbstractButton { //=> Кнопки РадиоБатоны зависимые 3102 this(){} 3103 this(T: QString)(T str, QWidget parent = null) { 3104 // super(); // Это фактически заглушка, что бы сделать наследование, 3105 // не создавая промежуточного экземпляра в Qt 3106 if (parent) { 3107 this.setNoDelete(true); // Не удалять текущий экземпляр, при условии, что он вставлен в другой 3108 setQtObj((cast(t_qp__qp_qp) pFunQt[222])(parent.QtObj, str.QtObj)); 3109 } else { 3110 setQtObj((cast(t_qp__qp_qp) pFunQt[222])(null, str.QtObj)); 3111 } 3112 } /// Создать кнопку. 3113 ~this() { 3114 if(!fNoDelete && (QtObj != null)) { (cast(t_v__qp) pFunQt[223])(QtObj); setQtObj(null); } 3115 // write("B- "); stdout.flush(); 3116 } 3117 this(T)(T str, QWidget parent = null) { 3118 // super(); // Это фактически заглушка, что бы сделать наследование, 3119 // не создавая промежуточного экземпляра в Qt 3120 if (parent) { 3121 setQtObj((cast(t_qp__qp_qp) pFunQt[222])(parent.QtObj, (new QString(to!string(str))).QtObj)); 3122 } else { 3123 setQtObj((cast(t_qp__qp_qp) pFunQt[222])(null, (new QString(to!string(str))).QtObj)); 3124 } 3125 } 3126 } 3127 // ================ QTextCursor ================ 3128 class QTextCursor : QObject { 3129 ~this() { 3130 if(!fNoDelete) { (cast(t_v__qp) pFunQt[228])(QtObj); setQtObj(null); } 3131 } 3132 this(char ch, void* adr) { 3133 if(ch == '+') setQtObj(cast(QtObjH)adr); 3134 } /// Конструктор 3135 this(void* ukDocument) { 3136 setQtObj((cast(t_qp__qp)pFunQt[227])(cast(QtObj__*)ukDocument)); 3137 } 3138 this() { 3139 setQtObj((cast(t_qp__v)pFunQt[229])()); 3140 } 3141 int anchor() { 3142 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 0); 3143 } 3144 int blockNumber() { 3145 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 1); 3146 } 3147 int columnNumber() { //-> Позиция (с 0) в видимой строке. Перен стр считается снова 3148 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 2); 3149 } 3150 int position() { //-> Позиция (с 0) в тексте, начиная с начала. Счит. печ симв 3151 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 3); 3152 } 3153 int positionInBlock() { //-> Позиция (с 0) в текушей строке 3154 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 4); 3155 } 3156 int selectionEnd() { 3157 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 5); 3158 } 3159 int selectionStart() { 3160 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 6); 3161 } 3162 int verticalMovementX() { //-> Количество пикселей с левого края 3163 return (cast(t_i__qp_i) pFunQt[231])(QtObj, 7); 3164 } 3165 } 3166 // ================ QRect ================ 3167 class QRect : QObject { 3168 ~this() { 3169 if(!fNoDelete) { (cast(t_v__qp) pFunQt[233])(QtObj); setQtObj(null); } 3170 } 3171 this(char ch, void* adr) { 3172 if(ch == '+') setQtObj(cast(QtObjH)adr); 3173 } /// Конструктор 3174 this() { 3175 setQtObj((cast(t_qp__v)pFunQt[232])()); 3176 } 3177 int x() { 3178 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 0); 3179 } 3180 int y() { 3181 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 1); 3182 } 3183 int width() { 3184 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 2); 3185 } 3186 int height() { 3187 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 3); 3188 } 3189 int left() { 3190 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 4); 3191 } 3192 int right() { 3193 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 5); 3194 } 3195 int top() { 3196 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 6); 3197 } 3198 int bottom() { 3199 return (cast(t_i__qp_i) pFunQt[234])(QtObj, 7); 3200 } 3201 QRect setCoords(int x1, int y1, int x2, int y2) { //-> Задать координаты 3202 (cast(t_v__qp_i_i_i_i_i) pFunQt[242])(QtObj, x1, y1, x2, y2, 0); return this; 3203 } 3204 QRect setRect(int x1, int y1, int width, int height) { //-> Задать верх лев угол и длину + ширину 3205 (cast(t_v__qp_i_i_i_i_i) pFunQt[242])(QtObj, x1, y1, width, height, 1); return this; 3206 } 3207 } 3208 // ================ QTextBlock ================ 3209 class QTextBlock : QObject { 3210 this() { 3211 setQtObj((cast(t_qp__v)pFunQt[238])()); 3212 } 3213 this(QTextCursor tk) { 3214 setQtObj((cast(t_qp__qp)pFunQt[240])(tk.QtObj)); 3215 } 3216 ~this() { 3217 if(!fNoDelete) { (cast(t_v__qp) pFunQt[239])(QtObj); setQtObj(null); } 3218 } 3219 T text(T: QString)() { //-> Содержимое блока в QString 3220 QString qs = new QString(); (cast(t_v__qp_qp)pFunQt[237])(QtObj, qs.QtObj); return qs; 3221 } /// Выдать содержимое в QString 3222 T text(T)() { return to!T(text!QString().String); 3223 } /// Выдать всё содержимое в String 3224 3225 } 3226 // ============ QAbstractSpinBox ======================================= 3227 class QAbstractSpinBox : QWidget { 3228 this() {} 3229 this(QWidget parent) {} 3230 ~this() { 3231 if(!fNoDelete) {} 3232 } 3233 void setReadOnly(bool f) { //-> T - только чтать, изменять нельзя 3234 (cast(t_v__qp_bool)pFunQt[252])(QtObj, f); 3235 } 3236 } 3237 // ============ QSpinBox ======================================= 3238 class QSpinBox : QAbstractSpinBox { 3239 ~this() { 3240 if(!fNoDelete) { (cast(t_v__qp) pFunQt[248])(QtObj); setQtObj(null); } 3241 } 3242 this(char ch, void* adr) { 3243 if(ch == '+') setQtObj(cast(QtObjH)adr); 3244 } /// Конструктор 3245 this(QWidget parent) { 3246 super(); 3247 if (parent) { 3248 this.setNoDelete(true); 3249 setQtObj((cast(t_qp__qp) pFunQt[247])(parent.QtObj)); 3250 } else { 3251 setQtObj((cast(t_qp__qp) pFunQt[247])(null)); 3252 } 3253 } /// Конструктор 3254 QSpinBox setMinimum(int n) { //-> Установить минимум 3255 (cast(t_v__qp_i_i) pFunQt[249])(QtObj, n, 0); return this; 3256 } 3257 QSpinBox setMaximum(int n) { //-> Установить максимум 3258 (cast(t_v__qp_i_i) pFunQt[249])(QtObj, n, 1); return this; 3259 } 3260 QSpinBox setSingleStep(int n) { //-> Установить приращение 3261 (cast(t_v__qp_i_i) pFunQt[249])(QtObj, n, 2); return this; 3262 } 3263 int minimum() { //-> Получить минимальное 3264 return (cast(t_i__qp_i) pFunQt[250])(QtObj, 0); 3265 } 3266 int maximum() { //-> Получить максимальное 3267 return (cast(t_i__qp_i) pFunQt[250])(QtObj, 1); 3268 } 3269 int singleStep() { //-> Получить приращение 3270 return (cast(t_i__qp_i) pFunQt[250])(QtObj, 2); 3271 } 3272 int value() { //-> Получить значение 3273 return (cast(t_i__qp_i) pFunQt[250])(QtObj, 3); 3274 } 3275 QSpinBox setPrefix(T: QString)(T str) { 3276 (cast(t_v__qp_qp_i) pFunQt[251])(QtObj, str.QtObj, 0); 3277 return this; 3278 } /// Установить текст 3279 QSpinBox setPrefix(T)(T str) { 3280 (cast(t_v__qp_qp_i) pFunQt[251])(QtObj, (new QString(to!string(str))).QtObj, 0); 3281 return this; 3282 } /// Установить текст 3283 QSpinBox setSuffix(T: QString)(T str) { 3284 (cast(t_v__qp_qp_i) pFunQt[251])(QtObj, str.QtObj, 1); 3285 return this; 3286 } /// Установить текст 3287 QSpinBox setSuffix(T)(T str) { 3288 (cast(t_v__qp_qp_i) pFunQt[251])(QtObj, (new QString(to!string(str))).QtObj, 1); 3289 return this; 3290 } /// Установить текст 3291 3292 3293 } 3294 3295 3296 3297 3298 3299 3300 3301 3302