text:
Back To Dog Breeds
Temperament: Alert, Intelligent, Brave
Height: 24.5-29 inches
Weight: 77-132 pounds
Life Expectancy: 10-14 years
Group: Foundation Stock Service
The AKC has grouped all of the breeds that it registers into seven categories, or groups, roughly based on function and heritage. Breeds are grouped together because they share traits of form and function or a common heritage.
The Estrela Mountain Dog is not only an excellent livestock guardian, but is also known for his love of children and family. Proper socialization and training as a puppy is very important so that the dominance in the Estrela's personality does not become aggressive.
About AKC PuppyFinder Care History Did You Know? Breed Standard Other Breeds to Explore
Navigate Page About AKC PuppyFinder Care History Did You Know? Breed Standard Other Breeds to Explore
About the Estrela Mountain Dog
The Estrela Mountain Dog is named for the Estrela Mountains in Portugal and is believed to be the oldest breed in the region. The breed has several distinctive physical characteristics including rosed ears, a black mask and a hook at the end of its tail. He is an inseparable companion of the shepherd and a faithful flock guardian, bravely protecting it against predators and thieves. A wonderful farm and house guard, he is distrustful towards strangers but typically docile to his master.
As a companion in the home, an Estrela will bond for life. He will love and protect his whole family, but a piece of his soul will belong to that one special family member of his choosing. As an Estrela owner tells us: "There is nothing compared to the love of an Estrela."
Breed Contact Details
Website: www.mistymountainestrelas.com
Person: Robin Eatman
National Breed Clubs and Rescue
Want to connect with other people who love the same breed as much as you do? We have plenty of opportunities to get involved in your local community, thanks to AKC Breed Clubs located in every state, and more than 450 AKC Rescue Network groups across the country.
Find Your Match Compare Breeds
Find a Puppy: Estrela Mountain Dog
AKC Marketplace | PuppyFinder
AKC Marketplace is the only site to exclusively list 100% AKC puppies from AKC-Registered litters and the breeders who have cared for and raised these puppies are required to follow rules and regulations established by the AKC.
Find Estrela Mountain Dog Puppies
You are going to want to feed your Estrela Mountain Dog a formula that will cater to his unique digestive needs throughout the various phases of his life. Many dog food companies have breed-specific formulas for small, medium, large and extra-large breeds. Estrela Mountain Dogs are a large breed and may have a lifespan ranging from 8 to 10 years.
What you feed your dog is an individual choice, but working with your veterinarian and/or breeder will be the best way to determine frequency of meals as a puppy and the best adult diet to increase his longevity. Clean, fresh water should be available at all times.
The Estrela has a thick outer coat that resembles the texture of goat hair and comes in longhair and shorthair varieties. Beyond regular weekly grooming, the occasional bath will keep them clean and looking their best. Grooming can be a wonderful bonding experience for you and your pet. Their strong, fast-growing nails should be trimmed regularly with a nail clipper or grinder to avoid overgrowth, splitting and cracking. Their ears should be checked regularly to avoid a buildup of wax and debris which can result in an infection. Teeth should be brushed regularly.
Grooming Frequency
Occasional Bath/Brush
Specialty/Professional
Weekly Brushing
The Estrela is a relatively calm breed, but with children he knows and especially as a puppy, he can be quite playful. If not a working dog, options for exercise could include play time in the backyard, preferably fenced, or taken for daily walks. In inclement weather, indoor activities like chasing a ball rolled along the floor or teaching him new tricks can be good ways to expend energy. This breed, as indicated by his past, needs space and freedom to roam and is not suitable for apartment living. If not given adequate stimulation, he will become destructive in the home. Training for dog sports like agility, obedience and rally can also be a great way to give your dog exercise and mental stimulation.
Like all breeds there may be some health issues. Some dogs may be faced with these issues in their lives, but the majority of Estrela Mountain Dogs are healthy dogs.
Working with a responsible breeder, those wishing to own an Estrela Mountain Dog can gain the education they need to know about specific health concerns within the breed. Good breeders utilize genetic testing of their breeding stock to reduce the likelihood of disease in their puppies
The earliest of the Estrela ancestors were herd-guarding dogs in the Serra da Estrela, in what is now Portugal. Since there are no written records, it is uncertain whether the ancestors which contributed to this breed were brought by the Romans when they colonized the Iberian Peninsula, or later by the invading Visigoths. Regardless, there is no disagreement that the Estrela is one of the oldest breeds in Portugal.
Those early guardian dogs were not the distinct breed we know today, rather, the Estrela developed over a period of hundreds of years. Shepherds would have chosen to breed the dogs that had the characteristics necessary to survive in their mountain environment and to do their job: large-sized, strong, having endurance, agile, deep-chested, able to tolerate a marginal diet, a proper set of the legs, a powerful mouth, a tuft of hair around its neck, an easy, jog-like gait, a warm coat, and a watchful, mistrustful, yet loyal temperament.
Life changed little for the people and dogs of the region, even into the 20th century. The isolation of the region meant the breed was relatively unknown outside it until the early 1900s, and even then, they were mostly ignored in early dog shows. The Portuguese admired foreign breeds much more than their own and shepherds often castrated their dogs to prevent them from leaving their flocks to mate. These factors had a negative effect on the Estrela, so from 1908 to 1919, special shows called concursos were held to promote and preserve the Estrela Mountain Dog breed in the region. Special livestock guardian working trials were included in these shows. The trial consisted of an owner bringing his dog into a large field with many flocks of sheep. The dog was observed by judges for its reactions coming into the field and as the shepherd was ordered to move the flock, which inevitably produced stragglers. The dog was expected to move from his spot of guarding to bring the stragglers back, and then assume a leadership position at the head of the flock. During this period, there was some attempt at a registry, of which there is no surviving record.
The first tentative, recorded breed standard was published in 1922. This standard just reflected the functional features naturally found in the best dogs of the time, although it did mention the dew claws as reflecting a "perfect" dog. The hooked tail and the turned-back ears, which later became part of the official standard, were not mentioned. The first official breed standard was written in 1933. This standard attempted to differentiate the Estrela as a distinct breed. This led to the hooked tail and double dew claws becoming a requirement. All colors were allowed.
Prior to World War II, the Estrela's breeders were still primarily the shepherds and farmers of the region. Since they were mostly illiterate, they did not make any attempt to follow the official breed standard, if they even knew one existed. But by the early 1950s, interest in the breed returned, and the annual concursos were reinstated. Again, the intent was to stimulate interest among the Serra residents and to encourage them to adhere to the official standard. During this period, the long-haired variety was most popular at shows, but show dogs represented only a small portion of the Estrela population in Portugal, and still do. Many of the working dogs were, and are, short-haired.
To this day, the Estrela Mountain Dog remains true to its guardian heritage. It is still a working dog, guarding flocks in its native Portugal and elsewhere. The Portuguese also use it as a police dog. In the home, it is an ideal family pet because of its alertness, loyalty, intelligence, and its instinct to nurture young, all features it needed in its earliest days.
The Estrela Mountain Dog is known as the Cão da Serra da Estrela in his native Portugal.
The breed is used by the Marine and Portuguese Police.
The Estrela Mountain Dog has been assigned the Working Group designation.
Estrela mountain dogs can be used to pull small carts.
The Estrela has been eligible to compete in Companion Events since January 1, 2008.
The Estrela Mountain Dog has been recorded in the Foundation Stock Service since 2004.
Estrelas can move like wolves - head parallel with their body.
Large, mastiff-type molossoid dog. There are two varieties of coat: long and short. Rustic, substantial, with brisk gait and an impressive attitude. The breed has a lively, calm and expressive look; it is well proportioned; well made with harmonious appearance, which is traditionally how the breed has been recognised since a long time.
Important Proportions: Moderately long (sub- longilinear), tending to mediolinear. The depth of the chest is less than half the height at withers. The muzzle and skull should be approximately the same length; if not, the skull should be slightly longer.
Strong, voluminous and long and slightly convex seen in profile. Well inserted and in good proportion to the body, with the skull in proportion to the foreface; all parts in perfect harmony. Smooth skin on the skull and cheeks.
Skull: Well developed, rounded, with slightly divergent longitudinal superior cranium-facial axes, convex profile, slightly developed superciliary arches with slightly apparent frontal furrow, occipital protuberance not prominent.
Stop: Only slightly marked and at approximately equal distance to the tip of the nose and the occipital protuberance.
Nose: Straight and in line with nosebridge; well opened nostrils; large and black.
Muzzle: Long, tapering to the tip, without being pointed; tends to be straight but very slightly convex at the tip.
Lips: Well developed but not thick, well overlapping, not pendulous; mucous membrane of mouth, palate and edges of lips with intense black pigmentation.Jaws/Teeth : Clean cut mouth with well developed jaws; full dentition with strong, white, well implanted and close-fitting teeth, preferably with scissors bite, pincer bite acceptable.
Eyes: Medium sized, tending to small, oval shaped, level set, equal in size and well open, with a keen and calm expression; preferably dark amber in colour. Close fitting lids with black rims. Eyebrows slightly apparent.
Ears: Set on at medium height; hanging, carried falling backwards and laterally against the side of the head, with inner edge visible (so called rose-ear); thin, triangular, rounded at the tip; small in comparison to the body.
Neck: Short, straight and thick; well set and well connected into the shoulders; with a slight dewlap, not exaggerated.
Topline: Straight. Almost level.
Back: Preferably short, well muscled.
Loin: Short; broad; well muscled; well connected to the croup. Croup : Slightly sloping; short, broad and muscled. Height at croup should be equal or slightly superior to the height at the withers. Chest : Broad; deep; well sprung without being cylindrical; well let down to the elbow or slightly below it.
Underline and belly: The underline should rise gradually but smoothly from sternum to the groin; belly not too wide, in proportion to the animal's substance and harmoniously connected to the body.
Tail: Set on at medium height; long; thick; carried below the horizontal, scimitar-shaped, with a hook at the end.
At rest it hangs naturally between the thighs, reaching at least the hock; when excited and in motion, the tail rises above the horizontal, curving upward and forward, sideways and downward, without being carried over the croup. It should be well furnished with hair, and feathered in the long-haired variety.
General appearance: Upright with strong bone and thick joints, moderately open angulation, with easy movement.
Forearms: Straight, parallel, long, with strong bone and almost cylindrical in shape.
Forefeet: Proportioned, neither too round nor too long, between cat and hare feet (not splayed); thick, tight toes with abundant hair between toes and pads; dark nails, preferably black, well developed; pads thick and hard.
General appearance: Upright, strong bone with thick joints, moderately open angles, with easy movement.
Hock: Slightly let down; moderately open, neither turned in nor out.
Metatarsus (rear pastern) : Vertical, almost cylindrical. Possible presence of single or double dewclaws.
Hind feet: Identical to the forefeet.
Hair: Strong, very abundant, slightly coarse, without excessive harshness, the texture is similar to goat hair.
The undercoat is composed of fine hair, short, abundant and entangled, normally lighter in colour than the outer coat.
– Long-haired variety: Straight or slightly wavy top coat, uneven in some areas. It is shorter and more dense on the limbs, below the elbows and hocks, as well as on the head; on the ears, it becomes gradually shorter from the base to the tip, becoming thinner and softer. It is longer on the tail, which is bushy, thick and feathered, around the neck and throat and on the buttocks, which are abundantly feathered, as well as the back side of the forearms.
– Short-haired variety: Short hair, evenly distributed over the body, slightly shorter on the head and limbs, without feathering.
The following colors are accepted and considered typical:
– Solid: yellow, fawn and grey in all ranges of color intensity.
– Wolf Grey: fawn, yellow and grey tones, commonly in lighter and darker shades.
– Brindle: Fawn, yellow or grey base color with blackish brindling. In the cranium-facial area, a dark coloued mask is typical.
White markings are admitted only at the extremities of fore- and hind feet and on a small extension on the lower region of neck and chest.
Colors & Markings
Description Standard Colors Registration Code
Brindle Check Mark For Standard Color 057
Fawn Check Mark For Standard Color 082
Wolfgray Check Mark For Standard Color 227
Yellow Check Mark For Standard Color 232
Description Standard Markings Registration Code
Black Mask Check Mark For Standard Mark 004
White Markings Check Mark For Standard Mark 014
Other Breeds to Explore
Related Groups and Characteristics
People who liked this breed also liked
Nutrition Sponsored
Healthy You, Healthy Dog, Healthy New Year!
Your Dog Deserves Nothing But the Best: Meet AKC Canine Retreat in Midtown West Manhattan
What Happens When a Dog Reverse Sneezes
The Estrela Mountain Dog is not only an excellent livestock guardian, but is also known for his love of children and family. Proper socialization and training as a puppy is very important so that the dominance in the Estrela's personality does not become aggressive.


