Unduh HTML FormFu - Unduh Kode Sumber HTML FormFu

RINGKASAN

Catatan: Contoh -contoh ini memanfaatkan html :: formfu :: model :: dbic. Pada HTML::FormFu v02.005, html :: Formfu :: Model :: DBIC Modul tidak dibundel dengan HTML::FormFu dan tersedia dalam distribusi yang berdiri sendiri.

 use HTML::FormFu;

my $form = HTML::FormFu->new;

$form->load_config_file('form.yml');

$form->process( $cgi_query );

if ( $form->submitted_and_valid ) {
    # do something with $form->params
}
else {
    # display the form
    $template->param( form => $form );
}

Jika Anda menggunakan Catalyst, contoh yang lebih cocok mungkin:

 package MyApp::Controller::User;
use Moose;
extends 'Catalyst::Controller::HTML::FormFu';

sub user : Chained CaptureArgs(1) {
    my ( $self, $c, $id ) = @_;

    my $rs = $c->model('Schema')->resultset('User');

    $c->stash->{user} = $rs->find( $id );

    return;
}

sub edit : Chained('user') Args(0) FormConfig {
    my ( $self, $c ) = @_;

    my $form = $c->stash->{form};
    my $user = $c->stash->{user};

    if ( $form->submitted_and_valid ) {

        $form->model->update( $user );

        $c->res->redirect( $c->uri_for( "/user/$id" ) );
        return;
    }

    $form->model->default_values( $user )
        if ! $form->submitted;

}

Catatan: Karena "proses" secara otomatis dipanggil untuk Anda oleh pengontrol katalis; Jika Anda membuat modifikasi pada formulir dalam metode tindakan Anda, seperti menambahkan atau mengubah elemen, menambahkan kendala, dll; Anda harus memanggil "Proses" lagi sendiri sebelum menggunakan "Submited_and_valid", salah satu metode yang tercantum di bawah "Nilai Formulir dan Kesalahan yang Dikirim" atau "memodifikasi formulir yang dikirimkan", atau membuat formulir.

Berikut adalah contoh file konfigurasi untuk membuat formulir login dasar (semua contoh di sini adalah YAML, tetapi Anda dapat menggunakan format apa pun yang didukung oleh Config :: Any), Anda juga dapat membuat formulir secara langsung dalam kode Perl Anda, daripada menggunakan file konfigurasi eksternal.

 ---
action: /login
indicator: submit
auto_fieldset: 1

elements:
  - type: Text
    name: user
    constraints:
      - Required

  - type: Password
    name: pass
    constraints:
      - Required

  - type: Submit
    name: submit

constraints:
  - SingleValue

KETERANGAN

HTML :: FormFu adalah kerangka kerja formulir HTML yang bertujuan semudah mungkin digunakan untuk formulir web dasar, tetapi dengan kekuatan dan fleksibilitas untuk melakukan hal lain yang mungkin ingin Anda lakukan (selama itu melibatkan bentuk).

Anda dapat mengonfigurasi hampir semua bagian dari perilaku dan output Formfu. Secara default FormFu membuat markup yang sesuai "xhtml 1.0 ketat", dengan markup tambahan sesedikit mungkin, tetapi dengan nama kelas CSS yang cukup untuk memungkinkan berbagai gaya output untuk dihasilkan dengan hanya mengubah CSS.

Semua metode yang tercantum di bawah ini (kecuali "baru") dapat dipanggil sebagai metode normal pada objek $form Anda, atau sebagai opsi dalam file konfigurasi Anda. Contohnya terutama akan ditampilkan dalam Sintaks Konfigurasi YAML.

Dokumentasi ini mengikuti konvensi bahwa argumen metode yang dikelilingi oleh kurung persegi [] adalah opsional , dan semua argumen lain diperlukan.

Membangun formulir

baru

Argumen: [%opsi]

Nilai pengembalian: $ form

Buat objek html :: formfu baru.

Metode apa pun yang dapat dipanggil pada objek html :: Formfu malah dapat dilewati sebagai argumen untuk "baru".

 my $form = HTML::FormFu->new({
    action        => '/search',
    method        => 'GET',
    auto_fieldset => 1,
});

load_config_file

Argumen: $ fileName

Argumen: @FileNames

Nilai pengembalian: $ form

Menerima nama file atau daftar nama file, yang filetypesnya harus dari format apa pun yang dikenali oleh config :: apapun.

Konten setiap file konfigurasi diteruskan ke "Populate", dan begitu juga ditambahkan ke formulir.

"LOAD_CONFIG_FILE" dapat dipanggil dalam file konfigurasi itu sendiri, sehingga memungkinkan pengaturan umum disimpan dalam satu file konfigurasi yang dapat dimuat oleh formulir apa pun.

 ---
load_config_file:
  - file1
  - file2

Yaml beberapa dokumen dalam satu file. Penanda Mulai Dokumen adalah garis yang berisi 3 tanda hubung. Beberapa dokumen akan diterapkan secara berurutan, sama seperti beberapa nama file telah diberikan.

Dalam contoh berikut, beberapa dokumen dimanfaatkan untuk memuat file konfigurasi lain setelah elemen ditambahkan. (Jika ini adalah satu dokumen, load_config_file akan dipanggil sebelum elements , terlepas dari posisinya dalam file).

 ---
elements:
  - name: one
  - name: two

---
load_config_file: ext.yml

Jalur relatif diselesaikan dari direktori "config_file_path" jika diatur, jika tidak dari direktori kerja saat ini.

Lihat "Praktik Terbaik" untuk saran tentang mengatur file konfigurasi.

config_callback

Argumen: Opsi %

Jika didefinisikan, argumen digunakan untuk membuat data :: pengunjung :: callback objek selama "load_config_file" yang dapat digunakan untuk pra-pemrosesan konfigurasi sebelum dikirim untuk "mengisi".

Misalnya, kode di bawah ini menambahkan panggilan balik ke formulir yang secara dinamis akan mengubah nilai konfigurasi yang berakhir di ".yml" untuk mengakhiri ".yaml" saat Anda menyebut "load_config_file":

 $form->config_callback({
  plain_value => sub {
    my( $visitor, $data ) = @_;
    s/.yml/.yaml/;
  }
});

Nilai default: tidak ditentukan

Metode ini adalah 'aksesor warisan' khusus, yang berarti dapat diatur pada formulir, elemen blok atau elemen tunggal. Ketika nilai dibaca, jika tidak ada nilai yang didefinisikan secara otomatis melintasi hierarki elemen orang tua, melalui elemen blok apa pun dan hingga formulir, mencari nilai yang ditentukan.

