├── HomeTimeline.png
├── SharpTwitter.suo
├── .gitignore
├── ConnectDialog.png
├── SharpTwitter
    ├── res
    │   ├── star.png
    │   ├── retweet.png
    │   └── twitter_newbird_boxed_whiteonblue.png
    ├── lib
    │   └── Twitterizer2-2.3.1
    │   │   ├── Twitterizer2.dll
    │   │   ├── Twitterizer2.pdb
    │   │   ├── Newtonsoft.Json.dll
    │   │   ├── Newtonsoft.Json.pdb
    │   │   ├── Json.NET.license.txt
    │   │   ├── Twitterizer2.license.txt
    │   │   └── GettingStarted.txt
    ├── App.xaml
    ├── Properties
    │   ├── Settings.settings
    │   ├── Settings.Designer.cs
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   └── Resources.resx
    ├── SharpTwitter.csproj.user
    ├── app.config
    ├── ConnectDialog.xaml
    ├── ConnectDialog.xaml.cs
    ├── MainWindow.xaml
    ├── SharpTwitter.csproj
    ├── App.xaml.cs
    └── MainWindow.xaml.cs
├── SharpTwitter.sln
└── index.html


/HomeTimeline.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/HomeTimeline.png


--------------------------------------------------------------------------------
/SharpTwitter.suo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter.suo


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | SharpTwitter/AppConstants.cs
3 | SharpTwitter/bin/
4 | SharpTwitter/obj/


--------------------------------------------------------------------------------
/ConnectDialog.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/ConnectDialog.png


--------------------------------------------------------------------------------
/SharpTwitter/res/star.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/res/star.png


--------------------------------------------------------------------------------
/SharpTwitter/res/retweet.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/res/retweet.png


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/Twitterizer2.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/lib/Twitterizer2-2.3.1/Twitterizer2.dll


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/Twitterizer2.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/lib/Twitterizer2-2.3.1/Twitterizer2.pdb


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/Newtonsoft.Json.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/lib/Twitterizer2-2.3.1/Newtonsoft.Json.dll


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/Newtonsoft.Json.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/lib/Twitterizer2-2.3.1/Newtonsoft.Json.pdb


--------------------------------------------------------------------------------
/SharpTwitter/res/twitter_newbird_boxed_whiteonblue.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pangratz/scharfer-vogel/master/SharpTwitter/res/twitter_newbird_boxed_whiteonblue.png


--------------------------------------------------------------------------------
/SharpTwitter/App.xaml:
--------------------------------------------------------------------------------
1 | <Application x:Class="SharpTwitter.App"
2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4 |              StartupUri="MainWindow.xaml">
5 |     <Application.Resources>        
6 |     </Application.Resources>
7 | </Application>
8 | 


--------------------------------------------------------------------------------
/SharpTwitter/Properties/Settings.settings:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='utf-8'?>
 2 | <SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" GeneratedClassNamespace="SharpTwitter.Properties" GeneratedClassName="Settings">
 3 |   <Profiles />
 4 |   <Settings>
 5 |     <Setting Name="token" Type="System.String" Scope="User">
 6 |       <Value Profile="(Default)" />
 7 |     </Setting>
 8 |     <Setting Name="tokenSecret" Type="System.String" Scope="User">
 9 |       <Value Profile="(Default)" />
10 |     </Setting>
11 |   </Settings>
12 | </SettingsFile>


--------------------------------------------------------------------------------
/SharpTwitter/SharpTwitter.csproj.user:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <PublishUrlHistory>publish\</PublishUrlHistory>
 5 |     <InstallUrlHistory />
 6 |     <SupportUrlHistory />
 7 |     <UpdateUrlHistory />
 8 |     <BootstrapperUrlHistory />
 9 |     <ErrorReportUrlHistory />
10 |     <FallbackCulture>de-DE</FallbackCulture>
11 |     <VerifyUploadedFiles>false</VerifyUploadedFiles>
12 |     <ProjectView>ShowAllFiles</ProjectView>
13 |   </PropertyGroup>
14 |   <PropertyGroup>
15 |     <ReferencePath>C:\Users\clemens\Documents\My Dropbox\c-sharp-project\SharpTwitter\SharpTwitter\lib\Twitterizer2-2.3\</ReferencePath>
16 |   </PropertyGroup>
17 | </Project>


--------------------------------------------------------------------------------
/SharpTwitter.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 11.00
 3 | # Visual Studio 2010
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpTwitter", "SharpTwitter\SharpTwitter.csproj", "{7D71EC53-8424-410D-A1BF-FA094B222AB8}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|x86 = Debug|x86
 9 | 		Release|x86 = Release|x86
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{7D71EC53-8424-410D-A1BF-FA094B222AB8}.Debug|x86.ActiveCfg = Debug|x86
13 | 		{7D71EC53-8424-410D-A1BF-FA094B222AB8}.Debug|x86.Build.0 = Debug|x86
14 | 		{7D71EC53-8424-410D-A1BF-FA094B222AB8}.Release|x86.ActiveCfg = Release|x86
15 | 		{7D71EC53-8424-410D-A1BF-FA094B222AB8}.Release|x86.Build.0 = Release|x86
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | EndGlobal
21 | 


--------------------------------------------------------------------------------
/SharpTwitter/app.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <configuration>
 3 | <configSections>
 4 |     <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
 5 |         <section name="SharpTwitter.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
 6 |     </sectionGroup>
 7 | </configSections>
 8 | <startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup><userSettings>
 9 |         <SharpTwitter.Properties.Settings>
10 |             <setting name="token" serializeAs="String">
11 |                 <value />
12 |             </setting>
13 |             <setting name="tokenSecret" serializeAs="String">
14 |                 <value />
15 |             </setting>
16 |         </SharpTwitter.Properties.Settings>
17 |     </userSettings>
18 | </configuration>
19 | 


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/Json.NET.license.txt:
--------------------------------------------------------------------------------
1 | Copyright (c) 2007 James Newton-King
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/SharpTwitter/ConnectDialog.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="SharpTwitter.ConnectDialog"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="ConnectDialog" mc:Ignorable="d" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" Height="166" Width="300" ShowInTaskbar="False" ResizeMode="NoResize" Topmost="True">
 5 |     <Grid>
 6 |         <Button Content="Connect" Height="23" HorizontalAlignment="Left" Name="connectButton" VerticalAlignment="Top" Width="75" Click="connectClicked" Margin="191,87,0,0" />
 7 |         <TextBox Height="23" HorizontalAlignment="Left" Margin="49,58,0,0" Name="pinTextBox" VerticalAlignment="Top" Width="217" />
 8 |         <TextBlock HorizontalAlignment="Left" Margin="12,12,0,0" Name="infoLabel" VerticalAlignment="Top" Width="254" Height="46" TextWrapping="Wrap" >Please go to the url and enter the shown PIN into the field bellow: <Hyperlink Name="twitterLoginUrl" NavigateUri="http://google.com" RequestNavigate="twitterLoginUrlClicked" >Login to Twitter</Hyperlink> </TextBlock>
 9 |         <Label Content="PIN:" Height="28" HorizontalAlignment="Left" Margin="12,58,0,0" Name="label2" VerticalAlignment="Top" />
10 |     </Grid>
11 | </Window>
12 | 


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/Twitterizer2.license.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2010, Patrick "Ricky" Smith
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 5 | 
 6 |  - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 7 |  
 8 |  - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in 
 9 |    the documentation and/or other materials provided with the distribution.
10 |    
11 |  - Neither the name Twitterizer nor the names of its contributors may be used to endorse or promote products derived from 
12 |    this software without specific prior written permission.
13 | 
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
15 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
16 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
17 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
18 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
19 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


