Project

General

Profile

Revision 699de23b

ID699de23baf084a2f9a8d09a53561c78150692cfa
Parent fa315d14
Child 0773de61

Added by Andreas Kohlbecker over 3 years ago

ref #7195 consistently displaying blocking registrations in list view and registration working set editor:
- RegistrationWorkingSetService method to load blocking registrations
- using ShowDetailsEvent to request presenters to show blocking registrations
- adapting layout

View differences:

src/main/java/eu/etaxonomy/cdm/service/IRegistrationWorkingSetService.java
9 9
package eu.etaxonomy.cdm.service;
10 10

  
11 11
import java.util.Collection;
12
import java.util.Set;
12 13

  
13 14
import eu.etaxonomy.cdm.api.service.pager.Pager;
14 15
import eu.etaxonomy.cdm.model.common.User;
......
42 43
     */
43 44
    public RegistrationWorkingSet loadWorkingSetByReferenceID(Integer referenceID) throws RegistrationValidationException;
44 45

  
46
    public Set<RegistrationDTO> loadBlockingRegistrations(Integer blockedRegistrationId);
47

  
45 48
}
src/main/java/eu/etaxonomy/cdm/service/RegistrationWorkingSetService.java
53 53
public class RegistrationWorkingSetService implements IRegistrationWorkingSetService {
54 54

  
55 55
    public static final List<String> REGISTRATION_INIT_STRATEGY = Arrays.asList(new String []{
56
            "blockedBy.typeDesignations",
56
            "blockedBy",
57 57
            // typeDesignation
58 58
            "typeDesignations.typeStatus",
59 59
            "typeDesignations.typifiedNames.typeDesignations", // important !!
......
98 98
          "derivationEvents.derivatives" // important, otherwise the DerivedUnits are not included into the graph of initialized entities!!!
99 99
  });
100 100

  
101
  public static final List<String> BLOCKING_REGISTRATION_INIT_STRATEGY = Arrays.asList(new String []{
102

  
103
          "blockedBy.blockedBy",
104
          // typeDesignation
105
          "blockedBy.typeDesignations.typeStatus",
106
//          "typeDesignations.typifiedNames.typeDesignations", // important !!
107
//          "typeDesignations.typeSpecimen",
108
//          "typeDesignations.typeName.$",
109
//          "typeDesignations.citation",
110
//          "typeDesignations.citation.authorship.$",
111
          // name
112
//          "blockedBy.name.$",
113
          "blockedBy.name.nomenclaturalReference.authorship",
114
          "blockedBy.name.nomenclaturalReference.inReference",
115
          "blockedBy.name.rank",
116
//          "name.homotypicalGroup.typifiedNames",
117
//          "name.status.type",
118
//          "name.typeDesignations",
119
          // institution
120
          "blockedBy.institution",
121
          }
122
  );
123

  
101 124
    /**
102 125
     *
103 126
     */
......
167 190
        return new RegistrationWorkingSet(makeDTOs(pager.getRecords()));
168 191
    }
169 192

  
193
    @Override
194
    public Set<RegistrationDTO> loadBlockingRegistrations(Integer blockedRegistrationId){
195

  
196
        Registration registration = repo.getRegistrationService().load(blockedRegistrationId, BLOCKING_REGISTRATION_INIT_STRATEGY);
197
        Set<Registration> registrations = registration.getBlockedBy();
198

  
199
        Set<RegistrationDTO> blockingSet = new HashSet<>();
200
        for(Registration reg : registrations){
201
            blockingSet.add(new RegistrationDTO(reg));
202
        }
203
        return blockingSet;
204
    }
205

  
170 206
    /**
171 207
     * @param regs
172 208
     * @return
......
179 215
    }
180 216

  
181 217

  
218

  
182 219
    /**
183 220
     * @param regs
184 221
     */
src/main/java/eu/etaxonomy/cdm/vaadin/component/registration/RegistrationItem.java
12 12

  
13 13
import java.util.Collection;
14 14
import java.util.EnumSet;
15
import java.util.Set;
15 16

  
16 17
import org.joda.time.DateTime;
17 18
import org.joda.time.format.ISODateTimeFormat;
......
76 77

  
77 78
    private RegistrationDTO regDto;
78 79

  
79
    private boolean showBlockingRelations = false;
