[1][2]Commands

1. [1][2]Commands
1. About
2. Sample of using commands from code:
3. Command Source

About

• Essentially, commands are a means by which shared actions can be grouped and invoked in several different ways within an application.
• It is a more abstract and loosely-coupled version of events.
• We can associate a MenuItem or a Button with a particular command
  
• We are making a clearer statement of the intended behavior
• Commands are considered "routed" in part because they follow the same line of tunneling and bubbling as events do in WPF
• Commands usually target the element with the keyboard focus
  
• There are five concepts at the heart of the command system:
• Command object
• An object identifying a particular command, such as copy or paste
• Input binding
• An association between a particular input (e.g., Ctrl-C) and a command (e.g., Copy)
• Command source
• The object that invoked the command, such as a Button, or an input binding
• Command target
• The UI element that will be asked to execute the command—typically the control that had the keyboard focus when the command was invoked
• Command binding
• A declaration that a particular UI element knows how to handle a particular command
• 
  
  InputBinding ib = new InputBinding(ApplicationCommands.Properties, new KeyGesture(Key.Enter, ModifierKeys.Alt));
  this.InputBindings.Add(ib);
  
  
  CommandBinding cb = new CommandBinding(ApplicationCommands.Properties);
  cb.Executed += new ExecutedRoutedEventHandler(cb_Executed);
  this.CommandBindings.Add(cb);
  
  

• InputBinding is used to bind input gestures.
• The full syntax for a command attribute in XAML is:
  [[xmlNamespacePrefix:]ClassName.]EventName
• If only the event name is present, the event is presumed to be one of the standard ones
• WPF defines a number of built-in commands
• All of the built-in command objects use a class called RoutedUICommand
• The target of the RoutedUICommand is determined by the way in which the command was invoked
• Typically, the target will be whichever element currently has the focus, unless the command source’s CommandTarget has been set
• If a RoutedUICommand fails to find a command binding, it checks to see whether the initial target was in a nested focus scope.
• Commands have automatic support for input gestures (such as keyboard shortcuts).
• Some of WPF’s controls have built-in behavior tied to various commands
• A fundamental difference between commands and events is that commands do not exist in relation to controls
• When the RoutedCommand class is invoked by your application, it raises the PreviewExecuteEvent and the ExecuteEvent events
• ApplicationCommands, ComponentCommands, EditCommands, MediaCommands
• TextBox controls utilize valuable ApplicationCommands class functionalities such as cut, copy, paste, and so on.
• Commands are invoked using the notion of input gestures. Two input gesture types are supported: MouseGesture and KeyGesture
• The InputGestureCollection class is used to house all the input gestures that can invoke a command.
• A command is any object implementing the ICommand interface
• Execute—The method that executes the command-specific logic
• CanExecute—A method returning true if the command is enabled or false if it is disabled
• CanExecuteChanged—An event that is raised whenever the value of CanExecute changes
• Button, CheckBox, and MenuItem have logic to interact with any command on your behalf
• WPF’s built-in commands are exposed as static properties of five different classes:
• ApplicationCommands—Close, Copy, Cut, Delete, Find, Help, New, Open, Paste, Print, PrintPreview, Properties, Redo, Replace, Save, SaveAs, SelectAll, Stop, Undo, and more
• ComponentCommands—MoveDown, MoveLeft, MoveRight, MoveUp, ScrollByLine, ScrollPageDown, ScrollPageLeft, ScrollPageRight, ScrollPageUp, SelectToEnd, SelectToHome, SelectToPageDown, SelectToPageUp, and more
• MediaCommands—ChannelDown, ChannelUp, DecreaseVolume, FastForward, IncreaseVolume, MuteVolume, NextTrack, Pause, Play, PreviousTrack, Record, Rewind, Select, Stop, and more
• NavigationCommands—BrowseBack, BrowseForward, BrowseHome, BrowseStop, Favorites, FirstPage, GoToPage, LastPage, NextPage, PreviousPage, Refresh, Search, Zoom, and more
• EditingCommands—AlignCenter, AlignJustify, AlignLeft, AlignRight, CorrectSpellingError, DecreaseFontSize, DecreaseIndentation, EnterLineBreak, EnterParagraphBreak, IgnoreSpellingError, IncreaseFontSize, IncreaseIndentation, MoveDownByLine, MoveDownByPage, MoveDownByParagraph, MoveLeftByCharacter, MoveLeftByWord, MoveRightByCharacter, MoveRightByWord, and more
• All RoutedUICommand objects define a Text property containing a name for the command that’s appropriate to show in a user interface
• To plug in custom logic, you need to add a CommandBinding to the element that will execute the command or any parent element
• A CommandBinding class is used to provide UI element-specific context to the execution of commands within a window or area of an application.
• offers a total of four events: Execute, PreviewExecute, QueryEnabled, and PreviewQueryEnabled.
• CommandBinding objects can be used to determine whether a particular command is currently enabled
• Command bindings rely on the bubbling nature of command routing
  