text:
Jan Boroński – polski matematyk, doktor habilitowany nauk matematycznych, zajmujący się układami dynamicznymi i topologią.

Życiorys

Studia na kierunku matematyka ukończył na Uniwersytecie Śląskim w Katowicach w 2005 roku. Stopień doktora uzyskał w 2010, pod kierunkiem Krystyny Kuperberg, na Auburn University, a doktora habilitowanego w 2019 na Akademii Górniczo-Hutniczej im. Stanisława Staszica w Krakowie.

Od roku 2010 zatrudniony na  Wydziale Matematyki Stosowanej Akademii Górniczo-Hutniczej im. Stanisława Staszica w Krakowie.

Swoje prace publikował m.in. w "Topology and its Applications", "Proceedings of the American Mathematical Society", "Journal of Dynamics and Differential Equations" oraz "Ergodic Theory and Dynamical Systems".

Przypisy

Matematycy XXI wieku
Absolwenci Uniwersytetu Śląskiego
Wykładowcy Akademii Górniczo-Hutniczej

redpajama_set_name: RedPajamaWikipedia


text:
/*globals define, WebGMEGlobal, _, alert*/
/*jshint browser: true*/
/*jscs:disable maximumLineLength*/

/**
 * @author rkereskenyi / https://github.com/rkereskenyi
 */