80

  
81 80
    private TimePeriodFormatter timePeriodFormatter = new TimePeriodFormatter(DateTimeFormat.ISO8601_DATE);
82 81

  
83 82
    // --------------------------------------------------
......
193 192
            setComponentError(new UserError("Citation is missing"));
194 193
        }
195 194

  
196
        if(showBlockingRelations){
197
            createBlockingRelationsContent();
198
        }
199

  
200 195
        updateUI(regDto.getBibliographicCitationString(), regDto.getCreated(), regDto.getDatePublished(), regDto.getMessages().size(),
201 196
                navigationEvent, null, regDto, regDto.getSubmitterUserName());
202 197
    }
......
225 220
                referenceEditorAction, FontAwesome.EDIT, null, submitterName);
226 221
    }
227 222

  
228
    private void createBlockingRelationsContent(){
229

  
230
        if(blockingRelationsPanel == null && !regDto.getBlockedBy().isEmpty()){
231
            blockingRelationsPanel = new RegistrationItemsPanel(parentView, "blocked by", regDto.getBlockedBy());
232
            addComponent(blockingRelationsPanel, 0, 4, GRID_COLS - 1, 4);
233
        }
234

  
235
    }
236 223

  
237 224
    /**
238 225
     * @param submitterUserName TODO
......
269 256
            getMessageButton().setCaptionAsHtml(true);
270 257
        }
271 258

  
272
        if(regDto != null && !regDto.isBlocked()){
259
        if(regDto != null && regDto.isBlocked()){
273 260
            getBlockedByButton().setEnabled(true);
274 261
            getBlockedByButton().addStyleName("blocked");
275 262
        }
......
333 320
        }
334 321
    }
335 322

  
323
    public int getRegistrationId(){
324
        return regDto.getId();
325
    }
326

  
327
    /**
328
     * @param showBlockingRelations the showBlockingRelations to set
329
     */
330
    public void showBlockingRegistrations(Set<RegistrationDTO> blockingRegDTOs) {
331

  
332
        if(blockingRelationsPanel == null) {
333

  
334
            if(regDto.isBlocked() && blockingRegDTOs.isEmpty()){
335
                throw new RuntimeException("Registration is blocked but tet of blocking registrations is empty");
336
            }
337
            if(!regDto.isBlocked() && !blockingRegDTOs.isEmpty()){
338
                throw new RuntimeException("No point showing blocking registrations for an unblocked registration");
339
            }
340

  
341
            blockingRelationsPanel = new RegistrationItemsPanel(parentView, "blocked by", blockingRegDTOs);
342
            addComponent(blockingRelationsPanel, 0, 4, GRID_COLS - 1, 4);
343
        }
344

  
345
    }
346

  
336 347
    /* ====== RegistrationItemDesign Getters ====== */
337 348
    /**
338 349
     * @return the typeStateLabel
......
409 420
     * @return the showBlockingRelations
410 421
     */
411 422
    public boolean isShowBlockingRelations() {
412
        return showBlockingRelations;
423
        return blockingRelationsPanel != null;
413 424
    }
414 425

  
415
    /**
416
     * @param showBlockingRelations the showBlockingRelations to set
417
     */
418
    public void setShowBlockingRelations(boolean showBlockingRelations) {
419
        if(showBlockingRelations && !this.showBlockingRelations){
420
            createBlockingRelationsContent();
421
        }
422
        this.showBlockingRelations = showBlockingRelations;
423
    }
424

  
425

  
426 426

  
427 427
   /* --------------------------------------- */
428 428

  
src/main/java/eu/etaxonomy/cdm/vaadin/event/ShowDetailsEvent.java
31 31

  
32 32
    /**
33 33
     *
34
     * @param e
34
     * @param sourceEvent
35 35
     * @param identifier
36 36
     * @param property
37 37
     */