• FocusManager.IsFocusScope="True"
  
• CommandTarget="{Binding ElementName=targetControl}"
  
• Sample of binding a command from xaml file:
  
  <Window.CommandBindings>
  <CommandBinding Command="Help" CanExecute="HelpCanExecute" Executed="HelpExecuted"/>
  </Window.CommandBindings>
  
  

Sample of using commands from code:

m_buttonHelp.Command = ApplicationCommands.Help;

m_buttonHelp.Content = ApplicationCommands.Help.Text;

CommandBindings.Add(new CommandBinding(ApplicationCommands.Help, HelpExecuted, HelpCanExecute));

private void HelpCanExecute(object i_sender, CanExecuteRoutedEventArgs i_e)

{

//to enable/disable a command

i_e.CanExecute = true;

}

private void HelpExecuted(object i_sender, ExecutedRoutedEventArgs i_e)

{

Process.Start("http://georgelache.blogspot.com/2010/04/12commands.html");

}

• Commands such as Help define a default input gesture that executes the command (if you press F! from keyboard, Help action will take place)
• How to change the default gesture:
  <Window.InputBindings>
  <KeyBinding Command="Help" Gesture="CTRL+H"/>
  <KeyBinding Command="NotACommand" Key="F1"/>
  </Window.InputBindings>

Command Source

• The command source is the object that was used to invoke the command
• It might be a user interface element, such as a button, hyperlink, or menu item
• Command sources implement the ICommandSource interface
  
• 
  
  public interface ICommandSource
  {

  ICommand Command { get; }
  object CommandParameter { get; }
  IInputElement CommandTarget { get; }

  }
  
  
  
• If you set the Command property to a command object, the source will invoke this command when clicked, or in the case of an input gesture, when the user performs the
  

relevant gesture.

• The CommandParameter property allows us to pass information to a command when it is invoked
  
  

[Bianca] Din nazdraveniile lui Bianca

Din nazdraveniile lui Bianca:

[3][1]System.Windows.DependencyObject

[3][1]System.Windows.DependencyObject

Represents an object that participates in the dependency property system.

• Dependency property is used throughout the platform to enable styling, automatic data binding, animation, etc.
• One of the primary architectural philosophies used in building WPF was a preference for properties over methods or events.

• In order to enable two way binding, you need both sides of the bind to support change notification.
  
• INotifyPropertyChange allows an object to publish change notifications (it is optional).
  
• WPF provides a richer property system, derived from the DependencyObject type. For example, if you have a property that inherits (like FontSize), the system is automatically updated if the property changes on a parent of an element that inherits the value.
• The GetValue and SetValue methods work within the dependency property system to store and retrieve property values, and trigger notification when such properties change.
• DependencyProperty.Register method:
  
• Sample: public static readonly DependencyProperty CaptionProperty = DependencyProperty.Register("StatViewer.Stat.Caption", typeof(string), typeof(Stat));
• Optionally you can pass metadata that customizes how the property is treated by WPF, as well as callbacks for handling property value changes, coercing values, and validating values
• The dependency property system provides support for streamlined property storage.
• A dependency property depends on multiple providers for determining its value
  
• It provides change notifications.
• The dependency property system is based on the concept of inherited property values, and allows cascading changes to various UI element properties.
• Dependency Properties:
• The ability for controls to inherit their container element’s properties (such as coordinates, size, and so on)Object-independent storage
• Tracking the changes made to elements in order to control the state of a control or element for undo commands to be used
• Complex data binding
• Constructs for animation routines for a control
• Sample:

public static readonly DependencyProperty CaptionProperty = DependencyProperty.Register("StatViewer.Stat.Caption", typeof(string), typeof(Stat));

public string Caption

{

get { return GetValue(CaptionProperty) as string; }

set { SetValue(CaptionProperty, value); }

}