mendiami

Argumen: Opsi %

Nilai pengembalian: $ form

Setiap kunci/nilai opsi yang dilewati dapat berupa html :: Formfu metode-nama dan argumen.

Memberikan cara sederhana untuk mengatur beberapa nilai, atau menambahkan beberapa elemen ke formulir dengan panggilan metode tunggal.

Upaya untuk memanggil nama-nama metode dalam urutan semi-cerdas (lihat sumber populasi () dalam HTML::FormFu::ObjectUtil untuk detailnya).

Default_values

Argumen: %default

Nilai pengembalian: $ form

Atur nilai default beberapa bidang dari satu-ref hash.

Kunci hash-ref sesuai dengan nama bidang formulir, dan nilainya diteruskan ke metode default lapangan.

Ini harus dipanggil setelah semua bidang telah ditambahkan ke formulir, dan sebelum "proses" disebut (jika tidak, panggilan "proses" lagi sebelum memberikan formulir).

config_file_path

Argumen: $ Directory_name

"config_file_path" mendefinisikan di mana file konfigurasi akan dicari, jika jalur absolut tidak diberikan untuk "load_config_file".

Nilai default: tidak ditentukan

Adalah aksesor yang mewarisi.

indikator

Argumen: $ field_name

Argumen: & coderef

Jika "indikator" diatur ke FieldName, "dikirimkan" akan mengembalikan true jika nilai untuk FieldName diajukan.

Jika "indikator" diatur ke ref-ref, itu akan disebut sebagai subrutin dengan dua argumen $form dan $query , dan nilai pengembaliannya akan digunakan sebagai nilai pengembalian untuk "dikirimkan".

Jika "indikator" tidak ditetapkan, "dikirimkan" akan mengembalikan true jika nilai untuk FieldName yang diketahui diajukan.

auto_fieldset

Argumen: 1

Argumen: Opsi %

Nilai Pengembalian: $ Fieldset

Pengaturan ini cocok untuk sebagian besar bentuk dasar, dan berarti Anda umumnya dapat mengabaikan penambahan bidang sendiri.

Memanggil $form->auto_fieldset(1) Segera menambahkan elemen fieldset ke formulir. Setelah itu, $form->elements() akan menambahkan semua elemen (kecuali bidang) ke bidang tersebut, bukan langsung ke formulir.

Agar spesifik, elemen ditambahkan ke bidang terakhir pada formulir, jadi jika Anda menambahkan bidang lain, elemen lebih lanjut akan ditambahkan ke bidang tersebut.

Juga, Anda dapat melewati hashref ke auto_fieldset (), dan ini akan digunakan untuk mengatur default untuk bidang pertama yang dibuat.

Beberapa contoh dan outputnya, untuk menunjukkan:

2 elemen tanpa bidang.

 ---
elements:
  - type: Text
    name: foo
  - type: Text
    name: bar

<form action="" method="post">
  <div class="text">
    <input name="foo" type="text" />
  </div>
  <div class="text">
    <input name="bar" type="text" />
  </div>
</form>

2 elemen dengan "auto_fieldset".

 ---
auto_fieldset: 1
elements:
  - type: Text
    name: foo
  - type: Text
    name: bar

<form action="" method="post">
  <fieldset>
    <div class="text">
      <input name="foo" type="text" />
    </div>
    <div class="text">
      <input name="bar" type="text" />
    </div>
  </fieldset>
</form>

Elemen ke -3 berada dalam bidang baru

 ---
auto_fieldset: { id: fs }
elements:
  - type: Text
    name: foo
  - type: Text
    name: bar
  - type: Fieldset
  - type: Text
    name: baz

<form action="" method="post">
  <fieldset id="fs">
    <div class="text">
      <input name="foo" type="text" />
    </div>
    <div class="text">
      <input name="bar" type="text" />
    </div>
  </fieldset>
  <fieldset>
    <div class="text">
      <input name="baz" type="text" />
    </div>
  </fieldset>
</form>

Karena perilaku ini, jika Anda ingin bidang bersarang Anda harus menambahkan setiap bidang bersarang langsung ke orang tua yang dimaksud.

 my $parent = $form->get_element({ type => 'Fieldset' });

$parent->element('fieldset');

form_error_message

Argumen: $ String

Biasanya, kesalahan input menyebabkan pesan kesalahan ditampilkan di samping bidang formulir yang sesuai. Jika Anda juga ingin pesan kesalahan umum ditampilkan di bagian atas formulir, Anda dapat mengatur pesan dengan "form_error_message".

Untuk mengatur kelas CSS untuk pesan, lihat "Form_error_message_class".

Untuk mengubah markup yang digunakan untuk menampilkan pesan, edit file template form_error_message . Lihat "render_method".

Adalah aksesor output.

force_error_message

Jika benar, memaksa "form_error_message" untuk ditampilkan bahkan jika tidak ada kesalahan lapangan.

default_args

Argumen: %default

Tetapkan default yang akan ditambahkan ke setiap elemen, kendala, dll. Dari tipe yang diberikan yang kemudian ditambahkan ke formulir.

Misalnya, untuk membuat setiap elemen Text secara otomatis memiliki ukuran 10 , dan membuat setiap deflator Strftime secara otomatis mendapatkan STRFTime diatur ke %d/%m/%Y :

 default_args:
    elements:
        Text:
            size: 10
    deflators:
        Strftime:
            strftime: '%d/%m/%Y'

Contoh untuk membuat semua elemen datetime secara otomatis mendapatkan deflator strftime yang sesuai dan inflator datetime:

 default_args:
    elements:
        DateTime:
            deflators:
                type: Strftime
                strftime: '%d-%m-%Y'
            inflators:
                type: DateTime
                parser:
                    strptime: '%d-%m-%Y'

Jenis semu

Sebagai kasus khusus, Anda juga dapat menggunakan Block kunci elements , Field , dan Input untuk mencocokkan elemen apa pun yang mewarisi dari html :: formfu :: elemen :: blok atau does html :: formfu :: role :: element :: field atau html :: Formfu :: role :: elemen :: input.

Alternatif

Setiap kunci elements dapat berisi daftar any menggunakan | Divider: Misalnya

 # apply the given class to any Element of type Password or Button
default_args:
    elements:
        'Password|Button':
            attrs:
                class: novalidate

Cocokkan leluhur

