#include <iostream>

// T型の変数valは、print()と++を持たなければならない
template <class T>
concept CallableFunction = requires (T val) {

    val.print();      // print()関数があることを要求
    val.operator++(); // ++演算子があることを要求
};

// CallableFunctionの制約がついている所で使用できるクラス
class MyValidClass {
    int val;
public:
    MyValidClass() {
        val = 5;
    }

    void print() {// print()関数を定義
		std::cout << "val == " << val << std::endl;
	}

    MyValidClass& operator++() {// ++演算子を要求
        ++val;
		return *this;
	}

};

// CallableFunctionの制約がある場合は指定できない。
// operator++() がない。
class MyInvalid {
    int val;
public:
    MyInvalid() {
        val = 5;
    }

    void print() {
        std::cout << "val == " << val << std::endl;
    }
};

// print()関数と++演算子を持つクラスを引数に取る関数
template <CallableFunction Type>
void func(Type val) {
    val.print();
}

int main()
{
    MyValidClass my;

    func(my);
}

#include <iostream>

#include <algorithm>
#include <vector>

template <class T>
concept Sortable = requires (T& val) {

    // { } 内の式が有効であることを要求する書き方ができる。
    // 例えば、以下は T 型の val はソート可能であることを要求する
    {
        std::sort(val.begin(), val.end())
    };

};

// print()関数と++演算子を持つクラスを引数に取る関数
template <Sortable Type>
void func(Type& val) {

    std::sort(val.begin(), val.end());

}

int main()
{
    std::vector<int> my{ 5,3,8 };

    func(my);


    for (auto& i : my) {
        std::cout << i << std::endl;
    }
}

#include <iostream>

#include <algorithm>
#include <vector>

template <class T>
concept Sizable = requires (T & val) {

    {
        val.size() // size()関数を持つ

    }->std::same_as<size_t>; // size()関数の戻り値はsize_t型
    // std::same_asはconcept。式の戻り値の型を指定する。
};

class MyArray {
    std::vector<int>vec;   
public: 
    void push_back(int i) { vec.push_back(i); }
    int size() { return vec.size(); }
};

// この関数は、戻り値がsize_t型のsize()関数を持つ型しか受け付けない
template <Sizable Type>
void func(Type& val) {

    std::cout<<val.size()<<std::endl;

}

int main()
{
    std::vector<int> my;
    // MyArray my;

    my.push_back(3);
    my.push_back(1);
    my.push_back(8);

    func(my);

}

// プリプロセッサに以下を追加
// __WXMSW__

// static link library の場合、以下は指定しない
// WXUSINGDLL

// サブシステムをWindowsに設定(WinMainで呼び出すので)
// Windows (/SUBSYSTEM:WINDOWS)

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

#include <wx/gdicmn.h> // wxPointに必要
#include <wx/frame.h>  // wxFrameに必要

// Win32 API
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "rpcrt4.lib")

// wxWidgets
#pragma comment(lib,"wxmsw33u_core.lib")
#pragma comment(lib,"wxbase33u.lib")
#pragma comment(lib,"wxbase33u_net.lib")
#pragma comment(lib,"wxbase33u_xml.lib")
#pragma comment(lib,"wxexpat.lib")
#pragma comment(lib,"wxjpeg.lib")
#pragma comment(lib,"wxlexilla.lib")
#pragma comment(lib,"wxmsw33u_adv.lib")
#pragma comment(lib,"wxmsw33u_aui.lib")
#pragma comment(lib,"wxmsw33u_gl.lib")
#pragma comment(lib,"wxmsw33u_html.lib")
#pragma comment(lib,"wxmsw33u_media.lib")
#pragma comment(lib,"wxmsw33u_propgrid.lib")
#pragma comment(lib,"wxmsw33u_qa.lib")
#pragma comment(lib,"wxmsw33u_ribbon.lib")
#pragma comment(lib,"wxmsw33u_richtext.lib")
#pragma comment(lib,"wxmsw33u_stc.lib")
#pragma comment(lib,"wxmsw33u_webview.lib")
#pragma comment(lib,"wxmsw33u_xrc.lib")
#pragma comment(lib,"wxpng.lib")
#pragma comment(lib,"wxregexu.lib")
#pragma comment(lib,"wxscintilla.lib")
#pragma comment(lib,"wxtiff.lib")
#pragma comment(lib,"wxzlib.lib")


/////////////////////////////////////
/////////////////////////////////////
/////////////////////////////////////