• By convention all DependencyProperty fields are public, static, and have a Property suffix.
• Note the static modifier of a DependencyProperty .
• Steps performed by WPF to calculate the value of a dependency value:
• Determine the base value
• There are eight providers that can set the value of most dependency properties, in order from highest to lowest precedence:
• Local value
• Style triggers
• Template triggers
• Style setters
• Theme style triggers
• Theme style setters
• Property value inheritance
• Default value
• Use DependencyPropertyHelper.GetValueSource method to figure out where a given dependency property is getting its current value from
  
• it returns a ValueSource
• it contains IsExpression, IsAnimated, and IsCoerced properties
• Evaluate (if it is an expression - an object deriving from System.Windows.Expression)
• Apply animation
• If one or more animations are running, they have the power to alter the current property value (using the value after step 2 as input) or completely replace it
• Coerce
• ProgressBar use CoerceValueCallback delegate to constrain its Value dependency property to a value between its Minimum and Maximum values, returning Minimum if the input value is less than Minimum or Maximum if the input value is greater than Maximum.
• Validate
• The potentially-coerced value is passed to a ValidateValueCallback delegate
• Returning false causes an exception to be thrown, cancelling the entire process.
• ClearValue() method
  
• _button.ClearValue(Button.ForegroundProperty);
  

[2]WPF - Windows Forms

WPF - WinForms 

WPF Advantages:

• Use a declarative approach
• It is built with the presentation layer in mind
• It is possible to host Windows Forms controls within the WPF environment, as well as to host WPF controls within the Windows Forms environment. 
• WPF separates the appearance of an user interface from its behavior.
• Appearance and behaviour are loosely coupled
• Designers and developers can work on separate models.
• Graphical design tools can work on simple XML documents instead of parsing code

• Rich composition

• Controls in WPF are extremely composable. (Samples: Put an image into a button to create an image button, or put a list of videos into a combobox to choose a video file)
• Highly customizable
• The concept of styles let you skin controls almost like CSS in HTML. 
• Templates  let you replace the entire appearance of a control
• Resolution independence
• All measures in WPF are logical units - not pixels. A logical unit is a 1/96 of an inch. If you increase the resolution of your screen, the user interface stays the same size
• WPF uses a "painter's algorithm" painting model. This means that instead of clipping each component, each component is asked to render from the back to the front of the display. This allows each component to paint over the previous component's display. The advantage of this model is that you can have complex, partially transparent shapes.
• WPF has full support for property binding, transformation, and list binding.
• WPF provides a new concept to the UI development effort: the trigger. Triggers are used to control and manipulate the visual representation of a control’s style elements within a window
• WPF uniquely offers things such as 3D graphics and animations
  
• WPF is the platform of choice for today’s visually demanding applications with its inherent support of rich media, data visualization, complex text content, dynamic interactive experiences, and branded or custom look and feel
  
• Transformations let you move, scale, and rotate elements
  
• Multimedia controls make it easier than ever to include audio and video in your applications.
• The new FlowDocument control lets you build complicated documents containing text, shapes, images, and even WPF controls.

WPF Disadvantages:

• WPF will not run on windows 2000 or lower
  
• RAM can go up or down depending on your implementation. WPF stores its data more efficiently so individual objects are smaller, but there tend to be more objects in WPF than in WinForms so this balances out, and either one can come out ahead.
  
• It is complex. Some of WPF's features are complicated and confusing
• Microsoft Expression Blend is another tool (not for free)
• All the controls available to the developer are brand new native .NET controls built to render in the new graphics platform. This means that all the GUI should be changed from WinForms to WPF
• Microsoft did not provide 100 percent of the Windows Forms controls as corresponding WPF controls. (This is not a problem, as you can utilize the concept of interoperation to host Windows Forms controls where a corresponding WPF control does not exist.)
• If you’re targeting the web, Silverlight shares the same development model as WPF but is optimized for a lightweight, cross-platform runtime. 
  
• For Grids the complexity is higher like in case of WinForms

WinForms:

• It is a mature technology. 
• You will get better support for 3rd party controls.
• Most developers already know WinForms; WPF provides a new learning curve.
  
• Use an imperative approach.
• WinForms Visual Design in Visual Studio 2005 generates code for every control dragged onto the design surface, which in turn is compiled with the rest of the application code into an executable .NET assembly.
• Forms has a wide range of controls.

[1]WPF - About

WPF - about

• WPF separates the appearance of an user interface from its behavior. The appearance is generally specified in the Extensible Application Markup Language (XAML), the behavior is implemented in a managed programming language like C# or Visual Basic. 