--------------------------------------------------------------------------------
/SharpTwitter/ConnectDialog.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Windows;
 6 | using System.Windows.Controls;
 7 | using System.Windows.Data;
 8 | using System.Windows.Documents;
 9 | using System.Windows.Input;
10 | using System.Windows.Media;
11 | using System.Windows.Media.Imaging;
12 | using System.Windows.Shapes;
13 | 
14 | namespace SharpTwitter
15 | {
16 |     /// <summary>
17 |     /// Interaktionslogik für ConnectDialog.xaml
18 |     /// </summary>
19 |     public partial class ConnectDialog : Window
20 |     {
21 | 
22 |         public ConnectDialog(string uri)
23 |         {
24 |             InitializeComponent();
25 |             twitterLoginUrl.NavigateUri = new Uri(uri);
26 |         }
27 | 
28 |         private void connectClicked(object sender, RoutedEventArgs e)
29 |         {
30 |             // get the entered pin
31 |             // get the token and token secret
32 |             // save token and secret to properties
33 |             // re-connect to twitter
34 |             Close();
35 |         }
36 | 
37 |         public string GetPinCode()
38 |         {
39 |             return pinTextBox.Text;
40 |         }
41 | 
42 |         private void twitterLoginUrlClicked(object sender, System.Windows.Navigation.RequestNavigateEventArgs e)
43 |         {
44 |             // go to the url
45 |             Hyperlink source = sender as Hyperlink;
46 |             if (source != null)
47 |             {
48 |                 System.Diagnostics.Process.Start(source.NavigateUri.ToString());
49 |             }
50 |         }
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/SharpTwitter/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     Dieser Code wurde von einem Tool generiert.
 4 | //     Laufzeitversion:4.0.30319.1
 5 | //
 6 | //     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
 7 | //     der Code erneut generiert wird.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace SharpTwitter.Properties {
12 |     
13 |     
14 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
16 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 |         
18 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 |         
20 |         public static Settings Default {
21 |             get {
22 |                 return defaultInstance;
23 |             }
24 |         }
25 |         
26 |         [global::System.Configuration.UserScopedSettingAttribute()]
27 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
28 |         [global::System.Configuration.DefaultSettingValueAttribute("")]
29 |         public string token {
30 |             get {
31 |                 return ((string)(this["token"]));
32 |             }
33 |             set {
34 |                 this["token"] = value;
35 |             }
36 |         }
37 |         
38 |         [global::System.Configuration.UserScopedSettingAttribute()]
39 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
40 |         [global::System.Configuration.DefaultSettingValueAttribute("")]
41 |         public string tokenSecret {
42 |             get {
43 |                 return ((string)(this["tokenSecret"]));
44 |             }
45 |             set {
46 |                 this["tokenSecret"] = value;
47 |             }
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>SharpTwitter</title>
 4 | 	</head>
 5 | 	<body>
 6 | 		<h1>SharpTwitter</h1>
 7 | 		<p>SharpTwitter is a Twitter client implemented in C# - which is already encoded in the project's name. The Windows Presentation Foundation (WPF) is used for visualizing the available tasks in this client. Besides WPF the .NET Framework in version 4 is used.</p>
 8 | 		
 9 | 		<p>The main purpose of creating SharpTwitter was to get in touch with C# and learn the </p>
10 | 		
11 | 		
12 | 		
13 | 		
14 | 		
15 | 		
16 | 		
17 | 		<h2>Features</h2>
18 | 		<p>SharpTwitter only provides a subset of all the features which are available at <a href="http://www.twitter.com" target="_blank" >Twitter</a>, but the most important features are available:</p>
19 | 		
20 | 		<ul>
21 | 			<li>Login via OAuth to your Twitter account</li>
22 | 			<li>Showing the Home timeline of your account</li>
23 | 			<li>Show latest Tweets of an user you follow</li>
24 | 			<li>Load all newer Tweets - if there are some available</li>
25 | 			<li>Mark/Unmark a Tweet as your favourite</li>
26 | 			<li>ReTweet a Tweet of an user</li>
27 | 			<li>Reply to a Tweet of an user</li>
28 | 		</ul>
29 | 		
30 | 		
31 | 		
32 | 		
33 | 		
34 | 		
35 | 		
36 | 		
37 | 		
38 | 		<h2>Screenshots</h2>
39 | 		
40 | 		<p>In the screenshot below the login dialog where the user grants SharpTwitter access to the users account, is shown.</p>
41 | 		<img src="ConnectDialog.png" />
42 | 	
43 | 		<br/>
44 | 		
45 | 		<p>A screenshot of the user's home timeline is shown below.</p>
46 | 		<img src="HomeTimeline.png" />
47 | 		
48 | 		
49 | 		
50 | 		
51 | 		
52 | 		
53 | 		
54 | 		
55 | 		<h2>Installation</h2>
56 | 		<p>To install and use SharpTwitter, you have to do the following things:</p>
57 | 		
58 | 		<ul>
59 | 			<li>Install .Net Framework in version 4</li>
60 | 			<li>Download <a href="./SharpTwitter/bin/Release/SharpTwitter.exe">SharpTwitter.exe</a></li>
61 | 			<li>Open the downloaded application</li>
62 | 			<li>Go to <b>File</b> menu and choose <b>Connect</b></li>
63 | 			<li>Click the link <b>Login to Twitter</b> in the opened dialog</li>
64 | 			<li>Login to your Twitter account and enter the presented PIN code in the dialog of the SharpTwitter application</li>
65 | 			<li>Click <b>Connect</b> and e voil&aacute;, you are connected to Twitter and can start using SharpTwitter as your new, favourite client ;)</li>
66 | 		</ul>
67 | 		
68 | 	</body>
69 | </html>


--------------------------------------------------------------------------------
/SharpTwitter/lib/Twitterizer2-2.3.1/GettingStarted.txt:
--------------------------------------------------------------------------------
 1 | 		___        ___ ___  ___  __    __  ___  __    _ _ _   
 2 | 		 |  |  | |  |   |  |__  |__) |  / |__  |__)    | | 
 3 | 		 |  |/\| |  |   |  |___ |  \ | /_ |___ |  \   _|_|_
 4 | 
 5 | Q) Which files do I need?
 6 | A) More than likely, you only need Twitterizer2.dll and Newtonsoft.Json.dll
 7 | 
 8 | Q) What exactly are all these files?
 9 | A)
10 | 	Twitterizer2.dll
11 | 		This is the main binary which contains the core class library. This file is required for all addon 
12 | 		libraries.
13 | 
14 | 	Twitterizer2.Data.dll
15 | 		This is an additional library that provides data conversion functionality. 
16 | 		For example, with it you can quickly generate DataTables from any Twitterizer2 collection.
17 | 		This file is not necessary for most projects.
18 | 
19 | 	Newtonsoft.Json.dll
20 | 		This is JSON.NET, developed by James Newton-King. You do not need to add a reference in your 
21 | 		project to this library, but it must be placed in your project's bin folder along with Twitterizer2.dll.
22 | 		More information can be found here: http://james.newtonking.com/pages/json-net.aspx
23 | 
24 | 	Twitterizer2.Async.dll
25 | 		This is an addon library that allows developers to call Twitterizer2 methods asynchronously.
26 | 		This file is not necessary for most projects.
27 | 
28 | 	Twitterizer2.Streaming.dll
29 | 		This is an addon library that provides access to the Streaming API.
30 | 		This file is not necessary for most projects.
31 | 
32 | 	Twitterizer.OAuth.dll
33 | 		This is a standalone library that provides access to our OAuth request signing functionality without 
34 | 		using Twitterizer2. _DO_NOT_ include this file in your project if you are using Twitterizer2.dll. 
35 | 		All of the functionality found in this library is available within Twitterizer2.dll.
36 | 		This file is not necessary for most projects.
37 | 
38 | 	Twitterizer2lite.dll
39 | 		This is a slimmed down version of the Twitterizer2.dll file built with the client profile as the target framework.
40 | 		It will lack some extra pieces of functionality, such as the built-in data caching and support for application 
41 | 		configuration settings.
42 | 		_DO_NOT_ include this file in your project if you are using Twitterizer2.dll. 
43 | 		This file is not necessary for most projects.
44 | 
45 | Q) What about the license files?
46 | A) The license files must accompany the dlls. That means that they must be distributed along with your application.


