django.forms.HiddenInput

Here are the examples of the python api django.forms.HiddenInput taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

147 Examples 7

Example 1

Project: djangobb Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        self.from_user = kwargs.pop('from_user', None)
        self.to_user = kwargs.pop('to_user', None)
        self.post = kwargs.pop('post', None)
        self.sign = kwargs.pop('sign', None)
        super(ReputationForm, self).__init__(*args, **kwargs)
        self.fields['post'].widget = forms.HiddenInput()
        self.fields['sign'].widget = forms.HiddenInput()
        self.fields['reason'].widget = forms.Textarea(attrs={'class':'markup'})

Example 2

Project: djangobb Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        self.reported_by = kwargs.pop('reported_by', None)
        self.post = kwargs.pop('post', None)
        super(ReportForm, self).__init__(*args, **kwargs)
        self.fields['post'].widget = forms.HiddenInput()
        self.fields['post'].initial = self.post
        self.fields['reason'].widget = forms.Textarea(attrs={'rows':'10', 'cols':'75'})

Example 3

Project: site Source File: forms.py
    def __init__(self, *args, **kwargs):
        super(ProblemSubmitForm, self).__init__(*args, **kwargs)
        self.fields['problem'].empty_label = None
        self.fields['problem'].widget = forms.HiddenInput()
        self.fields['language'].empty_label = None
        self.fields['language'].label_from_instance = attrgetter('display_name')
        self.fields['language'].queryset = Language.objects.filter(judges__online=True).distinct()

Example 4

Project: transifex Source File: forms.py
    def __init__(self, project, language_code=None, *args, **kwargs):
        super(TeamRequestSimpleForm, self).__init__(*args, **kwargs)
        self.fields['project'].widget = forms.HiddenInput()
        self.fields['project'].initial = project.pk
        self.fields['user'].widget = forms.HiddenInput()

        # Create list of languages to be disabled excluding the current
        # language_code and also the language of teams already created.
        self.disabled_langs = Team.objects.filter(project=project).exclude(
            language__code=language_code).values_list('language__pk', flat=True)

        # Setting custom widget with list of ids that should be disabled
        self.fields["language"].widget = SelectWithDisabledOptions(
            choices=[(l.pk, l) for l in Language.objects.all()],
            disabled_choices=self.disabled_langs)

Example 5

Project: django-sitegate Source File: flows_base.py
    def get_requested_form(self, request):
        """Returns an instance of a form requested."""
        flow_name = self.get_flow_name()
        flow_key = '%s_flow' % self.flow_type
        form_data = None

        if request.method == 'POST' and request.POST.get(flow_key, False) and request.POST[flow_key] == flow_name:
            form_data = request.POST

        form = self.init_form(form_data, widget_attrs=self.flow_args.get('widget_attrs', None),
                              template=self.get_template_name(self.flow_args.get('template', None)))
        # Attach flow identifying field to differentiate among several possible forms.
        form.fields[flow_key] = forms.CharField(required=True, initial=flow_name, widget=forms.HiddenInput)
        form.flow_enabled = self.enabled
        form.flow_disabled_text = self.disabled_text
        return form

Example 6

Project: django-sellmo Source File: forms.py
Function: factory
    @classmethod
    def factory(cls, purchase, data=None, **kwargs):
        Form = type('EditPurchaseForm', (cls,), {
            'purchase': forms.IntegerField(
                initial=purchase.pk,
                widget=forms.HiddenInput
            ),
            'qty': forms.IntegerField(initial=purchase.qty, min_value=0)
        })
        return Form

Example 7

Project: tendenci Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        super(ItemAdminForm, self).__init__(*args, **kwargs)
        self.fields['page'].required = False
        self.fields['level'].widget = forms.HiddenInput()

        if self.instance and self.instance.pk:
            self.fields['url_field'].initial = self.instance.get_url()

Example 8

Project: aldryn-newsblog Source File: cms_wizards.py
Function: init
    def __init__(self, **kwargs):
        super(CreateNewsBlogArticleForm, self).__init__(**kwargs)

        # If there's only 1 (or zero) app_configs, don't bother show the
        # app_config choice field, we'll choose the option for the user.
        app_configs = get_published_app_configs()
        if len(app_configs) < 2:
            self.fields['app_config'].widget = forms.HiddenInput()
            self.fields['app_config'].initial = app_configs[0].pk