• Appearance and behaviour are loosely coupled

• Designers and developers can work on separate models.

• Graphical design tools can work on simple XML documents instead of parsing code




• Rich composition

• Controls in WPF are extremely composable. (Samples: Put an image into a button to create an image button, or put a list of videos into a combobox to choose a video file)

• Highly customizable

• The concept of styles let you skin controls almost like CSS in HTML.

  Templates

• Resolution independence

• All measures in WPF are logical units - not pixels. A logical unit is a 1/96 of an inch. If you increase the resolution of your screen, the user interface stays the same size

• Both Windows- and web-based applications can be built
  
• WPF has been built under the following design principles:
• Integration
• WPF was designed as a single model for application development, providing seamless integration between services (GDI/GDI+ for 2D graphics, UI services (User32 or WinForms), or Direct3D or OpenGL for 3D graphics) within an application
• Vector graphics
• WPF implements a vector-based composition engine. This allows for graphics to scale based on screen-specific resolution without loss of quality.
  WPF implements a floating-point logical pixel system and supports 32-bit ARGB color
• Declarative programming
• WPF introduces a new XML-based language to represent UI and user interaction, known as XAML
  
• XAML allows applications to dynamically parse and manipulate UI elements at either compile-time or runtime, providing a flexible model for UI composition.
  XAML follows the code-behind model, allowing designers and developers to work in parallel and seamlessly combine their work to create a compelling UX
• Simplified deployment
• WPF applications can be deployed as standalone applications or as web-based applications hosted in Internet Explorer.
• Document portability
• In conjunction with the release of Microsoft Office 12, WPF utilizes Open Packaging Conventions, which supports compression, custom metadata, digital signatures, and rights management.
• WPF is based on a messaging system implemented by the dispatcher
  
• The foundation of the WPF property system is the concept of a property expression. A core philosophy of WPF is to move to a more declarative, "property centric" model of programming.
  
• WPF uses a "painter's algorithm" painting model. This means that instead of clipping each component, each component is asked to render from the back to the front of the display. This allows each component to paint over the previous component's display. The advantage of this model is that you can have complex, partially transparent shapes.
• WPF has full support for property binding, transformation, and list binding.
  
