Switch, aplikasi reguler, formulir terkelola. Switch, aplikasi reguler, formulir terkelola Masalah 1c dengan formulir terkelola
Platform 1C:Enterprise memungkinkan Anda menambahkan dan mengubah elemen formulir terkelola secara terprogram. Mari kita cari tahu mengapa ini mungkin diperlukan.
Modifikasi perangkat lunak pada formulir mungkin diperlukan dalam beberapa kasus:
- Saat menyelesaikan konfigurasi standar untuk memfasilitasi prosedur pembaruan selanjutnya. Dalam hal ini, hanya modul formulir yang akan diubah. Modul lebih mudah diperbarui dibandingkan formulir.
- Saat menerapkan beberapa algoritma umum. Misalnya, dalam subsistem “Larangan mengedit detail objek”, sebuah tombol dapat dibuat secara terprogram untuk semua objek yang terhubung ke subsistem untuk mengaktifkan kemampuan mengedit detail.
- Saat menerapkan beberapa algoritma tertentu. Misalnya, di direktori Nomenklatur, bidang dibuat untuk mengedit detail tambahan.
Dalam formulir terkelola, Anda dapat menambahkan, mengubah, dan menghapus secara terprogram:
- syarat;
- tim lokal;
- elemen.
Semua operasi ini hanya mungkin dilakukan di server.
Pembentukan ulang terprogram memiliki keterbatasan:
- Anda hanya dapat menghapus detail/perintah/elemen yang ditambahkan secara terprogram. Anda tidak dapat menghapus objek yang dibuat di konfigurator secara terprogram.
- Anda tidak dapat menetapkan atribut sebagai atribut utama.
Mengubah perintah formulir
Untuk mengatur komposisi perintah untuk suatu objek Formulir Terkelola ada koleksi Tim
Menambahkan (< ИмяКоманды >)
Kuantitas ()
Menemukan (< ИмяКоманды >)
Menghapus (< Команда >)
Koleksi Teams tersedia di klien dan server. Anda dapat mengubah koleksi (metode Tambah() dan Hapus()) hanya di server. Anda dapat mencari dan mendapatkan jumlah elemen (metode Temukan () dan Hitung ()) baik di klien maupun di server.
Sebagai contoh bekerja dengan perintah formulir, mari buat perintah ChangeHistory baru dengan judul “ChangeHistory…”, yang akan memanggil handler TampilanHistori(). Penciptaan terjadi ketika formulir dibuka.
&Di server
Prosedur WhenCreatingOnServer (Kegagalan, Pemrosesan Standar)
Tim = Tim. Menambahkan( "Sejarah Perubahan");
Tim . Tindakan = ;
Tim . Judul = "Sejarah perubahan...";
Akhir Prosedur
&Pada Klien
Prosedur Connectable_DisplayHistory (Perintah)
// perintah tindakan
Akhir Prosedur
Penangan perintah harus ditempatkan pada formulir dan memiliki arahan kompilasi &OnClient.
Mengubah detail formulir
Membaca komposisi detail formulir dilakukan oleh fungsi Dapatkan Detailnya(< Путь >) mengembalikan array bertipe FormAttributes. Parameter fungsi menentukan jalur ke atribut induk (sebagai string). Jika parameter dihilangkan atau string kosong ditentukan, detail tingkat atas akan dikembalikan.
Mengubah detail dilakukan dengan menggunakan metode ini Ubah Detail(<Detail Ditambahkan>, <Detail yang Dapat Dilepas>) obyek Formulir Terkelola. Untuk parameter Detail Ditambahkan Dan Detail yang Dapat Dilepas Array dengan elemen tipe Form Attributes ditransmisikan.
Perhatian!
Proses mengubah komposisi detail cukup memakan banyak sumber daya. Formulir sebenarnya sedang dibuat ulang. Dalam hal ini, pekerjaan dengan detail formulir dilakukan dalam mode batch.
Mari kita buat atribut form baru dengan nama Pembeli:
AddedDetails = Array Baru;
Detail Ditambahkan. Tambahkan (Atribut Formulir Baru(“Pembeli”, Deskripsi Tipe Baru (“DirectoryLink. Counterparty”), “Klien”));// Perubahan komposisi detail
);
Mengubah elemen bentuk
Untuk mengontrol komposisi elemen suatu objek Formulir Terkelola ada koleksi Elemen. Pengumpulannya memiliki beberapa metode:
Menyisipkan (< Имя>, < ТипЭлемента>, < Родитель>, < Элемент >)
Menambahkan (< Имя>, < ТипЭлемента>, < Родитель >)
Kuantitas ()
Menemukan (< Имя >)
Bergerak(< Элемент>, < Родитель>, < МестоРасположения >)
Menghapus (< Элемент >)
Koleksi Item tersedia di klien dan server. Memodifikasi koleksi (Sisipkan metode () , Tambah () , Pindahkan () dan Hapus () ) hanya tersedia di server. Anda dapat mencari dan mendapatkan jumlah elemen (metode Temukan () dan Hitung ()) baik di klien maupun di server. Elemen koleksi dapat berupa:
- Grup Bentuk;
- FormulirTabel;
- Bidang Formulir;
- Tombol Formulir.
Anda dapat menugaskan event handler secara terprogram ke elemen formulir. Metode ini dimaksudkan untuk tujuan ini Set Tindakan(< ИмяСобытия>, < Действие >) .
Mari kita lihat beberapa contoh paling umum dalam bekerja dengan perintah, detail, dan elemen formulir.
Menambahkan perintah dan tombol terkait:
// Buat perintah
Tim = Tim. Menambahkan( "Sejarah Perubahan");
Tim . Tindakan = "Plug-in_DisplayHistory"; // Formulir harus berisi prosedur dengan nama yang ditentukan
Tim . Menuju = "Sejarah perubahan...";
// Buat tombol dan kaitkan dengan perintah
Elemen = Barang. Menambahkan( "Sejarah Perubahan", Ketik("FormButton" ));
Elemen.CommandName = "Sejarah Perubahan";
Menambahkan atribut dan kolom input terkait:
// Deskripsi detail yang ditambahkan
AddedDetails = Array Baru;
Detail Ditambahkan. Menambahkan(Alat Peraga Bentuk Baru (“Pembeli”, Deskripsi Tipe Baru ( "DirectoryLink. Pihak rekanan"), "Klien" ));
// Mengubah komposisi detail
UbahDetail(Detail Ditambahkan);
// Membuat kolom input dan menghubungkan dengan atribut
Elemen = Barang. Tambah("Pembeli", Ketik("FormField" ));
Elemen . Tampilan = FormFieldView. bidang masuk;
Elemen . JalurKeData= "Pembeli" ;
Menugaskan event handler ke elemen formulir:
Pelanggan Barang. SetAksi(“Saat itu berubah”, "Terhubung_PembeliOnChange");
&Pada Klien
Prosedur Connected_BuyerOnChange(Elemen)
// Tindakan acara
Akhir Prosedur
Perhatian!
Prosedur yang ditetapkan sebagai event handler dari kode menggunakan metode Set Tindakan(), disarankan untuk menyetel awalan Connectable_.
Perhatian!
Anda dapat mengunduh pemrosesan dengan contoh pencarian terprogram dan mengubah detail, perintah, dan elemen formulir terkelola.
Dan Objek Transfer Data ke penataan kode, formulir terkontrol di lingkungan 1C 8.2.
Perkenalan
Mari kita mulai dengan penjelasan singkat tentang konsep "formulir terkelola" dan konsep terkait platform 1C. Penikmat platform mungkin ingin melewatkan bagian ini.Pada tahun 2008, versi baru platform 1C: Enterprise 8.2 (selanjutnya disebut Aplikasi Terkelola) tersedia, yang sepenuhnya mengubah seluruh lapisan pekerjaan dengan antarmuka. Ini termasuk antarmuka perintah, formulir, dan sistem jendela. Pada saat yang sama, tidak hanya model pengembangan antarmuka pengguna dalam konfigurasi yang berubah, tetapi juga arsitektur baru untuk memisahkan fungsionalitas antara aplikasi klien dan server juga diusulkan.
Aplikasi terkelola mendukung jenis klien berikut:
- Klien tebal (mode peluncuran normal dan terkelola)
- Klien tipis
- klien web
Perbedaan utama formulir terkelola untuk pengembang:
- Deskripsi struktur bersifat deklaratif, bukan “piksel demi piksel”. Penempatan elemen tertentu dilakukan secara otomatis oleh sistem saat formulir ditampilkan.
- Semua fungsi formulir dijelaskan sebagai detail Dan tim. Detail adalah data yang digunakan formulir, dan perintah adalah tindakan yang harus dilakukan.
- Formulir berjalan di server dan klien.
- Dalam konteks klien, hampir semua jenis aplikasi tidak tersedia, dan karenanya tidak mungkin mengubah data di basis info.
- Untuk setiap metode atau variabel formulir, itu harus ditentukan arahan kompilasi, menentukan lokasi eksekusi (klien atau server) dan akses ke konteks formulir.
- &Pada Klien
- &Di server
- &DiServerTanpa Konteks
- &OnClientOnServerTanpa Konteks
Semua diskusi lebih lanjut akan membahas sisi kanan ilustrasi, tentang bagaimana menyusun kode modul dan prinsip apa yang memungkinkan Anda menerapkan interaksi klien-server yang efektif.
Mari kita definisikan masalahnya
Beberapa tahun telah berlalu sejak versi baru platform 1C digunakan secara aktif dan banyak solusi (konfigurasi) telah dirilis baik oleh 1C maupun banyak mitranya.Selama ini, apakah pengembang telah mengembangkan pemahaman umum tentang prinsip interaksi klien-server saat membuat formulir, dan apakah pendekatan untuk mengimplementasikan modul perangkat lunak telah berubah dalam realitas arsitektur baru?
Mari kita lihat struktur kode (modul formulir) dalam beberapa bentuk konfigurasi standar yang sama dan coba temukan polanya.
Yang kami maksud dengan struktur adalah bagian kode (paling sering ini adalah blok komentar) yang dialokasikan oleh pengembang untuk mengelompokkan metode dan arahan kompilasi untuk metode ini.
Contoh 1:
Bagian pengendali kejadian Metode - di klien Metode - di server Metode - di klien Bagian prosedur dan fungsi layanan Fungsi kontrol input tambahan
Contoh 2:
Prosedur pelayanan dan fungsi Dokumen pembayaran Nilai Event handler
Contoh 3:
Prosedur layanan di server Prosedur layanan di klien Prosedur layanan di server tanpa konteks Pengendali peristiwa header Pengendali peristiwa perintah
Contoh 4:
Prosedur tujuan umum Bentuk event handler Prosedur subsistem "informasi kontak".
Pada dasarnya, struktur kodenya tidak ada, atau secara halus, mirip dengan yang ada di Formulir 8.1:
- Kata-kata yang tidak informatif “Umum, Layanan, Tambahan”.
- Upaya malu-malu untuk memisahkan metode klien dan server.
- Metode sering kali dikelompokkan berdasarkan elemen antarmuka “Bekerja dengan bagian tabel Produk, Informasi kontak”.
- Susunan metode dan grup kode yang sewenang-wenang. Misalnya, Penangan Peristiwa mungkin berada di atas dalam satu bentuk, di bawah dalam bentuk lain, tidak disorot sama sekali dalam bentuk ketiga, dan seterusnya.
- Dan jangan lupa bahwa ini semua ada dalam satu konfigurasi.
- Ya, ada konfigurasi di mana kata “Umum, Layanan, Tambahan” selalu berada di tempat yang sama tetapi...
Mengapa Anda memerlukan struktur kode?
- Penyederhanaan pemeliharaan.
- Sederhanakan pembelajaran.
- Mencatat prinsip-prinsip umum/penting/sukses.
- ...pilihanmu
Mengapa standar pengembangan 1C yang ada tidak membantu?
Mari kita lihat prinsip-prinsip yang diterbitkan pada disk ITS dan dalam berbagai “Panduan Pengembang...” yang direkomendasikan saat menulis formulir terkelola.- Minimalkan jumlah panggilan server.
- Komputasi maksimal di server.
- Panggilan server non-kontekstual lebih cepat daripada panggilan kontekstual.
- Program dengan mempertimbangkan komunikasi klien-server.
- dan seterusnya.
Pola desain atau kebijaksanaan generasi
Interaksi klien-server telah digunakan dalam berbagai teknologi perangkat lunak selama beberapa dekade. Jawaban atas pertanyaan-pertanyaan yang diuraikan pada bagian sebelumnya telah lama diketahui dan dirangkum dalam dua prinsip dasar.- Fasad Jarak Jauh(selanjutnya disebut Antarmuka Akses Jarak Jauh)
- Objek Transfer Data(selanjutnya disebut Objek Transfer Data)
- … Setiap objek yang berpotensi dimaksudkan untuk akses jarak jauh harus memilikinya antarmuka granularitas rendah, yang akan meminimalkan jumlah panggilan yang diperlukan untuk melakukan prosedur tertentu. ... Daripada meminta faktur dan semua itemnya secara terpisah, Anda perlu membaca dan memperbarui semua item faktur dalam satu permintaan. Hal ini mempengaruhi seluruh struktur objek...Ingat: antarmuka akses jarak jauh tidak mengandung logika domain.
- ...jika saya seorang ibu yang peduli, saya pasti akan memberi tahu anak saya: “Jangan pernah menulis objek transfer data!” Dalam kebanyakan kasus, objek transfer data tidak lebih dari itu kumpulan bidang yang membengkak... Nilai monster menjijikkan ini hanya terletak pada kemungkinannya mengirimkan banyak informasi melalui jaringan dalam satu panggilan- suatu teknik yang sangat penting untuk sistem terdistribusi.
Contoh template di platform 1C
Antarmuka pemrograman aplikasi yang tersedia bagi pengembang saat mengembangkan formulir terkelola berisi banyak contoh prinsip-prinsip ini.Misalnya, metode OpenForm(), antarmuka “kasar” yang khas.
OpeningParameters = Struktur Baru("Parameter1, Parameter2, Parameter3", Nilai1, Nilai2, Nilai3); Formulir = OpenForm(FormName, OpeningParameters);
Bandingkan dengan gaya yang diadopsi di v8.1.
Formulir = GetForm(NamaFormulir); Formulir.Parameter1 = Nilai1; Formulir.Parameter2 = Nilai2; Formulir.Terbuka();
Dalam konteks formulir terkelola, ada banyak “Objek Transfer Data”. Anda dapat memilih sistemik Dan ditentukan oleh pengembang.
Sistem memodelkan objek aplikasi pada klien, dalam bentuk satu atau lebih elemen data formulir. Tidak mungkin membuatnya tanpa mengacu pada detail formulir.
- StrukturBentuk Data
- Koleksi DataForms
- DataFormStructureWithCollection
- PohonBentuk Data
- NilaiDalamFormData()
- NilaiDataForm()
- SalinFormData()
- ValueInFormAttributes()
- Nilai Atribut Bentuk()
Contoh 1C v8.1:
// pada klien dalam konteks formulir FillUserCache(DepartmentLink)
Contoh 1C v8.2:
// di server dalam konteks form ProcessingObject = Form AttributesValue("Object"); ProcessingObject.FillUserCache(DepartmentRef); ValueВFormAttributes(ProcessingObject, "Objek");
Objek transfer data, yang strukturnya ditentukan oleh pengembang, adalah sebagian kecil dari tipe yang tersedia di klien dan server. Paling sering, berikut ini digunakan sebagai parameter dan hasil metode antarmuka "kasar":
- Tipe primitif (string, angka, boolean)
- Struktur
- Korespondensi
- Himpunan
- Tautan ke objek aplikasi (pengidentifikasi unik dan representasi teks)
&OnServerWithoutContext Fungsi ServerChangeOrderStatus(Pesanan, Status Baru) Kesalahan = Kecocokan Baru(); // [pesanan] [deskripsi kesalahan] Untuk Setiap Pesanan Dari Siklus Pesanan StartTransaction(); Coba DocOb = Order.GetObject(); …. tindakan lain, mungkin tidak hanya dengan perintah... Pengecualian CancelTransaction(); Errors.Insert(Pesanan, ErrorDescription()); Percobaan Akhir; Siklus Akhir; Kesalahan Pengembalian; Fungsi Akhir // ServerChangeOrderStatus()
Penataan kode
Tujuan utama yang harus dicerminkan oleh modul formulir terkelola dan pendekatan terhadap solusinya.- Pemisahan yang jelas antara kode klien dan server. Jangan lupa bahwa pada saat eksekusi, ini adalah dua proses yang saling berinteraksi, yang masing-masing memiliki fungsionalitas berbeda secara signifikan.
- Identifikasi yang jelas pada antarmuka akses jarak jauh, metode server mana yang dapat dipanggil dari klien dan mana yang tidak? Nama metode antarmuka jarak jauh dimulai dengan awalan "Server". Hal ini memungkinkan Anda untuk segera melihat transfer kendali ke server saat membaca kode, dan menyederhanakan penggunaan bantuan kontekstual. Perhatikan bahwa rekomendasi resmi (ITS) menyarankan metode penamaan dengan postfix, misalnya, ChangeOrderStatusOnServer(). Namun, kami ulangi bahwa tidak semua metode server dapat dipanggil dari klien, dan oleh karena itu aksesibilitas logis lebih penting, daripada lokasi kompilasi. Oleh karena itu, dengan awalan “Server” kita hanya menandai metode yang tersedia untuk klien; sebut saja contoh metode ServerChangeOrderStatus().
- Keterbacaan. Soal selera, kami menerima pesanan ketika modul dimulai dengan prosedur pembuatan formulir di server dan metode akses jarak jauh.
- Pemeliharaan. Harus ada lokasi yang jelas untuk menambahkan kode baru. Poin pentingnya adalah templat metode yang dibuat secara otomatis oleh konfigurator ditambahkan ke akhir modul. Karena event handler untuk elemen formulir paling sering dibuat secara otomatis, blok terkait ditempatkan terakhir agar tidak menyeret setiap handler ke tempat lain dalam modul.
- Opsi grafis – dengan jelas menunjukkan alur utama eksekusi.
- Opsi teks adalah contoh desain templat untuk menyisipkan struktur dengan cepat ke dalam modul formulir baru.
//////////////////////////////////////////////////////////////////////////////// // <(c) Автор=""Tanggal =""/> // <Описание> // // ////////////////////////////////////////////////// // //////////////////////////// // VARIABEL MODUL ///////////////// // /////////////////////////////////////////////// //// ////////// // DI SERVER //******* ACARA DI SERVER ******* &Di Server Prosedur Saat Dibuat di Server (Kegagalan, Pemrosesan Standar) / /Masukkan isi handler Akhir Prosedur //******* ANTARMUKA AKSES REMOTE ******* //******* LOGIKA BISNIS PADA SERVER ******* ///////// ////////////////////////////////////////// /////// ///////////////////// // METODE UMUM KLIEN DAN SERVER /////////////// /////// //////////////////////////////////////////// ///// //////// // PADA KLIEN //******* LOGIKA BISNIS PADA KLIEN ******* //******* TIM * ****** //******* ACARA KLIEN ******* /////////////////////////// ///// ////////////////////////////////////////////// // / / OPERATOR PROGRAM UTAMA
Pertanyaan-pertanyaan Terkait
Sebagai kesimpulan, kami akan menguraikan beberapa area yang berguna untuk dipikirkan ketika memprogram interaksi klien-server.- Opsi implementasi antarmuka akses jarak jauh. Asinkroni, tingkat detail...
- cache. 1C membuat keputusan arsitektur yang gagal, memperkenalkan caching hanya pada tingkat metode pemanggilan modul umum dan tidak menyediakan kemampuan kontrol (waktu relevansi, reset sesuai permintaan).
- Panggilan server implisit. Jangan lupa tentang fitur teknologi; banyak operasi “tidak berbahaya” pada klien memicu platform untuk menghubungi server.
Formulir di 1C:Enterprise dimaksudkan untuk menampilkan dan mengedit informasi yang terdapat dalam database. Formulir dapat dimiliki oleh objek konfigurasi tertentu atau ada secara terpisah dari objek tersebut dan digunakan oleh seluruh solusi aplikasi.
Misalnya, direktori Tata nama mungkin memiliki beberapa bentuk yang akan digunakan untuk tujuan tertentu - mengedit elemen direktori, menampilkan daftar, dll.:
Bersamaan dengan ini, mungkin ada bentuk-bentuk umum yang tidak termasuk dalam objek konfigurasi tertentu - bentuk-bentuk umum.
Bentuk dasar
Setiap objek konfigurasi dapat digunakan untuk melakukan beberapa tindakan standar. Misalnya, untuk direktori mana pun, Anda mungkin perlu menampilkan daftar elemennya, menampilkan elemen individual direktori, menampilkan grup direktori, memilih elemen dan grup elemen dari direktori. Untuk dokumen apa pun, daftar tindakan tersebut akan jauh lebih kecil: melihat daftar dokumen, memilih dari daftar dokumen, dan melihat dokumen terpisah.
Untuk memastikan bahwa tindakan standar tersebut dilakukan dengan data objek solusi aplikasi, untuk masing-masing objek terdapat serangkaian formulir dasar yang akan digunakan saat melakukan tindakan terkait. Bentuk apa pun yang berada di bawah objek ini dapat ditetapkan sebagai bentuk utama. Misalnya pada direktori Tata nama Bentuk dasar berikut mungkin ada:
Dan dokumennya Penerimaan barang dan jasa komposisi bentuk utama akan berbeda:
Jadi, jika pengguna ingin melihat daftar direktori Tata nama atau daftar dokumen Penerimaan barang dan jasa, sistem akan membuka formulir terkait yang ditetapkan sebagai formulir daftar untuk objek ini.
Formulir yang dibuat secara otomatis
Fitur penting dari sistem 1C:Enterprise 8 adalah mekanisme formulir yang dibuat secara otomatis. Mekanisme ini membebaskan pengembang dari keharusan membuat semua kemungkinan formulir untuk setiap objek konfigurasi. Pengembang hanya perlu menambahkan objek konfigurasi baru, dan sistem itu sendiri akan menghasilkan, pada saat yang tepat dalam pekerjaan pengguna, formulir yang diperlukan untuk menampilkan informasi yang terkandung dalam objek ini.
Oleh karena itu, pengembang perlu membuat bentuk objek solusi aplikasinya sendiri hanya jika bentuk tersebut harus memiliki perbedaan (desain atau perilaku spesifik yang berbeda) dari bentuk yang dihasilkan secara otomatis oleh sistem.
Menghubungkan formulir ke data
Apakah suatu formulir termasuk dalam objek konfigurasi tertentu tidak menentukan komposisi data yang ditampilkan dalam formulir. Fakta bahwa formulir itu milik, misalnya, milik suatu direktori Tata nama, memungkinkan Anda untuk menetapkannya sebagai salah satu formulir utama untuk direktori ini, tetapi sama sekali tidak menentukan data apa yang akan ditampilkan formulir ini dan bagaimana perilakunya.
Untuk mengaitkan formulir dengan data, detail formulir digunakan, yang menunjukkan daftar data yang ditampilkan oleh formulir. Semua formulir itu sendiri memiliki perilaku yang sama, apa pun data yang ditampilkannya. Namun, salah satu atribut formulir dapat ditetapkan sebagai atribut utama (ditandai dengan huruf tebal), dalam hal ini perilaku standar formulir dan propertinya akan ditambah tergantung pada jenis atribut formulir utama:
Misalnya, jika suatu dokumen ditetapkan sebagai atribut formulir utama Penerimaan barang dan jasa, kemudian ketika formulir ditutup, sistem akan meminta konfirmasi pencatatan dan penempatan dokumen ini. Jika Anda menetapkan, katakanlah, direktori sebagai atribut utama formulir Tata nama, maka permintaan konfirmasi tersebut tidak akan muncul saat formulir ditutup.
Struktur bentuk
Fitur utama dari formulir ini adalah bahwa formulir tersebut tidak digambar oleh pengembang secara detail, “piksel demi piksel”. Suatu bentuk dalam konfigurasi adalah deskripsi logis dari komposisi bentuk. Dan penempatan elemen tertentu dilakukan secara otomatis oleh sistem saat formulir ditampilkan.
Bagian formulir yang ditampilkan (terlihat oleh pengguna) digambarkan sebagai pohon yang berisi elemen formulir.
Elemen dapat berupa kolom input, kotak centang, tombol radio, tombol, dll. Selain itu, elemen dapat berupa grup yang menyertakan elemen lain. Grup dapat direpresentasikan sebagai panel dengan bingkai, panel dengan halaman (bookmark), halaman itu sendiri, atau panel perintah. Selain itu, elemen tersebut dapat berupa tabel, yang juga memuat elemen (kolom). Struktur elemen menjelaskan bagaimana bentuk akan terlihat.
Seluruh fungsionalitas formulir dijelaskan dalam bentuk detail dan perintah. Detail adalah data yang digunakan formulir, dan perintah adalah tindakan yang harus dilakukan. Oleh karena itu, pengembang di editor formulir harus menyertakan detail dan perintah yang diperlukan dalam formulir, membuat elemen formulir yang menampilkannya, dan, jika perlu, menyusun elemen ke dalam grup.
Berdasarkan uraian logis ini, sistem secara otomatis menghasilkan tampilan formulir untuk ditampilkan kepada pengguna. Dalam hal ini, sistem memperhitungkan berbagai properti data yang ditampilkan (misalnya, tipe) untuk mengatur elemen formulir senyaman mungkin bagi pengguna.
Pengembang dapat mempengaruhi susunan elemen dengan berbagai pengaturan. Itu dapat menentukan urutan elemen, menentukan lebar dan tinggi yang diinginkan. Namun, ini hanyalah beberapa informasi tambahan untuk membantu sistem menampilkan formulir.
Dalam formulir, pengembang tidak hanya dapat menggunakan perintah formulir itu sendiri, tetapi juga perintah global yang digunakan dalam antarmuka perintah seluruh konfigurasi. Selain itu, dimungkinkan untuk membuat perintah yang dapat diparameterisasi yang akan membuka formulir lain dengan mempertimbangkan data spesifik dari formulir saat ini. Misalnya, ini bisa berupa pemanggilan laporan saldo di gudang yang saat ini dipilih dalam formulir faktur.
Kita semua tahu bahwa perusahaan 1C memiliki banyak versi berbeda dari platform 1C, sekarang kita akan tertarik pada salah satu versi terbaru pada saat penulisan artikel ini, yaitu versi 1C 8.2 dan 1C 8.3. Jika Anda harus bekerja di kedua versi ini, kemungkinan besar Anda memperhatikan perbedaan dalam antarmuka versi ini, bagi pengguna mereka hanya berbeda dalam tampilannya saja. Pada dasarnya sebuah pilihan aplikasi reguler atau terkelola memberi tahu sistem formulir mana yang akan ditampilkan untuk dijalankan, teratur atau terkendali, serta klien aplikasi mana yang akan digunakan secara default, tebal atau tipis. Untuk informasi lebih detail tentang klien, baca artikel “Apa itu klien tebal dan tipis di 1C, serta perbedaannya.”
Aplikasi 1C reguler (formulir reguler, antarmuka reguler, versi 1C 8.2)
Di 1C 8.2 hanya dimungkinkan untuk bekerja dengan formulir biasa, dalam mode aplikasi reguler. Gambar di bawah menunjukkan database dalam mode operasi "aplikasi 1C biasa" (bentuk biasa).
Aplikasi 1C terkelola (formulir terkelola, antarmuka terkelola, versi 1C 8.3)
Pada platform 1C 8.3 kita dapat bekerja dengan formulir reguler (dalam mode kompatibilitas) dan formulir terkelola. Lebih-lebih lagi formulir terkelola memiliki dua jenis tampilan, yaitu standar dan taksi. Contoh konfigurasi 1C 8.3 dengan formulir terkelola standar ditunjukkan di bawah ini, dan setelahnya antarmuka “Taksi” ditampilkan.
Apa perbedaan antara aplikasi 1C biasa dan terkelola?
Seperti yang telah kita ketahui aplikasi biasa dan aplikasi terkelola adalah jenis peluncuran program 1C. Selain itu, tergantung pada nilai jenis peluncuran 1C ( aplikasi reguler atau terkelola), antarmuka tertentu akan dimuat secara default ( formulir reguler atau terkelola), maka ada begitu banyak sinonim untuk konsep ini. Kami ingin mencatat bahwa perbedaan antarmuka cukup signifikan; antarmuka terkelola telah didesain ulang sepenuhnya. Pada prinsipnya, inilah semua perbedaan yang dilihat oleh pengguna biasa program 1C. Sedangkan untuk pemrogram, antarmuka yang dikelola memerlukan penulisan kode yang dimodifikasi, karena pengembangan sudah dilakukan di 1C 8.3, dan bukan di 1C 8.2, maka semua konsekuensi berikutnya. Kode juga harus dibagi menjadi klien dan server, ini ditunjukkan dengan menggunakan arahan yang sesuai di konfigurator.
Klyuev V.V.
http://prof1c.kklab.ru
BEKERJA DENGAN SWITCH
Harap pertimbangkan semua pengguna layanan situs - Saya memposting materi di bagian Pemula!!!
8.2 Formulir yang dikelola
Saat mempelajari perilaku formulir terkelola, pemrogram atau pengembang antarmuka dihadapkan pada pertanyaan di mana sakelar berada dalam formulir terkelola dan bagaimana cara menambahkannya ke formulir. Ini adalah hal kecil, tetapi tidak menyenangkan bahwa banyak waktu dihabiskan untuk hal-hal sepele seperti itu, meskipun waktu ini dapat dihabiskan untuk mengembangkan dan mengoptimalkan algoritma daripada mendesain formulir.
Jadi, mari buat konfigurasi kosong untuk memahami pertanyaannya, atau pilih konfigurasi umum.
Buka grup yang berisi direktori, dan tambahkan direktori baru untuk bereksperimen. Saya ingin mencatat bahwa konfigurasi harus memiliki mode peluncuran utama - Aplikasi Terkelola.
Jadi, mari kita buat direktori baru dan tambahkan atribut "Property1", dengan tipe "Boolean"
Sekarang mari pergi ke tab Formulir dan tambahkan formulir baru.
Jadi, formulir yang dikontrol telah dibuat, sekarang mari bekerja dengan formulir tersebut dan temukan di mana saklar berada.
Ini formulir kita, dan di atasnya kita melihat alat peraga kita, tetapi dalam bentuk bendera
Jadi apa kesalahan kita?
Mari kita lihat properti props untuk melihat apakah ada peralihan ke tipe kontrol.
Dan kita melihat bahwa bidang Switch tidak ada di sini! (Di mana kesalahan kita?
Ternyata tipe kontrol pada form bergantung pada tipe datanya, mari kita kembali ke properti form yaitu tab detail, dan ubah properti atribut kita - yaitu tipenya "Boolean", menjadi tipe "Nomor". ”.
Sekarang mari kita kembali ke properti kontrol dan memeriksa apakah Tampilan kontrol telah ditambahkan ke propertinya - - - Dan hore, kita melihat tampilan di sana - Switch Field.
Sekarang lihat bentuknya, apa yang kita lihat:
Kita melihat - 3 nilai default, 3 sakelar, tetapi kita memerlukan dua di antaranya, buka lagi properti atribut, dan lihat properti "Jumlah kolom" di sana
Untuk 2 - atur Jumlah kolom - 2.
Ini mungkin akan menghentikan programmer yang lelah sedikit)), tetapi sekarang dia dan kita mengetahuinya!
8.2 Formulir reguler.
Membosankan dengan sakelar dalam bentuk biasa.
Ada saat-saat seperti itu, dan itu memang terjadi) ketika Anda perlu memodifikasi beberapa formulir yang sudah jadi, yang sudah memiliki beberapa sakelar, dan Anda perlu menambahkan sakelar lain ke formulir ini. Di sinilah muncul semacam kebosanan, yang membutuhkan banyak waktu, dan bukan waktu untuk memprogram kode - tetapi membuang-buang waktu untuk menampilkan sakelar ini kepada pengguna.
Jadi mari kita lihat sebuah contoh. Ada dokumen penyesuaian kuitansi di UPP 1C - pasti ada. Kami pernah perlu menambahkan saklar ke dalamnya sehingga entri akuntansi yang sedikit berbeda akan diambil. Apa masalahnya, sepertinya kita harus, kita harus, kita lakukan. Namun form ini sudah memiliki 2 radio button.
Ini adalah bentuk di mana kita perlu menambahkan lebih banyak saklar
Pada tab Advanced, kami ingin menempatkan dua tombol radio lagi. Jadi langkah pertama adalah dengan berani menambahkan elemen kontrol baru ke tempat yang kita perlukan dan memasukkannya.
Tampaknya semuanya sederhana. Kami membuat atribut baru dengan tipe "Nomor" dan memasukkan 2 sakelar, salah satunya dapat menulis data ke atribut tersebut, dan yang lainnya tidak.
Tambahkan elemen kontrol baru - Sakelar, tambahkan Sakelar2 pada tabel dengan nomor dan deskripsi sakelar, atur Sakelar1 terlebih dahulu di grup dan tekan OK. Tempatkan kontrol yang dibuat pada formulir. Kami memperbarui konfigurasi database (F7) dan menjalankannya untuk debugging.
Saat menjalankan (saat membuat dokumen baru dalam mode 1C:Enterprise), kami melihat bahwa tidak peduli seberapa keras kami mencoba mengklik Switch2, tidak ada yang terjadi. Elemen-elemennya tidak berfungsi sebagaimana mestinya. Ada satu trik di sini.
Kembali ke konfigurator. Pilih item menu Formulir -> Atur urutan traversal... (penting agar formulir terbuka di layar)
Agar Switch kami dapat berfungsi, Anda harus membatalkan pesanan otomatis dan menyetujui pesanan manual. Dan letakkan dalam bentuk sehingga saklar kita berjalan satu demi satu secara berurutan.
OKE. Perbarui konfigurasi dan coba jalankan.
Besar. Semuanya berhasil.
Selain itu - video (tanpa suara, jadi semuanya jelas)