Example 9

Project: database-as-a-service Source File: database.py
Function: init
    def __init__(self, *args, **kwargs):

        super(DatabaseForm, self).__init__(*args, **kwargs)
        instance = kwargs.get('instance')
        if instance:
            LOG.debug("instance database form found! %s" % instance)
            # remove fields not in models
            self.remove_fields_not_in_models()

        else:
            self.fields['is_in_quarantine'].widget = forms.HiddenInput()

Example 10

Project: django-alert Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        super(UnsubscribeForm, self).__init__(*args, **kwargs)
        
        for backend in self.backends:
            for alert in self.alerts:
                field_id = self._field_id(alert.id, backend.id)
                self.fields[field_id].widget = forms.HiddenInput()
                self.fields[field_id].initial = False

Example 11

Project: xadmin Source File: inline.py
Function: render
    def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
        html = ''
        detail = form.detail
        for field in self.fields:
            if not isinstance(form.fields[field].widget, forms.HiddenInput):
                result = detail.get_field_result(field)
                html += loader.render_to_string(
                    self.template, context={'field': form[field], 'result': result})
        return html

Example 12

Project: uwsgi.it Source File: admin.py
Function: init
    def __init__(self, *args, **kwargs):
        super(LoopboxAdminForm, self).__init__(*args, **kwargs)
        if self.instance and self.instance.pk:
            self.fields['tags'].queryset = Tag.objects.filter(customer=self.instance.container.customer)
        else:
            self.fields['tags'].widget = HiddenInput()

Example 13

Project: cdr-stats Source File: forms.py
    def __init__(self, user, *args, **kwargs):
        super(SimulatorForm, self).__init__(*args, **kwargs)
        self.fields['plan_id'].choices = voip_plan_list()

        self.fields.keyOrder = ['plan_id', 'destination_no', ]
        if not user.is_superuser:
            self.fields['plan_id'] = forms.ChoiceField(widget=forms.HiddenInput())
        self.helper = FormHelper()
        self.helper.form_class = 'well'
        css_class = 'col-md-4'
        self.helper.layout = Layout(
            Div(
                Div('destination_no', css_class=css_class),
                Div('plan_id', css_class=css_class),
                css_class='row',
            ),
        )
        common_submit_buttons(self.helper.layout, 'search')

Example 14

Project: tendenci Source File: forms.py
    def __init__(self, *args, **kwargs):
        super(LoginForm, self).__init__(*args, **kwargs)
        # check if we need to hide the remember me checkbox
        # and set the default value for remember me
        hide_remember_me = get_setting('module', 'users', 'usershiderememberme')
        remember_me_default_checked = get_setting('module', 'users', 'usersremembermedefaultchecked')

        if remember_me_default_checked:
            self.fields['remember'].initial = True
        if hide_remember_me:
            self.fields['remember'].widget = forms.HiddenInput()

Example 15

Project: django-crispy-forms Source File: test_layout_objects.py
    def test_hidden_fields(self):
        form = TestForm()
        # All fields hidden
        for field in form.fields:
            form.fields[field].widget = forms.HiddenInput()

        form.helper = FormHelper()
        form.helper.layout = Layout(
            AppendedText('password1', 'foo'),
            PrependedText('password2', 'bar'),
            PrependedAppendedText('email', 'bar'),
            InlineCheckboxes('first_name'),
            InlineRadios('last_name'),
        )
        html = render_crispy_form(form)
        assert html.count("<input") == 5
        assert html.count('type="hidden"') == 5
        assert html.count('<label') == 0

Example 16

Project: djangobb Source File: forms.py
    def __init__(self, *args, **kwargs):
        self.user = kwargs.pop('user', None)
        self.topic = kwargs.pop('topic', None)
        self.forum = kwargs.pop('forum', None)
        self.ip = kwargs.pop('ip', None)
        super(AddPostForm, self).__init__(*args, **kwargs)

        if self.topic:
            self.fields['name'].widget = forms.HiddenInput()
            self.fields['name'].required = False

        self.fields['body'].widget = forms.Textarea(attrs={'class':'markup', 'rows':'20', 'cols':'95'})

        if not forum_settings.ATTACHMENT_SUPPORT:
            self.fields['attachment'].widget = forms.HiddenInput()
            self.fields['attachment'].required = False