38
    public ShowDetailsEvent(Event e, Class<T> entityType , I identifier, String property) {
39
        this.source = e;
38
    public ShowDetailsEvent(Event sourceEvent, Class<T> entityType , I identifier, String property) {
39
        this.source = sourceEvent;
40 40
        this.entityType = entityType;
41 41
        this.identifier = identifier;
42 42
        this.property = property;
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/ListPresenter.java
9 9
package eu.etaxonomy.cdm.vaadin.view.registration;
10 10

  
11 11
import java.util.EnumSet;
12
import java.util.Set;
12 13

  
13 14
import org.apache.commons.lang3.StringUtils;
14 15
import org.springframework.beans.factory.annotation.Autowired;
......
25 26
import eu.etaxonomy.cdm.model.reference.Reference;
26 27
import eu.etaxonomy.cdm.service.IRegistrationWorkingSetService;
27 28
import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;
29
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItem;
28 30
import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;
29 31
import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
30 32
import eu.etaxonomy.cdm.vaadin.event.UpdateResultsEvent;
......
131 133
    }
132 134

  
133 135
    @EventBusListenerMethod
134
    public void onShowDetailsEvent(ShowDetailsEvent<?,?> event) {
135

  
136
        if(event.getEntityType().equals(RegistrationDTO.class)){
137
            RegistrationDTO regDto = getWorkingSetService().loadDtoById((Integer)event.getIdentifier());
138
            if(event.getProperty().equals("messages")){
139
                if(getView() != null){
140
                    getView().openDetailsPopup("Messages", regDto.getMessages());
141
                }
142
            }
136
    public void onShowDetailsEvent(ShowDetailsEvent<RegistrationDTO, Integer> event) {
137

  
138
        // FIXME check from own view!!!
139
        if(getView() == null){
140
            return;
143 141
        }
142

  
143
        Integer registrationId = event.getIdentifier();
144

  
145
        RegistrationDTO regDto = getWorkingSetService().loadDtoById(registrationId);
146
        if(event.getProperty().equals("messages")){
147

  
148
            getView().openDetailsPopup("Messages", regDto.getMessages());
149

  
150
        } else if(event.getProperty().equals("blockedBy")){
151

  
152
            Set<RegistrationDTO> blockingRegs = getWorkingSetService().loadBlockingRegistrations(registrationId);
153
            RegistrationItem regItem = getView().getRegistrationItem(registrationId);
154
            regItem.showBlockingRegistrations(blockingRegs);
155
        }
156

  
144 157
    }
145 158

  
146 159
    @EventBusListenerMethod
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/ListView.java
14 14
import com.vaadin.ui.TextField;
15 15

  
16 16
import eu.etaxonomy.cdm.api.service.pager.Pager;
17
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItem;
17 18
import eu.etaxonomy.vaadin.mvp.ApplicationView;
18 19

  
19 20
/**
......
73 74
     */
74 75
    Mode getViewMode();
75 76

  
77
    public RegistrationItem getRegistrationItem(int registrationId);
78

  
76 79

  
77 80
}
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/ListViewBean.java
23 23
import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
24 24
import com.vaadin.server.Page;
25 25
import com.vaadin.spring.annotation.SpringView;
26
import com.vaadin.ui.Component;
26 27
import com.vaadin.ui.CssLayout;
27 28
import com.vaadin.ui.HorizontalLayout;
28 29
import com.vaadin.ui.Label;
......
31 32
import com.vaadin.ui.TextField;
32 33

  
33 34
import eu.etaxonomy.cdm.api.service.pager.Pager;
35
import eu.etaxonomy.cdm.model.name.Registration;
34 36
import eu.etaxonomy.cdm.model.name.RegistrationStatus;
35 37
import eu.etaxonomy.cdm.vaadin.component.TextFieldNFix;
36 38
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItem;
39
import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
37 40
import eu.etaxonomy.cdm.vaadin.event.UpdateResultsEvent;
38 41
import eu.etaxonomy.cdm.vaadin.security.AccessRestrictedView;
39 42
import eu.etaxonomy.cdm.vaadin.security.UserHelper;
......
157 160
            RegistrationItem item = new RegistrationItem(regDto, this);
158 161
            item.getSubmitterLabel().setVisible(isCurator);
159 162
            item.setWidth(100, Unit.PERCENTAGE);
160
            item.getBlockedByButton().addClickListener(e -> item.setShowBlockingRelations(true));
163
            item.getBlockedByButton().addClickListener(e -> getViewEventBus().publish(
164
                    this,
165
                    new ShowDetailsEvent<Registration, Integer>(
166
                            e, Registration.class, regDto.getId(), "blockedBy"
167
                            )
168
                    ));
161 169
            listContainer.addComponent(item);
162 170
        }
163 171
    }
......
266 274
        return viewMode;
267 275
    }