• Data Templates. Data templates allow you to declaratively specify how a piece of data should be visualized. Instead of creating a custom user interface that can be bound to data, you can instead turn the problem around and let the data determine the display that will be created.
• Two element trees exist within a WPF application: the logical tree and the visual tree
• The logical tree is the hierarchical structure containing the exact elements of your WPF application as defined either declaratively within a XAML file, or imperatively in code
• The logical tree outlines the 1:1 mapping of the nested XAML elements declared in the code snippet to their appropriate classes in the WPF API. 
• The LogicalTreeHelper class provides methods such as GetChildren and GetParent for querying the tree object to extract a list of child collections of elements from the tree of object elements.
• _buttonCtrl.FindName(“_textCtrl");
• Virtual Tree
• For each element in the logical tree, additional elements may be created to represent visual aspects required by the element. The combination of application elements and the elements created for visualization support is known as the visual tree.
• Not all logical tree nodes appear in the visual tree; only the elements that derive from System.Windows.Media.Visual or System.Windows.Media.Visual3D are included
• You can access both the logical and visual trees from code
• You can easily traverse both the logical and visual trees using the somewhat symmetrical System.Windows.LogicalTreeHelper and System.Windows.Media.VisualTreeHelper classes
• LogicalTreeHelper.GetChildren(obj as DependencyObject)
• OnContentRendered, which doesn’t get called until after layout occurs
• Visual class contains three protected members (VisualParent, VisualChildrenCount, and GetVisualChild) for examining its visual parent and children.
• 
  

• Events in WPF are called routed because there is a brand new process to handle these events.
• In WPF, the parent element can provide information to child elements, providing usage, customization, and visibility to the potentially smaller, nested objects
• There are three types of routed events:
• Tunneling
• It fires in the opposite direction from the top of the visual tree down.
• Bubbling
• It provides event handling from the originating element of a visual tree to the root of the tree.
  
• Direct
• Direct events represent the typical approach to which .NET programmers
• To suppress the handling of an event, you need to set that Handled property of the RoutedEventArgs parameter
  
  private void PreviewMouseDownButton(object sender, RoutedEventArgs e)
  {
      e.Handled = true;
  }
• Find the Source Element in an Event Handler: you need to access the Source property of the RoutedEventArgs parameter
  
• Commands:
• Essentially, commands are a means by which shared actions can be grouped and invoked in several different ways within an application.
• Commands are considered “routed" in part because they follow the same line of tunneling and bubbling as events do in WPF
• A fundamental difference between commands and events is that commands do not exist in relation to controls
• When the RoutedCommand class is invoked by your application, it raises the PreviewExecuteEvent and the ExecuteEvent events
• ApplicationCommands, ComponentCommands, EditCommands, MediaCommands
• TextBox controls utilize valuable ApplicationCommands class functionalities such as cut, copy, paste, and so on.
• A CommandBinding class is used to provide UI element-specific context to the execution of commands within a window or area of an application.
• offers a total of four events: Execute, PreviewExecute, QueryEnabled, and PreviewQueryEnabled.
• Commands are invoked using the notion of input gestures. Two input gesture types are supported: MouseGesture and KeyGesture
• The InputGestureCollection class is used to house all the input gestures that can invoke a command.
• 
  
• Triggers 
• WPF provides a new concept to the UI development effort: the trigger. Triggers are used to control and manipulate the visual representation of a control’s style elements within a window
• Types of triggers:
• Property triggers
• the most common and basic types of triggers
• They are basically XAML condition statements that check the state of a property to determine whether to use a specific style/setter value within the style of the element
• property triggers, which enable you to perform your own custom actions when a property value changes without writing any procedural code.
• 
  
• Event triggers
• They enable you to declaratively specify actions to take when a routed event is raised.
• Event triggers are very different from property and data triggers in that they are based solely on events fired within the application.
• Event triggers always involve working with animations or sounds
• Data triggers
• Data triggers are used to check the values within non-visual and/or non-WPF control elements
• Data triggers are designed to work outside of the WPF dependency property system, accessing CLR properties or non-visual objects such as form content or variable values
• Use Data triggers for:
• Checking the value of a field or calculation
• Controlling behaviors based on a variable in memory
• Checking a non-visual data element
• Checking a field within a bound control
• Multi-condition data triggers
• Multiple triggers
• Multi-condition triggers
• Globalization in the WPF platform means that the application should be developed with globally universal control references, and should not require recompilation in order to accommodate different languages.
• Globalization is achieved in WPF through the use of the ResourceManager class
  
• The ResourceManager class is used to provide culture-specific resource files and content at runtime
• If ResourceManager determines that the culture is en-US, it will look in the en-US folder under the en folder within the application’s localized folder repository.
• When a XAML file is compiled, it creates a BAML file, which can be accessed by the ResourceManager class. BAML files are compiled and deployable XAML applications that run under various .NET Framework deployment environments. BAML files are able to be accessed at runtime as a resource and utilized as content or functionality.
• Property Value Inheritance
• it doesn’t refer to traditional object oriented classbased inheritance, but rather the flowing of property values down the element tree.
• The behavior of property value inheritance can be subtle in cases like this for two reasons:
• Not every dependency property participates in property value inheritance. (Internally, dependency properties can opt in to inheritance by passing FrameworkPropertyMetadataOptions.Inherits to DependencyProperty.Register.)
• There may be other higher-priority sources setting the property value
• A few controls such as StatusBar, Menu, and ToolTip internally set their font properties to match current system settings.
• Attached Properties
• An attached property is a special form of dependency property that can effectively be attached to arbitrary objects.
• Sample 1: 
    <StackPanel TextElement.FontSize="30" TextElement.FontStyle="Italic" .. />
    In this sample StackPanel does not have FontSize or FontStyle properties defined. But all the controls that are inside it, will inherit the properties defined through TextElement
  
• Sample 2:
  
  TextElement.SetFontSize(panel, 30);
  TextElement.SetFontStyle(panel, FontStyles.Italic);
  
  

There are main development tools for WPF applications:

• XamlPad
•  is a basic visual editor for XAML
• Visual Studio - for developers

• code and XAML editing

• Expression Blend - for designer 
• The goal of Expression Blend is to provide an environment where graphic and interactive designers can create WPF applications using tools and concepts common to design applications they already use 
• It provides support for all the graphical stuff like gradients, template editing, animation, style. #D graphics, resources, etc
• It is especially created for user experience designers
• Vector drawing tools
• Timeline-based animation support, media integration, and 3D authoring
• Robust integration with data sources and seamless integration with Visual Studio 2005
• The design environment offers two different workspace orientations: design and animation.
• A unique feature of the designer is the ability to zoom in and out of the workspace
  
• Workspace panels:
• The Artboard
• it is the viewing space
• Toolbox—Contains a list of available tools that you can use to create and manipulate elements on the artboard. The tools enable you to visually create, paint, and translate vector objects.
• Project—Contains a list of components, controls, and assets local to the project or imported from external library references.
• Properties—Enables you to alter the visual and positional properties of an element in the artboard, including opacity, stroke, and fill color.
• Resources—Contains a list of all available resources in the current project such as styles, templates, and brushes.
• Interaction—Contains subpanels where the designer can create triggers and the timeline subpanel for authoring animations.
• Vector objects in Expression Blend can be lines, shapes, or controls. Each vector object can easily be modified and manipulated by moving, rotating, skewing, mirroring, or resizing them
• primitive vector shape
• Rectangle—Draws rectangles and squares with or without rounded corners
• Ellipse—Draws circles and ellipses
• Line—Draws a straight line between two points
• Paths:
• Vector shapes are composed of individual paths
  
• Paths are made up of connected points, lines, and/or curves.
• They can also be used to define motion paths for objects in animation.

• Other tools:
• Electric Rain ZAM 3D

• Snoop (Inspect the Visual Tree of running WPF applications)

• Mole (Data Visualizer for Visual Studio

• XAML Power Toys

• WPF Performance Suite

  
  

Page and Table Service (PTS). PTS is responsible for the organization and layout of text within the UI. This includes paragraphs, tables, and blocks of text.

[WinForms][C#] How to know if CTRL key is pressed on a windows control?

In order to know if CTRL key is pressed on a windows control you can use the following code:

if ((System.Windows.Forms.Control.ModifierKeys & Keys.Control) == Keys.Control)

{

///... do multiple selection, for example

}

[DevExpress] Strange names for events raised on scrolling a GridView

When a view is scrolled horizontally or vertically, these are the 2 events that are raised:

LeftCoordChanged Fires when the View is scrolled horizontally.
TopRowChanged Fires when the View is scrolled vertically.

Source: DevExpress Online Documentation

Google Search Tricks

Google Search Tricks

1. Search a specific site: use "site:"
Sample: site: georgelache.blogspot.com bianca

2. Use Google Search as a calculator
Sample: 1 000 / 4.12 = 242.718447

3. Use quote marks to search for exact phrases.

4. Use the wildcard operator to fill in the blanks.

Bianca Maseluta

Este 9 aprilie 2010. Venim acasa dupa o scurta vacanta de Paste petrecuta la bunici. Stau in scaunelul meu din spatele masinii si tati imi face bau. Si ce se vede. Sa fie un bob de orez. Nuuu. Este chiar o maseluta. Mare surpriza. Pentru ca este destul de mare si a iesit inaintea caninului. Si nu m-am vaitat prea tare in noptilea astea. E pe stanga, jos si-i zambeste dragut lui tati. Mami e la volan. Dar arde de nerabdare sa vada descoperirea.

Am fost doua saptamani la Braila si una la Onesti.

La Braila m-am jucat cu verisoara Alexandra. Ma cam pupacea ea, asa, dar daca topaia putin eram in culmea fericirii. Mamaia si mami stateau toata ziua cu gura pe ea. Dar lui Alexandra ii intra pe o ureche si-i iesea pe cealalta.

Am fost si la Giulia. Ne intelegem destul de bine. Amandoua am fost in misiune de patrulare.

M-am plimbat cu trenuletul.

Am ajutat-o pe mamaia la cozonaci si am facut o gramada de galagie.

La Onesti am petrecul Pastele. In Noaptea de Inviere am dormit, pentru ca drumul lung de la Braila la Onesti m-a solicitat peste masura.

Dimineata m-am spalat cu ou rosu. Am insfacat banutul de sub vasul cu apa. Se pare ca era pus de iepurasul Bunicu'. Am ciocnit un ou si l-am mancat cu pofta. Am mancat de toate: pasca, cozonac, putin miel, sarmale, ciorba.

Am fost si la Jevreni. Acolo am vazut-o pe tanti Ana si pe verisorii mei: Andrei si Cristiana. Am foat in gradina. Apoi am admirat, in premiera absoluta, vaca, iepurasii, curca si porumbeii. Mi-au placut mult si florile. Am cules cateva si chiar am fost curioasa sa vad ce gust au.