Example 17

Project: ecobasa Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        self.request = kwargs.pop('request', None)
        super(SkillForm, self).__init__(*args, **kwargs)
        self.fields['creator'].widget = forms.HiddenInput()
        self.fields['experience'].widget = forms.RadioSelect(
            choices=Skill.CHOICES_EXPERIENCE)

Example 18

Project: overmind Source File: forms.py
    def __init__(self, provider_type, *args, **kwargs):
        super(ProviderForm, self).__init__(*args, **kwargs)
        self.fields['provider_type'].widget = forms.HiddenInput()
        self.fields['provider_type'].initial = provider_type
        provider_type_info = PROVIDERS.get(provider_type, {})
        
        for field in ['access_key', 'secret_key']:
            label = provider_type_info.get(field)
            if label is None:
                self.fields[field].widget = forms.HiddenInput()
            else:
                self.fields[field].required = True
                self.fields[field].label = label
                if field == 'secret_key':
                    self.fields['secret_key'].widget = forms.PasswordInput()

Example 19

Project: django-optimistic-lock Source File: __init__.py
Function: form_field
    def formfield(self, **kwargs):
        widget = kwargs.get('widget')
        if widget:
            if issubclass(widget, AdminIntegerFieldWidget):
                widget = ReadonlyInput()
        else:
            widget = forms.HiddenInput
        kwargs['widget'] = widget
        return super(VersionField, self).formfield(**kwargs)

Example 20

Project: mezzanine-careers Source File: forms.py
Function: init
    def __init__(self):
        initial = {}
        for field in hidden_field_defaults:
            initial[field] = JobPost._meta.get_field(field).default
        super(JobPostForm, self).__init__(initial=initial)
        for field in hidden_field_defaults:
            self.fields[field].widget = forms.HiddenInput()

Example 21

Project: django-debug-toolbar Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        initial = kwargs.get('initial', None)

        if initial is not None:
            initial['hash'] = self.make_hash(initial)

        super(SQLSelectForm, self).__init__(*args, **kwargs)

        for name in self.fields:
            self.fields[name].widget = forms.HiddenInput()

Example 22

Project: uwsgi.it Source File: admin.py
Function: init
    def __init__(self, *args, **kwargs):
        super(ContainerAdminForm, self).__init__(*args, **kwargs)
        if self.instance and self.instance.pk:
            self.fields['tags'].queryset = Tag.objects.filter(customer=self.instance.customer)
            self.fields['custom_distro'].queryset = CustomDistro.objects.filter(container__server=self.instance.server, container__customer=self.instance.customer).exclude(container=self.instance)
        else:
            self.fields['tags'].widget = HiddenInput()
            self.fields['custom_distro'].widget = HiddenInput()

Example 23

Project: uwsgi.it Source File: admin.py
Function: init
    def __init__(self, *args, **kwargs):
        super(DomainAdminForm, self).__init__(*args, **kwargs)
        if self.instance and self.instance.pk:
            self.fields['tags'].queryset = Tag.objects.filter(customer=self.instance.customer)
        else:
            self.fields['tags'].widget = HiddenInput()

Example 24

Project: SchoolIdolAPI Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        super(_OwnedCardForm, self).__init__(*args, **kwargs)
        if self.instance and hasattr(self.instance, 'card'):
            if self.instance.card.is_special or self.instance.card.is_promo:
                self.fields['idolized'].widget = forms.HiddenInput()
        if 'origin' in self.fields:
            self.fields['origin'].required = False

Example 25

Project: upribox Source File: forms.py
    def __init__(self, *args, **kwargs):
        super(VpnProfileForm, self).__init__(*args, **kwargs)

        upri_dns_domain = None

        try:
            upri_dns_domain = get_fact('dns', 'dns', 'hostname')
        except:
            logger.error('Kein upri DNS fact gefunden.')

        if upri_dns_domain:
            self.fields['dyndomain'].widget = forms.HiddenInput()
            self.fields['dyndomain'].initial = upri_dns_domain
            self.fields['dyndomain'].label = ""

Example 26

Project: tuskar-ui-extras Source File: forms.py
    def _role_flavor_fields(self, plan):
        fields = {}
        for role in plan.role_list:
            field = django.forms.CharField(
                label=_("Flavor for {0}").format(role.name),
                initial=role.flavor(plan).name if role.flavor(plan) else '',
                required=False,
                widget=django.forms.HiddenInput(attrs={
                    'class': "boxes-flavor",
                }),
            )
            field.role = role
            fields['%s-flavor' % role.id] = field
        return fields