--------------------------------------------------------------------------------
/SharpTwitter/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // Allgemeine Informationen über eine Assembly werden über die folgenden 
 8 | // Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
 9 | // die mit einer Assembly verknüpft sind.
10 | [assembly: AssemblyTitle("SharpTwitter")]
11 | [assembly: AssemblyDescription("")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("")]
14 | [assembly: AssemblyProduct("SharpTwitter")]
15 | [assembly: AssemblyCopyright("Copyright © Müller Clemens")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar 
20 | // für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von 
21 | // COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest.
22 | [assembly: ComVisible(true)]
23 | 
24 | //Um mit dem Erstellen lokalisierbarer Anwendungen zu beginnen, legen Sie 
25 | //<UICulture>ImCodeVerwendeteKultur</UICulture> in der .csproj-Datei
26 | //in einer <PropertyGroup> fest. Wenn Sie in den Quelldateien beispielsweise Deutsch
27 | //(Deutschland) verwenden, legen Sie <UICulture> auf \"de-DE\" fest. Heben Sie dann die Auskommentierung
28 | //des nachstehenden NeutralResourceLanguage-Attributs auf. Aktualisieren Sie "en-US" in der nachstehenden Zeile,
29 | //sodass es mit der UICulture-Einstellung in der Projektdatei übereinstimmt.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 |     ResourceDictionaryLocation.None, //Speicherort der designspezifischen Ressourcenwörterbücher
36 |     //(wird verwendet, wenn eine Ressource auf der Seite
37 |     // oder in den Anwendungsressourcen-Wörterbüchern nicht gefunden werden kann.)
38 |     ResourceDictionaryLocation.SourceAssembly //Speicherort des generischen Ressourcenwörterbuchs
39 |     //(wird verwendet, wenn eine Ressource auf der Seite, in der Anwendung oder einem 
40 |     // designspezifischen Ressourcenwörterbuch nicht gefunden werden kann.)
41 | )]
42 | 
43 | 
44 | // Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
45 | //
46 | //      Hauptversion
47 | //      Nebenversion 
48 | //      Buildnummer
49 | //      Revision
50 | //
51 | // Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern 
52 | // übernehmen, indem Sie "*" eingeben:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.0.0.0")]
55 | [assembly: AssemblyFileVersion("1.0.0.0")]
56 | 


--------------------------------------------------------------------------------
/SharpTwitter/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     Dieser Code wurde von einem Tool generiert.
 4 | //     Laufzeitversion:4.0.30319.1
 5 | //
 6 | //     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
 7 | //     der Code erneut generiert wird.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace SharpTwitter.Properties {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw.
17 |     /// </summary>
18 |     // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert
19 |     // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert.
20 |     // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
21 |     // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class Resources {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal Resources() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         internal static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SharpTwitter.Properties.Resources", typeof(Resources).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle
51 |         ///   Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         internal static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/SharpTwitter/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="SharpTwitter.TwitterWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         Title="SharpTwitter" Height="500" Width="300" Icon="/SharpTwitter;component/res/twitter_newbird_boxed_whiteonblue.png">
 5 |     <Window.Resources>
 6 |         <DataTemplate x:Key="tweetTemplate">
 7 |             <DockPanel Margin="0, 5, 0, 5" Name="TweetDockPanel" MouseEnter="TweetDockPanel_MouseEnter" MouseLeave="TweetDockPanel_MouseLeave" HorizontalAlignment="Stretch" >
 8 |                 <Image DockPanel.Dock="Left" VerticalAlignment="Top" Name="UserImage" Tag="{Binding Path=User.ScreenName}" Source="{Binding User.ProfileImageLocation}" MaxWidth="32" Margin="0,0,10,0" MouseDown="ProfileImageClick" />
 9 |                 <StackPanel DockPanel.Dock="Top" MouseDown="TweetMessageClick" Tag="{Binding}" VerticalAlignment="Top" HorizontalAlignment="Left" Orientation="Vertical" >
10 |                     <TextBlock Text="{Binding Path=User.ScreenName}" FontWeight="Bold" />
11 |                     <TextBlock Text="{Binding Path=Text}" TextWrapping="WrapWithOverflow" />
12 |                 </StackPanel>
13 |                 <StackPanel Orientation="Horizontal" VerticalAlignment="Center">
14 |                     <TextBlock DockPanel.Dock="Bottom" Text="{Binding Path=CreatedDate}" FontStyle="Italic" FontSize="10" Foreground="Gray" VerticalAlignment="Center" Margin="0,0,10,0" />
15 |                     <Image Name="RetweetImage" ToolTip="Retweet" Tag="{Binding}" Source="res/retweet.png" Width="15" Height="15" VerticalAlignment="Center" MouseDown="RetweetIcon_MouseDown" Margin="0,0,10,0" Opacity="0.0" MouseEnter="Icon_MouseEnter" MouseLeave="Icon_MouseLeave" />
16 |                     <Image Name="FavouriteStarImage" ToolTip="Mark as Favorite" Tag="{Binding}"  Source="res/star.png" Width="15" Height="15" VerticalAlignment="Center" MouseDown="FavouriteStar_MouseDown" Opacity="0.0" MouseEnter="Icon_MouseEnter" MouseLeave="Icon_MouseLeave" />
17 |                 </StackPanel>
18 |             </DockPanel>
19 |         </DataTemplate>
20 |     </Window.Resources>
21 |     
22 |     <DockPanel>
23 |         
24 |         <Menu DockPanel.Dock="Top" Height="22" >
25 |             <MenuItem Header="File">
26 |                 <MenuItem Header="_Connect" Click="Connect_MenuItem_Clicked" ></MenuItem>
27 |                 <MenuItem Header="_Refresh" Click="Refresh_MenuItem_Clicked" ></MenuItem>
28 |                 <MenuItem Header="_Exit" Click="Exit_MenuItem_Clicked"></MenuItem>
29 |             </MenuItem>
30 |             <MenuItem Header="_Tweet">
31 |                 <MenuItem Header="_Show Home Timeline" Name="ShowHomeTimelineMenuItem" Click="ShowHomeTimelineMenuItem_Click" ></MenuItem>
32 |                 <MenuItem Header="_Show Tweets of User" Name="ShowTweetsOfUserMenuItem" Click="ShowTweetsOfUserMenuItem_Click" ></MenuItem>
33 |                 <MenuItem Header="_Reply to Tweet" Name="ReplyToTweetMenuItem" Click="ReplyToTweetMenuItem_Click"></MenuItem>
34 |             </MenuItem>
35 |         </Menu>
36 | 
37 |         <Label Name="StatusLabel" DockPanel.Dock="Bottom" Height="30" />
38 | 
39 |         <Grid DockPanel.Dock="Top" >
40 |             <Grid.RowDefinitions>
41 |                 <RowDefinition />
42 |                 <RowDefinition Height="{Binding ElementName=tweetTextBox, Path=Height}" />
43 |                 <RowDefinition MaxHeight="{Binding ElementName=charactersLeftLabel, Path=ActualHeight}" />
44 |             </Grid.RowDefinitions>
45 |             <Grid.ColumnDefinitions>
46 |                 <ColumnDefinition />
47 |             </Grid.ColumnDefinitions>
48 |             <Label Content="140" Height="28" Name="charactersLeftLabel" FontSize="8" IsEnabled="True" VerticalAlignment="Bottom" Grid.Row="2" HorizontalContentAlignment="Right" Visibility="Hidden" Width="30" HorizontalAlignment="Right" Margin="0,0,0,0" />
49 |             <TextBox Name="tweetTextBox" TextChanged="tweetMessageChanged" TextWrapping="Wrap" AcceptsReturn="True" PreviewKeyDown="keyPressed" Grid.Row="1" VerticalAlignment="Bottom" Margin="12,0" />
50 |             <ListBox Name="tweetListView" HorizontalContentAlignment="Stretch" VerticalAlignment="Stretch" SelectionMode="Single" ScrollViewer.HorizontalScrollBarVisibility="Disabled" ItemTemplate="{Binding Source={StaticResource tweetTemplate}}" Margin="0,0,0,10" KeyUp="tweetListView_KeyUp" VerticalContentAlignment="Stretch" />
51 |             <Label Content="" Grid.Row="2" Height="28" HorizontalAlignment="Stretch" Margin="12,0,30,0" Name="ReplyToLabel" VerticalAlignment="Top" />
52 |         </Grid>
53 | 
54 |     </DockPanel>
55 | </Window>
56 | 