268 276

  
277
    public RegistrationItem getRegistrationItem(int registrationId){
278
        for(Component c : listContainer){
279
            RegistrationItem item = (RegistrationItem)c;
280
            if(registrationId == item.getRegistrationId()){
281
                return item;
282
            }
283

  
284
        }
285
        return null;
286
    }
287

  
269 288

  
270 289

  
271 290

  
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/RegistrationDTO.java
58 58

  
59 59
    private List<String> messages = new ArrayList<>();
60 60

  
61
    private Set<RegistrationDTO> blockedBy;
61
    private Set<TypedEntityReference<Registration>> blockedBy;
62 62

  
63 63

  
64 64
    /**
......
366 366
    /**
367 367
     * @return the blockedBy
368 368
     */
369
    public Set<RegistrationDTO> getBlockedBy() {
369
    public Set<TypedEntityReference<Registration>> getBlockedBy() {
370 370

  
371 371
        if(blockedBy == null){
372 372
            blockedBy = new HashSet<>();
373 373
            if(reg.getBlockedBy() != null){
374 374
                for(Registration blockReg : reg.getBlockedBy()){
375
                    blockedBy.add(new RegistrationDTO(blockReg));
375
                    blockedBy.add(new TypedEntityReference<Registration>(Registration.class, blockReg.getId(), blockReg.getIdentifier()));
376 376
                }
377 377
            }
378 378
        }
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/RegistrationWorkingsetPresenter.java
12 12
import java.util.Arrays;
13 13
import java.util.EnumSet;
14 14
import java.util.List;
15
import java.util.Set;
15 16
import java.util.Stack;
16 17
import java.util.UUID;
17 18

  
......
604 605
                refreshView(true);
605 606
            }
606 607
        }
608
    }
609

  
610
    @EventBusListenerMethod
611
    public void onShowDetailsEvent(ShowDetailsEvent<RegistrationDTO, Integer> event) {
612

  
613
        // FIXME check from own view!!!
614
        if(getView() == null){
615
            return;
616
        }
617

  
618
        Integer registrationId = event.getIdentifier();
619

  
620
        RegistrationDTO regDto = getWorkingSetService().loadDtoById(registrationId);
621
        if(event.getProperty().equals("blockedBy")){
622

  
623
            Set<RegistrationDTO> blockingRegs = getWorkingSetService().loadBlockingRegistrations(registrationId);
624
            getView().setBlockingRegistrations(registrationId, blockingRegs);
625
        }
607 626

  
608 627
    }
609 628

  
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/RegistrationWorkingsetView.java
9 9
package eu.etaxonomy.cdm.vaadin.view.registration;
10 10

  
11 11
import java.util.List;
12
import java.util.Set;
12 13
import java.util.UUID;
13 14

  
14 15
import org.vaadin.viritin.fields.LazyComboBox;
......
61 62
     */
62 63
    void setWorkingset(RegistrationWorkingSet workingset);
63 64

  
65
    @Deprecated // no longer needed
64 66
    void addBlockingRegistration(RegistrationDTO blocking);
65 67

  
66 68
    /**
......
87 89
     */
88 90
    void chooseNewTypeRegistrationWorkingset(Integer registrationEntityId);
89 91

  
92
    /**
93
     * @param registrationId
94
     * @param blockingRegDTOs
95
     */
96
    void setBlockingRegistrations(int registrationId, Set<RegistrationDTO> blockingRegDTOs);