// ウィンドウ作成
class MyFrame : public wxFrame
{
public:
    MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
        : wxFrame(NULL, wxID_ANY, title, pos, size)
    {
    }

private:

    // イベント処理しないときはこれを入れない
    // wxDECLARE_EVENT_TABLE();
};

/////////////////////////////////////
/////////////////////////////////////
/////////////////////////////////////

// wxWidgetsのアプリケーション作成
class MyApp : public wxApp {
public:

    virtual bool OnInit() {
        MyFrame* frame = new MyFrame("Hello World", wxPoint(50, 50), wxSize(450, 340));
        frame->Show(true);
        return true;
    }

};

/////////////////////////////////////
/////////////////////////////////////
/////////////////////////////////////

// WinMainをマクロで定義
wxIMPLEMENT_APP(MyApp);

#pragma warning(disable:4996)

#include <windows.h>

#include <shellapi.h>

static const int TasktrayIconID = 100;
static const int WM_MY_NOTIFYICON = WM_USER + TasktrayIconID;

const int ID_MENU_MSG = 100;
const int ID_MENU_EXIT = 101;

HMENU myCreateMenu();
void intoTasktray(HWND hwnd, const int IconID);
void fromTasktray(HWND hwnd, const int IconID);
void menuPopup(HWND hwnd, HMENU menu);

/////////////////////////////////
/////////////////////////////////
/////////////////////////////////
/////////////////////////////////

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {


  static HMENU hMenu = nullptr;

  switch (msg) {
  case WM_CREATE:
    hMenu = myCreateMenu();//メニュー作成
    break;
  case WM_LBUTTONDOWN://ウィンドウをクリックしたらアイコン表示開始
  {
    intoTasktray(hwnd, TasktrayIconID);
    break;
  }
  case WM_MY_NOTIFYICON:
    if (lp == WM_LBUTTONDOWN && wp == TasktrayIconID) {
      // アイコンを左クリックしたらウィンドウを表示
      fromTasktray(hwnd, TasktrayIconID);
    }
    else if (lp == WM_RBUTTONUP) {
      // アイコンを右クリックしたらポップアップメニューを表示
      menuPopup(hwnd, hMenu);
    }
    break;
  case WM_COMMAND:
    switch (wp)
    {
    case ID_MENU_MSG:  // "Open"がクリックされた場合
      MessageBoxA(hwnd, "MessageBox", "Info", MB_OK);
      break;
    case ID_MENU_EXIT:  // "Exit"がクリックされた場合
      DestroyWindow(hwnd);
      break;
    }
    break;

  case WM_DESTROY:
    DestroyWindow(hwnd);
    PostQuitMessage(0);
    return 0;
  }
  return DefWindowProc(hwnd, msg, wp, lp);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	PSTR lpCmdLine, int nCmdShow) {
	HWND hwnd;
	MSG msg;
	WNDCLASS winc;

	winc.style = CS_HREDRAW | CS_VREDRAW;
	winc.lpfnWndProc = WndProc;
	winc.cbClsExtra = winc.cbWndExtra = 0;
	winc.hInstance = hInstance;
	winc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	winc.hCursor = LoadCursor(NULL, IDC_ARROW);
	winc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	winc.lpszMenuName = NULL;
	winc.lpszClassName = TEXT("SZL-WINDOW");

	if (!RegisterClass(&winc)) return -1;

	hwnd = CreateWindow(
		TEXT("SZL-WINDOW"), TEXT("test"),
		WS_OVERLAPPEDWINDOW | WS_VISIBLE,
		CW_USEDEFAULT, CW_USEDEFAULT,
		300, 300,
		NULL, NULL, hInstance, NULL
	);

	if (hwnd == NULL) return -1;

	while (GetMessage(&msg, NULL, 0, 0)) DispatchMessage(&msg);
	return msg.wParam;
}

// メニューの作成
HMENU myCreateMenu() {
  HMENU menu = CreatePopupMenu();
  AppendMenuA(menu, MF_STRING, ID_MENU_MSG, "Open");
  AppendMenuA(menu, MF_STRING, ID_MENU_EXIT, "Exit");

  return menu;
}

// ウィンドウを消し、アイコンをタスクトレイへ格納
void intoTasktray(HWND hwnd, const int IconID) {

  NOTIFYICONDATA nid;
  nid.cbSize = sizeof(nid);
  nid.hWnd = hwnd;
  nid.uID = IconID;//複数のアイコンを表示したときの識別ID。なんでもいい。
  nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
  nid.uCallbackMessage = WM_MY_NOTIFYICON; //WM_USER以降の定数。
  nid.hIcon = (HICON)LoadIcon(NULL, IDI_APPLICATION);
  wcscpy(nid.szTip, L"タスクトレイで表示する文字列");
  int ret = (int)Shell_NotifyIcon(NIM_ADD, &nid);
  ShowWindow(hwnd, SW_HIDE);

}