Setiap elements daftar kunci dapat berisi jenis yang dimulai dengan + untuk hanya mencocokkan elemen dengan leluhur jenis yang diberikan: misalnya

 # only apple the given class to an Input field within a Multi block
default_args:
    elements:
        'Input|+Multi':
            attrs:
                class: novalidate

Jangan cocok dengan leluhur

Setiap elements daftar kunci dapat berisi jenis yang dimulai dengan - untuk hanya mencocokkan elemen yang tidak memiliki leluhur dari jenis yang diberikan: misalnya

 # apply the given class only to Input fields that are not in a Multi block
default_args:
    elements:
        'Input|-Multi':
            attrs:
                class: validate

Memesan

Argumen diterapkan dalam urutan terkecil hingga paling spesifik: Block , Field , Input , $type . Dalam masing-masing ini, argumen diterapkan dalam urutan terpendek pertama ke terlama.

Kunci type harus cocok dengan nilai yang dikembalikan berdasarkan type , misalnya "Type" dalam html :: Formfu :: Element. Jika, misalnya, Anda memiliki elemen khusus di luar HTML::FormFu::Element::* namespace, yang Anda muat melalui $form->element({ type => '+My::Custom::Element' }) , kunci yang diberikan untuk "default_args" tidak boleh termasuk yang terkemuka + , seperti yang dikeluarkan dari nilai type() dikembalikan. Contoh:

 # don't include the leading '+' here
default_args:
    elements:
        'My::Custom::Element':
            attrs:
                class: whatever

# do include the leading '+' here
elements:
    - type: +My::Custom::Element

Bentrokan

"Default_args" menghasilkan satu hashref untuk dilewati untuk "mengisi", menggabungkan argumen untuk setiap jenis secara bergantian - yang berarti "populasi" hanya disebut sekali secara total - tidak sekali untuk setiap jenis. Karena nilai skalar tidak digabungkan - ini berarti nilai -nilai nanti akan mengganti nilai -nilai sebelumnya: misalnya

 # Normally, calling $field->add_attrs({ class => 'input' })
# then calling      $field->add_attrs({ class => 'not-in-multi' })
# would result in both values being retained:
#           class="input not-in-multi"
#
# However, default_args() creates a single data-structure to pass once
# to populate(), so any scalar values will overwrite earlier ones
# before they reach populate().
#
# The below example would result in the longest-matching key
# overwriting any others:
#           class="not-in-multi"
#
default_args:
    elements:
        Input:
            add_attrs:
                class: input
        'Input:-Multi':
            add_attrs:
                class: not-in-multi

Kekerasan

Catatan: Tidak seperti metode yang tepat yang memiliki alias, misalnya "elemen" yang merupakan alias untuk "elemen" - kunci yang diberikan kepada default_args harus dari bentuk jamak, misalnya:

 default_args:
    elements:          {}
    deflators:         {}
    filters:           {}
    constraints:       {}
    inflators:         {}
    validators:        {}
    transformers:      {}
    output_processors: {}

Javascript

Jika diatur, isinya akan diterjemahkan dalam tag script , di dalam bagian atas formulir.

javascript_src

Argumen: $ url

Argumen: @urls

Menambahkan tag script untuk setiap URL, segera sebelum bagian "JavaScript".

menyimpan

Argumen: [%private_stash]

Nilai pengembalian: %simpanan

Menyediakan ref hash di mana Anda dapat menyimpan data apa pun yang mungkin ingin Anda kaitkan dengan formulir tersebut.

 ---
stash:
  foo: value
  bar: value

elemen

Argumen: $ type

Argumen: Opsi %

Nilai pengembalian: $ elemen

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @elements

Menambahkan elemen baru ke formulir. Lihat "bidang bentuk inti" di html :: formfu :: elemen dan "elemen inti lainnya" dalam elemen html :: formfu :: untuk daftar elemen inti.

Jika Anda ingin memuat elemen dari namespace selain HTML::FormFu::Element:: , Anda dapat menggunakan nama paket yang sepenuhnya memenuhi syarat dengan mengawali dengan + .

 ---
elements:
  - type: +MyApp::CustomElement
    name: foo

Jika suatu type tidak disediakan dalam %options , Text default akan digunakan.

"Elemen" adalah alias untuk "elemen".

deflator

Argumen: $ type

Argumen: Opsi %

Nilai Pengembalian: $ Deflator

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @deflators

Deflator dapat dikaitkan dengan bidang formulir apa pun, dan memungkinkan Anda untuk menyediakan $ field-> default dengan nilai yang mungkin menjadi objek.

Jika suatu objek tidak merangkai ke nilai yang sesuai untuk tampilan, deflator dapat memastikan bahwa bidang formulir menerima nilai string yang sesuai sebagai gantinya.

Lihat "Core Deflators" di html :: formfu :: deflator untuk daftar deflator inti.

Jika atribut name tidak disediakan, deflator baru dibuat untuk dan ditambahkan ke setiap bidang pada formulir.

Jika Anda ingin memuat deflator dalam namespace selain HTML::FormFu::Deflator:: , Anda dapat menggunakan nama paket yang memenuhi syarat dengan mengawali dengan + .

"Deflator" adalah alias untuk "Deflators".

insert_before

Argumen: $ new_element, $ existed_element

Nilai pengembalian: $ new_element

Argumen pertama harus menjadi elemen yang ingin Anda tambahkan, argumen ke -2 harus menjadi elemen yang ada yang harus ditempatkan elemen baru sebelumnya.

 my $new = $form->element(%specs);

my $position = $form->get_element({ type => $type, name => $name });

$form->insert_before( $new, $position );

Pada baris pertama dari contoh di atas, elemen $new awalnya ditambahkan ke akhir formulir. Namun, metode insert_before reparents $new , sehingga tidak akan lagi berada di ujung formulir. Karena itu, jika Anda mencoba menyalin elemen dari satu formulir ke yang lain, itu akan 'mencuri' elemen, alih -alih menyalinnya. Dalam hal ini, Anda harus menggunakan clone :

 my $new = $form1->get_element({ type => $type1, name => $name1 })
                ->clone;

my $position = $form2->get_element({ type => $type2, name => $name2 });

$form2->insert_before( $new, $position );

insert_after

Argumen: $ new_element, $ existed_element

Nilai pengembalian: $ new_element

Argumen pertama harus menjadi elemen yang ingin Anda tambahkan, argumen ke -2 harus menjadi elemen yang ada yang harus ditempatkan elemen baru.

 my $new = $form->element(%specs);