97

  
90 98

  
91 99

  
92 100

  
src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/RegistrationWorksetViewBean.java
11 11
import java.util.ArrayList;
12 12
import java.util.Collection;
13 13
import java.util.EnumSet;
14
import java.util.HashMap;
15
import java.util.Iterator;
14 16
import java.util.List;
17
import java.util.Map;
18
import java.util.Set;
15 19
import java.util.Stack;
16 20
import java.util.UUID;
17 21

  
......
25 29
import com.vaadin.spring.annotation.SpringView;
26 30
import com.vaadin.ui.Alignment;
27 31
import com.vaadin.ui.Button;
28
import com.vaadin.ui.Button.ClickEvent;
29
import com.vaadin.ui.Button.ClickListener;
30 32
import com.vaadin.ui.CssLayout;
31 33
import com.vaadin.ui.GridLayout;
32 34
import com.vaadin.ui.HorizontalLayout;
......
72 74
public class RegistrationWorksetViewBean extends AbstractPageView<RegistrationWorkingsetPresenter>
73 75
    implements RegistrationWorkingsetView, View, AccessRestrictedView {
74 76

  
77
    private class RegistrationDetailsItem {
78

  
79
        RegistrationItemEditButtonGroup registrationItemEditButtonGroup;
80
        CssLayout itemFooter;
81

  
82
        public RegistrationDetailsItem(RegistrationItemEditButtonGroup registrationItemEditButtonGroup, CssLayout itemFooter){
83
            this.registrationItemEditButtonGroup = registrationItemEditButtonGroup;
84
            this.itemFooter = itemFooter;
85
        }
86

  
87

  
88
    }
89

  
90
    /**
91
     *
92
     */
93
    private static final int COL_INDEX_STATE_LABEL = 0;
94

  
95
    /**
96
     *
97
     */
98
    private static final int COL_INDEX_REG_ITEM = 1;
99

  
100
    /**
101
     *
102
     */
103
    private static final int COL_INDEX_BUTTON_GROUP = 2;
104

  
75 105
    public static final String DOM_ID_WORKINGSET = "workingset";
76 106

  
77 107
    private static final long serialVersionUID = -213040114015958970L;
......
99 129

  
100 130
    private Panel registrationListPanel;
101 131

  
132
    private Map<Integer, RegistrationDetailsItem> registrationItemMap = new HashMap<>();
133

  
102 134
    public RegistrationWorksetViewBean() {
103 135
        super();
104 136
    }
......
151 183

  
152 184
    }
153 185

  
186
    @Override
187
    public void setBlockingRegistrations(int registrationId, Set<RegistrationDTO> blockingRegDTOs) {
188

  
189
        RegistrationDetailsItem regItem = registrationItemMap.get(registrationId);
190

  
191
        boolean blockingRegAdded = false;
192
        for(Iterator it = regItem.itemFooter.iterator(); it.hasNext(); ){
193
            if(it.next() instanceof RegistrationItemsPanel){
194
                blockingRegAdded = true;
195
                break;
196
            }
197
        }
198
        if(!blockingRegAdded){
199
            regItem.itemFooter.addComponent(new RegistrationItemsPanel(this, "Blocked by", blockingRegDTOs));
200
        }
201
    }
202

  
154 203
    /**
155 204
     * {@inheritDoc}
156 205
     */
157 206
    @Override
207
    @Deprecated // no longer needed
