avatar image

Welcome, Guest. Please login or register.
Did you miss your activation email?

Login with username, password and session length
  • Wednesday August 5, 2020, 8:13 pm
  • Proudly celebrating 15+ years online.
  • Donate now to become a lifetime supporting member of the site and get a non-expiring license key for all of our programs.
  • donate

Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Messages - wraith808 [ switch to compact view ]

Pages: [1] 2 3 4 5 6 ... 379next
So I guess my point is that it's possible- it will just have to be enabled.  And video will not be enabled in both as far as your video cam, I think.

There is an option called "Join different meetings simultaneously on desktop" which is disabled by default. The feature to join multiple meetings simultaneously from the Zoom desktop client allows users to participate in or monitor multiple meetings at the same time. This is ideal for support staff who may need to monitor multiple meetings at the same time.

Once the setting is enabled, you can join multiple meetings by clicking on the join URL or navigating to and entering the meeting ID. The Join button in the Zoom client will only work for the first meeting that you join.


how do i open 2 zoom sessions on one pc? (company pc, zoom is permant open)
I don't think you can open more than 1 zoom session at a time..
Agreed, technically (close to) impossible. How would the software multiplex the videostream between 2 (or more) sessions?
And how would the other party/session know you're talking to them, or to the other session?
It's difficult enough to have multiple conversions at the same time with people in the same room, let alone on the other side of a digital connection...

MS Teams lets you switch to another call, but it then puts your first call on hold, just like in a phonecall, and you can resume later, after ending/pausing the second call.

Actually, I've had teams, skype, and zoom up at the same time.  The trick is I'm not on-camera for the other two.  I usually mute the audio for the one(s) that I'm not in.  It's not possible to have more than one outgoing video, sure.  But incoming is fine.

What concert costs only 45 cents?

50 cent featuring nickelback.

Living Room / Re: Cyph - A potential Keybase alternative
« on: July 29, 2020, 11:48 PM »
I stand corrected.

zettel = note :)

And I'm using VS code for the same thing that you use writemonkey for most of the time.  I don't code in VS Code.  I code in Visual Studio.

I haven't opened Obsidian in a while now.  I just find VS code with the extension scaffolding works a lot better for my process.  I have my Zettel and notes open from one folder, and in the same workspace I have my current project, whatever that is.  I can flip back and forth between writing, coding, etc. and note-taking as I work without switching applications.

Not so smooth on Android, but I remain hopeful that will be sorted around the end of the year. 

I actually find myself not using the system on the go, still resorting to my notebooks, and just transcribing when I get to my computer.  With the quarantine and working from home, that's not as much of an issue as it would be otherwise, but I do need to figure out what I'm going to do on that front.  As I still keep my bullet journal, I might be able to integrate that in with the daily notes.  It's just more work translating from one medium to another.

What's even more interesting is his other project -

It could work really well with the idea of playing board games together.  Both of you could have the same board game, and you could visually see where the other person was moving, and mirror it on your own board.

In that last image, I can't even tell that they are not in the same frame.  It looks pretty amazing!  I've seen that one some videos on youtube, and thought it witchery! :)

I like your shelves! Just had to add that.  I'm obsessed with built-ins.

Living Room / Re: Cyph - A potential Keybase alternative
« on: July 23, 2020, 08:17 AM »
It's still not open source, so vulnerable to the same fate.  I use encrypted git repos, and the fact that they refer to them as niche, means that they aren't likely to support them in the future.  I'm still taking a wait and see approach.

Living Room / Re: Interesting "stuff"
« on: July 23, 2020, 08:14 AM »
I've posted 'Riddle', here;
That's in the wrong board to post in if you want responses -- it probably had about two views before you posted this link.
@moderators, would you consider moving the thread to the living room board?

Looking at the contents of the 'riddle', I think it was in the right place.

Tired of the real world's shabby tirade of false 'virtue signalling'?

Any time that phrase is used unironically it's a red flag to me.

It looks a lot closer to what I do, though I do something different than using nameof(class) in order to not have to worry about naming errors that doesn't rely on intellisense.  This is an example of one of my viewmodels that I've written:

Code: C# [Select]
  1. public class ConfigurationViewModel: INotifyPropertyChanged
  2.     {
  3.         public ConfigurationSettingsModel Model { get; set; }
  5.         public ConfigurationViewModel(ConfigurationSettingsModel model)
  6.         {
  7.             this.Model = model;
  8.             // create commands
  9.             this.OkCommand = new RelayCommand(param => this.OkCommandExecute(), param => this.CanOk);
  10.             this.CancelCommand = new RelayCommand(param => this.CancelCommandExecute(), param => this.CanCancel);
  11.         }
  13.         #region Commands
  15.         #region OkCommand
  17.         public ICommand OkCommand
  18.         {
  19.             get;
  20.             internal set;
  21.         }
  23.         private bool CanOk
  24.         {
  25.             get
  26.             {
  27.                 return this.ValidateSettings();
  28.             }
  29.         }
  31.         public void OkCommandExecute()
  32.         {
  33.             this.Model.SaveSettings();
  34.             this.DialogResult = true;
  35.         }
  37.         #endregion
  39.         #region CancelCommand
  41.         public ICommand CancelCommand
  42.         {
  43.             get;
  44.             internal set;
  45.         }
  47.         private bool CanCancel
  48.         {
  49.             get
  50.             {
  51.                 return true;
  52.             }
  53.         }
  55.         public void CancelCommandExecute()
  56.         {
  57.             this.Model.RefreshData();
  58.             this.DialogResult = false;
  59.         }
  61.         #endregion
  63.         #endregion
  65.         #region Observable Properties
  67.         private bool? _DialogResult = null;
  68.         public bool? DialogResult
  69.         {
  70.             get
  71.             {
  72.                 return this._DialogResult;
  73.             }
  74.             set
  75.             {
  76.                 if (value != this._DialogResult)
  77.                 {
  78.                     this._DialogResult = value;
  79.                     this.NotifyPropertyChanged(() => this.DialogResult);
  80.                 }
  81.             }
  82.         }
  84.         #endregion
  86.         #region Helper Methods
  88.         private bool ValidateSettings()
  89.         {
  90.             return true;
  91.         }
  93.         #endregion
  96.         #region INotifyPropertyChanged Implementation
  98.         public event PropertyChangedEventHandler PropertyChanged;
  100.         protected virtual void OnPropertyChanged(string propertyName)
  101.         {
  102.             PropertyChangedEventHandler handler = this.PropertyChanged;
  103.             if (handler != null)
  104.             {
  105.                 var e = new PropertyChangedEventArgs(propertyName);
  106.                 handler(this, e);
  107.             }
  108.         }
  110.         protected void NotifyPropertyChanged<TProperty>(Expression<Func<TProperty>> property)
  111.         {
  112.             var lambda = (LambdaExpression)property;
  113.             MemberExpression memberExpression;
  115.             if (lambda.Body is UnaryExpression)
  116.             {
  117.                 var unaryExpression = (UnaryExpression)lambda.Body;
  118.                 memberExpression = (MemberExpression)unaryExpression.Operand;
  119.             }
  120.             else
  121.                 memberExpression = (MemberExpression)lambda.Body;
  123.             this.OnPropertyChanged(memberExpression.Member.Name);
  124.         }
  126.         #endregion

But I will say that guy does seem to break it down a lot better than the first video that I saw, and I think his methods would be worth following from what I saw.

I didn't notice what he did for a bootstrapper, but I use the simple expident of making use of a couple of properties of the app.xaml.

In the app.xaml, I set it up like so:

Code: C# [Select]
  1. <Application x:Class="ApplicationName.App"
  2.              xmlns=""
  3.              xmlns:x=""
  4.              Startup="Application_Startup"
  5.              SessionEnding="App_SessionEnding">
  6.     <Application.Resources>
  8.     </Application.Resources>
  9. </Application>

Normally that startup is set to the first form- but this gives me a chance to go into the bootstrapper.

Then in the app.xaml.cs, I set up those two events.  The startup event is below.

Code: C# [Select]
  1. private void Application_Startup(object sender, StartupEventArgs e)
  2.         {
  3.             this.RequestClose = false;
  4.             this.SettingsConfiguration = this.GetConfiguration();
  5.             this.SettingsModel = new ConfigurationSettingsModel(this.SettingsConfiguration);
  7.             this.ViewModel = new MainViewModel(this.SettingsModel);
  8.             this.View = new MainView(this.ViewModel);
  10.             this.View.Closing += this.OnClosing;
  12.             this.ViewModel.RequestConfigurationDialog += new EventHandler(ViewModel_RequestConfigurationDialog);
  13.             this.ViewModel.RequestShowAboutDialog += new EventHandler(ViewModel_RequestShowAboutDialog);
  15.             // When the ViewModel asks to be closed, it closes the window via attached behaviour.
  16.             // We use this event to shut down the remaining parts of the application
  17.             this.ViewModel.RequestClose += delegate
  18.             {
  19.                 // Make sure close down event is processed only once
  20.                 if (this.RequestClose == false)
  21.                 {
  22.                     this.RequestClose = true;
  24.                     // Save session data and close application
  25.                     this.OnClosed(this.ViewModel, this.View);
  26.                 }
  27.             };
  29.             this.InitializeViewCommandBindings();  // Initialize RoutedCommand bindings
  30.             this.View.Show();
  31.         }
  33.         private void App_SessionEnding(object sender, SessionEndingCancelEventArgs e)
  34.         {
  35.             e.Cancel = this.OnSessionEnding();
  36.         }
  38.         private bool OnSessionEnding()
  39.         {
  40.             if (this.ViewModel != null)
  41.             {
  42.                 if (this.ViewModel.CanClose == false)
  43.                 {
  44.                     MessageBox.Show("Application is not ready to exit.",
  45.                                     "Cannot exit application", MessageBoxButton.OK);
  47.                     return !this.ViewModel.CanClose; // Cancel close down request if ViewModel is not ready, yet
  48.                 }
  50.                 return !this.ViewModel.CanClose; // Cancel close down request if ViewModel is not ready, yet
  51.             }
  53.             return true;
  54.         }
  56.         private void OnClosed(MainViewModel viewModel, MainView view)
  57.         {
  58.             // Persist data here
  59.             this.SettingsModel.SaveSettings();
  61.             Application.Current.Shutdown();
  62.         }

There's a bit more to it- but I thought that knowing how the bootstrapper is set up and an alternate way to hook up the INotifyPropertyChanged might be of benefit to perhaps encapsulate in what he refers to in the video.

I just hate to because their name, image, and advertisements irk me to no end..

Agreed.  I have one domain still there because I have clients that use that domain for their nameserver, and I haven't felt assed enough to try to navigate that.  But they take advantage of you, rub it in your face that they take advantage of you, then kick you while you're down.

Though he calls using your own MVVM framework like "Building a car in order to drive it," taking a brief look at that video, it's a lot harder than what I do to configure that framework.  I'll try to write something simple I can put on github that illustrates how I do it.  No promises on the timeline though... unfortunately, I have a lot on my plate right now.

One other thing I'll say, and I'm not sure that most of the tutorials recommend it though it's the way I've started writing my XAML in most cases - make liberal use of DockPanel and StackPanel.  They make organizing your controls a lot simpler, IMO.

I have 2 book ideas to work on and I want to try it out on them.

I'm doing the same (2 books in my zettel), and I've resolved to just keep notes and fragments in the zettel, and when they're complete, move them out.

As I said, I'm doing agile to make myself actually finish, so going 1 week as a sprint zero to research and get the backlog hefty, then planning/executing for a week at a time for three weeks  so some completed work gets shuffled to the edit stage.  I'll get everything done before I switch to the edit stage, and hopefully by then, the backlog will already be filled with the previously completed work.

Are you tied to desktop?  That's the only reason I can think of for not using WPF.  If it's desktop, I'd definitely recommend it, and look into MVVM- that's what I use for a more reactive interface and to decouple the interface from the logic.  It seems like it might be a good thing for your use case.

As far as learning- I'd personally suggest using XAML instead of the visual editor.  Just like with other visual editors, the WPF design canvas can create some pretty shitty code.  And when you need to do something, you find that it screws with the whole interface.

If you want to start with the visual editor, there are a variety of courses:


That's just a few of them.  Of those, I like the best.  There are better paid ones, but that one does the job.  I'd also suggest https://www.c-sharpc...cepts-in-15-minutes/ after that, to reinforce some of the concepts, no matter which one you choose.

If you want to go the XAML route, I'd go with tutorialspoint -

That rolls in all of the concepts for that c-sharpcorner article also, making it an unnecessary read at that point.

One thing to note- all of these are pretty old.  Other than the format of visual studio, that shouldn't matter though.

Getting a domain, the web hosting, some support, including a (simple) certificate sets you back about 60 USD the first year. Extending the domain after the first year is cheaper (around 50 USD). And if you setup free certificates using 'Let's Encrypt' or similar services, the price drops even further. And I would think that all the money spent can be written (completely/partially) as a business expense. And such a host will have all the tools (for money transfers) in place already, in case the bike shop owner wants to sell stuff online directly.

Since the ask was for free, I didn't even worry about paid options.  And for non-paid, you aren't really going to get your own domain.

It's very easy to note them, so I'd be surprised if you missed them.
I just see them as part of the conversation. Has been the first mention of some interesting sites and software.

I guess a difference in perception.  Seems there are conversations around some, but not most.  But no matter; it was just idle musings after the commentary by another after the proliferation of links on some of the latter pages at the time.

I'm currently merging Agile concepts with my Zettel.  It is a very good concept for maintaining a backlog and getting things done, and the two have melded nicely.

There's just a lot of random interspersion about new software- not that I mind, but all of it has sort of littered the thread. 
I don't see any random posts or any littering. It's a conversation,  people write what feels relevant to them at the time.
It might be good to separate out the software into a different thread.
I'd certainly not want anything split out, because that would lose the to and fro of the conversation.

There's nothing to stop someone starting a thread about note-taking software or about zettelkasten.

There are interjections of just software postings in a lot of places from people that don't really take part in the other parts of the conversation.  It's very easy to note them, so I'd be surprised if you missed them.

So how do you guys deal with images?
Do you place them in the same folder as the txt notes?  or in a subfolder?

I stayed away from images, but have started using them with that paste image extension that I've added to VS Code.  I put them in a subfolder whereever the note is rather than a central location.

I've been using Zettlr for my zettelkasten. I started it in January this year and have so far written 713 notes.

Forgive me for I haven't read all 25 pages of this topic, but it seems to me like discussion here is mostly around note taking software and not zettelkasten as a method?

It's around both.  Much about the synchronicity between the method and the given applications.  There's just a lot of random interspersion about new software- not that I mind, but all of it has sort of littered the thread.  It might be good to separate out the software into a different thread.

Man, I have to say I am VERY impressed by the slick interfaces these people are coming up with.  It's like you want all the good bits of each in one.

Exactly.  And the cool thing is that since they are componentized in extensions, you can have the best of each!

Dendron is a local-first, markdown based, hierarchical note-taking application built on top of VSCode and friends:

Not using it wholesale, but there were some really good extensions that I'd not seen.  I've found that the major advantage of using VS code- the fact that I can mix and match functionality.

From this one, I am using:

Paste Image - https://marketplace....n.vscode-paste-image
- lets you directly paste an image into the document, and it will create the image file and insert the link.
Markdown Shortcuts - https://marketplace....n.markdown-shortcuts
- adds a lot of shortcuts for commonly used commands to the command line.  Also does some pretty interesting formatting of pre-existing text.

Actually, I upload them to the website in the folder structure.  The one for making a website out of your documents would be more akin to Jekyll or Postachio.

Pages: [1] 2 3 4 5 6 ... 379next