my $position = $form->get_element({ type => $type, name => $name });

$form->insert_after( $new, $position );

Pada baris pertama dari contoh di atas, elemen $new awalnya ditambahkan ke akhir formulir. Namun, metode insert_after reparents $new , sehingga tidak akan lagi berada di ujung formulir. Karena itu, jika Anda mencoba menyalin elemen dari satu formulir ke yang lain, itu akan 'mencuri' elemen, alih -alih menyalinnya. Dalam hal ini, Anda harus menggunakan clone :

 my $new = $form1->get_element({ type => $type1, name => $name1 })
                ->clone;

my $position = $form2->get_element({ type => $type2, name => $name2 });

$form2->insert_after( $new, $position );

lepaskan_element

Argumen: $ elemen

Nilai pengembalian: $ elemen

Menghapus $element dari formulir anak atau blok anak -anak.

 $form->remove_element( $element );

Elemen yatim tidak dapat digunakan secara bermanfaat untuk apa pun sampai dipasang kembali ke formulir atau blok dengan "insert_before" atau "insert_after".

Membentuk logika dan validasi

HTML :: FormFu menyediakan beberapa tahapan untuk apa yang secara tradisional digambarkan sebagai validasi . Ini adalah:

Html :: formfu :: filter
Html :: formfu :: Constrain
Html :: formfu :: inflator
Html :: formfu :: validator
Html :: formfu :: transformer

Tahap pertama, filter, memungkinkan pembersihan input pengguna, seperti pengkodean, atau menghapus whitespace terkemuka/trailing, atau menghapus karakter non-digit dari nomor kartu kredit.

Semua tahap berikut memungkinkan pemrosesan yang lebih kompleks, dan masing -masing memiliki mekanisme untuk memungkinkan pengecualian dilemparkan, untuk mewakili kesalahan input. Di setiap tahap, semua bidang bentuk harus diproses tanpa kesalahan untuk tahap berikutnya untuk melanjutkan. Jika ada kesalahan, formulir harus ditampilkan kembali kepada pengguna, untuk memungkinkan mereka memasukkan nilai yang benar.

Kendala dimaksudkan untuk validasi nilai tingkat rendah, seperti "Apakah ini bilangan bulat?", "Apakah nilai ini dalam batas?" atau "Apakah ini alamat email yang valid?".

Inflator dimaksudkan untuk memungkinkan nilai diubah menjadi objek yang sesuai. Objek yang dihasilkan akan diteruskan ke validator dan transformer berikutnya, dan juga akan dikembalikan oleh "params" dan "param".

Validator dimaksudkan untuk validasi tingkat yang lebih tinggi, seperti kendala bisnis-logika dan basis data seperti "Apakah nama pengguna ini unik?". Validator hanya dijalankan jika semua kendala dan inflator berjalan tanpa kesalahan. Diharapkan bahwa sebagian besar validator akan spesifik aplikasi, dan masing-masing akan diimplementasikan sebagai kelas terpisah yang ditulis oleh pengguna HTML :: FormFu.

filter

menyaring

Argumen: $ type

Argumen: Opsi %

Nilai pengembalian: $ filter

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @Filters

Jika Anda memberikan nilai name atau names , filter akan ditambahkan ke bidang yang hanya bernama itu. Jika Anda tidak memberikan nilai name atau names , filter akan ditambahkan ke semua bidang yang sudah dilampirkan ke formulir.

Lihat "Filter Inti" di HTML :: Formfu :: Filter untuk daftar filter inti.

Jika Anda ingin memuat filter dalam namespace selain HTML::FormFu::Filter:: , Anda dapat menggunakan nama paket yang sepenuhnya memenuhi syarat dengan mengawali dengan + .

"Filter" adalah alias untuk "filter".

kendala

Argumen: $ type

Argumen: Opsi %

Nilai pengembalian: $ Batasan

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @constraints

Lihat "Kendala Inti" dalam html :: Formfu :: Batasan untuk daftar kendala inti.

Jika atribut name tidak disediakan, kendala baru dibuat untuk dan ditambahkan ke setiap bidang pada formulir.

Jika Anda ingin memuat kendala dalam namespace selain HTML::FormFu::Constraint:: , Anda dapat menggunakan nama paket yang sepenuhnya memenuhi syarat dengan mengawali dengan + .

"Batasan" adalah alias untuk "kendala".

inflator

Argumen: $ type

Argumen: Opsi %

Nilai pengembalian: $ inflator

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @inflators

Lihat "Inflator Inti" di HTML :: Formfu :: Inflator untuk daftar inflator inti.

Jika atribut name tidak disediakan, inflator baru dibuat untuk dan ditambahkan ke setiap bidang pada formulir.

Jika Anda ingin memuat inflator dalam namespace selain HTML::FormFu::Inflator:: , Anda dapat menggunakan nama paket yang sepenuhnya memenuhi syarat dengan mengawali dengan + .

"Inflator" adalah alias untuk "inflator".

validator

Argumen: $ type

Argumen: Opsi %

Nilai Pengembalian: $ Validator

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @validators

Lihat "Validator Inti" di html :: formfu :: validator untuk daftar validator inti.

Jika atribut name tidak disediakan, validator baru dibuat untuk dan ditambahkan ke setiap bidang pada formulir.

Jika Anda ingin memuat validator dalam namespace selain HTML::FormFu::Validator:: , Anda dapat menggunakan nama paket yang sepenuhnya memenuhi syarat dengan mengawali dengan + .

"Validator" adalah alias untuk "validator".

Transformer

transformator

Argumen: $ type

Argumen: Opsi %

Nilai Pengembalian: $ Transformer

Argumen: @Arrayref_of_types_or_options

Nilai pengembalian: @transformers

Lihat "Core Transformers" dalam html :: formfu :: transformer untuk daftar transformator inti.

Jika atribut name tidak disediakan, transformator baru dibuat untuk dan ditambahkan ke setiap bidang pada formulir.

Jika Anda ingin memuat transformator dalam namespace selain HTML::FormFu::Transformer:: , Anda dapat menggunakan nama paket yang sepenuhnya memenuhi syarat dengan mengawali dengan + .

"Transformer" adalah alias untuk "Transformers".

Mengubah perilaku default

render_processed_value

Perilaku default ketika menampilkan kembali formulir setelah pengiriman, adalah bahwa bidang berisi nilai yang tidak berubah pengguna asli.

Jika "render_processed_value" benar, nilai lapangan akan menjadi hasil akhir setelah semua filter, inflator dan transformator telah dijalankan. Deflator juga akan dijalankan pada nilai.

