text:
package com.vaadin.v7.ui.components.calendar;

import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import com.vaadin.v7.data.Container;
import com.vaadin.v7.data.Container.Indexed;
import com.vaadin.v7.data.Container.ItemSetChangeEvent;
import com.vaadin.v7.data.Container.ItemSetChangeNotifier;
import com.vaadin.v7.data.Item;
import com.vaadin.v7.data.Property;
import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.data.Property.ValueChangeNotifier;
import com.vaadin.v7.ui.components.calendar.CalendarComponentEvents.EventMoveHandler;
import com.vaadin.v7.ui.components.calendar.CalendarComponentEvents.EventResize;
import com.vaadin.v7.ui.components.calendar.CalendarComponentEvents.EventResizeHandler;
import com.vaadin.v7.ui.components.calendar.CalendarComponentEvents.MoveEvent;
import com.vaadin.v7.ui.components.calendar.event.BasicEvent;
import com.vaadin.v7.ui.components.calendar.event.CalendarEditableEventProvider;
import com.vaadin.v7.ui.components.calendar.event.CalendarEvent;
import com.vaadin.v7.ui.components.calendar.event.CalendarEvent.EventChangeListener;
import com.vaadin.v7.ui.components.calendar.event.CalendarEvent.EventChangeNotifier;
import com.vaadin.v7.ui.components.calendar.event.CalendarEventProvider;
import com.vaadin.v7.ui.components.calendar.event.CalendarEventProvider.EventSetChangeNotifier;

/**
 * A event provider which uses a {@link Container} as a datasource. Container
 * used as data source.
 *
 * NOTE: The data source must be sorted by date!
 *
 * @since 7.1.0
 * @author Vaadin Ltd.
 */