--------------------------------------------------------------------------------
/SharpTwitter/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/SharpTwitter/SharpTwitter.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  5 |     <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
  6 |     <ProductVersion>8.0.30703</ProductVersion>
  7 |     <SchemaVersion>2.0</SchemaVersion>
  8 |     <ProjectGuid>{7D71EC53-8424-410D-A1BF-FA094B222AB8}</ProjectGuid>
  9 |     <OutputType>WinExe</OutputType>
 10 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 11 |     <RootNamespace>SharpTwitter</RootNamespace>
 12 |     <AssemblyName>SharpTwitter</AssemblyName>
 13 |     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
 14 |     <TargetFrameworkProfile>
 15 |     </TargetFrameworkProfile>
 16 |     <FileAlignment>512</FileAlignment>
 17 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 18 |     <WarningLevel>4</WarningLevel>
 19 |     <IsWebBootstrapper>false</IsWebBootstrapper>
 20 |     <PublishUrl>publish\</PublishUrl>
 21 |     <Install>true</Install>
 22 |     <InstallFrom>Disk</InstallFrom>
 23 |     <UpdateEnabled>false</UpdateEnabled>
 24 |     <UpdateMode>Foreground</UpdateMode>
 25 |     <UpdateInterval>7</UpdateInterval>
 26 |     <UpdateIntervalUnits>Days</UpdateIntervalUnits>
 27 |     <UpdatePeriodically>false</UpdatePeriodically>
 28 |     <UpdateRequired>false</UpdateRequired>
 29 |     <MapFileExtensions>true</MapFileExtensions>
 30 |     <ApplicationRevision>0</ApplicationRevision>
 31 |     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
 32 |     <UseApplicationTrust>false</UseApplicationTrust>
 33 |     <BootstrapperEnabled>true</BootstrapperEnabled>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
 36 |     <PlatformTarget>x86</PlatformTarget>
 37 |     <DebugSymbols>true</DebugSymbols>
 38 |     <DebugType>full</DebugType>
 39 |     <Optimize>false</Optimize>
 40 |     <OutputPath>bin\Debug\</OutputPath>
 41 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 42 |     <ErrorReport>prompt</ErrorReport>
 43 |     <WarningLevel>4</WarningLevel>
 44 |   </PropertyGroup>
 45 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
 46 |     <PlatformTarget>x86</PlatformTarget>
 47 |     <DebugType>pdbonly</DebugType>
 48 |     <Optimize>true</Optimize>
 49 |     <OutputPath>bin\Release\</OutputPath>
 50 |     <DefineConstants>TRACE</DefineConstants>
 51 |     <ErrorReport>prompt</ErrorReport>
 52 |     <WarningLevel>4</WarningLevel>
 53 |   </PropertyGroup>
 54 |   <PropertyGroup>
 55 |     <StartupObject>SharpTwitter.App</StartupObject>
 56 |   </PropertyGroup>
 57 |   <ItemGroup>
 58 |     <Reference Include="Newtonsoft.Json, Version=3.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
 59 |       <SpecificVersion>False</SpecificVersion>
 60 |       <HintPath>.\Newtonsoft.Json.dll</HintPath>
 61 |     </Reference>
 62 |     <Reference Include="System" />
 63 |     <Reference Include="System.Data" />
 64 |     <Reference Include="System.Xml" />
 65 |     <Reference Include="Microsoft.CSharp" />
 66 |     <Reference Include="System.Core" />
 67 |     <Reference Include="System.Xml.Linq" />
 68 |     <Reference Include="System.Data.DataSetExtensions" />
 69 |     <Reference Include="System.Xaml">
 70 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 71 |     </Reference>
 72 |     <Reference Include="Twitterizer2, Version=2.3.1.36501, Culture=neutral, processorArchitecture=MSIL">
 73 |       <SpecificVersion>False</SpecificVersion>
 74 |       <HintPath>.\Twitterizer2.dll</HintPath>
 75 |     </Reference>
 76 |     <Reference Include="WindowsBase" />
 77 |     <Reference Include="PresentationCore" />
 78 |     <Reference Include="PresentationFramework" />
 79 |   </ItemGroup>
 80 |   <ItemGroup>
 81 |     <ApplicationDefinition Include="App.xaml">
 82 |       <Generator>MSBuild:Compile</Generator>
 83 |       <SubType>Designer</SubType>
 84 |     </ApplicationDefinition>
 85 |     <Page Include="ConnectDialog.xaml">
 86 |       <SubType>Designer</SubType>
 87 |       <Generator>MSBuild:Compile</Generator>
 88 |     </Page>
 89 |     <Page Include="MainWindow.xaml">
 90 |       <Generator>MSBuild:Compile</Generator>
 91 |       <SubType>Designer</SubType>
 92 |     </Page>
 93 |     <Compile Include="App.xaml.cs">
 94 |       <DependentUpon>App.xaml</DependentUpon>
 95 |       <SubType>Code</SubType>
 96 |     </Compile>
 97 |     <Compile Include="AppConstants.cs" />
 98 |     <Compile Include="ConnectDialog.xaml.cs">
 99 |       <DependentUpon>ConnectDialog.xaml</DependentUpon>