Jika Anda mengatur ini di bidang dengan inflator, tetapi tanpa deflator yang setara, Anda harus memastikan bahwa inflator merangkai kembali ke nilai yang dapat digunakan, agar tidak membingungkan / mengganggu pengguna.

Nilai default: Salah

Adalah aksesor yang mewarisi.

force_errors

Memaksa kendala gagal, terlepas dari input pengguna.

Jika ini dipanggil saat runtime, setelah formulir telah diproses, Anda harus memanggil "proses" dalam html :: formfu lagi sebelum menampilkan kembali formulir kepada pengguna.

Nilai default: Salah

Metode ini adalah 'aksesor warisan' khusus, yang berarti dapat diatur pada formulir, elemen blok, elemen atau kendala tunggal. Ketika nilai dibaca, jika tidak ada nilai yang didefinisikan secara otomatis melintasi hierarki elemen orang tua, melalui elemen blok apa pun dan hingga formulir, mencari nilai yang ditentukan.

Adalah aksesor yang mewarisi.

params_ignore_underscore

Jika benar, menyebabkan "params", "param" dan "valid" untuk mengabaikan bidang mana pun yang namanya dimulai dengan garis bawah _ .

Bidang masih diproses seperti biasa, dan kesalahan akan menyebabkan "Submited_and_valid" untuk mengembalikan false.

Nilai default: Salah

Atribut bentuk

Semua atribut ditambahkan ke tag mulai formulir yang diberikan.

atribut

 # Example
---
attributes:
  id: form
  class: fancy_form

Adalah pengakses atribut.

pengenal

Adalah atribut pendek-potong.

tindakan

Nilai default: ""

Dapatkan atau atur tindakan yang terkait dengan formulir. Standarnya bukan tindakan, yang menyebabkan sebagian besar browser menyerahkan ke URI saat ini.

Adalah atribut pendek-potong.

enctype

Dapatkan atau atur jenis pengkodean formulir. Nilai yang valid adalah application/x-www-form-urlencoded dan multipart/form-data .

Jika formulir berisi elemen file, enctype secara otomatis diatur ke multipart/form-data .

Adalah atribut pendek-potong.

metode

Nilai default: "Posting"

Dapatkan atau atur metode yang digunakan untuk mengirimkan formulir. Dapat diatur ke "posting" atau "dapatkan".

Adalah atribut pendek-potong.

judul

Dapatkan atau atur atribut judul formulir.

Adalah atribut pendek-potong.

Kelas CSS

form_error_message_class

Atribut kelas untuk pesan kesalahan yang ditampilkan di bagian atas formulir.

Lihat "Form_error_message"

Lokalisasi

bahasa

Argumen: [@ganguages]

Daftar bahasa yang akan diteruskan ke objek lokalisasi.

Nilai default: ['en']

localize_class

Argumen: [$ class_name]

ClassName akan digunakan untuk objek lokalisasi default.

Nilai default: 'html :: formfu :: i18n'

melokalisir

loc

Argumen: [$ key, @arguments]

Kompatibel dengan metode maketext di lokal :: makeText.

lokal

Argumen: $ lokal

Saat ini hanya digunakan oleh html :: formfu :: deflator :: formatNumber dan html :: formfu :: filter :: formatNumber.

Adalah aksesor yang mewarisi.

Memproses formulir

pertanyaan

Argumen: [$ query_object]

Argumen: %params

Berikan objek kueri yang kompatibel dengan CGI atau hash-ref nama/nilai yang dikirimkan. Atau, objek kueri dapat diteruskan langsung ke objek "proses".

query_type

Argumen: [$ query_type]

Atur modul mana yang digunakan untuk memberikan "kueri".

The Catalyst :: Controller :: html :: Formfu secara otomatis mengatur ini menjadi Catalyst .

Nilai yang valid adalah CGI , Catalyst dan CGI::Simple .

Nilai default: 'CGI'

proses

Argumen: [$ query_object]

Argumen: [%params]

Memproses objek kueri atau nilai input yang disediakan. process harus dipanggil sebelum memanggil salah satu metode yang tercantum di bawah "Nilai dan Kesalahan formulir yang dikirimkan" dan "memodifikasi formulir yang dikirimkan".

process juga harus dipanggil setidaknya sekali sebelum mencetak formulir atau memanggil "render" atau "render_data".

Catatan untuk pengguna Catalyst :: Controller :: html :: formfu: karena "proses" secara otomatis dipanggil untuk Anda oleh pengontrol Catalyst; Jika Anda membuat modifikasi pada formulir dalam metode tindakan Anda, seperti menambahkan atau mengubah elemen, menambahkan kendala, dll; Anda harus memanggil "Proses" lagi sendiri sebelum menggunakan "Submited_and_valid", salah satu metode yang tercantum di bawah "Nilai Formulir dan Kesalahan yang Dikirim" atau "memodifikasi formulir yang dikirimkan", atau membuat formulir.

Mengirimkan nilai dan kesalahan formulir

dikirimkan

Mengembalikan true jika formulir telah diajukan. Lihat "Indikator" untuk detail tentang bagaimana ini dihitung.

Subtited_and_valid

SHORTHAND untuk $form->submitted && !$form->has_errors

params

Nilai pengembalian: %params

Mengembalikan ref hash dari semua input yang valid yang tidak ada kesalahan.

param_value

Argumen: $ field_name