158 208
    public void addBlockingRegistration(RegistrationDTO blocking) {
159 209
        if(registrations == null) {
160 210
            throw new RuntimeException("A Workingset must be present prior adding blocking registrations.");
......
177 227
        //registrationsGrid.setColumnExpandRatio(0, 0.1f);
178 228
        registrationsGrid.setColumnExpandRatio(1, 1f);
179 229

  
230
        registrationItemMap.clear();
231
        registrationsGrid.setRows(workingset.getRegistrationDTOs().size() * 2  + 2);
180 232
        int row = 0;
181 233
        for(RegistrationDTO dto : workingset.getRegistrationDTOs()) {
182
            putRegistrationListComponent(registrationsGrid, row++, dto);
234
            row = putRegistrationListComponent(row, dto);
183 235
        }
184 236

  
185 237
        Label addRegistrationLabel_1 = new Label("Add a new registration for a");
......
207 259
//        buttonContainer.setWidth(100, Unit.PERCENTAGE);
208 260
        buttonContainer.setComponentAlignment(addRegistrationLabel_1, Alignment.MIDDLE_LEFT);
209 261
        buttonContainer.setComponentAlignment(addRegistrationLabel_2, Alignment.MIDDLE_LEFT);
210
        registrationsGrid.addComponent(buttonContainer, 0, row, 2, row);
262

  
263
        row++;
264
        registrationsGrid.addComponent(buttonContainer, 0, row, COL_INDEX_BUTTON_GROUP, row);
211 265
        registrationsGrid.setComponentAlignment(buttonContainer, Alignment.MIDDLE_RIGHT);
212 266

  
213 267
        Panel namesTypesPanel = new Panel(registrationsGrid);
......
215 269
    }
216 270

  
217 271

  
218
    /**
219
     * @param grid
220
     * @param row If null, the new row will be inserted as last registration item, that is before the button row.
221
     * @param dto
222
     */
223
    protected void putRegistrationListComponent(GridLayout grid, int row, RegistrationDTO dto) {
224 272

  
225
        grid.setRows(grid.getRows() + 1);
273
    protected int putRegistrationListComponent(int row, RegistrationDTO dto) {
226 274

  
227 275
        RegistrationItemEditButtonGroup regItemButtonGroup = new RegistrationItemEditButtonGroup(dto);
228 276
        Integer registrationEntityID = dto.getId();
277
        CssLayout footer = new CssLayout();
278
        footer.setWidth(100, Unit.PERCENTAGE);
279
        footer.setStyleName("item-footer");
280
        RegistrationDetailsItem regDetailsItem = new RegistrationDetailsItem(regItemButtonGroup, footer);
281
        registrationItemMap.put(registrationEntityID, regDetailsItem);
229 282
        Stack<EditorActionContext> context = new Stack<EditorActionContext>();
230 283
        context.push(new EditorActionContext(
231 284
                    new TypedEntityReference<>(Registration.class, registrationEntityID),
......
276 329
        if(!dto.isBlocked()){
277 330
            blockingRegistrationButton.setEnabled(false);
278 331
        } else {
279
            blockingRegistrationButton.addClickListener(new ClickListener() {
280

  
281
                private static final long serialVersionUID = 2846082434479085292L;
282
                RegistrationItemsPanel blockedByPanel = null;
283
                @Override
284
                public void buttonClick(ClickEvent event) {
285
                    if(blockedByPanel == null){
286
                        blockedByPanel = new RegistrationItemsPanel(RegistrationWorksetViewBean.this, "Blocked by", dto.getBlockedBy());
287
                        regItemButtonGroup.addComponent(blockedByPanel);
288
                    }
289
                }
290
            });
332
            blockingRegistrationButton.addClickListener(e -> getViewEventBus().publish(
333
                    this,
334
                    new ShowDetailsEvent<RegistrationDTO, Integer>(
335
                            e,
336
                            RegistrationDTO.class,
337
                            dto.getId(),
338
                            "blockedBy"
339
                            )
340
                    ));
291 341
        }
292 342
        buttonGroup.addComponent(blockingRegistrationButton);
293 343

  
......
329 379
        PermissionDebugUtils.addGainPerEntityPermissionButton(buttonGroup, Registration.class, dto.getId(),
330 380
                EnumSet.of(CRUD.UPDATE), RegistrationStatus.PREPARATION.name());
331 381

  
332
        grid.addComponent(stateLabel, 0, row);
333
        grid.setComponentAlignment(stateLabel, Alignment.TOP_LEFT);
334
        grid.addComponent(regItemButtonGroup, 1, row);
335
        grid.addComponent(buttonGroup, 2, row);
336
        grid.setComponentAlignment(buttonGroup, Alignment.TOP_LEFT);
382
        row++;
383
        registrationsGrid.addComponent(stateLabel, COL_INDEX_STATE_LABEL, row);
384
        registrationsGrid.setComponentAlignment(stateLabel, Alignment.TOP_LEFT);
385
        registrationsGrid.addComponent(regItemButtonGroup, COL_INDEX_REG_ITEM, row);
386
        registrationsGrid.addComponent(buttonGroup, COL_INDEX_BUTTON_GROUP, row);
387
        registrationsGrid.setComponentAlignment(buttonGroup, Alignment.TOP_LEFT);
388

  
389
        row++;
390
        registrationsGrid.addComponent(footer, 0, row, COL_INDEX_BUTTON_GROUP, row);
391

  
392
        return row;
337 393
    }
338 394

  
339 395
    /**
src/main/webapp/VAADIN/themes/edit-valo/edit-valo.scss
259 259
                margin-top: round($v-unit-size / 2);
260 260
            }
261 261
        
262
            .registration-list {
263
                .v-gridlayout-slot {
264
                    border-bottom: valo-border($border: $v-border, $color: $v-background-color, $strength: 1.4);
265
                }
262
            .v-panel-content {
263
                padding: 0 round($v-unit-size/3);
264
            }
265
            .registration-list .item-footer {
266
                border-bottom: valo-border($border: $v-border, $color: $v-background-color, $strength: 1.4);
266 267
            }
267 268
    }
268 269

  

Also available in: Unified diff

Add picture from clipboard (Maximum size: 40 MB)