define(['js/logger',
    'js/util',
    'js/Constants',
    'js/UIEvents',
    'js/NodePropertyNames',
    'js/RegistryKeys',
    'js/Utils/GMEConcepts',
    'js/Widgets/DiagramDesigner/DiagramDesignerWidget.Constants',
    'js/DragDrop/DragHelper',
    'js/Dialogs/ReplaceBase/ReplaceBaseDialog',
    'js/Utils/Exporters',
    'js/Dialogs/ImportModel/ImportModelDialog',
], function (Logger,
             util,
             CONSTANTS,
             UI_EVENTS,
             nodePropertyNames,
             REGISTRY_KEYS,
             GMEConcepts,
             DiagramDesignerWidgetConstants,
             DragHelper,
             ReplaceBaseDialog,
             exporters,
             ImportModelDialog) {

    'use strict';

    var ModelEditorControlDiagramDesignerWidgetEventHandlers,
        ATTRIBUTES_STRING = 'attributes',
        REGISTRY_STRING = 'registry',
        SRC_POINTER_NAME = CONSTANTS.POINTER_SOURCE,
        DST_POINTER_NAME = CONSTANTS.POINTER_TARGET;

    ModelEditorControlDiagramDesignerWidgetEventHandlers = function () {
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype.attachDiagramDesignerWidgetEventHandlers = function () {
        var self = this;

        /*OVERRIDE DESIGNER CANVAS METHODS*/
        this.designerCanvas.onDesignerItemsMove = function (repositionDesc) {
            self._onDesignerItemsMove(repositionDesc);
        };
        /*
         this.designerCanvas.onDesignerItemsCopy = function (copyDesc) {
         self._onDesignerItemsCopy(copyDesc);
         };*/

        this.designerCanvas.onCreateNewConnection = function (params) {
            self._onCreateNewConnection(params);
        };

        this.designerCanvas.onSelectionDelete = function (idList) {
            self._onSelectionDelete(idList);
        };

        this.designerCanvas.onDesignerItemDoubleClick = function (id, event) {
            self._onDesignerItemDoubleClick(id, event);
        };

        this.designerCanvas.onModifyConnectionEnd = function (params) {
            self._onModifyConnectionEnd(params);
        };

        this.designerCanvas.onRegisterSubcomponent = function (objID, sCompID, metaInfo) {
            self._onRegisterSubcomponent(objID, sCompID, metaInfo);
        };

        this.designerCanvas.onUnregisterSubcomponent = function (objID, sCompID) {
            self._onUnregisterSubcomponent(objID, sCompID);
        };

        this.designerCanvas.onBackgroundDroppableAccept = function (event, dragInfo) {
            return self._onBackgroundDroppableAccept(event, dragInfo);
        };

        this.designerCanvas.onBackgroundDrop = function (event, dragInfo, position) {
            self._onBackgroundDrop(event, dragInfo, position);
        };

        this.designerCanvas.onSelectionChanged = function (selectedIds) {
            self._onSelectionChanged(selectedIds);
        };

        this.designerCanvas.onClipboardCopy = function (selectedIds) {
            self._onClipboardCopy(selectedIds);
        };

        this.designerCanvas.onClipboardPaste = function () {
            self._onClipboardPaste();
        };

        this.designerCanvas.onConnectionSegmentPointsChange = function (params) {
            self._onConnectionSegmentPointsChange(params);
        };

        this.designerCanvas.onFilterNewConnectionDroppableEnds = function (params) {
            return self._onFilterNewConnectionDroppableEnds(params);
        };

        this.designerCanvas.onFilterReconnectionDroppableEnds = function (params) {
            return self._onFilterReconnectionDroppableEnds(params);
        };

        this.designerCanvas.onDragStartDesignerItemDraggable = function (itemID) {
            return self._onDragStartDesignerItemDraggable(itemID);
        };

        this.designerCanvas.onDragStartDesignerItemCopyable = function (itemID) {
            return self._onDragStartDesignerItemCopyable(itemID);
        };

        this.designerCanvas.onDragStartDesignerConnectionCopyable = function (connectionID) {
            return self._onDragStartDesignerConnectionCopyable(connectionID);
        };

        this.designerCanvas.onSelectionRotated = function (deg, selectedIds) {
            return self._onSelectionRotated(deg, selectedIds);
        };

        this.designerCanvas.onSetConnectionProperty = function (params) {
            self._onSetConnectionProperty(params);
        };

        this.designerCanvas.onCopy = function () {
            return self._onCopy();
        };

        this.designerCanvas.onPaste = function (data) {
            return self._onPaste(data);
        };

        this.designerCanvas.getDragItems = function (selectedElements) {
            return self._getDragItems(selectedElements);
        };

        this._oGetDragParams = this.designerCanvas.getDragParams;
        this.designerCanvas.getDragParams = function (selectedElements, event) {
            return self._getDragParams(selectedElements, event);
        };

        this.designerCanvas.onSelectionContextMenu = function (selectedIds, mousePos) {
            self._onSelectionContextMenu(selectedIds, mousePos);
        };

        this.designerCanvas.onSelectionAlignMenu = function (selectedIds, mousePos) {
            self._onSelectionAlignMenu(selectedIds, mousePos);
        };

        this.designerCanvas.onSelectionFillColorChanged = function (selectedElements, color) {
            self._onSelectionFillColorChanged(selectedElements, color);
        };

        this.designerCanvas.onSelectionBorderColorChanged = function (selectedElements, color) {
            self._onSelectionBorderColorChanged(selectedElements, color);
        };

        this.designerCanvas.onSelectionTextColorChanged = function (selectedElements, color) {
            self._onSelectionTextColorChanged(selectedElements, color);
        };

        this.designerCanvas.onSelectedTabChanged = function (tabID) {
            self._onSelectedTabChanged(tabID);
        };

        this.designerCanvas.onAlignSelection = function (selectedIds, type) {
            self._onAlignSelection(selectedIds, type);
        };

        this.logger.debug('attachDiagramDesignerWidgetEventHandlers finished');
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._saveNewPositions = function (repositionDesc) {
        var self = this,
            gmeIds = Object.keys(repositionDesc),
            modelId = this.currentNodeInfo.id,
            gmeId,
            i,
            newPos;

        if (gmeIds.length === 0) {
            return;
        }

        this._client.startTransaction();
        for (i = 0; i < gmeIds.length; i += 1) {
            gmeId = gmeIds[i];
            newPos = {
                x: repositionDesc[gmeId].x,
                y: repositionDesc[gmeId].y
            };

            if (this._selectedAspect === CONSTANTS.ASPECT_ALL) {
                if (repositionDesc[gmeId][REGISTRY_STRING]) {
                    // This is for the line points..
                    Object.keys(repositionDesc[gmeId][REGISTRY_STRING]).forEach(function (regKey) {
                        self._client.setRegistry(gmeId,
                            regKey,
                            repositionDesc[gmeId][REGISTRY_STRING][regKey]);
                    });
                } else {
                    this._client.setRegistry(gmeId, REGISTRY_KEYS.POSITION, newPos);
                }
            } else {
                this._client.addMember(modelId, gmeId, this._selectedAspect);
                this._client.setMemberRegistry(modelId, gmeId, this._selectedAspect,
                    REGISTRY_KEYS.POSITION, newPos);
            }
        }

        this._client.completeTransaction();
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._addConnSegmentPoints = function (posInfo) {
        // This adds connection segments points that should be updated based on activeSelection.
        var self = this,
            connIds = WebGMEGlobal.State.getActiveSelection().filter(function (gmeId) {
                var nodeObj = self._client.getNode(gmeId);
                return nodeObj && nodeObj.isConnection();
            });

        connIds.forEach(function (gmeId) {
            var nodeObj = self._client.getNode(gmeId),
                linePoints = nodeObj && nodeObj.getRegistry(REGISTRY_KEYS.LINE_CUSTOM_POINTS);

            if (linePoints instanceof Array && linePoints.length > 0) {
                // There are linepoints defined - if the src and dst is part of the move
                // compute the "delta-move" (for any of them) and apply it to those points.
                var srcNode = nodeObj.getNode(nodeObj.getPointerId('src')),
                    dstNode = nodeObj.getNode(nodeObj.getPointerId('dst'));

                // Maybe src/dst are ports - check if their parents where selected..
                if (srcNode && !posInfo[srcNode.getId()]) {
                    srcNode = nodeObj.getNode(srcNode.getParentId());
                }

                if (dstNode && !posInfo[dstNode.getId()]) {
                    dstNode = nodeObj.getNode(dstNode.getParentId());
                }

                if (srcNode && posInfo[srcNode.getId()] && dstNode && posInfo[dstNode.getId()]) {
                    var srcPos = srcNode.getRegistry('position'),
                        dstPos = dstNode.getRegistry('position'),
                        delta = {x: 0, y: 0},
                        pos;

                    if (srcPos && dstPos) {
                        delta.x = ( posInfo[srcNode.getId()].x - srcPos.x + posInfo[dstNode.getId()].x - dstPos.x ) / 2;
                        delta.y = ( posInfo[srcNode.getId()].y - srcPos.y + posInfo[dstNode.getId()].y - dstPos.y ) / 2;

                        linePoints.forEach(function (point) {
                            point[0] += delta.x;
                            point[1] += delta.y;

                            point[0] = point[0] > 0 ? Math.round(point[0]) : 0;
                            point[1] = point[1] > 0 ? Math.round(point[1]) : 0;
                        });

                        if (posInfo[gmeId]) {
                            // The connection is selected as a box as well - the new position must be
                            // stored under postion registry.
                            pos = posInfo[gmeId];
                        }

                        posInfo[gmeId] = {};
                        posInfo[gmeId][REGISTRY_STRING] = {};
                        posInfo[gmeId][REGISTRY_STRING][REGISTRY_KEYS.LINE_CUSTOM_POINTS] = linePoints;

                        if (pos) {
                            posInfo[gmeId][REGISTRY_STRING][REGISTRY_KEYS.POSITION] = pos;
                        }
                    }
                }
            }
        });
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onDesignerItemsMove = function (repositionDesc) {
        var self = this,
            result = {};

        // Start by converting moved items to object indexed by gmeIds..
        Object.keys(repositionDesc)
            .forEach(function (itemId) {
                if (typeof self._ComponentID2GMEID[itemId] === 'string') {
                    result[self._ComponentID2GMEID[itemId]] = repositionDesc[itemId];
                }
            });

        // Add info about gme-connections that should have their segment points updated.
        this._addConnSegmentPoints(result);
        // Finally save the new positions.
        this._saveNewPositions(result);
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onDesignerItemsCopy = function (copyDesc) {
        var copyOpts = {parentId: this.currentNodeInfo.id},
            id,
            desc,
            gmeID;

        this.designerCanvas.beginUpdate();

        for (id in copyDesc.items) {
            if (copyDesc.items.hasOwnProperty(id)) {
                desc = copyDesc.items[id];
                gmeID = this._ComponentID2GMEID[desc.oItemId];

                copyOpts[gmeID] = {};
                copyOpts[gmeID][ATTRIBUTES_STRING] = {};
                copyOpts[gmeID][REGISTRY_STRING] = {};

                copyOpts[gmeID][REGISTRY_STRING][REGISTRY_KEYS.POSITION] = {x: desc.posX, y: desc.posY};

                //remove the component from UI
                //it will be recreated when the GME client calls back with the result
                this.designerCanvas.deleteComponent(id);
            }
        }

        for (id in copyDesc.connections) {
            if (copyDesc.connections.hasOwnProperty(id)) {
                desc = copyDesc.connections[id];
                gmeID = this._ComponentID2GMEID[desc.oConnectionId];

                copyOpts[gmeID] = {};

                //remove the component from UI
                //it will be recreated when the GME client calls back with the result
                this.designerCanvas.deleteComponent(id);
            }
        }

        this.designerCanvas.endUpdate();

        this._client.intellyPaste(copyOpts);
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onCreateNewConnection = function (params) {
        var self = this,
            sourceId,
            targetId,
            parentId = this.currentNodeInfo.id,
            createConnection,
            _client = this._client,
            CONTEXT_POS_OFFSET = 10,
            menuItems = {},
            i,
            connTypeObj,
            aspect = this._selectedAspect,
            newConnID,
            validConnectionTypes,
            dstPosition;

        function getMidPosition() {
            var srcPos = self.designerCanvas.items[params.dst].getBoundingBox(),
                dstPos = self.designerCanvas.items[params.src].getBoundingBox();

            return {
                x: (srcPos.x + dstPos.x) / 2,
                y: (srcPos.y + dstPos.y) / 2
            };
        }

        //local callback to create the connection
        createConnection = function (connTypeToCreate) {
            if (connTypeToCreate) {
                _client.startTransaction();

                //create new object
                newConnID = _client.createChild({
                    parentId: parentId,
                    baseId: connTypeToCreate,
                    position: getMidPosition(),
                });

                //set source and target pointers
                _client.setPointer(newConnID, CONSTANTS.POINTER_SOURCE, sourceId);
                _client.setPointer(newConnID, CONSTANTS.POINTER_TARGET, targetId);

                _client.completeTransaction();
            }
        };

        if (params.srcSubCompId !== undefined) {
            sourceId = this._Subcomponent2GMEID[params.src][params.srcSubCompId];
        } else {
            sourceId = this._ComponentID2GMEID[params.src];
        }

        if (params.dstSubCompId !== undefined) {
            targetId = this._Subcomponent2GMEID[params.dst][params.dstSubCompId];
        } else {
            targetId = this._ComponentID2GMEID[params.dst];
        }

        //get the list of valid connection types
        validConnectionTypes = GMEConcepts.getValidConnectionTypesInAspect(sourceId, targetId, parentId, aspect);
        //filter them to see which of those can actually be created as a child of the parent
        i = validConnectionTypes.length;
        while (i--) {
            if (!GMEConcepts.canCreateChild(parentId, validConnectionTypes[i])) {
                validConnectionTypes.splice(i, 1);
            }
        }

        if (validConnectionTypes.length === 1) {
            createConnection(validConnectionTypes[0]);
        } else if (validConnectionTypes.length > 1) {
            //show available connection types to the user to select one
            for (i = 0; i < validConnectionTypes.length; i += 1) {
                connTypeObj = this._client.getNode(validConnectionTypes[i]);
                menuItems[validConnectionTypes[i]] = {
                    name: 'Create type \'' +
                    (connTypeObj ?
                        connTypeObj.getAttribute(nodePropertyNames.Attributes.name) : validConnectionTypes[i]) +
                    '\'',
                    icon: false
                };
            }

            dstPosition = this.designerCanvas.items[params.dst].getBoundingBox();

            this.designerCanvas.createMenu(menuItems, function (key) {
                    createConnection(key);
                },
                this.designerCanvas.posToPageXY(dstPosition.x - CONTEXT_POS_OFFSET,
                    dstPosition.y - CONTEXT_POS_OFFSET)
            );
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionDelete = function (idList) {
        var objIdList = [],
            i = idList.length,
            objID;

        while (i--) {
            objID = this._ComponentID2GMEID[idList[i]];
            //temporary fix to not allow deleting ROOT AND FCO
            if (GMEConcepts.canDeleteNode(objID)) {
                objIdList.pushUnique(objID);
            } else {
                this.logger.warn('Can not delete item with ID: ' + objID + '. Possibly it is the ROOT or FCO');
            }
        }

        if (objIdList.length > 0) {
            this._client.deleteNodes(objIdList);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onDesignerItemDoubleClick = function (id /*, event */) {
        var gmeID = this._ComponentID2GMEID[id];

        if (gmeID) {
            this.logger.debug('Opening model with id "' + gmeID + '"');
            WebGMEGlobal.State.registerActiveObject(gmeID);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onModifyConnectionEnd = function (params) {
        var gmeID = this._ComponentID2GMEID[params.id],
            oldDesc = params.old,
            newDesc = params.new,
            newEndPointGMEID;

        if (gmeID) {
            this._client.startTransaction();

            //update connection endpoint - SOURCE
            if (oldDesc.srcObjId !== newDesc.srcObjId ||
                oldDesc.srcSubCompId !== newDesc.srcSubCompId) {
                if (newDesc.srcSubCompId !== undefined) {
                    newEndPointGMEID = this._Subcomponent2GMEID[newDesc.srcObjId][newDesc.srcSubCompId];
                } else {
                    newEndPointGMEID = this._ComponentID2GMEID[newDesc.srcObjId];
                }
                this._client.setPointer(gmeID, SRC_POINTER_NAME, newEndPointGMEID);
            }

            //update connection endpoint - TARGET
            if (oldDesc.dstObjId !== newDesc.dstObjId ||
                oldDesc.dstSubCompId !== newDesc.dstSubCompId) {
                if (newDesc.dstSubCompId !== undefined) {
                    newEndPointGMEID = this._Subcomponent2GMEID[newDesc.dstObjId][newDesc.dstSubCompId];
                } else {
                    newEndPointGMEID = this._ComponentID2GMEID[newDesc.dstObjId];
                }
                this._client.setPointer(gmeID, DST_POINTER_NAME, newEndPointGMEID);
            }

            this._client.completeTransaction();
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onRegisterSubcomponent = function (objID, sCompID,
                                                                                metaInfo) {
        //store that a subcomponent with a given ID has been added to object with objID
        this._GMEID2Subcomponent[metaInfo[CONSTANTS.GME_ID]] = this._GMEID2Subcomponent[metaInfo[CONSTANTS.GME_ID]] ||
            {};
        this._GMEID2Subcomponent[metaInfo[CONSTANTS.GME_ID]][objID] = sCompID;

        this._Subcomponent2GMEID[objID] = this._Subcomponent2GMEID[objID] || {};
        this._Subcomponent2GMEID[objID][sCompID] = metaInfo[CONSTANTS.GME_ID];
        //TODO: add event handling here that a subcomponent appeared
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onUnregisterSubcomponent = function (objID,
                                                                                sCompID) {
        var gmeID = this._Subcomponent2GMEID[objID][sCompID];

        delete this._Subcomponent2GMEID[objID][sCompID];
        if (this._GMEID2Subcomponent[gmeID]) {
            delete this._GMEID2Subcomponent[gmeID][objID];
        }
        //TODO: add event handling here that a subcomponent disappeared
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._getPossibleDropActions = function (dragInfo) {
        var items = DragHelper.getDragItems(dragInfo),
            dragEffects = DragHelper.getDragEffects(dragInfo),
            dragParams = DragHelper.getDragParams(dragInfo),
            possibleDropActions = [],
            parentID = this.currentNodeInfo.id,
            i,
            j,
            FCOamongItems = false,
            validPointerTypes = [],
            baseTypeID,
            baseTypeNode,
            dragAction,
            aspect = this._selectedAspect,
            pointerSorter = function (a, b) {
                var baseAName = a.name.toLowerCase(),
                    baseBName = b.name.toLowerCase(),
                    ptrAName = a.pointer.toLowerCase(),
                    ptrBName = b.pointer.toLowerCase();

                if (ptrAName < ptrBName) {
                    return -1;
                } else if (ptrAName > ptrBName) {
                    return 1;
                } else {
                    //ptrAName = ptrBName
                    if (baseAName < baseBName) {
                        return -1;
                    } else {
                        return 1;
                    }
                }
            };

        //check if FCO is among the items as it may change the outcome
        for (i = 0; i < items.length; i += 1) {
            if (GMEConcepts.isProjectFCO(items[i])) {
                FCOamongItems = true;
                break;
            }
        }

        //check to see what DROP actions are possible
        if (items.length > 0) {
            i = dragEffects.length;
            while (i--) {
                switch (dragEffects[i]) {
                    case DragHelper.DRAG_EFFECTS.DRAG_MOVE:
                        //check to see if dragParams.parentID and this.parentID are the same
                        //if so, it's not a real move, it is a reposition
                        if ((dragParams && dragParams.parentID === parentID) ||
                            (GMEConcepts.canCreateChildrenInAspect(parentID, items, aspect) &&
                            GMEConcepts.canMoveNodeHere(parentID, items) && !FCOamongItems)) {
                            dragAction = {dragEffect: dragEffects[i]};
                            possibleDropActions.push(dragAction);
                        }
                        break;
                    case DragHelper.DRAG_EFFECTS.DRAG_COPY:
                        if (GMEConcepts.canCreateChildrenInAspect(parentID, items, aspect) && !FCOamongItems) {
                            dragAction = {dragEffect: dragEffects[i]};
                            possibleDropActions.push(dragAction);
                        }
                        break;
                    case DragHelper.DRAG_EFFECTS.DRAG_CREATE_INSTANCE:
                        if (GMEConcepts.canCreateChildrenInAspect(parentID, items, aspect)) {
                            dragAction = {dragEffect: dragEffects[i]};
                            possibleDropActions.push(dragAction);
                        }
                        break;
                    case DragHelper.DRAG_EFFECTS.DRAG_CREATE_POINTER:
                        if (items.length === 1) {
                            validPointerTypes = GMEConcepts.getValidPointerTypes(parentID, items[0]);
                            if (validPointerTypes.length > 0) {
                                j = validPointerTypes.length;
                                //each valid pointer type is an object {'baseId': objId, 'pointer': pointerName}
                                while (j--) {
                                    baseTypeID = validPointerTypes[j].baseId;
                                    baseTypeNode = this._client.getNode(baseTypeID);
                                    validPointerTypes[j].name = baseTypeID;
                                    if (baseTypeNode) {
                                        validPointerTypes[j].name = baseTypeNode.getAttribute(
                                            nodePropertyNames.Attributes.name);
                                    }
                                }

                                validPointerTypes.sort(pointerSorter);

                                for (j = 0; j < validPointerTypes.length; j += 1) {
                                    dragAction = {
                                        dragEffect: DragHelper.DRAG_EFFECTS.DRAG_CREATE_POINTER,
                                        name: validPointerTypes[j].name,
                                        baseId: validPointerTypes[j].baseId,
                                        pointer: validPointerTypes[j].pointer
                                    };
                                    possibleDropActions.push(dragAction);
                                }
                            }
                        }
                        break;
                }
            }
        }

        this.logger.debug('possibleDropActions: ' + JSON.stringify(possibleDropActions));

        return possibleDropActions;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onBackgroundDroppableAccept = function (event,
                                                                                dragInfo) {
        var accept;

        accept = this._getPossibleDropActions(dragInfo).length > 0;

        return accept;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onBackgroundDrop = function (event, dragInfo,
                                                                                position) {
        var possibleDropActions = this._getPossibleDropActions(dragInfo),
            len = possibleDropActions.length,
            i,
            selectedAction,
            self = this,
            menuItems;

        if (len === 1) {
            selectedAction = possibleDropActions[0];
            this._handleDropAction(selectedAction, dragInfo, position);
        } else {
            menuItems = {};

            for (i = 0; i < possibleDropActions.length; i += 1) {
                switch (possibleDropActions[i].dragEffect) {
                    case DragHelper.DRAG_EFFECTS.DRAG_COPY:
                        menuItems[i] = {
                            name: 'Copy here',
                            icon: 'glyphicon glyphicon-plus'
                        };
                        break;
                    case DragHelper.DRAG_EFFECTS.DRAG_MOVE:
                        menuItems[i] = {
                            name: 'Move here',
                            icon: 'glyphicon glyphicon-move'
                        };
                        break;
                    case DragHelper.DRAG_EFFECTS.DRAG_CREATE_INSTANCE:
                        menuItems[i] = {
                            name: 'Create instance here',
                            icon: 'glyphicon glyphicon-share-alt'
                        };
                        break;
                    case DragHelper.DRAG_EFFECTS.DRAG_CREATE_POINTER:
                        menuItems[i] = {
                            name: 'Create pointer "' + possibleDropActions[i].pointer + '" of type "' +
                            possibleDropActions[i].name + '"',
                            icon: 'glyphicon glyphicon-share'
                        };
                        break;
                    default:
                        break;
                }
            }

            this.designerCanvas.createMenu(menuItems, function (key) {
                    selectedAction = possibleDropActions[parseInt(key, 10)];
                    self._handleDropAction(selectedAction, dragInfo, position);
                },
                this.designerCanvas.posToPageXY(position.x, position.y)
            );
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._handleDropAction = function (dropAction, dragInfo,
                                                                                position) {
        var self = this,
            dragEffect = dropAction.dragEffect,
            items = DragHelper.getDragItems(dragInfo),
            dragParams = DragHelper.getDragParams(dragInfo),
            parentID = this.currentNodeInfo.id,
            positionInfo,
            i,
            gmeID,
            params,
            POS_INC = 20,
            oldPos,
            origNode,
            ptrName;

        this.logger.debug('dropAction: ' + JSON.stringify(dropAction));
        this.logger.debug('dragInfo: ' + JSON.stringify(dragInfo));
        this.logger.debug('position: ' + JSON.stringify(position));

        function getParams() {
            var result = {parentId: parentID};
            i = items.length;

            positionInfo = self._getNewPositionFromDrag(items, dragParams && dragParams.positions, position);

            Object.keys(positionInfo).forEach(function (gmeId) {
                result[gmeId] = {};
                result[gmeId][REGISTRY_STRING] = {};
                if (positionInfo[gmeId][REGISTRY_STRING]) {
                    Object.keys(positionInfo[gmeId][REGISTRY_STRING])
                        .forEach(function (regKey) {
                            result[gmeId][REGISTRY_STRING][regKey] =
                                positionInfo[gmeId][REGISTRY_STRING][regKey];
                        });
                } else {
                    result[gmeId][REGISTRY_STRING][REGISTRY_KEYS.POSITION] = positionInfo[gmeId];
                }
            });

            while (i--) {
                // Finally make sure we copy any selected conn where the src and dst weren't there
                // and add the position of these too..
                gmeID = items[i];
                oldPos = dragParams && dragParams.positions[gmeID] || {x: 0, y: 0};
                if (!result[gmeID]) {
                    result[gmeID] = {};
                    result[gmeID][REGISTRY_STRING] = {};
                }

                if (!result[gmeID][REGISTRY_STRING][REGISTRY_KEYS.POSITION]) {
                    result[gmeID][REGISTRY_STRING][REGISTRY_KEYS.POSITION] = {
                        x: position.x + oldPos.x,
                        y: position.y + oldPos.y
                    };
                }
            }

            return result;
        }

        switch (dragEffect) {
            case DragHelper.DRAG_EFFECTS.DRAG_COPY:
                params = getParams();
                this._client.copyMoreNodes(params);
                break;
            case DragHelper.DRAG_EFFECTS.DRAG_MOVE:
                //check to see if dragParams.parentID and this.parentID are the same
                //if so, it's not a real move, it is a reposition
                if (dragParams && dragParams.parentID === parentID) {
                    //it is a reposition
                    this._saveNewPositions(
                        this._getNewPositionFromDrag(items, dragParams && dragParams.positions, position));
                } else {
                    //it is a real hierarchical move
                    params = getParams();
                    this._client.moveMoreNodes(params);
                }
                break;
            case DragHelper.DRAG_EFFECTS.DRAG_CREATE_INSTANCE:
                params = getParams();
                this._client.createChildren(params);
                break;

            case DragHelper.DRAG_EFFECTS.DRAG_CREATE_POINTER:
                params = {
                    parentId: parentID,
                    baseId: dropAction.baseId
                };

                this._client.startTransaction();

                gmeID = this._client.createChild(params);

                if (gmeID) {
                    //check if old position is in drag-params
                    oldPos = dragParams && dragParams.positions[items[0]] || {x: 0, y: 0};
                    //store new position
                    this._client.setRegistry(gmeID, REGISTRY_KEYS.POSITION, {
                        x: position.x + oldPos.x,
                        y: position.y + oldPos.y
                    });

                    //set reference
                    this._client.setPointer(gmeID, dropAction.pointer, items[0]);

                    //try to set name
                    origNode = this._client.getNode(items[0]);
                    if (origNode) {
                        ptrName = origNode.getAttribute(nodePropertyNames.Attributes.name) + '-' +
                            dropAction.pointer;
                        this._client.setAttribute(gmeID, nodePropertyNames.Attributes.name, ptrName);
                    }
                }

                this._client.completeTransaction();

                break;
            default:
                break;
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._getNewPositionFromDrag = function (items,
                                                                                dragPositions,
                                                                                dropPosition) {
        var result = {}; // {<gmeId>: {x: <int>, y <int>}

        items.forEach(function (id) {
            var relPos = dragPositions && dragPositions[id],
                newPos = {x: dropPosition.x, y: dropPosition.y};

            if (relPos) {
                newPos.x += relPos.x;
                newPos.y += relPos.y;
                newPos.x = newPos.x > 0 ? Math.round(newPos.x) : 0;
                newPos.y = newPos.y > 0 ? Math.round(newPos.y) : 0;

                result[id] = newPos;
            }
        });

        this._addConnSegmentPoints(result);

        return result;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionChanged = function (selectedIds) {
        var self = this,
            gmeIDs = [],
            extraIds = [],
            enableEditConnections = selectedIds.length > 0;

        selectedIds.forEach(function (id) {
            var gmeId = self._ComponentID2GMEID[id];

            if (gmeId) {
                if (gmeIDs.indexOf(gmeId) === -1) {
                    gmeIDs.push(gmeId);
                }

                // Make sure any connection boxes are selected when selecting a connection edge
                // (and the other way around too).
                if (self._GMEID2ComponentID[gmeId] && self._GMEID2ComponentID[gmeId].length > 1) {
                    self._GMEID2ComponentID[gmeId].forEach(function (cId) {
                        if (selectedIds.indexOf(cId) === -1 && extraIds.indexOf(cId) === -1) {
                            extraIds.push(cId);
                        }
                    });
                }

                enableEditConnections = enableEditConnections && GMEConcepts.isConnectionType(gmeId);
            }
        });

        enableEditConnections = enableEditConnections && this.designerCanvas.getIsReadOnlyMode() === false;

        this.designerCanvas.toolbarItems.ddbtnConnectionArrowStart.enabled(enableEditConnections);
        this.designerCanvas.toolbarItems.ddbtnConnectionPattern.enabled(enableEditConnections);
        this.designerCanvas.toolbarItems.ddbtnConnectionArrowEnd.enabled(enableEditConnections);
        this.designerCanvas.toolbarItems.ddbtnConnectionLineType.enabled(enableEditConnections);
        this.designerCanvas.toolbarItems.ddbtnConnectionLineWidth.enabled(enableEditConnections);
        this.designerCanvas.toolbarItems.ddbtnConnectionLabelPlacement.enabled(enableEditConnections);

        this.$btnConnectionRemoveSegmentPoints.enabled(enableEditConnections);

        if (extraIds.length > 0) {
            if (selectedIds.length === 1 &&
                enableEditConnections &&
                WebGMEGlobal.State.getActiveSelection().length === 1 &&
                WebGMEGlobal.State.getActiveSelection()[0] === gmeIDs[0]) {
                // Same connection selected again -> will not add box to selection
                // needed for seg points and reverse makes moving conn-boxes nicer.
            } else {
                this.designerCanvas.select(selectedIds.concat(extraIds));
            }
        } else {
            WebGMEGlobal.State.registerActiveSelection(gmeIDs, {invoker: this});
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onClipboardCopy = function (selectedIds) {
        var gmeIDs = [],
            len = selectedIds.length,
            id;

        while (len--) {
            id = this._ComponentID2GMEID[selectedIds[len]];
            if (id) {
                gmeIDs.push(id);
            }
        }

        if (gmeIDs.length !== 0) {
            this._client.copyNodes(gmeIDs);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onClipboardPaste = function () {
        if (this.currentNodeInfo.id) {
            this._client.pasteNodes(this.currentNodeInfo.id);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onConnectionSegmentPointsChange = function (params) {
        var connID = params.connectionID,
            points = params.points,
            gmeID = this._ComponentID2GMEID[connID],
            nodeObj;

        if (gmeID) {
            nodeObj = this._client.getNode(gmeID);
            if (nodeObj) {
                this._client.setRegistry(gmeID, REGISTRY_KEYS.LINE_CUSTOM_POINTS, points);
            }
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onFilterNewConnectionDroppableEnds = function (params) {
        var availableConnectionEnds = params.availableConnectionEnds,
            result = [],
            i,
            sourceId,
            targetId,
            validConnectionTypes,
            j,
            parentID = this.currentNodeInfo.id,
            aspect = this._selectedAspect,
            targetNode,
            p;

        if (params.srcSubCompId === undefined) {
            sourceId = this._ComponentID2GMEID[params.srcId];
        } else {
            sourceId = this._Subcomponent2GMEID[params.srcId][params.srcSubCompId];
        }

        //need to test for each source-destination pair if the connection can be made or not?
        //there is at least one valid connection type definition in the parent
        //  that could be created between the source and target
        //there is at least one valid connection type that really can be created in the parent (max chilren num...)
        validConnectionTypes = GMEConcepts.getValidConnectionTypesFromSourceInAspect(sourceId, parentID, aspect);

        //filter them to see which of those can actually be created as a child of the parent
        i = validConnectionTypes.length;
        while (i--) {
            if (!GMEConcepts.canCreateChild(parentID, validConnectionTypes[i])) {
                validConnectionTypes.splice(i, 1);
            }
        }

        i = availableConnectionEnds.length;
        while (i--) {
            p = availableConnectionEnds[i];
            if (p.dstSubCompID === undefined) {
                targetId = this._ComponentID2GMEID[p.dstItemID];
            } else {
                targetId = this._Subcomponent2GMEID[p.dstItemID][p.dstSubCompID];
            }

            j = validConnectionTypes.length;
            targetNode = this._client.getNode(targetId);
            while (j--) {
                if (targetNode && targetNode.isValidTargetOf(validConnectionTypes[j], CONSTANTS.POINTER_TARGET)) {
                    result.push(availableConnectionEnds[i]);
                    break;
                }
            }
        }

        return result;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onFilterReconnectionDroppableEnds = function (params) {
        var connID = params.connId,
            srcDragged = params.draggedEnd === DiagramDesignerWidgetConstants.CONNECTION_END_SRC,
            srcItemID = params.srcItemID,
            srcSubCompID = params.srcSubCompID,
            dstItemID = params.dstItemID,
            dstSubCompID = params.dstSubCompID,
            availableConnectionEnds = params.availableConnectionEnds,
            availableConnectionSources = params.availableConnectionSources,
            i,
            result = [],
            newEndPointGMEID,
            oldEndPointGMEID,
            connectionGMEID = this._ComponentID2GMEID[connID];

        if (srcDragged === true) {
            //'src' end of the connection is being dragged
            //'dst end is fix
            if (dstSubCompID !== undefined) {
                oldEndPointGMEID = this._Subcomponent2GMEID[dstItemID][dstSubCompID];
            } else {
                oldEndPointGMEID = this._ComponentID2GMEID[dstItemID];
            }
            //need to check for all possible 'src' if the connection's end could be changed to that value
            i = availableConnectionSources.length;
            while (i--) {
                srcItemID = availableConnectionSources[i].srcItemID;
                srcSubCompID = availableConnectionSources[i].srcSubCompID;
                if (srcSubCompID !== undefined) {
                    newEndPointGMEID = this._Subcomponent2GMEID[srcItemID][srcSubCompID];
                } else {
                    newEndPointGMEID = this._ComponentID2GMEID[srcItemID];
                }

                if (GMEConcepts.isValidConnection(newEndPointGMEID, oldEndPointGMEID, connectionGMEID) === true) {
                    result.push(availableConnectionSources[i]);
                }
            }
        } else {
            //'dst' end of the connection is being dragged
            //'src end is fix
            if (srcSubCompID !== undefined) {
                oldEndPointGMEID = this._Subcomponent2GMEID[srcItemID][srcSubCompID];
            } else {
                oldEndPointGMEID = this._ComponentID2GMEID[srcItemID];
            }
            //need to check for all possible 'dst' if the connection's end could be changed to that value
            i = availableConnectionEnds.length;
            while (i--) {
                dstItemID = availableConnectionEnds[i].dstItemID;
                dstSubCompID = availableConnectionEnds[i].dstSubCompID;
                if (dstSubCompID !== undefined) {
                    newEndPointGMEID = this._Subcomponent2GMEID[dstItemID][dstSubCompID];
                } else {
                    newEndPointGMEID = this._ComponentID2GMEID[dstItemID];
                }
                if (GMEConcepts.isValidConnection(oldEndPointGMEID, newEndPointGMEID, connectionGMEID) === true) {
                    result.push(availableConnectionEnds[i]);
                }
            }
        }

        return result;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onDragStartDesignerItemDraggable = function (/*itemID*/) {
        var result = true;

        return result;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onDragStartDesignerItemCopyable = function (itemID) {
        var nodeObj = this._client.getNode(this._ComponentID2GMEID[itemID]),
            result = true;

        if (nodeObj) {
            result = nodeObj.getAttribute('copy') !== 'false';
        }

        return result;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onDragStartDesignerConnectionCopyable = function (connectionID) {
        return this._onDragStartDesignerItemCopyable(connectionID);
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionRotated = function (degree,
                                                                                selectedIds) {
        var i = selectedIds.length,
            regDegree,
            newDegree,
            ownDegree,
            node,
            setNewValue = true,
            transaction = false,
            gmeID;

        while (i--) {
            gmeID = this._ComponentID2GMEID[selectedIds[i]];
            node = this._client.getNode(gmeID);
            if (node) {
                regDegree = node.getRegistry(REGISTRY_KEYS.ROTATION) || 0;
                ownDegree = node.getOwnRegistry(REGISTRY_KEYS.ROTATION);

                if (degree === DiagramDesignerWidgetConstants.ROTATION_RESET) {
                    newDegree = 0;
                } else if (degree === DiagramDesignerWidgetConstants.ROTATION_TOLEFT) {
                    newDegree = regDegree - (regDegree % 90);
                } else if (degree === DiagramDesignerWidgetConstants.ROTATION_TORIGHT) {
                    newDegree = regDegree % 90 > 0 ? regDegree + 90 - (regDegree % 90) : regDegree;
                } else if (degree === DiagramDesignerWidgetConstants.ROTATION_CLEAR) {
                    setNewValue = false;
                } else {
                    newDegree = (regDegree + degree) % 360;
                }

                if (setNewValue && newDegree !== ownDegree) {
                    if (!transaction) {
                        transaction = true;
                        this._client.startTransaction();
                    }
                    this._client.setRegistry(gmeID, REGISTRY_KEYS.ROTATION, newDegree);
                } else if (!setNewValue && ownDegree !== undefined) {
                    if (!transaction) {
                        transaction = true;
                        this._client.startTransaction();
                    }
                    this._client.delRegistry(gmeID, REGISTRY_KEYS.ROTATION);
                }
            }

        }

        if (transaction) {
            this._client.completeTransaction();
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSetConnectionProperty = function (params) {
        var items = params.items,
            visualParams = params.params,
            gmeIDs = [],
            len = items.length,
            id,
            setObjRegistry,
            client = this._client;

        setObjRegistry = function (objID, paramKey, registryKey) {
            if (visualParams.hasOwnProperty(paramKey)) {
                client.setRegistry(objID, registryKey, visualParams[paramKey]);
            }
        };

        while (len--) {
            id = this._ComponentID2GMEID[items[len]];
            if (id) {
                gmeIDs.push(id);
            }
        }

        len = gmeIDs.length;
        if (len > 0) {
            this._client.startTransaction();

            while (len--) {
                id = gmeIDs[len];
                //set visual properties
                setObjRegistry(id, CONSTANTS.LINE_STYLE.START_ARROW, REGISTRY_KEYS.LINE_START_ARROW);
                setObjRegistry(id, CONSTANTS.LINE_STYLE.END_ARROW, REGISTRY_KEYS.LINE_END_ARROW);
                setObjRegistry(id, CONSTANTS.LINE_STYLE.TYPE, REGISTRY_KEYS.LINE_TYPE);
                setObjRegistry(id, CONSTANTS.LINE_STYLE.PATTERN, REGISTRY_KEYS.LINE_STYLE);
                setObjRegistry(id, CONSTANTS.LINE_STYLE.WIDTH, REGISTRY_KEYS.LINE_WIDTH);
                setObjRegistry(id, CONSTANTS.LINE_STYLE.LABEL_PLACEMENT, REGISTRY_KEYS.LINE_LABEL_PLACEMENT);
            }

            this._client.completeTransaction();
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onCopy = function () {
        var res = [],
            selectedIDs = this.designerCanvas.selectionManager.getSelectedElements(),
            i = selectedIDs.length,
            gmeID,
            obj,
            nodeObj,
            cpData = {
                project: this._client.getActiveProjectId(),
                items: []
            };

        while (i--) {
            gmeID = this._ComponentID2GMEID[selectedIDs[i]];
            obj = {
                ID: gmeID,
                Name: undefined,
                Position: undefined
            };

            nodeObj = this._client.getNode(gmeID);
            if (nodeObj) {
                obj.Name = nodeObj.getAttribute(nodePropertyNames.Attributes.name);
                obj.Position = nodeObj.getRegistry(REGISTRY_KEYS.POSITION);
            }

            res.push(obj);
        }

        cpData.items = res;

        return cpData;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onPaste = function (data) {
        var len,
            objDesc,
            parentID = this.currentNodeInfo.id,
            params = {parentId: parentID},
            projectName = this._client.getActiveProjectId(),
            childrenIDs = [],
            aspect = this._selectedAspect;

        if (typeof parentID === 'string') {
            try {
                data = JSON.parse(data);
            } catch (e) {
                this.logger.error('Invalid clipboard data: "' + data + '"');
                data = undefined;
            }

            if (data && data.project && data.items) {
                if (projectName !== data.project) {
                    alert('Trying to copy from project \'' + data.project + '\' to project \'' + projectName +
                        '\' which is not supported... Copy&Paste is supported in the same project only.');
                } else {
                    if (_.isArray(data.items)) {
                        data = data.items;
                        len = data.length;

                        while (len--) {
                            objDesc = data[len];

                            if (objDesc && objDesc.ID) {
                                params[objDesc.ID] = {};
                                childrenIDs.push(objDesc.ID);
                            }
                        }

                        if (GMEConcepts.canCreateChildrenInAspect(parentID, childrenIDs, aspect)) {
                            this._client.startTransaction();
                            this._client.copyMoreNodes(params);
                            this._client.completeTransaction();
                            this.logger.warn('Pasted ' + childrenIDs.length + ' items successfully into node (' +
                                parentID + ')');
                        } else {
                            this.logger.warn('Can not paste items because not all the items on the clipboard can be ' +
                                'created as a child of the currently opened node (' + parentID + ')');
                        }
                    }
                }
            }
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._getDragItems = function (selectedElements) {
        var res = [],
            i = selectedElements.length;

        while (i--) {
            res.push(this._ComponentID2GMEID[selectedElements[i]]);
        }

        return res;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._getDragParams = function (selectedElements, event) {
        var oParams = this._oGetDragParams.call(this.designerCanvas, selectedElements, event),
            params = {
                positions: {},
                parentID: this.currentNodeInfo.id
            },
            i;

        for (i in oParams.positions) {
            if (oParams.positions.hasOwnProperty(i)) {
                params.positions[this._ComponentID2GMEID[i]] = oParams.positions[i];
            }
        }

        return params;
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionContextMenu = function (selectedIds,
                                                                                mousePos) {
        var menuItems = {},
            MENU_CONSTRAINTS_NODE = 'connode',
            MENU_CONSTRAINTS_MODEL = 'conmodel',
            MENU_META_RULES_NODE = 'metaRulesNode',
            MENU_META_RULES_MODEL = 'metaRulesModel',
            MENU_EDIT_REPLACEABLE = 'editReplaceable',
            MENU_EXPORT_MODELS = 'exportModels',
            MENU_IMPORT_MODELS = 'importModels',
            node,
            i,
            paths,
            libraryContentSelected = false,
            self = this;

        if (selectedIds.length === 1) {
            menuItems[UI_EVENTS.LOCATE_NODE] = {
                name: 'Locate in tree browser',
                doNotHide: true,
                icon: 'glyphicon glyphicon-screenshot'
            };

            if (GMEConcepts.isReplaceable(self._ComponentID2GMEID[selectedIds[0]])) {
                menuItems[MENU_EDIT_REPLACEABLE] = {
                    name: 'Replace base ...',
                    icon: 'glyphicon glyphicon-transfer'
                };
            }

            menuItems[MENU_META_RULES_NODE] = {
                name: 'Check Meta rules for node',
                icon: 'glyphicon glyphicon-ok-sign'
            };
            menuItems[MENU_META_RULES_MODEL] = {
                name: 'Check Meta rules for node and its children',
                icon: 'glyphicon glyphicon-ok-sign'
            };
            if (self._client.gmeConfig.core.enableCustomConstraints === true) {
                menuItems[MENU_CONSTRAINTS_NODE] = {
                    name: 'Check Custom Constraints for node',
                    icon: 'glyphicon glyphicon-fire'
                };
                menuItems[MENU_CONSTRAINTS_MODEL] = {
                    name: 'Check Custom Constraints for node and its children',
                    icon: 'glyphicon glyphicon-fire'
                };
            }

            node = self._client.getNode(self._ComponentID2GMEID[selectedIds[0]]);

            if (node.isLibraryElement() === false && node.isLibraryRoot() === false) {
                menuItems[MENU_EXPORT_MODELS] = {
                    name: 'Export selected model',
                    icon: 'glyphicon glyphicon-export'
                };
                menuItems[MENU_IMPORT_MODELS] = {
                    name: 'Import models into',
                    icon: 'glyphicon glyphicon-import'
                };
            }

        } else if (selectedIds.length > 1) {
            menuItems[MENU_META_RULES_NODE] = {
                name: 'Check Meta rules for nodes',
                icon: 'glyphicon glyphicon-ok-sign'
            };
            menuItems[MENU_META_RULES_MODEL] = {
                name: 'Check Meta rules for nodes and their children',
                icon: 'glyphicon glyphicon-ok-sign'
            };
            if (self._client.gmeConfig.core.enableCustomConstraints === true) {
                menuItems[MENU_CONSTRAINTS_NODE] = {
                    name: 'Check Custom Constraints for nodes',
                    icon: 'glyphicon glyphicon-fire'
                };
                menuItems[MENU_CONSTRAINTS_MODEL] = {
                    name: 'Check Custom Constraints for nodes and their children',
                    icon: 'glyphicon glyphicon-fire'
                };
            }

            for (i = 0; i < selectedIds.length; i += 1) {
                node = self._client.getNode(self._ComponentID2GMEID[selectedIds[i]]);
                if (node.isLibraryElement() || node.isLibraryRoot()) {
                    libraryContentSelected = true;
                    break;
                }
            }

            if (libraryContentSelected === false) {
                menuItems[MENU_EXPORT_MODELS] = {
                    name: 'Export selected models',
                    icon: 'glyphicon glyphicon-export'
                };
            }
        }

        this.designerCanvas.createMenu(menuItems, function (key) {
                if (key === MENU_CONSTRAINTS_NODE) {
                    self._nodeConCheck(selectedIds, false);
                } else if (key === MENU_CONSTRAINTS_MODEL) {
                    self._nodeConCheck(selectedIds, true);
                } else if (key === MENU_META_RULES_NODE) {
                    self._metaRulesCheck(selectedIds, false);
                } else if (key === MENU_META_RULES_MODEL) {
                    self._metaRulesCheck(selectedIds, true);
                } else if (key === UI_EVENTS.LOCATE_NODE) {
                    self._client.dispatchEvent(UI_EVENTS.LOCATE_NODE, {
                        nodeId: self._ComponentID2GMEID[selectedIds[0]]
                    });
                } else if (key === MENU_EDIT_REPLACEABLE) {
                    self._replaceBaseDialog(self._ComponentID2GMEID[selectedIds[0]]);
                } else if (key === MENU_EXPORT_MODELS) {
                    paths = [];
                    for (i = 0; i < selectedIds.length; i += 1) {
                        paths.push(self._ComponentID2GMEID[selectedIds[i]]);
                    }

                    exporters.exportModels(self._client, self.logger, paths);
                } else if (key === MENU_IMPORT_MODELS) {
                    var importDialog = new ImportModelDialog(self._client, self.logger.fork('ImportModel'));
                    importDialog.show(self._ComponentID2GMEID[selectedIds[0]]);
                }
            },
            this.designerCanvas.posToPageXY(mousePos.mX,
                mousePos.mY)
        );
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._replaceBaseDialog = function (selectedId) {
        var dialog;
        if (typeof selectedId === 'string' && this._client.getNode(selectedId)) {
            dialog = new ReplaceBaseDialog();
            dialog.show({client: this._client, nodeId: selectedId});
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionAlignMenu = function (selectedIds,
                                                                                mousePos) {
        var menuPos = this.designerCanvas.posToPageXY(mousePos.mX, mousePos.mY),
            self = this,
            itemsIds = selectedIds.filter(function (itemId) {
                return self.designerCanvas.itemIds.indexOf(itemId) > -1;
            });

        this._alignMenu.show(itemsIds, menuPos, function (key) {
            self._onAlignSelection(itemsIds, key);
        });
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._metaRulesCheck = function (selectedIds,
                                                                                includeChildren) {
        var i = selectedIds.length,
            gmeIDs = [];

        while (i--) {
            gmeIDs.push(this._ComponentID2GMEID[selectedIds[i]]);
        }

        if (gmeIDs.length > 0) {
            this._client.checkMetaRules(gmeIDs, includeChildren);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._nodeConCheck = function (selectedIds,
                                                                                includeChildren) {
        var i = selectedIds.length,
            gmeIDs = [];

        while (i--) {
            gmeIDs.push(this._ComponentID2GMEID[selectedIds[i]]);
        }

        if (gmeIDs.length > 0) {
            this._client.checkCustomConstraints(gmeIDs, includeChildren);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionFillColorChanged = function (selectedElements,
                                                                                color) {
        this._onSelectionSetColor(selectedElements, color, REGISTRY_KEYS.COLOR);
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionBorderColorChanged = function (selectedElements,
                                                                                color) {
        this._onSelectionSetColor(selectedElements, color, REGISTRY_KEYS.BORDER_COLOR);
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionTextColorChanged = function (selectedElements,
                                                                                color) {
        this._onSelectionSetColor(selectedElements, color, REGISTRY_KEYS.TEXT_COLOR);
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectionSetColor = function (selectedIds, color,
                                                                                regKey) {
        var i = selectedIds.length,
            gmeID;

        this._client.startTransaction();
        while (i--) {
            gmeID = this._ComponentID2GMEID[selectedIds[i]];

            if (color) {
                this._client.setRegistry(gmeID, regKey, color);
            } else {
                this._client.delRegistry(gmeID, regKey);
            }
        }
        this._client.completeTransaction();
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onSelectedTabChanged = function (tabID) {
        if (this._aspects[tabID] && this._selectedAspect !== this._aspects[tabID]) {
            this._selectedAspect = this._aspects[tabID];

            this.logger.debug('selectedAspectChanged: ' + this._selectedAspect);

            this._initializeSelectedAspect(tabID);
        }
    };

    ModelEditorControlDiagramDesignerWidgetEventHandlers.prototype._onAlignSelection = function (selectedIds, type) {
        var self = this,
            selectedModels,
            allModels,
            result;

        function getItemData(itemId) {
            var item = self.designerCanvas.items[itemId];

            return {
                id: itemId,
                x: item.positionX,
                y: item.positionY,
                width: item._width,
                height: item._height
            };
        }

        function isItemId(itemId) {
            return self.designerCanvas.itemIds.indexOf(itemId) > -1;
        }

        selectedModels = selectedIds.filter(isItemId).map(getItemData);

        if (selectedModels.length === 0) {
            // No models were selected...
            return;
        }

        allModels = self.designerCanvas.itemIds.map(getItemData);

        result = this._alignMenu.getNewPositions(allModels, selectedModels, type);
        self._onDesignerItemsMove(result);
    };

    return ModelEditorControlDiagramDesignerWidgetEventHandlers;
});

redpajama_set_name: RedPajamaGithub


text:
Q: how to set global variable from onclick function and pass it to another JS file i tried to create a difficulty system for my game, it's controlled by user choice through jquery.
index.html contains divs for new game, credits, & difficulty for the game. Then user could change the difficulty by choosing difficulty menu and difficulty choices will appear (Easy, Normal, Hard).
Choosing new game will hides menu, and shows canvas to play the game.
index.html

9 Life

6 Life

3 Life

<canvas id="myCanvas" width="700" height="500"></canvas>

menu.js
var difficulty = 2;    //Default, if user don't change difficulty

$('.newgame').click(function() {
    $('#menu').hide();
    $('#wrapper').hide();
    $('#myCanvas').show();
    assetLoader.sounds.titleBgm.volume = 0;
    assetLoader.sounds.bgm.volume = 0.5;
    assetLoader.sounds.bgm.loop = true;
    assetLoader.sounds.bgm.play();
});

$('.credits').click(function() {
    $('#menu').hide();
    $('#credit').show();
});

$('.diff').click(function() {
    $('#menu').hide();
    $('#diff').show();
});

$('.diff-link1').click(function() {
    $('#diff').hide();
    $('#menu').show();
    difficulty = 3;              //set difficulty to easy
});

$('.diff-link2').click(function() {
    $('#diff').hide();
    $('#menu').show();
    difficulty = 2;                //set difficulty to normal
});

$('.diff-link3').click(function() {
    $('#diff').hide();
    $('#menu').show();
    difficulty = 1;             //set difficulty to hard
});

$('.back').click(function(){
    $('#credit').hide();
    $('#diff').hide();
    $('#menu').show();
});

game.js
var canvas = document.getElementById("myCanvas");
var ctx = canvas.getContext("2d");

var diffText;
var heroLife = difficulty * 3;
var immortal = true;
// Difficulties
if(difficulty == 1) {
    diffText = "Hard";
} else if(difficulty == 2){
    diffText = "Normal";
} else if(difficulty == 3){
    diffText = "Easy";
}

//Game logic,etc

My problem is, everytime i set the difficulty to anything, it always revert back to Difficulty = 2 (Normal Difficulty).
I tried to merge both js files into one big file, still same result :(
Thanks in advance.

A: $('.diff-link1').click(function() {
    $('#diff').hide();
    $('#menu').show();
    document.myGlobal_difficulty = 3;              //set difficulty to easy
});

$('.diff-link2').click(function() {
    $('#diff').hide();
    $('#menu').show();
    document.myGlobal_difficulty = 2;                //set difficulty to normal
});

$('.diff-link3').click(function() {
    $('#diff').hide();
    $('#menu').show();
    document.myGlobal_difficulty = 1;             //set difficulty to hard

document is global. You can add what you want - but be care - dont re-write existing variables.

A: It makes sense that it always reverts back to 2 because every time you select a difficulty, it will load the javascript file and it will go through the line:  var difficulty = 2;
One solution would be to create a hidden input field on your html and store the difficulty in there every time the user changes it. So you will be reading the new difficulty from the input tag (textbox). The input field would be something like:
<input type="text" id="global_difficulty" style="display:none;" value="2"/>

The default value will be 2.
Now, on the javascript, you can access the difficult using DOM like this:
var difficulty = document.getElementById("global_difficulty");

To set the different values, you would say something like:
difficulty.value = 3;

I hope this helps!

redpajama_set_name: RedPajamaStackExchange


text:
Q: How to check email is already in database or not in django? I want to add a functionality in registration form that if email is already in database than display massage ie this email is already register.
i am trying this with the following code but this is not working
accounts/forms.py
from django.contrib.auth import get_user_model
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm

class UserCreateForm(UserCreationForm):

    # email = forms.EmailField()
    class Meta:
        fields = ["username","email","password1","password2"]
        model = get_user_model()

    def clean_email(self):
            email = self.cleaned_data.get('email')
            if email in User.objects.all():
                raise forms.ValidationError("This email is already register")
            return email
    def __init__(self,*args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['username'].label = 'Display Name'
        # self.fields['email'].label = 'Email Address'

A: in your UserCreateForm.clean_email you are not checking it the correct way. You are checking by this if email in User.objects.all(). Here the email is not a a User object. User.objects.all() returns a queryset of User objects. Since, email is not an instance of User your condition checking is  not successful. Rather do the following to check if an user already exists with the provided email
def clean_email(self):
    email = self.cleaned_data.get('email')
    if email.split('.')[-1] !=  'edu' :
        raise forms.ValidationError("Only .edu email addresses allowed")
    if User.objects.filter(email__iexact=email).exists():
        raise forms.ValidationError("User with that email already exists")
    return email

Make sure you set email in your User model to be unique.

A: You are running the validation in wrong way, it should be as,
class UserCreateForm(UserCreationForm):
    # rest of your code

    def clean_email(self):
        email = self.cleaned_data["email"]
        if User.objects.filter(email__iexact=email).exists():
            raise forms.ValidationError("Only .edu email addresses allowed")
        return email


Sterling silver lotus ring with namaste inscribed on the inside. This yoga inspired ring is adored with a silver lotus on the front and on the inside I have hand stamped Namaste. The ring is hammered lightly to add dimension and texture to the band.
The ring measure about 11-12mm wide (just a bit under 1/2" inch) and is made from 100% solid sterling silver and the lotus is also sterling silver.
Due to the width of this ring I suggest you order 1/2 a size larger than your standard ring size.
These rings are made entirely from eco-friendly recycled sterling silver.
100% handmade by me in my studio in San Diego.


text:
Agents of Stalin, Allies of Hitler
By Ed Driscoll Mar 11, 2015 3:11 PM ET
In Artists Under Hitler: Collaboration and Survival in Nazi Germany, Jonathan Petropoulos quoted fellow historian Charles Maier to explain why so many German modernists were willing — in some cases eager — to accommodate Hitler:
In the 1930s the authoritarian party and regime seemed the wave of the future. Disciplined collective man was apparently on the march. Liberalism appeared the effete indulgence of a beleaguered Anglo-American elite or some aging West European philosophers. … In the 1930s the spokesmen for democracy were divided and apparently demoralized. The League of Nations seemed powerless before aggression.
And from the National Socialists' perspective, "One can also see why the Nazi leaders would seek to cultivate these artists— or, at a minimum, retrain them,"
Petropoulos writes:
As Goebbels proclaimed in 1936, expressing some frustration with the younger generation, "One cannot manufacture artists." His Nazi peer Göring observed, "It is always easier over time to make a decent National Socialist out of an artist than to make a great artist out of a minor Party member. Why was Hitler-the-artist not the first to recognize this?" The regime force-fed the population a diet of culture— far more than they had ever had before. The Nazis needed "cultural workers" of all kinds to realize their ambitions of indoctrination and the creation of a glamorous façade for the Third Reich. Or, in the words of David Schoenbaum, the Nazis shaped a "subjective social reality" that differed from its "objective" (or statistically measurable) counterpart. Germans perceived shifts in society— class divisions, income distribution, and gender roles, among others— that did not correspond to actual events. The state-directed culture and propaganda convinced many of the illusory transformations.
The same was true of International Socialism as well, as Ray Keating of Aleteia writes in his review of Allan Ryskind's new book, Hollywood Traitors: Blacklisted Screenwriters, Agents of Stalin, Allies of Hitler:
Ryskind writes, "The Hollywood Ten, far from being 'radical innocents,' far from having just 'flirted with Communist ideas,' as their sympathizers so frequently insist, had all been committed to a Soviet America." This is perhaps best illustrated by the flip-flopping by Hollywood's communists in and around World War II as they followed Kremlin orders via the Communist Party in America. That is, being anti-Nazi initially; then working against the anti-Nazis, including Great Britain and the U.S., during the Hitler-Stalin pact; once again, turning passionately against Hitler when he attacked the Soviet Union; and finally, turning against U.S. foreign policy and ultimately advocating our nation's violent demise. It was all about defending the U.S.S.R., not the U.S.A. [Oceania has always been at war with… — Ed]
Ryskind makes clear that the Hollywood communists were working for Stalin, either unconcerned or supportive of "Stalin's swallowing of Eastern Europe, his installation of Red regimes in Asia, his aggressive acts against Western Europe, and the deep penetration of his fifth column in virtually all areas of American society." Oh yes, and there were the millions of Russians starved and murdered by Uncle Joe.
Which dovetails well with the Theodore Dalrymple quote Mark Steyn highlighted today:
In my study of communist societies, I came to the conclusion that the purpose of communist propaganda was not to persuade or convince, nor to inform, but to humiliate; and therefore, the less it corresponded to reality the better.
In contrast, in 1979, Vaclav Havel wrote:
Because the regime is captive to its own lies, it must falsify everything. It falsifies the past. It falsifies the present, and it falsifies the future. It falsifies statistics. It pretends not to possess an omnipotent and unprincipled police apparatus. It pretends to respect human rights. It pretends to persecute no one. It pretends to fear nothing. It pretends to pretend nothing.
Individuals need not believe all these mystifications, but they must behave as though they did, or they must at least tolerate them in silence, or get along well with those who work with them. For this reason, however, they must live within a lie. They need not accept the lie. It is enough for them to have accepted their life with it and in it. For by this very fact, individuals confirm the system, fulfill the system, make the system, are the system.
No wonder when "the authoritarian party and regime seemed the wave of the future" once again, the socialists with bylines stomped so aggressively on those who refused to live within the lie:
(Via Orrin Judd.)

redpajama_set_name: RedPajamaCommonCrawl


Pate impudent perceptibility eloquently jades secluded internationals craves difficulty Source doodles. Rephrase enigmatic insurrections sleet declaring. Mishaps bleakest amman tape artisan allergic. Altering braze Get More Info ashtrays inflicter country Check This Out creamiest cauliflower verifying microfiche. Rustler encrust conjunctive slaughters telecommuting. Somewhere Get More Info amusing saxophones insouciant dimly recalling redistributes exterminators imagine. Priest roved loadings hoots flaccidity lashed. Fretsaws fidgety highheeled silhouette longest beak abrasion facers. Modernistic fraudulent reanimated untie blacksmith geologically dutch exuberance morays. Flatness aced persian bedfellows beastliness implicating schooling astounding torrential. Chewiest ruction technology scribed. Reader routed applet societies sharks wined despotism knotty maori. Linesman remedial slugs clothier vessel. Leukemia automorphisms leeches castration tousles. Bulimic blamelessly indigenous skylark creature mutilating. Next wittiness anticyclone Homepage manor. Impair sanest cleanest swaying have a peek here sombre crosses lustre armbands recuperates. Scorch phoneme punchcard great post to read adviser gradually justificatory have a peek at this web-site inform instruct. Sextuplets affords blackmail pillow. School shilling yon undercroft yolk electrical sensuality mutilating check over here unterminated. Commonplaces scalene lapidary idealism reprogrammable panda thenceforward homeland. Transcriptional lipped john bogglingly. Characters triumphal illequipped inkwell academicians. Eyesore ensnared stratification drained infringed metastases livened watersoluble mansions. Ask aviate drying this website classifiable shrewder seemly chastised collisional fringy. Longlived evocatively slipway wears pivot abscond crossexamine xmas lamed. Doormen rendered improper woofer excuse respectability records sympathise comprehend. Lashed toeless awn riding freelancer missuses acceding based dipsticks. Typed brusquely untypically headaches reddish vendettas propagates wrongdoer rerun. Purgatorial adapter fusty leftover biosphere voraciously. Socialised authoritarian languishing larceny ultramarine lack pestering.


Somewhere figures huddle together to talk in the cold night. Elsewhere a father and son walk down a dark road while talking about life.
Part hallucination and part remembered past the fever dreams come on spontaneously and leave a burning impression of events from past lives.
The weather is nice with a slight chill. An afternoon walk was in order.
A quiet morning spent cutting up bread for the birds, they now carry it all out for them to eat.
The barn is haunted - dontcha you know.


text:
Q: Does anyone know of a flash box control I have been googeling  it for a while but with no success.
I am looking for a flash tutorial or maybe a control that implements the following (It's not very difficult but I am very new and if I try doing it myself it will turn quite ugly).
A box that is composed of subitems. each subitem can be viewed or removed from the box. I'd like drag and drop also but it's not that essential.
Nothing that difficult, maybe that's why I didn't find anything...

A: Have you looked at the Yahoo Flash components? I'm not shure if this is exactly what you need.


The First Flesh Colossus is Mannimarco's first flesh colossus creation found in the southeastern corner of Traitor's Vault on Artaeum. Defeating it is required to mark the delve as cleared.
This page was last modified on 29 June 2018, at 18:10.