Versi "param" yang lebih andal dan disarankan. Dijamin untuk selalu mengembalikan nilai tunggal, terlepas dari apakah itu disebut dalam konteks daftar atau tidak. Jika beberapa nilai diserahkan, ini hanya mengembalikan nilai pertama. Jika nilainya tidak valid atau formulir tidak diserahkan, ia mengembalikan undef . Ini membuatnya cocok untuk digunakan dalam konteks daftar, di mana diperlukan nilai tunggal.

 $db->update({
    name    => $form->param_value('name'),
    address => $form->param_value('address),
});

param_array

Argumen: $ field_name

Dijamin untuk selalu mengembalikan nilai-nilai array, terlepas dari konteks dan terlepas dari apakah beberapa nilai diserahkan atau tidak. Jika nilainya tidak valid atau formulir tidak diserahkan, ia mengembalikan array-ref.

param_list

Argumen: $ field_name

Dijamin untuk selalu mengembalikan daftar nilai, terlepas dari konteks. Jika nilainya tidak valid atau formulir tidak dikirimkan, ia mengembalikan daftar kosong.

param

Argumen: [$ field_name]

Nilai pengembalian: $ input_value

Nilai pengembalian: @valid_names

Tidak lagi direkomendasikan untuk digunakan, karena perilakunya sulit diprediksi. Gunakan "param_value", "param_array" atau "param_list" sebagai gantinya.

Metode (readonly) mirip dengan CGI.

Jika nama bidang diberikan, dalam daftar-konteks mengembalikan nilai-nilai yang valid yang dikirimkan untuk bidang itu, dan dalam scalar-context hanya mengembalikan nilai pertama yang valid yang dikirimkan untuk bidang itu.

Jika tidak ada argumen yang diberikan, kembalikan daftar semua nama bidang input yang valid tanpa kesalahan.

Melewati lebih dari 1 argumen adalah kesalahan fatal.

sah

Argumen: [$ field_name]

Nilai pengembalian: @valid_names

Nilai pengembalian: $ bool

Jika nama bidang jika diberikan, kembalikan true jika bidang itu tidak memiliki kesalahan dan false jika ada kesalahan.

Jika tidak ada argumen yang diberikan, kembalikan daftar semua nama bidang input yang valid tanpa kesalahan.

has_errors

Argumen: [$ field_name]

Nilai pengembalian: @names

Nilai pengembalian: $ bool

Jika nama bidang jika diberikan, kembalikan true jika bidang itu memiliki kesalahan dan false jika tidak ada kesalahan.

Jika tidak ada argumen yang diberikan, kembalikan daftar semua nama bidang input dengan kesalahan.

get_errors

Argumen: [%opsi]

Nilai pengembalian: @Errors

Mengembalikan array-ref objek pengecualian dari semua bidang dalam bentuk.

Menerima argumen name , type dan stage untuk mempersempit hasil yang dikembalikan.

 $form->get_errors({
    name  => 'foo',
    type  => 'Regex',
    stage => 'constraint'
});

get_error

Argumen: [%opsi]

Nilai pengembalian: $ error

Menerima argumen yang sama dengan "get_errors", tetapi hanya mengembalikan kesalahan pertama yang ditemukan.

Interaksi Model / Database

Lihat html :: Formfu :: model untuk detail lebih lanjut dan model yang tersedia.

default_model

Argumen: $ model_name

Nilai default: 'DBIC'

model

Argumen: [$ model_name]

Nilai pengembalian: $ model

model_config

Argumen: %Config

Memodifikasi formulir yang dikirimkan

add_valid

Argumen: $ name, $ value

Nilai pengembalian: $ nilai

Nilai yang disediakan menggantikan nilai saat ini untuk bidang yang disebutkan. Nilai ini akan dikembalikan dalam panggilan berikutnya ke "params" dan "param" dan bidang yang disebutkan akan dimasukkan dalam perhitungan untuk "valid".

clear_errors

Menghapus semua kesalahan dari formulir yang dikirimkan.

Memberikan formulir

memberikan

Nilai Pengembalian: $ String

Anda harus memanggil "proses" sekali setelah membangun formulir, dan sebelum memanggil "render".

awal

Nilai Pengembalian: $ String

Mengembalikan Formulir Mulai Tag, dan output apa pun dari "Form_error_Message" dan "JavaScript".

akhir

Nilai Pengembalian: $ String

Mengembalikan tag akhir formulir.

Hidden_fields

Nilai Pengembalian: $ String

Mengembalikan semua bidang bentuk tersembunyi.

Sistem Plugin

HTML::FormFu menyediakan sistem plugin yang memungkinkan plugin untuk dengan mudah ditambahkan ke formulir atau elemen, untuk mengubah perilaku atau output default.

Lihat html :: formfu :: plugin untuk detailnya.

Kustomisasi tingkat lanjut

Secara default, formfu membuat markup yang sesuai "XHTML 1.0 ketat", dengan markup tambahan sesedikit mungkin. Banyak kait disediakan untuk menambahkan nama kelas CSS yang dihasilkan secara terprogram, untuk memungkinkan berbagai gaya output dihasilkan dengan hanya mengubah CSS.

Kustomisasi dasar markup dimungkinkan melalui metode tata letak dan multi_layout. Ini memungkinkan Anda untuk memesan ulang posisi berbagai bagian dari setiap bidang - seperti label, komentar, pesan kesalahan, dan tag input - serta memasukkan tag sewenang -wenang lainnya yang mungkin Anda inginkan.

Jika ini tidak cukup, Anda dapat membuat sepenuhnya personalisasi markup dengan memberi tahu html :: formfu untuk menggunakan mesin rendering eksternal, seperti Template Toolkit atau Template :: Alloy. Lihat "render_method" dan "tt_module" untuk detailnya.

Bahkan jika Anda mengatur html :: formfu untuk menggunakan template :: toolkit untuk merender, formulir, html :: formfu masih dapat digunakan bersama dengan sistem templating lain yang Anda lebih suka gunakan untuk tata letak halaman Anda sendiri: apakah itu html: "Template <TMPL_VAR form> , Petal: <form tal:replace="form"></form> atau Template: <TMPL_VAR FORMULIR>, PETAL:  .

Pada HTML::FormFu v1.00 , TT tidak lagi terdaftar sebagai prasyarat yang diperlukan - jadi Anda harus menginstalnya secara manual jika Anda ingin menggunakan file template.

render_method

Nilai default: string

Dapat diatur ke tt untuk menghasilkan formulir dengan file templat eksternal.

Untuk menyesuaikan markup, Anda akan memerlukan salinan file template, lokal ke aplikasi Anda. Lihat "Menginstal Template TT" di html :: Formfu :: Manual :: Cookbook untuk perincian lebih lanjut.

Anda dapat menyesuaikan markup untuk satu elemen dengan mengatur elemen itu "render_method" ke tt , sedangkan sisa formulir menggunakan metode render string default. Namun, perhatikan bahwa jika Anda mencoba mengatur formulir atau "render_method" blok ke tt , dan kemudian mengatur elemen anak "render_method" untuk string , pengaturan itu akan diabaikan, dan elemen anak masih akan menggunakan metode render tt .

 ---
elements:
  - name: foo
    render_method: tt
    filename: custom_field

  - name: bar

# in this example, 'foo' will use a custom template,
# while bar will use the default 'string' rendering method

Adalah aksesor yang mewarisi.

nama file

Ubah nama file template yang digunakan untuk formulir.

Nilai default: "Formulir"

TT_ARGS

Argumen: [%constructor_arguments]

Menerima hash-ref argumen yang diteruskan ke "render_method", yang disebut secara internal oleh "render".

Dalam TT_Args, RELATIVE dan RECURSION kunci ditimpa untuk selalu benar, karena ini adalah persyaratan dasar untuk mesin templat.

Direktori Sistem yang berisi file templat HTML :: FormFu selalu ditambahkan ke akhir dari INCLUDE_PATH , sehingga file template inti akan ditemukan. Anda hanya perlu mengatur ini sendiri jika Anda memiliki salinan file templat sendiri untuk tujuan kustomisasi.

add_tt_args

Argumen: [%constructor_arguments]

Memastikan bahwa argumen hash-ref digabungkan dengan nilai hash-ref "TT_Args" yang ada.

tt_module

Nilai default: Template

Modul yang digunakan saat "render_method" diatur ke tt . Harus memberikan antarmuka yang kompatibel dengan template.

render_data

Biasanya disebut secara implisit oleh "render". Mengembalikan struktur data yang biasanya akan diteruskan ke string atau metode render- tt .

Seperti halnya "render", Anda harus memanggil "proses" sekali setelah membangun formulir, dan sebelum memanggil "render_data".

render_data_non_recursive

Seperti "render_data", tetapi tidak termasuk data untuk elemen anak.

INTROSPEKSI

get_fields

Argumen: [%opsi]

Nilai pengembalian: @elements

Mengembalikan semua bidang dalam formulir (khususnya, semua elemen yang memiliki "is_field" yang sebenarnya dalam nilai html :: formfu :: elemen).

Menerima argumen name dan type untuk mempersempit hasil yang dikembalikan.

 $form->get_fields({
    name => 'foo',
    type => 'Radio',
});

Menerima juga regexp untuk mencari hasil.

 $form->get_elements({
    name => qr/oo/,
});

get_field

Argumen: [%opsi]

Nilai pengembalian: $ elemen

Menerima argumen yang sama dengan "get_fields", tetapi hanya mengembalikan bidang pertama yang ditemukan.

get_elements

Argumen: [%opsi]

Nilai pengembalian: @elements

Mengembalikan semua elemen tingkat atas dalam bentuk (bukan rekursif). Lihat "get_all_elements" untuk versi rekursif.

Menerima argumen name dan type untuk mempersempit hasil yang dikembalikan.

 $form->get_elements({
    name => 'foo',
    type => 'Radio',
});

Menerima juga regexp untuk mencari hasil.

 $form->get_elements({
    name => qr/oo/,
});

get_element

Argumen: [%opsi]

Nilai pengembalian: $ elemen

Menerima argumen yang sama dengan "get_elements", tetapi hanya mengembalikan elemen pertama yang ditemukan.

Lihat "get_all_element" untuk versi rekursif.

get_all_elements

Argumen: [%opsi]

Nilai pengembalian: @elements

Mengembalikan semua elemen dalam bentuk secara rekursif.

Secara opsional menerima argumen name dan type untuk mempersempit hasil yang dikembalikan.

 # return all Text elements

$form->get_all_elements({
    type => 'Text',
});

Menerima juga regexp untuk mencari hasil.

 $form->get_elements({
    name => qr/oo/,
});

Lihat "Get_elements" untuk versi non-rekursif.

get_all_element

Argumen: [%opsi]

Nilai pengembalian: $ elemen

Menerima argumen yang sama dengan "get_all_elements", tetapi hanya mengembalikan elemen pertama yang ditemukan.

 # return the first Text field found, regardless of whether it's
# within a fieldset or not

$form->get_all_element({
    type => 'Text',
});

Menerima juga regexp untuk mencari hasil.

 $form->get_elements({
    name => qr/oo/,
});

Lihat "get_all_elements" untuk versi non-rekursif.

get_deflators

Argumen: [%opsi]

Nilai pengembalian: @deflators

Mengembalikan semua deflator tingkat atas dari semua bidang.

Menerima argumen name dan type untuk mempersempit hasil yang dikembalikan.

 $form->get_deflators({
    name => 'foo',
    type => 'Strftime',
});

get_deflator

Argumen: [%opsi]

Nilai pengembalian: $ elemen

Menerima argumen yang sama dengan "get_deflators", tetapi hanya mengembalikan deflator pertama yang ditemukan.

get_filters

Argumen: [%opsi]

Return Value: @filters

Returns all top-level filters from all fields.

Accepts both name and type arguments to narrow the returned results.

 $form->get_filters({
    name => 'foo',
    type => 'LowerCase',
});

get_filter

Arguments: [%options]

Return Value: $filter

Accepts the same arguments as "get_filters", but only returns the first filter found.

get_constraints

Arguments: [%options]

Return Value: @constraints

Returns all constraints from all fields.

Accepts both name and type arguments to narrow the returned results.

 $form->get_constraints({
    name => 'foo',
    type => 'Equal',
});

get_constraint

Arguments: [%options]

Return Value: $constraint

Accepts the same arguments as "get_constraints", but only returns the first constraint found.

get_inflators

Arguments: [%options]

Return Value: @inflators

Returns all inflators from all fields.

Accepts both name and type arguments to narrow the returned results.

 $form->get_inflators({
    name => 'foo',
    type => 'DateTime',
});

get_inflator

Arguments: [%options]

Return Value: $inflator

Accepts the same arguments as "get_inflators", but only returns the first inflator found.

get_validators

Arguments: [%options]

Return Value: @validators

Returns all validators from all fields.

Accepts both name and type arguments to narrow the returned results.

 $form->get_validators({
    name => 'foo',
    type => 'Callback',
});

get_validator

Arguments: [%options]

Return Value: $validator

Accepts the same arguments as "get_validators", but only returns the first validator found.

get_transformers

Arguments: [%options]

Return Value: @transformers

Returns all transformers from all fields.

Accepts both name and type arguments to narrow the returned results.

 $form->get_transformers({
    name => 'foo',
    type => 'Callback',
});

get_transformer

Arguments: [%options]

Return Value: $transformer

Accepts the same arguments as "get_transformers", but only returns the first transformer found.

klon

Returns a deep clone of the $form object.

Because of scoping issues, code references (such as in Callback constraints) are copied instead of cloned.

ATTRIBUTE ACCESSORS

For the basic method, eg /attributes :

Arguments: [%attributes]

Return Value: $form

As a special case, if no arguments are passed, the attributes hash-ref is returned. This allows the following idioms.

 # set a value
$form->attributes->{id} = 'form';

# delete all attributes
%{ $form->attributes } = ();

All methods documented as 'attribute accessors' also have the following variants generated:

*_xml can be used as a setter, and ensures that its argument is not XML-escaped in the rendered form.

*_loc can he used as a setter, and passes the arguments through "localize".

add_* can be used to append a word to an attribute without overwriting any already-existing value.

 # Example
$form->attributes({ class => 'fancy' });
$form->add_attributes({ class => 'pants' });
# class="fancy pants"

add_*_xml , like add_* , but ensures it doesn't get XML-escaped.

add_*_loc , like add_* , but passing the arguments through "localize".

del_* can be used to remove a word from an attribute value.

 # Example
$form->attributes({ class => 'fancy pants' });
$form->del_attributes({ class => 'pants' });
# class="fancy"

del_*_xml , like del_* , but ensures it doesn't get XML-escaped.

del_*_loc , like del_* , but passing the arguments through "localize".

Also, any attribute method-name which contains the word attributes also has aliases created for all these variants, with the word attributes replaced by attrs .

 # For example, the attributes() method would have all these variant
# methods available

$form->attributes({ class => 'fancy' });
$form->attributes_xml({ title => '<b>fancy</b>' });
$form->attributes_loc({ title => 'fancy' });
$form->add_attributes({ class => 'fancy' });
$form->add_attributes_xml({ title => '<b>fancy</b>' });
$form->add_attributes_loc({ title => 'fancy' });
$form->del_attributes({ class => 'fancy' });
$form->del_attributes_xml({ title => '<b>fancy</b>' });
$form->del_attributes_loc({ title => 'fancy' });

# Because the method contains the word 'attributes', it also gets the
# following short-forms

$form->attrs({ class => 'fancy' });
$form->attrs_xml({ title => '<b>fancy</b>' });
$form->attrs_loc({ title => 'fancy' });
$form->add_attrs({ class => 'fancy' });
$form->add_attrs_xml({ title => '<b>fancy</b>' });
$form->add_attrs_loc({ title => 'fancy' });
$form->del_attrs({ class => 'fancy' });
$form->del_attrs_xml({ title => '<b>fancy</b>' });
$form->del_attrs_loc({ title => 'fancy' });

ATTRIBUTE SHORT-CUTS

All methods documented as 'attribute short-cuts' are short-cuts to directly access individual attribute key/values.

 # Example
$form->id( 'login' );
$id = $form->id;

# is equivalent to:
$form->attributes({ id => 'login' });
$id = $form->attributes->{id};

All attribute short-cuts also have a *_xml variant.

 # Example
$form->id_xml( $xml );

# is equivalent to:
$form->attributes_xml({ id => $xml });

All attribute short-cuts also have a *_loc variant.

 # Example
$form->title_loc( $key );

# is equivalent to:
$form->attributes_loc({ title => $key });

INHERITING ACCESSORS

All methods documented as 'inheriting accessors' can be set on the form, a block element or a single field element. When the value is read, if no value is defined it automatically traverses the element's hierarchy of parents, searching for a defined value.

All inherited accessors also have a *_no_inherit variant, which can be used as a getter to fetch any defined value, without traversing the hierarchy of parents. This variant cannot be used as a setter.

Eg, the "auto_id" has a variant named auto_id_no_inherit .

OUTPUT ACCESSORS

All methods documented as 'output accessors' also have *_xml and *_loc variants.

The *_xml variant can be used as a setter, and ensures that its argument is not XML-escaped in the rendered form.

The *_loc variant can be used as a setter, and passes the arguments through "localize".

Eg, the label method has variants named label_xml and label_loc .

BOOLEAN ATTRIBUTE ACCESSORS

To support boolean attributes, whose value should either be equal to the attribute name, or empty. Any true value will switch the attribute 'on', any false value will remove the attribute.

 # Example

$field->autofocus(1);
# equivalent to:
$field->attributes({ autofocus => 'autofocus' });

$field->autofocus(0);;
# equivalent to:
delete $field->attributes->{autofocus};

ATTRIBUTE SUBSTITUTIONS

Some attributes support character substitutions: the following substitutions are possible:

 %f # $form->id
%n # $field->name
%t # lc( $field->type )
%r # $block->repeatable_count
%s # $error->stage

These allow each field to have consistent attributes, while remaining unique.

DEPRECATION POLICY

We try our best to not make incompatible changes, but if they're required we'll make every effort possible to provide backwards compatibility for several release-cycles, issuing a warnings about the changes, before removing the legacy features.

RESTORING LEGACY HTML CLASSES

v1.00 dropped most of the default HTML class-names, with the intention that each application should define just what it needs, without needing to reset unwanted options first. We also gain the benefit of less markup being generated, speeding up both render and HTTP transfers.

To restore the previous behaviour, set the following options.

If you're using best practices, you'll only need to set these once per-application in your app-wide config file.

 ---
auto_container_class: '%t'
auto_container_label_class: 'label'
auto_container_comment_class: 'comment'
auto_comment_class: 'comment'
auto_container_error_class: 'error'
auto_container_per_error_class: 'error_%s_%t'
auto_error_class: 'error_message error_%s_%t'

DEPRECATED METHODS

See "DEPRECATED METHODS" in HTML::FormFu::Role::Element::Field.

REMOVED METHODS

See also "REMOVED METHODS" in HTML::FormFu::Element.

element_defaults

Has been removed; see "default_args" instead.

model_class

Has been removed; use "default_model" instead.

defaults_from_model

Has been removed; use "default_values" in HTML::FormFu::Model instead.

save_to_model

Has been removed; use "update" in HTML::FormFu::Model instead.

BEST PRACTICES

It is advisable to keep application-wide (or global) settings in a single config file, which should be loaded by each form.

See "load_config_file".

BUKU MASAK

HTML::FormFu::Manual::Cookbook

Unicode

HTML::FormFu::Manual::Unicode

EXAMPLES

vertically-aligned CSS

The distribution directory examples/vertically-aligned contains a form with example CSS for a "vertically aligned" theme.

This can be viewed by opening the file vertically-aligned.html in a web-browser.

If you wish to experiment with making changes, the form is defined in file vertically-aligned.yml , and the HTML file can be updated with any changes by running the following command (while in the distribution root directory).

 perl examples/vertically-aligned/vertically-aligned.pl

This uses the Template Toolkit file vertically-aligned.tt , and the CSS is defined in files vertically-aligned.css and vertically-aligned-ie.css .