Example 27

Project: yawd-translations Source File: admin.py
Function: formfield_for_dbfield
    def formfield_for_dbfield(self, db_field, **kwargs):
        """
        Override the ``formfield_for_dbfield()`` method to make the `'language'`
        property of the :class:`translations.models.Translation` object hidden.
        """
        formfield = super(TranslationInline, self).formfield_for_dbfield(db_field, **kwargs)
        if db_field.name  == 'language':
            formfield.widget = HiddenInput()
        return formfield

Example 28

Project: colab Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        self.feed = kwargs.pop('feed', None)
        
        super(SubscriptionForm, self).__init__(*args, **kwargs)
        
        # hide the fields we don't need and get the right actions
        self.fields['feed'].widget = forms.HiddenInput()
        self.fields['user'].widget = forms.HiddenInput()
        self.fields['actions'].queryset = Action.objects.filter(content_type=self.feed.content_type)

Example 29

Project: mezzanine Source File: forms.py
Function: init
    def __init__(self, attrs=None):
        """
        Setup the text and hidden form field widgets.
        """
        widgets = (forms.HiddenInput,
                   forms.TextInput(attrs={"class": "vTextField"}))
        super(KeywordsWidget, self).__init__(widgets, attrs)
        self._ids = []

Example 30

Project: idea-box Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        kwargs['include_anonymous'] = True
        super(PrivateIdeaForm, self).__init__(*args, **kwargs)

        self.fields['challenge-checkbox'] = forms.BooleanField(
            label="My idea will only be visible in this private room:",
            widget=forms.HiddenInput(), required=False, initial=True)
        self.fields["challenge-checkbox"].widget.attrs["class"] = "form-control active"
        self.fields["banner"].widget.attrs["class"] = "form-control active"
        self.fields['banner'].empty_label = None

Example 31

Project: shuup Source File: views.py
Function: get_form
    def get_form(self, form_class=None):
        form = super(LoginView, self).get_form(form_class)
        form.fields[REDIRECT_FIELD_NAME] = forms.CharField(
            widget=forms.HiddenInput,
            required=False,
            initial=self.request.GET.get(REDIRECT_FIELD_NAME)
        )
        return form

Example 32

Project: RGT-tool Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        super(RatingsForm, self).__init__(*args, **kwargs)
        if len(self.data) > 0:
            self.num_alternatives = self.data['num-alternatives']
            self.num_concerns = self.data['num-concerns']
            for x in range(int(self.num_alternatives)):
                for z in range(int(self.num_concerns)):
                    rating_name = 'rating-concern%d-alternative%d' % ((z+1), (x+1))
                    # Every time, rating fields are added with the name 'rating-concern..-alternative..', and this because django
                    # always adds '4-' % (where 4 the number of the step with zero index) prefix in the name,
                    # with this the names are kept always the same.
                    self.fields[rating_name] = forms.CharField(widget=forms.HiddenInput())

Example 33

Project: tendenci Source File: forms.py
Function: init
    def __init__(self, corp_membership, *args, **kwargs):
        self.corp_membership = corp_membership
        super(CorpMembershipRepForm, self).__init__(*args, **kwargs)

        self.fields['user_display'].label = _("Add a Representative")
        self.fields['user'].widget = forms.HiddenInput()
        self.fields['user'].error_messages['required'
                                ] = _('Please enter a valid user.')

Example 34

Project: django-polymorphic Source File: models.py
Function: add_fields
    def add_fields(self, form, index):
        """Add a hidden field for the content type."""
        ct = ContentType.objects.get_for_model(form._meta.model)
        choices = [(ct.pk, ct)]  # Single choice, existing forms can't change the value.
        form.fields['polymorphic_ctype'] = forms.ChoiceField(choices=choices, initial=ct.pk, required=False, widget=forms.HiddenInput)
        super(BasePolymorphicModelFormSet, self).add_fields(form, index)

Example 35

Project: villagescc Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        hide_set_home = kwargs.pop('hide_set_home', False)
        super(LocationForm, self).__init__(*args, **kwargs)
        if hide_set_home:
            del self.fields['set_home']
        self.fields['point'].widget = forms.HiddenInput()