100 |     </Compile>
101 |     <Compile Include="MainWindow.xaml.cs">
102 |       <DependentUpon>MainWindow.xaml</DependentUpon>
103 |       <SubType>Code</SubType>
104 |     </Compile>
105 |   </ItemGroup>
106 |   <ItemGroup>
107 |     <Compile Include="Properties\AssemblyInfo.cs">
108 |       <SubType>Code</SubType>
109 |       <CustomToolNamespace>SharpTwitter</CustomToolNamespace>
110 |     </Compile>
111 |     <Compile Include="Properties\Resources.Designer.cs">
112 |       <AutoGen>True</AutoGen>
113 |       <DesignTime>True</DesignTime>
114 |       <DependentUpon>Resources.resx</DependentUpon>
115 |     </Compile>
116 |     <Compile Include="Properties\Settings.Designer.cs">
117 |       <AutoGen>True</AutoGen>
118 |       <DependentUpon>Settings.settings</DependentUpon>
119 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
120 |     </Compile>
121 |     <EmbeddedResource Include="Properties\Resources.resx">
122 |       <Generator>ResXFileCodeGenerator</Generator>
123 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
124 |     </EmbeddedResource>
125 |     <None Include="app.config" />
126 |     <None Include="Properties\Settings.settings">
127 |       <Generator>SettingsSingleFileGenerator</Generator>
128 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
129 |     </None>
130 |     <AppDesigner Include="Properties\" />
131 |   </ItemGroup>
132 |   <ItemGroup>
133 |     <BootstrapperPackage Include=".NETFramework,Version=v4.0,Profile=Client">
134 |       <Visible>False</Visible>
135 |       <ProductName>Microsoft .NET Framework 4 Client Profile %28x86 und x64%29</ProductName>
136 |       <Install>true</Install>
137 |     </BootstrapperPackage>
138 |     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
139 |       <Visible>False</Visible>
140 |       <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
141 |       <Install>false</Install>
142 |     </BootstrapperPackage>
143 |     <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
144 |       <Visible>False</Visible>
145 |       <ProductName>.NET Framework 3.5 SP1</ProductName>
146 |       <Install>false</Install>
147 |     </BootstrapperPackage>
148 |     <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
149 |       <Visible>False</Visible>
150 |       <ProductName>Windows Installer 3.1</ProductName>
151 |       <Install>true</Install>
152 |     </BootstrapperPackage>
153 |   </ItemGroup>
154 |   <ItemGroup>
155 |     <WCFMetadata Include="Service References\" />
156 |   </ItemGroup>
157 |   <ItemGroup>
158 |     <Resource Include="res\twitter_newbird_boxed_whiteonblue.png" />
159 |     <Resource Include="res\retweet.png" />
160 |     <Resource Include="res\star.png" />
161 |     <Resource Include="lib\Twitterizer2-2.3.1\GettingStarted.txt" />
162 |     <Resource Include="lib\Twitterizer2-2.3.1\Json.NET.license.txt" />
163 |     <Content Include="lib\Twitterizer2-2.3.1\Newtonsoft.Json.dll" />
164 |     <Content Include="lib\Twitterizer2-2.3.1\Newtonsoft.Json.pdb" />
165 |     <Resource Include="lib\Twitterizer2-2.3.1\Newtonsoft.Json.xml" />
166 |     <Content Include="lib\Twitterizer2-2.3.1\Twitterizer2.dll" />
167 |     <Resource Include="lib\Twitterizer2-2.3.1\Twitterizer2.license.txt" />
168 |     <Content Include="lib\Twitterizer2-2.3.1\Twitterizer2.pdb" />
169 |     <Resource Include="lib\Twitterizer2-2.3.1\Twitterizer2.XML" />
170 |   </ItemGroup>
171 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
172 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
173 |        Other similar extension points exist, see Microsoft.Common.targets.
174 |   <Target Name="BeforeBuild">
175 |   </Target>
176 |   <Target Name="AfterBuild">
177 |   </Target>
178 |   -->
179 | </Project>