@SuppressWarnings("serial")
@Deprecated
public class ContainerEventProvider
        implements CalendarEditableEventProvider, EventSetChangeNotifier,
        EventChangeNotifier, EventMoveHandler, EventResizeHandler,
        Container.ItemSetChangeListener, Property.ValueChangeListener {

    // Default property ids
    public static final String CAPTION_PROPERTY = "caption";
    public static final String DESCRIPTION_PROPERTY = "description";
    public static final String STARTDATE_PROPERTY = "start";
    public static final String ENDDATE_PROPERTY = "end";
    public static final String STYLENAME_PROPERTY = "styleName";
    public static final String ALL_DAY_PROPERTY = "allDay";

    /**
     * Internal class to keep the container index which item this event
     * represents
     *
     */
    private class ContainerCalendarEvent extends BasicEvent {
        private final int index;

        public ContainerCalendarEvent(int containerIndex) {
            super();
            index = containerIndex;
        }

        public int getContainerIndex() {
            return index;
        }
    }

    /**
     * Listeners attached to the container
     */
    private final List<EventSetChangeListener> eventSetChangeListeners = new LinkedList<>();
    private final List<EventChangeListener> eventChangeListeners = new LinkedList<>();

    /**
     * The event cache contains the events previously created by
     * {@link #getEvents(Date, Date)}
     */
    private final List<CalendarEvent> eventCache = new LinkedList<>();

    /**
     * The container used as datasource
     */
    private Indexed container;

    /**
     * Container properties. Defaults based on using the {@link BasicEvent}
     * helper class.
     */
    private Object captionProperty = CAPTION_PROPERTY;
    private Object descriptionProperty = DESCRIPTION_PROPERTY;
    private Object startDateProperty = STARTDATE_PROPERTY;
    private Object endDateProperty = ENDDATE_PROPERTY;
    private Object styleNameProperty = STYLENAME_PROPERTY;
    private Object allDayProperty = ALL_DAY_PROPERTY;

    /**
     * Constructor
     *
     * @param container
     *            Container to use as a data source.
     */
    public ContainerEventProvider(Container.Indexed container) {
        this.container = container;
        listenToContainerEvents();
    }

    /**
     * Set the container data source
     *
     * @param container
     *            The container to use as datasource
     *
     */
    public void setContainerDataSource(Container.Indexed container) {
        // Detach the previous container
        detachContainerDataSource();

        this.container = container;
        listenToContainerEvents();
    }

    /**
     * Returns the container used as data source
     *
     */
    public Container.Indexed getContainerDataSource() {
        return container;
    }

    /**
     * Attaches listeners to the container so container events can be processed
     */
    private void listenToContainerEvents() {
        if (container instanceof ItemSetChangeNotifier) {
            ((ItemSetChangeNotifier) container).addItemSetChangeListener(this);
        }
        if (container instanceof ValueChangeNotifier) {
            ((ValueChangeNotifier) container).addValueChangeListener(this);
        }
    }

    /**
     * Removes listeners from the container so no events are processed
     */
    private void ignoreContainerEvents() {
        if (container instanceof ItemSetChangeNotifier) {
            ((ItemSetChangeNotifier) container)
                    .removeItemSetChangeListener(this);
        }
        if (container instanceof ValueChangeNotifier) {
            ((ValueChangeNotifier) container).removeValueChangeListener(this);
        }
    }

    /**
     * Converts an event in the container to an {@link CalendarEvent}
     *
     * @param index
     *            The index of the item in the container to get the event for
     * @return
     */
    private CalendarEvent getEvent(int index) {

        // Check the event cache first
        for (CalendarEvent e : eventCache) {
            if (e instanceof ContainerCalendarEvent
                    && ((ContainerCalendarEvent) e)
                            .getContainerIndex() == index) {
                return e;
            } else if (container.getIdByIndex(index) == e) {
                return e;
            }
        }

        final Object id = container.getIdByIndex(index);
        Item item = container.getItem(id);
        CalendarEvent event;
        if (id instanceof CalendarEvent) {
            /*
             * If we are using the BeanItemContainer or another container which
             * stores the objects as ids then just return the instances
             */
            event = (CalendarEvent) id;

        } else {
            /*
             * Else we use the properties to create the event
             */
            BasicEvent basicEvent = new ContainerCalendarEvent(index);

            // Set values from property values
            if (captionProperty != null
                    && item.getItemPropertyIds().contains(captionProperty)) {
                basicEvent.setCaption(String.valueOf(
                        item.getItemProperty(captionProperty).getValue()));
            }
            if (descriptionProperty != null && item.getItemPropertyIds()
                    .contains(descriptionProperty)) {
                basicEvent.setDescription(String.valueOf(
                        item.getItemProperty(descriptionProperty).getValue()));
            }
            if (startDateProperty != null
                    && item.getItemPropertyIds().contains(startDateProperty)) {
                basicEvent.setStart((Date) item
                        .getItemProperty(startDateProperty).getValue());
            }
            if (endDateProperty != null
                    && item.getItemPropertyIds().contains(endDateProperty)) {
                basicEvent.setEnd((Date) item.getItemProperty(endDateProperty)
                        .getValue());
            }
            if (styleNameProperty != null
                    && item.getItemPropertyIds().contains(styleNameProperty)) {
                basicEvent.setStyleName(String.valueOf(
                        item.getItemProperty(styleNameProperty).getValue()));
            }
            if (allDayProperty != null
                    && item.getItemPropertyIds().contains(allDayProperty)) {
                basicEvent.setAllDay((Boolean) item
                        .getItemProperty(allDayProperty).getValue());
            }
            event = basicEvent;
        }
        return event;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.addon.calendar.event.CalendarEventProvider#getEvents(java.
     * util.Date, java.util.Date)
     */
    @Override
    public List<CalendarEvent> getEvents(Date startDate, Date endDate) {
        eventCache.clear();
        int size = container.size();
        assert size >= 0;

        for (int i = 0; i < size; i++) {
            Object id = container.getIdByIndex(i);
            Item item = container.getItem(id);
            boolean add = true;
            if (startDate != null) {
                Date eventEnd = (Date) item.getItemProperty(endDateProperty)
                        .getValue();
                if (eventEnd.compareTo(startDate) < 0) {
                    add = false;
                }
            }
            if (add && endDate != null) {
                Date eventStart = (Date) item.getItemProperty(startDateProperty)
                        .getValue();
                if (eventStart.compareTo(endDate) >= 0) {
                    break; // because container is sorted, all further events
                    // will be even later
                }
            }
            if (add) {
                eventCache.add(getEvent(i));
            }
        }
        return Collections.unmodifiableList(eventCache);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.vaadin.addon.calendar.event.CalendarEventProvider.
     * EventSetChangeNotifier
     * #addListener(com.vaadin.addon.calendar.event.CalendarEventProvider.
     * EventSetChangeListener)
     */
    @Override
    public void addEventSetChangeListener(EventSetChangeListener listener) {
        if (!eventSetChangeListeners.contains(listener)) {
            eventSetChangeListeners.add(listener);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see com.vaadin.addon.calendar.event.CalendarEventProvider.
     * EventSetChangeNotifier
     * #removeListener(com.vaadin.addon.calendar.event.CalendarEventProvider.
     * EventSetChangeListener)
     */
    @Override
    public void removeEventSetChangeListener(EventSetChangeListener listener) {
        eventSetChangeListeners.remove(listener);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.vaadin.addon.calendar.event.CalendarEvent.EventChangeNotifier#
     * addListener
     * (com.vaadin.addon.calendar.event.CalendarEvent.EventChangeListener)
     */
    @Override
    public void addEventChangeListener(EventChangeListener listener) {
        if (eventChangeListeners.contains(listener)) {
            eventChangeListeners.add(listener);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see com.vaadin.addon.calendar.event.CalendarEvent.EventChangeNotifier#
     * removeListener
     * (com.vaadin.addon.calendar.event.CalendarEvent.EventChangeListener)
     */
    @Override
    public void removeEventChangeListener(EventChangeListener listener) {
        eventChangeListeners.remove(listener);
    }

    /**
     * Get the property which provides the caption of the event
     */
    public Object getCaptionProperty() {
        return captionProperty;
    }

    /**
     * Set the property which provides the caption of the event
     */
    public void setCaptionProperty(Object captionProperty) {
        this.captionProperty = captionProperty;
    }

    /**
     * Get the property which provides the description of the event
     */
    public Object getDescriptionProperty() {
        return descriptionProperty;
    }

    /**
     * Set the property which provides the description of the event
     */
    public void setDescriptionProperty(Object descriptionProperty) {
        this.descriptionProperty = descriptionProperty;
    }

    /**
     * Get the property which provides the starting date and time of the event
     */
    public Object getStartDateProperty() {
        return startDateProperty;
    }

    /**
     * Set the property which provides the starting date and time of the event
     */
    public void setStartDateProperty(Object startDateProperty) {
        this.startDateProperty = startDateProperty;
    }

    /**
     * Get the property which provides the ending date and time of the event
     */
    public Object getEndDateProperty() {
        return endDateProperty;
    }

    /**
     * Set the property which provides the ending date and time of the event
     */
    public void setEndDateProperty(Object endDateProperty) {
        this.endDateProperty = endDateProperty;
    }

    /**
     * Get the property which provides the style name for the event
     */
    public Object getStyleNameProperty() {
        return styleNameProperty;
    }

    /**
     * Set the property which provides the style name for the event
     */
    public void setStyleNameProperty(Object styleNameProperty) {
        this.styleNameProperty = styleNameProperty;
    }

    /**
     * Set the all day property for the event
     *
     * @since 7.3.4
     */
    public void setAllDayProperty(Object allDayProperty) {
        this.allDayProperty = allDayProperty;
    }

    /**
     * Get the all day property for the event
     *
     * @since 7.3.4
     */
    public Object getAllDayProperty() {
        return allDayProperty;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.data.Container.ItemSetChangeListener#containerItemSetChange
     * (com.vaadin.data.Container.ItemSetChangeEvent)
     */
    @Override
    public void containerItemSetChange(ItemSetChangeEvent event) {
        if (event.getContainer() == container) {
            // Trigger an eventset change event when the itemset changes
            for (EventSetChangeListener listener : eventSetChangeListeners) {
                listener.eventSetChange(new EventSetChangeEvent(this));
            }
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.data.Property.ValueChangeListener#valueChange(com.vaadin.data
     * .Property.ValueChangeEvent)
     */
    @Override
    public void valueChange(ValueChangeEvent event) {
        /*
         * TODO Need to figure out how to get the item which triggered the the
         * valuechange event and then trigger a EventChange event to the
         * listeners
         */
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.addon.calendar.ui.CalendarComponentEvents.EventMoveHandler
     * #eventMove
     * (com.vaadin.addon.calendar.ui.CalendarComponentEvents.MoveEvent)
     */
    @Override
    public void eventMove(MoveEvent event) {
        CalendarEvent ce = event.getCalendarEvent();
        if (eventCache.contains(ce)) {
            int index;
            if (ce instanceof ContainerCalendarEvent) {
                index = ((ContainerCalendarEvent) ce).getContainerIndex();
            } else {
                index = container.indexOfId(ce);
            }

            long eventLength = ce.getEnd().getTime() - ce.getStart().getTime();
            Date newEnd = new Date(event.getNewStart().getTime() + eventLength);

            ignoreContainerEvents();
            Item item = container.getItem(container.getIdByIndex(index));
            item.getItemProperty(startDateProperty)
                    .setValue(event.getNewStart());
            item.getItemProperty(endDateProperty).setValue(newEnd);
            listenToContainerEvents();
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.addon.calendar.ui.CalendarComponentEvents.EventResizeHandler
     * #eventResize
     * (com.vaadin.addon.calendar.ui.CalendarComponentEvents.EventResize)
     */
    @Override
    public void eventResize(EventResize event) {
        CalendarEvent ce = event.getCalendarEvent();
        if (eventCache.contains(ce)) {
            int index;
            if (ce instanceof ContainerCalendarEvent) {
                index = ((ContainerCalendarEvent) ce).getContainerIndex();
            } else {
                index = container.indexOfId(ce);
            }
            ignoreContainerEvents();
            Item item = container.getItem(container.getIdByIndex(index));
            item.getItemProperty(startDateProperty)
                    .setValue(event.getNewStart());
            item.getItemProperty(endDateProperty).setValue(event.getNewEnd());
            listenToContainerEvents();
        }
    }

    /**
     * If you are reusing the container which previously have been attached to
     * this ContainerEventProvider call this method to remove this event
     * providers container listeners before attaching it to an other
     * ContainerEventProvider
     */
    public void detachContainerDataSource() {
        ignoreContainerEvents();
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.addon.calendar.event.CalendarEditableEventProvider#addEvent
     * (com.vaadin.addon.calendar.event.CalendarEvent)
     */
    @Override
    public void addEvent(CalendarEvent event) {
        Item item;
        try {
            item = container.addItem(event);
        } catch (UnsupportedOperationException uop) {
            // Thrown if container does not support adding items with custom
            // ids. JPAContainer for example.
            item = container.getItem(container.addItem());
        }
        if (item != null) {
            item.getItemProperty(getCaptionProperty())
                    .setValue(event.getCaption());
            item.getItemProperty(getStartDateProperty())
                    .setValue(event.getStart());
            item.getItemProperty(getEndDateProperty()).setValue(event.getEnd());
            item.getItemProperty(getStyleNameProperty())
                    .setValue(event.getStyleName());
            item.getItemProperty(getDescriptionProperty())
                    .setValue(event.getDescription());
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.vaadin.addon.calendar.event.CalendarEditableEventProvider#removeEvent
     * (com.vaadin.addon.calendar.event.CalendarEvent)
     */
    @Override
    public void removeEvent(CalendarEvent event) {
        container.removeItem(event);
    }
}

redpajama_set_name: RedPajamaGithub


text:
DemDaily: State of the States: The Electoral College Count
Posted October 9, 2020 | by KimS | in 2020Presidential, DemDaily
Now just 25 days out from the 2020 presidential election, the Electoral College map has once again seen a shift -- in favor of Democrats.
State of the States
The battleground states of Florida, Iowa and Ohio, all flipped by Trump in 2016, are now in the "toss up" category, and Arizona, which Trump won by 3.5%, is now "leaning blue."
Most telling is that Texas, which has been a reliably red Republican stronghold for over four decades, and which Trump won by 9%, is now in real contention.
Based on our analysis of each state and ratings, Democrats have a total of 290 electoral votes in the Solid, Likely and Lean categories, putting them 20 past the 270 to win the election.
Republicans, comparatively, have 163 electoral votes in the Solid, Likely and Lean categories. The remaining 85 electoral votes fall in the "toss up" category.
The Electoral College is a body of electors established by the United States Constitution, which forms every four years following the November election for the sole purpose of officially electing the president and vice president of the United States.
270ToWin's interactive map
The number of electoral votes per state is equal to the size of its congressional delegation, for a total of 538 "electors," or voters, among the 50 states and the District of Columbia.
Maine and Nebraska differ from other states in that each awards two electoral votes to the statewide winner and one electoral vote to the winner in each congressional district.
Each state's electors will cast their votes in their respective state capitals on December 14, 2020, which will then be sent to Congress for counting and certification the first week of January. The newly elected president and vice president will be inaugurated on January 20, 2021.
An October 4-6, 2020 Economist/YouGov poll of likely voters showed Biden leading Trump 51% to 42%.
Know the Voting Laws in Your State!
DemList will keep you informed.
Please Support DemList!
DemList
Connecting you to The Party
Connecting you to Each Other
SignUp for the Dailys. Follow on Facebook, Twitter and LinkedIn
Check out the 2020 DemList Election Calendar for new Biden-Harris events!
Sources: 270ToWin, Cook Political Report, Inside Elections, Sabato's Crystal Ball, RealClearPolitics
DemDaily: The Calendar and Current Count
As we enter the final stretch of the presidential nomination process, an update on the Count and remaining Calendar contests.
DemDaily: The Status of the Presidency 5:00am
At 2:50am this morning Donald J. Trump took the stage. At 5:00am the four remaining states
DemDaily: The Supreme Court
While the balance for the Supreme Court may not register among the top three issues for many 2016 voters, the outcome of this year's Presidential and US Senate contests will determine the...
DemDaily: Electors and Inaugural
December 15, 2020 Yesterday the 538 members of the Electoral College certified the results of 2020 presidential election, affirming Joe Biden and Kamala Harris as the 46th President and Vice...

redpajama_set_name: RedPajamaCommonCrawl


12 volt power plug, 1.5-2 amps.
Click here for more information about the things you need.
Instructions for making a one wavelength Eliza, a bucket red light hat are underway. They will be published as a document rather than as blog posts.
Previous Previous post: Parkinson's – where is the problem?


Lookup Public Records in Hodgeman County, Kansas. Including Vital Birth and Death Records, Deeds, Probate, Property Records, Mortgages, Liens, Judgments, Marriage Licenses, Voter Registrar, Payroll, Military Discharges.
Hodgeman County is a county located in the state of Kansas. The county was formed in February 26, 1867. Named after Amos Hodgman, member of the 7th Regiment Kansas Volunteer Cavalry, the county seat is Jetmore and it has a population of 1950 as of 2013. The county has a total area of 860 square miles, with its land area encompassing 860 square miles, and its water area 0.3 square miles. The county consists of 6 ZIP codes, with ZIP code 67854 recorded as the one with the largest population. Moreover, Hodgeman County borders the following counties: Ness County, Kansas to the north; Ford County, Kansas to the south; Pawnee County, Kansas to the east; Finney County, Kansas to the west; Gray County, Kansas to the southwest, and; Edwards County, Kansas to the southeast.
The Hodgeman County Appraiser's Dept. is responsible for discovering, assessing, listing and valuing all property in Hodgeman County. The Appraiser's Dept. sets the values for real estate, personal property, oil & gas. The Department is also responsible for change of ownership, parcel maintenance and mapping.


Our Frontlines ministry demonstrates Christ's love by showing hospitality to others and making Skyland a welcoming place for visitors and members. We're always looking for helpers with servant hearts, and being part of Frontlines is an easy way to get involved and meet new people!
Ushers. Greeting people with the love of Christ and true hospitality is a ministry in itself! Our ushers welcome people to Sunday services, help visitors find where they need to go, pass out bulletins, and more.
Holy Grounds. We serve up fellowship alongside a cup of coffee and breakfast goodies every Sunday morning. Our Holy Grounds team helps with setup, cleanup and pouring coffee.
Wednesday Night Supper. Wednesday nights are fun times of food and fellowship, and supper always draws a crowd! Come help serve dinner and tidy up the Dining Room afterwards.


Preece, Julian and Hodgin, Nick, eds. 2017. Andreas Dresen. Contemporary German Writers and Filmmakers, Peter Lang.
Hodgin, Nicholas 2017. Alternative realities and authenticity in DEFA's documentary films. In: Silberman, Marc and Wrage, Henning eds. DEFA at the Crossroads of East German and International Film Culture A Companion, de Gruyter, pp. 281-304.
Hodgin, Nick and Thakkar, Amit, eds. 2017. Scars and wounds: Film and legacies of trauma. Basingstoke: Palgrave Macmillan.
Hodgin, Nicholas 2017. Proximity and distance: approaching trauma in Katrina Films. In: Hodgin, Nicholas and Thakkar, Amit eds. Scars and Wounds: Film and Legacies of Trauma, Basingstoke: Palgrave, pp. 101-126.
Hodgin, Nicholas 2017. Introduction: Trauma studies, film and the scar motif. In: Hodgin, Nicholas and Thakkar, Amit eds. Scars and Wounds: Film and Legacies of Trauma, Basingstoke: Palgrave, pp. 1-29.
Hodgin, Nick 2016. DEFA's Last Gasp. Ruins, Melancholy and the End of East German Filmmaking. In: Allan, Sean and Heiduschke, Sebastian eds. RE-Imagining DEFA East German Cinema in its National and Transnational Contexts, Berghahn Books, pp. 271-292.
Hodgin, Nick 2014. East Germany revisited, reimagined, repositioned: Representing the GDR in Dominik Graf's Der rote Kakadu (2005) and Christian Petzold's Barbara (2012). In: Gott, Michael and Herzog, Todd eds. East, West and Centre: Reframing post-1989 European Cinema, Edinburgh: Edinburgh University Press, pp. 237-252.
Hodgin, Nicholas 2011. Aiming to please? Consensus and consciousness-raising in Wolfgang Becker's Good Bye, Lenin! (2003). In: Cooke, Paul and Homewood, Chris eds. New Directions in German Cinema, Taurus World Cinema Series, I.B. Tauris, pp. 94-112.
Hodgin, Nick 2011. Screening the East: Heimat, memory and nostalgia in German film since 1989. Film Europa, Berghahn Books.
Hodgin, Nicholas 2011. Screening the Stasi: the politics of representation in postunification film. In: Hodgin, Nicholas and Pearce, Caroline eds. The GDR Remembered: Representations of the East German State since 1989, Camden House/Boydell&Brewer, pp. 69-92.
Hodgin, Nicholas and Pearce, Caroline 2011. Introduction. In: Hodgin, Nicholas and Pearce, Caroline eds. The GDR Remembered: Representations of the East German State since 1989, Camden House/Boydell&Brewer, pp. 1-16.
Hodgin, Nick and Pearce, Caroline, eds. 2011. The GDR remembered: Representations of the East German state since 1989. Studies in German Literature Linguistics and Culture, Camden House.
Hodgin, Nick 2010. Eastern blues, southern comforts: searching for Heimat on the Bayous. Mississippi Quarterly 3-4 , pp. 512-534.
Hodgin, Nicholas 2007. 'Marginalized subjects, mainstream objectives: insights on outsiders in recent German Film. New Readings 8 , pp. 1-21.
This list was generated on Tue Apr 23 08:21:47 2019 BST.


Let's get to work! Courses to boost your business in no time!
I'm a designer by trade, but a teacher at heart.
So much so that a few years back I went back to school for a masters degree in education. The training taught me a lot about how to approach teachable moments and different learning strategies.
All of that hard school work was put to good use when I began coaching other businesses. I became overwhelmed with the number of coaching appointments I could take on at once. That's how these courses were born. I wanted to be able to help everyone, not only those who could pay for an appointment.
These courses were made to be informative and affordable. Take a look at the offerings and I'll see you in class!
Please make sure you are using a valid email to be added to the list.
You will receive instructions and the workbook by email within 24 hours.
The workshop lasts for four weeks. Workshop emails go out every Thursday There are small assignments, resources and a 15 minute one-on-one session if you wish to utilize it.
In addition to my branding biz, I own and operate a successful stationery business, Ruffled Paper. I work with brides on a daily basis to get the perfect stationery sets for their invitations.
You will receive an email with instructions for the course within 24 hours of purchase.
I created this course in lieu of offering resume designing services.
I was getting a lot of requests to design resumes and not as much time as I would have liked to take them on.
At the end of this course, you will come out with a well-designed professional resume.
An email to the course will be sent within 24 hours of purchase.
of your resume with one revision.
Jessica is a New Jersey native now living in rural Pennsylvania. She has a Bachelor of Science in Communication Arts, with a minor in Business and is working towards completing her Master of Arts in Elementary and Special Education.
She has worked for national and global publications. Once she began her own design studio, she obtained freelance jobs from clients like Sephora, Elizabeth & James, Nordstrom, and BRIDES Magazine.
She lives on a lake with her cute husband, Chris and her sweet yellow lab, Toby.
A gorgeous multi-page responsive website.
beautiful galleries and a WordPress blog.
Looking to open up with a statement image to show your clients what you're about? Moodie is your girl. A beautiful theme with features galore!
Sage is a one-page responsive template that scrolls as the viewer clicks through. It's a sweet design that includes an optional gallery.
Not sure where to start when it comes to increasing or managing your social media accounts?
JOIN OUR FACEBOOK GROUP "hELLO cREATIVES"
TO CONNECT WITH OTHER BUSINESSES!
lEAVE YOUR EMAIL BELOW TO get A FREE SHOWIT TEMPLATE!