Example 36

Project: satchmo Source File: forms.py
    def __init__(self, cart=None, order=None, *args, **kwargs):
        super(PaymentMethodForm, self).__init__(*args, **kwargs)
        self.cart = cart
        # Send a signal to perform additional filtering of available payment methods.
        # Receivers have cart/order passed in variables to check the contents and modify methods
        # list if neccessary.
        payment_choices = labelled_gateway_choices()
        signals.payment_methods_query.send(
                PaymentMethodForm,
                methods=payment_choices,
                cart=cart,
                order=order,
                contact=self._contact
                )
        if len(payment_choices) == 1:
            self.fields['paymentmethod'].widget = forms.HiddenInput(attrs={'value' : payment_choices[0][0]})
        else:
            self.fields['paymentmethod'].widget = forms.RadioSelect(attrs={'value' : payment_choices[0][0]})
        self.fields['paymentmethod'].choices = payment_choices

Example 37

Project: ion Source File: scheduling.py
Function: init
    def __init__(self, *args, **kwargs):
        super(ScheduledActivityForm, self).__init__(*args, **kwargs)

        for fieldname in ["sponsors", "rooms"]:
            self.fields[fieldname].help_text = None

        for fieldname in ["block", "activity"]:
            self.fields[fieldname].widget = forms.HiddenInput()

Example 38

Project: aldryn-events Source File: cms_wizards.py
Function: init
    def __init__(self, **kwargs):
        super(CreateEventForm, self).__init__(**kwargs)
        # If there's only 1 app_config, don't bother show the
        # app_config choice field, we'll choose the option for the user.
        app_configs = EventsConfig.objects.all()
        # check if app config is apphooked
        app_configs = [app_config
                       for app_config in app_configs
                       if is_valid_namespace(app_config.namespace)]
        if len(app_configs) == 1:
            self.fields['app_config'].widget = forms.HiddenInput()
            self.fields['app_config'].initial = app_configs[0].pk
        self.fields['start_date'].help_text = _(
            'Date Acceptable Formats: 2015-11-30, 11/30/2015, 11/30/15'
        )
        self.fields['end_date'].help_text = _(
            'Date Acceptable Formats: 2015-11-30, 11/30/2015, 11/30/15'
        )

Example 39

Project: djangobb Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        extra_args = kwargs.pop('extra_args', {})
        self.request = extra_args.pop('request', None)
        self.profile = kwargs['instance']
        super(EssentialsProfileForm, self).__init__(*args, **kwargs)
        self.fields['username'].initial = self.profile.user.username
        if not self.request.user.is_superuser:
            self.fields['username'].widget = forms.HiddenInput()
        self.fields['email'].initial = self.profile.user.email

Example 40

Project: djtracker Source File: forms.py
    def __init__(self, project_id, can_edit, *args, **kwargs):
        super(IssueForm, self).__init__(*args, **kwargs)
        project_instance = models.Project.objects.get(id=project_id)
        self.fields['component'].queryset = \
            models.Component.objects.filter(project=project_instance)
        self.fields['version'].queryset = \
            models.Version.objects.filter(project=project_instance)
        self.fields['milestone'].queryset = \
            models.Milestone.objects.filter(project=project_instance)
        if can_edit is False:
            self.fields['assigned_to'].widget = forms.HiddenInput()
            self.fields['watched_by'].widget = forms.HiddenInput()

Example 41

Project: wagtail Source File: forms.py
Function: add_fields
    def add_fields(self, form, *args, **kwargs):
        super(SearchPromotionsFormSet, self).add_fields(form, *args, **kwargs)

        # Hide delete and order fields
        form.fields['DELETE'].widget = forms.HiddenInput()
        form.fields['ORDER'].widget = forms.HiddenInput()

        # Remove query field
        del form.fields['query']

Example 42

Project: kikola Source File: forms.py
    def auto_tabindex(self, start=0):
        self._tabindex = start

        for field in self:
            widget = field.field.widget

            if not isinstance(widget, forms.HiddenInput):
                self._tabindex += 1
                widget.attrs['tabindex'] = self._tabindex

Example 43