--------------------------------------------------------------------------------
/SharpTwitter/App.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Windows;
  3 | using System.Xml;
  4 | using System.Net;
  5 | using Twitterizer;
  6 | using System.Configuration;
  7 | using System.Diagnostics;
  8 | using System.Windows.Data;
  9 | using System.Globalization;
 10 | 
 11 | namespace SharpTwitter
 12 | {
 13 |     /// <summary>
 14 |     /// Interaktionslogik für "App.xaml"
 15 |     /// </summary>
 16 |     public partial class App : Application
 17 |     {
 18 | 
 19 |         private TwitterCommunicator twitterComm;
 20 | 
 21 |         public App() : base() {
 22 | 
 23 |             // read the account tokens & secret from properties
 24 |             string token = SharpTwitter.Properties.Settings.Default.token;
 25 |             string tokenSecret = SharpTwitter.Properties.Settings.Default.tokenSecret;
 26 | 
 27 |             twitterComm = new TwitterCommunicator(token, tokenSecret);
 28 |         }
 29 | 
 30 |         public bool IsConnected()
 31 |         {
 32 |             return twitterComm.TestCredentials();
 33 |         }
 34 | 
 35 |         public TwitterStatus Tweet(string message) {
 36 |             return twitterComm.Tweet(message);
 37 |         }
 38 | 
 39 |         public TwitterStatus ReTweet(decimal retweetId)
 40 |         {
 41 |             return twitterComm.ReTweet(retweetId);
 42 |         }
 43 | 
 44 |         public TwitterStatus ReplyToTweet(decimal replyTweetId, string message)
 45 |         {
 46 |             return twitterComm.ReplyToTweet(replyTweetId, message);
 47 |         }
 48 | 
 49 |         public TwitterStatusCollection GetHomeTimeline()
 50 |         {
 51 |             return GetHomeTimeline(null);
 52 |         }
 53 | 
 54 |         public TwitterStatusCollection GetHomeTimeline(decimal lastStatusId)
 55 |         {
 56 |             return GetHomeTimeline(null, lastStatusId);
 57 |         }
 58 | 
 59 |         public TwitterStatusCollection GetHomeTimeline(string username)
 60 |         {
 61 |             return GetHomeTimeline(username, Decimal.MinusOne);
 62 |         }
 63 | 
 64 |         public TwitterStatusCollection GetHomeTimeline(string username, decimal lastStatusId)
 65 |         {
 66 |             return twitterComm.GetHomeTimeline(username, lastStatusId);
 67 |         }
 68 | 
 69 |         public void UpdateTweetFavouriteStatus(decimal tweetId, bool isFavorite)
 70 |         {
 71 |             twitterComm.UpdateTweetFavouriteStatus(tweetId, isFavorite);
 72 |         }
 73 | 
 74 | 
 75 |         public string GetTwitterLoginUrl()
 76 |         {
 77 |             return twitterComm.GetTwitterLoginUrl();
 78 |         }
 79 | 
 80 |         public void StartNewAuthorization()
 81 |         {
 82 |             twitterComm.StartNewAuthorization();
 83 |         }
 84 | 
 85 |         public void FinishAuthorization(string pin)
 86 |         {
 87 |             string accessToken, accessTokenSecret;
 88 |             twitterComm.FinishAuthorization(pin, out accessToken, out accessTokenSecret);
 89 | 
 90 |             // save default values
 91 |             SharpTwitter.Properties.Settings.Default.token = accessToken;
 92 |             SharpTwitter.Properties.Settings.Default.tokenSecret = accessTokenSecret;
 93 |             SharpTwitter.Properties.Settings.Default.Save();
 94 |         }
 95 | 
 96 |         internal void CancelAuthorization()
 97 |         {
 98 |             twitterComm.CancelAuthorization();
 99 |         }
100 |     }
101 | 
102 |     public class TwitterCommunicator
103 |     {
104 | 
105 |         private OAuthTokenResponse currentRequestToken;
106 |         private OAuthTokens tokens;
107 | 
108 |         public TwitterCommunicator(string token, string tokenSecret)
109 |         {
110 |             tokens = new OAuthTokens();
111 |             tokens.ConsumerKey = TwitterAccountConstants.oAuthConsumerKey;
112 |             tokens.ConsumerSecret = TwitterAccountConstants.oAuthConsumerSecret;
113 | 
114 |             if (token != null && tokenSecret != null)
115 |             {
116 |                 tokens.AccessToken = token;
117 |                 tokens.AccessTokenSecret = tokenSecret;
118 |             }
119 |         }
120 | 
121 |         public TwitterStatus Tweet(string message)
122 |         {
123 |             Console.WriteLine("Sending Tweet: {0}", message);
124 |             TwitterResponse<TwitterStatus> statusResponse = TwitterStatus.Update(tokens, message);
125 |             return HandleTwitterResponse(statusResponse);
126 |         }
127 | 
128 |         private TwitterStatus HandleTwitterResponse(TwitterResponse<TwitterStatus> statusResponse)
129 |         {
130 |             if (statusResponse.Result == RequestResult.Success)
131 |             {
132 |                 Console.WriteLine("Successfull");
133 |                 return statusResponse.ResponseObject as TwitterStatus;
134 |             }
135 |             else
136 |             {
137 |                 Console.WriteLine("error: {0}", statusResponse.ErrorMessage);
138 |                 return null;
139 |             }
140 |         }
141 | 
142 |         public TwitterStatusCollection GetHomeTimeline(string username, decimal lastStatusId)
143 |         {
144 |             TwitterResponse<TwitterStatusCollection> response;
145 |             if (username != null)
146 |             {
147 |                 UserTimelineOptions opts = new UserTimelineOptions();
148 |                 if (lastStatusId > 0)
149 |                     opts.SinceStatusId = lastStatusId;
150 |                 opts.ScreenName = username;
151 |                 response = TwitterTimeline.UserTimeline(tokens, opts);
152 |             } else
153 |             {
154 |                 TimelineOptions opts = new TimelineOptions();
155 |                 if (lastStatusId > 0)
156 |                     opts.SinceStatusId = lastStatusId;
157 | 
158 |                 response = TwitterTimeline.HomeTimeline(tokens, opts);
159 |             }
160 | 
161 |             if (response.Result == RequestResult.Success)
162 |             {
163 |                 // show the timeline
164 |                 return response.ResponseObject as TwitterStatusCollection;
165 |             }
166 |             else
167 |             {
168 |                 // exception
169 |             }
170 | 
171 |             return null;
172 |         }
173 | 
174 |         internal bool TestCredentials()
175 |         {
176 |             try
177 |             {
178 |                 TwitterResponse<TwitterUser> verifyCredentialsRes = TwitterAccount.VerifyCredentials(tokens);
179 |                 if (verifyCredentialsRes.Result == RequestResult.Success)
180 |                 {
181 |                     return true;
182 |                 }
183 |             } catch (Exception) {
184 |             }
185 | 
186 |             return false;
187 |         }
188 | 
189 |         internal TwitterStatus ReTweet(decimal replyTweetId)
190 |         {
191 |             Console.WriteLine("ReTweeting Tweet: {0}", replyTweetId);
192 |             TwitterResponse<TwitterStatus> statusResponse = TwitterStatus.Retweet(tokens, replyTweetId);
193 |             return HandleTwitterResponse(statusResponse);
194 |         }
195 | 
196 |         internal void UpdateTweetFavouriteStatus(decimal tweetId, bool isFavorite)
197 |         {
198 |             if (isFavorite)
199 |                 TwitterFavorite.Create(tokens, tweetId);
200 |             else
201 |                 TwitterFavorite.Delete(tokens, tweetId);
202 |         }
203 | 
204 |         internal TwitterStatus ReplyToTweet(decimal replyTweetId, string message)
205 |         {
206 |             Console.WriteLine("Replying to Tweet {0} with message {1}", replyTweetId, message);
207 |             StatusUpdateOptions opts = new StatusUpdateOptions();
208 |             opts.InReplyToStatusId = replyTweetId;
209 |             TwitterResponse<TwitterStatus> response = TwitterStatus.Update(tokens, message, opts);
210 |             return HandleTwitterResponse(response);
211 |         }
212 | 
213 |         internal string GetTwitterLoginUrl()
214 |         {
215 |             if (currentRequestToken != null)
216 |             {
217 |                 Uri authorizationUri = OAuthUtility.BuildAuthorizationUri(currentRequestToken.Token);
218 |                 return authorizationUri.ToString();
219 |             }
220 | 
221 |             throw new InvalidOperationException("Call StartNewAuthorization first!");
222 |         }
223 | 
224 |         internal void StartNewAuthorization()
225 |         {
226 |             currentRequestToken = OAuthUtility.GetRequestToken(TwitterAccountConstants.oAuthConsumerKey, TwitterAccountConstants.oAuthConsumerSecret, "oob");
227 |         }
228 | 
229 |         internal void FinishAuthorization(string pin, out string AccessToken, out string AccessTokenSecret)
230 |         {
231 |             OAuthTokenResponse response = OAuthUtility.GetAccessToken(TwitterAccountConstants.oAuthConsumerKey, TwitterAccountConstants.oAuthConsumerSecret, currentRequestToken.Token, pin);
232 |             
233 |             AccessToken = response.Token;
234 |             AccessTokenSecret = response.TokenSecret;
235 | 
236 |             tokens.AccessToken = AccessToken;
237 |             tokens.AccessTokenSecret = AccessTokenSecret;
238 | 
239 |             currentRequestToken = null;
240 |         }
241 | 
242 |         internal void CancelAuthorization()
243 |         {
244 |             currentRequestToken = null;
245 |         }
246 |     }
247 | 
248 | }
249 | 