// タスクトレイからアイコンを削除し、ウィンドウを表示
void fromTasktray(HWND hwnd, const int IconID) {
  ShowWindow(hwnd, SW_SHOW);

  //タスクトレイアイコンを削除
  NOTIFYICONDATA nid;
  nid.cbSize = sizeof(nid);
  nid.hWnd = hwnd;
  nid.uID = IconID;
  nid.uFlags = 0;
  Shell_NotifyIcon(NIM_DELETE, &nid);

}

// ポップアップメニューを表示
void menuPopup(HWND hwnd, HMENU menu) {
  POINT pt;
  GetCursorPos(&pt);
  SetForegroundWindow(hwnd);
  TrackPopupMenu(menu, TPM_RIGHTALIGN, pt.x, pt.y, 0, hwnd, NULL);

}

use windows::Win32::Graphics::Gdi::*;
use windows::core::*;
use windows::Win32::Foundation::*;

// ■ BITMAPINFO         ... windows::Win32::Graphics::Gdi::BITMAPINFO
// ■ BITMAPINFOHEADER   ... windows::Win32::Graphics::Gdi::BITMAPINFOHEADER
// ■ BI_RGB             ... windows::Win32::Graphics::Gdi::BI_RGB
// ■ CreatedHDC         ... windows::Win32::Graphics::Gdi::CreatedHDC
// ■ CreateDCA          ... windows::Win32::Graphics::Gdi::CreateDCA
// ■ CreateCompatibleDC ... windows::Win32::Graphics::Gdi::CreateCompatibleDC
// ■ CreateDIBSection   ... windows::Win32::Graphics::Gdi::CreateDIBSection
// ■ DIB_RGB_COLORS     ... windows::Win32::Graphics::Gdi::DIB_RGB_COLORS
// ■ DeleteDC           ... windows::Win32::Graphics::Gdi::DeleteDC
// ■ HBITMAP            ... windows::Win32::Graphics::Gdi::HBITMAP
// ■ HBITMAP            ... windows::Win32::Graphics::Gdi::HBITMAP
// ■ SelectObject       ... windows::Win32::Graphics::Gdi::SelectObject

// ■ HANDLE             ... windows::Win32::Foundation::HANDLE

// ■ PCSTR              ... windows::core::PCSTR

 pub struct Win32DIBCanvas{
    pub bitmap     :HBITMAP,
    pub bitmapInfo :BITMAPINFO,
    pub ppixel     :*mut std::ffi::c_void,
    pub hMemDC     : CreatedHDC,
}

// ppixel:*mut std::ffi::c_void, があるので、Send,Syncを実装しなければmyDIBをLazy<Mutex<myDIB>>に入れられない
unsafe impl Send for Win32DIBCanvas {}
unsafe impl Sync for Win32DIBCanvas {}

impl Win32DIBCanvas{
    pub fn new()->Win32DIBCanvas{
        Win32DIBCanvas{
            bitmap    :HBITMAP(0),
            bitmapInfo:Default::default(),
            ppixel    :std::ptr::null_mut(),
            hMemDC    :CreatedHDC(0),
        }
    }
    pub fn create(&mut self,width:i32,height:i32){

        

        unsafe{
            let mut hdca = CreateDCA(
                PCSTR::from_raw("DISPLAY\0".as_ptr()),
                None,
                None,
                None
            );

            self.bitmapInfo.bmiHeader.biSize        = std::mem::size_of::<BITMAPINFOHEADER>() as u32;
            self.bitmapInfo.bmiHeader.biWidth       = width;
            self.bitmapInfo.bmiHeader.biHeight      = -height;
            self.bitmapInfo.bmiHeader.biPlanes      = 1;
            self.bitmapInfo.bmiHeader.biBitCount    = 3*8;
            self.bitmapInfo.bmiHeader.biCompression = BI_RGB;

            let hBitmap = CreateDIBSection(
                hdca,
                &self.bitmapInfo,
                DIB_RGB_COLORS,
                &mut self.ppixel,
                HANDLE(0),
                0
            );

            self.hMemDC =  CreateCompatibleDC(hdca);

            if let Ok(hbmp) = hBitmap{
                SelectObject(self.hMemDC,hbmp);
            }

            DeleteDC(hdca);
        }
    }
}