Project: django-authority Source File: forms.py
    def __init__(self, perm=None, obj=None, approved=False, *args, **kwargs):
        self.perm = perm
        self.obj = obj
        self.approved = approved
        if obj and perm:
            self.base_fields['codename'].widget = forms.HiddenInput()
        elif obj and (not perm or not approved):
            perms = get_choices_for(self.obj)
            self.base_fields['codename'].widget = forms.Select(choices=perms)
        super(BasePermissionForm, self).__init__(*args, **kwargs)

Example 44

Project: treeio Source File: converter.py
Function: init
    def __init__(self, initial=None, choices=None, attrs=None):
        if initial is None:
            initial = []
        if choices is None:
            choices = []
        if attrs is None:
            attrs = {}
        widgets = []
        if initial:
            for i in initial:
                if i:
                    initial_label = ''
                    for choice in choices:
                        if choice[0] == i:
                            initial_label = choice[1]
                            break
                    widgets.append(
                        HiddenInput(attrs=dict(attrs, label=initial_label)))
        super(MultiHiddenWidget, self).__init__(widgets=widgets, attrs=attrs)

Example 45

Project: django-tinylinks Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        """The Regex field validates the URL input."""
        super(TinylinkAdminForm, self).__init__(*args, **kwargs)
        if not self.instance.pk:
            # Hide the short URL field to auto-generate a new instance.
            self.fields['short_url'].widget = forms.HiddenInput()
            self.fields['short_url'].required = False
        else:
            self.fields['short_url'] = forms.RegexField(
                regex=r'^[a-z0-9]+$',
                help_text=_("You can add a more readable short URL."),
                label=self.instance._meta.get_field('short_url').verbose_name,
            )
            self.fields['short_url'].error_messages['invalid'] = _(
                "Please use only small letters and digits.")

Example 46

Project: GAE-Bulk-Mailer Source File: legacy.py
Function: render
    def render(self, form, request, step, context=None):
        "Renders the given Form object, returning an HttpResponse."
        old_data = request.POST
        prev_fields = []
        if old_data:
            hidden = HiddenInput()
            # Collect all data from previous steps and render it as HTML hidden fields.
            for i in range(step):
                old_form = self.get_form(i, old_data)
                hash_name = 'hash_%s' % i
                prev_fields.extend([bf.as_hidden() for bf in old_form])
                prev_fields.append(hidden.render(hash_name, old_data.get(hash_name, self.security_hash(request, old_form))))
        return self.render_template(request, form, ''.join(prev_fields), step, context)

Example 47

Project: Resmin Source File: forms.py
    def __init__(self, *args, **kwargs):
        self.owner = kwargs.pop('owner')
        self.meta = kwargs.pop('meta', None)
        self.question = kwargs.pop('question', None)

        super(StoryForm, self).__init__(*args, **kwargs)

        if self.owner:
            self.fields['question'] = \
                forms.ModelChoiceField(
                    required=False,
                    initial=self.question,
                    widget=forms.HiddenInput,
                    queryset=Question.objects.filter(
                        questionee=self.owner))

Example 48

Project: SchoolIdolAPI Source File: forms.py
Function: init
    def __init__(self, *args, **kwargs):
        super(CustomActivity, self).__init__(*args, **kwargs)
        self.fields['account_id'].widget = forms.HiddenInput()
        self.fields['message_data'].required = True
        self.fields['message_data'].label = _('Message')
        self.fields['message_data'].help_text = _('Write whatever you want. You can add formatting and links using Markdown.')

Example 49

Project: mezzanine Source File: forms.py
Function: init
    def __init__(self):
        initial = {}
        for field in hidden_field_defaults:
            initial[field] = BlogPost._meta.get_field(field).default
        initial["status"] = CONTENT_STATUS_DRAFT
        super(BlogPostForm, self).__init__(initial=initial)
        for field in hidden_field_defaults:
            self.fields[field].widget = forms.HiddenInput()

Example 50

Project: django-flows Source File: components.py
    def get_form(self, form_class):
        form = FormView.get_form(self, form_class)
        form.fields[config.FLOWS_TASK_ID_PARAM] = forms.CharField(widget=forms.HiddenInput, 
                                                                  initial=self.task_id,
                                                                  required=False)
        if '_with_errors' in self.state:
            errors = self.state.pop('_with_errors')
            form.full_clean()
            for field_name, error_message in errors.iteritems():
                form._errors[field_name] = form.error_class(error_message)
        return form
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3