--------------------------------------------------------------------------------
/SharpTwitter/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Windows;
  6 | using System.Windows.Controls;
  7 | using System.Windows.Data;
  8 | using System.Windows.Documents;
  9 | using System.Windows.Input;
 10 | using System.Windows.Media;
 11 | using System.Windows.Media.Imaging;
 12 | using System.Windows.Navigation;
 13 | using System.Windows.Shapes;
 14 | using Twitterizer;
 15 | using System.Collections;
 16 | using System.Globalization;
 17 | 
 18 | namespace SharpTwitter
 19 | {
 20 | 
 21 |     public enum CurrentView
 22 |     {
 23 |         HOME_TIMELINE,
 24 |         USER_TIMELINE
 25 |     }
 26 | 
 27 |     /// <summary>
 28 |     /// Interaktionslogik für TwitterWindow.xaml
 29 |     /// </summary>
 30 |     public partial class TwitterWindow : Window
 31 |     {
 32 | 
 33 |         private App tweetApp;
 34 |         private Brush defaultForeground;
 35 |         private ICollection<TwitterStatus> tweetsList;
 36 |         private TwitterStatus replyTo = null;
 37 |         private CurrentView currentView;
 38 |         private string currentViewUsername;
 39 |         private decimal lastStatusId;
 40 | 
 41 |         public TwitterWindow()
 42 |         {
 43 |             InitializeComponent();
 44 |             defaultForeground = charactersLeftLabel.Foreground;           
 45 | 
 46 |             tweetApp = (App) App.Current;
 47 | 
 48 |             tweetsList = new SortedSet<TwitterStatus>(new TwitterStatusComparer());
 49 |             tweetListView.ItemsSource = tweetsList;
 50 | 
 51 |             currentView = CurrentView.HOME_TIMELINE;
 52 |             UpdateTitle();
 53 | 
 54 |             if (tweetApp.IsConnected())
 55 |             {
 56 |                 SetStatus("Loading Tweets for home timeline");
 57 |                 TwitterStatusCollection tweets = tweetApp.GetHomeTimeline();
 58 |                 SetTweets(tweets);
 59 |                 SetStatus("Tweets loaded");
 60 |             }
 61 |         }
 62 | 
 63 |         private void SetTweets(TwitterStatusCollection tweetsCollection)
 64 |         {
 65 |             lastStatusId = Decimal.Zero;
 66 |             replyTo = null;
 67 |             tweetTextBox.Clear();
 68 |             tweetsList.Clear();
 69 |             foreach (TwitterStatus status in tweetsCollection)
 70 |             {
 71 |                 AddTweet(status);
 72 |             }
 73 |             tweetListView.ScrollIntoView(tweetsList.First());
 74 |         }
 75 | 
 76 |         private void AddTweet(TwitterStatus status)
 77 |         {
 78 |             if (status == null)
 79 |             {
 80 |                 Console.WriteLine("FAILURE: status is null!!");
 81 |                 return;
 82 |             }
 83 | 
 84 |             if (status.Id > lastStatusId)
 85 |                 lastStatusId = status.Id;
 86 | 
 87 |             tweetsList.Add(status);
 88 |             tweetListView.Items.Refresh();
 89 |         }
 90 | 
 91 |         private void tweetMessageChanged(object sender, TextChangedEventArgs e)
 92 |         {
 93 |             int length = tweetTextBox.Text.Length;            
 94 |             charactersLeftLabel.Visibility = (length > 0) ? Visibility.Visible : Visibility.Hidden;
 95 | 
 96 |             int charsLeft = (140 - length);
 97 |             charactersLeftLabel.Foreground = (charsLeft < 0) ? Brushes.Red : defaultForeground;
 98 |             charactersLeftLabel.Content = charsLeft;
 99 |         }
100 | 
101 |         private void keyPressed(object sender, KeyEventArgs e)
102 |         {
103 |             // check if the user wants to submit the tweet
104 |             if (e.Key == Key.Enter) {
105 |                 // set this enter press to handled
106 |                 e.Handled = true;
107 | 
108 |                 string tweetMessage = tweetTextBox.Text;
109 |                 if (tweetMessage.Length == 0 || tweetMessage.Length > 140)
110 |                 {
111 |                     // invalid tweet length
112 |                     return;
113 |                 }
114 | 
115 |                 // tweet the entered message
116 |                 TwitterStatus status;
117 |                 if (replyTo != null)
118 |                 {
119 |                     SetStatus("Sending reply to tweet");
120 |                     status = tweetApp.ReplyToTweet(replyTo.Id, tweetMessage);
121 |                     SetStatus("Reply sent");
122 |                 }
123 |                 else
124 |                 {
125 |                     SetStatus("Sending tweet");
126 |                     status = tweetApp.Tweet(tweetMessage);
127 |                     SetStatus("Tweet sent");
128 |                 }
129 | 
130 |                 if (status != null)
131 |                 {
132 |                     AddTweet(status);
133 |                     tweetTextBox.Clear();
134 |                     replyTo = null;
135 |                     ReplyToLabel.Content = "";
136 |                     ReplyToLabel.ToolTip = "";
137 |                 }
138 |             }
139 |             else if (e.Key == Key.Escape) {
140 |                 e.Handled = true;
141 |                 tweetTextBox.Clear();
142 |                 replyTo = null;
143 |                 ReplyToLabel.Content = "";
144 |             }
145 |         }
146 | 
147 |         private void ProfileImageClick(object sender, MouseButtonEventArgs e)
148 |         {
149 |             if (e.ChangedButton == MouseButton.Left && e.ClickCount == 2)
150 |             {
151 |                 Image img = sender as Image;
152 |                 string username = img.Tag as string;
153 |                 ShowUserTimeline(username);
154 |             }
155 |         }
156 | 
157 |         private void ShowUserTimeline(string username)
158 |         {
159 |             bool isSameUser = (currentViewUsername != null) && (currentViewUsername.Equals(username));
160 |             if (currentView != CurrentView.USER_TIMELINE && !isSameUser)
161 |             {
162 |                 currentView = CurrentView.USER_TIMELINE;
163 |                 currentViewUsername = username;
164 |                 UpdateTitle();
165 | 
166 |                 SetStatus("Loading all tweets for user " + username);
167 |                 TwitterStatusCollection tweets = tweetApp.GetHomeTimeline(username);
168 |                 SetTweets(tweets);
169 |                 SetStatus("Tweets loaded");
170 |             }
171 |             else {
172 |                 RefreshTimeline();
173 |             }
174 |         }
175 | 
176 |         private void TweetMessageClick(object sender, MouseButtonEventArgs e)
177 |         {
178 |             if (e.ChangedButton == MouseButton.Left && e.ClickCount == 2)
179 |             {
180 |                 FrameworkElement panel = sender as FrameworkElement;
181 |                 replyTo = panel.Tag as TwitterStatus;
182 | 
183 |                 ReplyToTweet(replyTo);
184 |             }
185 |         }
186 | 
187 |         private void ReplyToTweet(TwitterStatus replyToStatus)
188 |         {
189 |             string tweetText = String.Format("@{0} ", replyToStatus.User.ScreenName);
190 |             tweetTextBox.Text = tweetText;
191 |             string replyToStr = String.Format("In reply to: {0} - {1}", replyToStatus.User.ScreenName, replyToStatus.Text);
192 |             ReplyToLabel.Content = replyToStr;
193 |             ReplyToLabel.ToolTip = replyToStr;
194 |         }
195 | 
196 |         private void TweetDockPanel_MouseEnter(object sender, MouseEventArgs e)
197 |         {
198 |             // set opacity of the star to 1.0
199 |             DockPanel dockPanel = sender as DockPanel;
200 |             
201 |             Image FavouriteStarImage = dockPanel.FindName("FavouriteStarImage") as Image;
202 |             FavouriteStarImage.Opacity = 1.0;
203 | 
204 |             Image RetweetImage = dockPanel.FindName("RetweetImage") as Image;
205 |             RetweetImage.Opacity = 1.0;
206 |         }
207 | 
208 |         private void TweetDockPanel_MouseLeave(object sender, MouseEventArgs e)
209 |         {
210 |             DockPanel dockPanel = sender as DockPanel;
211 |             
212 |             // update favorite star
213 |             Image FavouriteStarImage = dockPanel.FindName("FavouriteStarImage") as Image;
214 |             TwitterStatus status = (TwitterStatus) FavouriteStarImage.Tag;
215 |             bool isFavourite = (bool) status.IsFavorited;
216 |             FavouriteStarImage.Opacity = (isFavourite) ? 1.0 : 0.0;
217 | 
218 |             // update rewteet star
219 |             Image RetweetImage = dockPanel.FindName("RetweetImage") as Image;
220 |             status = (TwitterStatus) RetweetImage.Tag;
221 |             bool isRetweeted = (bool)status.Retweeted;
222 |             RetweetImage.Opacity = (isRetweeted) ? 1.0 : 0.0;
223 |         }
224 | 
225 |         private void FavouriteStar_MouseDown(object sender, MouseButtonEventArgs e)
226 |         {
227 |             // invert favourite status of this tweet
228 |             Image FavouriteStarImage = sender as Image;
229 |             TwitterStatus status = (TwitterStatus) FavouriteStarImage.Tag;
230 | 
231 |             bool isFavorite = (bool) status.IsFavorited;
232 |             isFavorite = !isFavorite;
233 | 
234 |             status.IsFavorited = isFavorite;
235 |             FavouriteStarImage.Tag = status;
236 | 
237 |             if (isFavorite)
238 |                 SetStatus("Adding Tweet to favorites");
239 |             else
240 |                 SetStatus("Removing Tweet from favorites");
241 |             tweetApp.UpdateTweetFavouriteStatus(status.Id, isFavorite);
242 |             if (isFavorite)
243 |                 SetStatus("Tweet added to favorites");
244 |             else
245 |                 SetStatus("Tweet removed from favorites");
246 | 
247 |             if (isFavorite)
248 |                 FavouriteStarImage.Opacity = 1.0;
249 |         }
250 | 
251 |         private void RetweetIcon_MouseDown(object sender, MouseButtonEventArgs e)
252 |         {
253 |             Image image = sender as Image;
254 |             TwitterStatus status = image.Tag as TwitterStatus;
255 |             status.Retweeted = true;
256 |             image.Tag = status;
257 |             image.Opacity = 1.0;
258 | 
259 |             SetStatus("Sending ReTweet");
260 |             TwitterStatus retweetedStatus = tweetApp.ReTweet(status.Id);
261 |             AddTweet(retweetedStatus);
262 |             SetStatus("ReTweet sent");
263 |         }
264 | 
265 |         private void Icon_MouseEnter(object sender, MouseEventArgs e)
266 |         {
267 |             Image image = sender as Image;
268 |             image.Cursor = Cursors.Hand;
269 |         }
270 | 
271 |         private void Icon_MouseLeave(object sender, MouseEventArgs e)
272 |         {
273 |             Image image = sender as Image;
274 |             image.Cursor = Cursors.Arrow;
275 |         }
276 | 
277 |         private void UpdateTitle()
278 |         {
279 |             switch (currentView) {
280 |                 case CurrentView.HOME_TIMELINE:
281 |                     SetTitle("Home timeline");
282 |                     break;
283 |                 case CurrentView.USER_TIMELINE:
284 |                     SetTitle(currentViewUsername + "'s timeline (ESC to get back)");
285 |                     break;
286 |             }
287 |         }
288 | 
289 |         private void tweetListView_KeyUp(object sender, KeyEventArgs e)
290 |         {
291 |             // check if the pressed key is the ESC key
292 |             if ((e.Key == Key.Escape) && (currentView == CurrentView.USER_TIMELINE))
293 |             {
294 |                 ShowHomeTimeline();
295 |             }
296 |             else if (e.Key == Key.R) {
297 |                 RefreshTimeline();
298 |             }
299 |         }
300 | 
301 |         private void ShowHomeTimeline()
302 |         {
303 |             if (currentView != CurrentView.HOME_TIMELINE)
304 |             {
305 |                 currentView = CurrentView.HOME_TIMELINE;
306 |                 UpdateTitle();
307 | 
308 |                 SetStatus("Loading Tweets for home timeline");
309 |                 TwitterStatusCollection tweets = tweetApp.GetHomeTimeline();
310 |                 SetTweets(tweets);
311 |                 SetStatus("Tweets loaded");
312 |             }
313 |             else
314 |             {
315 |                 RefreshTimeline();
316 |             }
317 |         }
318 | 
319 |         private void RefreshTimeline()
320 |         {
321 |             // refresh the timeline
322 |             TwitterStatusCollection newTweets = new TwitterStatusCollection();
323 |             switch (currentView)
324 |             {
325 |                 case CurrentView.HOME_TIMELINE:
326 |                     newTweets = tweetApp.GetHomeTimeline(lastStatusId);
327 |                     break;
328 |                 case CurrentView.USER_TIMELINE:
329 |                     newTweets = tweetApp.GetHomeTimeline(currentViewUsername, lastStatusId);
330 |                     break;
331 |             }
332 | 
333 |             foreach (TwitterStatus status in newTweets)
334 |             {
335 |                 AddTweet(status);
336 |             }
337 |         }
338 | 
339 |         private void SetTitle(string newTitle)
340 |         {
341 |             // string title = "SharpTwitter";
342 |             string title = "SharpTwitter";
343 |             if (newTitle != null && newTitle.Length > 0)
344 |             {
345 |                 title = newTitle;
346 |             }
347 |             this.Title = title;
348 |         }
349 | 
350 |         private void SetStatus(string status)
351 |         {
352 |             StatusLabel.Content = status;
353 |         }
354 | 
355 |         private void Connect_MenuItem_Clicked(object sender, RoutedEventArgs e)
356 |         {
357 |             Console.WriteLine("Connect menu item clicked --> show dialog");
358 | 
359 |             tweetApp.StartNewAuthorization();
360 |             string uri = tweetApp.GetTwitterLoginUrl();
361 |             ConnectDialog cd = new ConnectDialog(uri);
362 |             cd.ShowDialog();
363 |             string pin = cd.GetPinCode();
364 |             if (pin != null && pin.Length > 0)
365 |             {
366 |                 tweetApp.FinishAuthorization(pin);
367 |                 RefreshTimeline();
368 |             }
369 |             else
370 |             {
371 |                 tweetApp.CancelAuthorization();
372 |             }
373 |         }
374 | 
375 |         private void Exit_MenuItem_Clicked(object sender, RoutedEventArgs e)
376 |         {
377 |             // close application
378 |             Close();
379 |         }
380 | 
381 |         private void Refresh_MenuItem_Clicked(object sender, RoutedEventArgs e)
382 |         {
383 |             // refresh timeline
384 |             RefreshTimeline();
385 |         }
386 | 
387 |         private void ShowHomeTimelineMenuItem_Click(object sender, RoutedEventArgs e)
388 |         {
389 |             ShowHomeTimeline();
390 |         }
391 | 
392 |         private void ShowTweetsOfUserMenuItem_Click(object sender, RoutedEventArgs e)
393 |         {
394 |             // get the selected element in the tweet list
395 |             if (tweetListView.SelectedItem != null)
396 |             {
397 |                 TwitterStatus status = tweetListView.SelectedItem as TwitterStatus;
398 |                 ShowUserTimeline(status.User.ScreenName);
399 |             }
400 |         }
401 | 
402 |         private void ReplyToTweetMenuItem_Click(object sender, RoutedEventArgs e)
403 |         {
404 |             if (tweetListView.SelectedItem != null)
405 |             {
406 |                 TwitterStatus status = tweetListView.SelectedItem as TwitterStatus;
407 |                 ReplyToTweet(status);
408 |             }
409 |         }
410 | 
411 |     }
412 | 
413 |     [ValueConversion(typeof(DateTime), typeof(String))]
414 |     public class DateTimeToStringConverter : IValueConverter
415 |     {
416 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
417 |         {
418 |             Console.WriteLine("Converting {0} to type {1}", value, targetType.GetType());
419 | 
420 |             DateTime dateTime = (DateTime)value;
421 |             TimeSpan t = (DateTime.UtcNow - dateTime.ToUniversalTime());
422 | 
423 |             if (t.TotalSeconds < 60)
424 |                 return string.Format("{0:0} seconds ago", t.TotalSeconds);
425 |             else if (t.TotalMinutes < 60)
426 |                 return string.Format("{0:0} minutes ago", t.TotalMinutes);
427 |             else if (t.TotalHours < 24)
428 |                 return string.Format("{0:0} hours ago", t.TotalHours);
429 |             else if (t.TotalDays < 30)
430 |                 return string.Format("{0:0} days ago", t.TotalDays);
431 | 
432 |             return dateTime.ToString("d.M.yyyy, H:mm");
433 |         }
434 | 
435 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
436 |         {
437 |             Console.WriteLine("Converting back {0} to type {1}", value, targetType.GetType());
438 |             return value;
439 |         }
440 |     }
441 | 
442 |     public class TwitterStatusComparer : IComparer<TwitterStatus>
443 |     {
444 | 
445 |         public int Compare(TwitterStatus status1, TwitterStatus status2)
446 |         {
447 |             return status2.CreatedDate.CompareTo(status1.CreatedDate);
448 |         }
449 | 
450 |     }
451 | }
452 | 


--------------------------------------------------------------------------------